package weixin

import (
	"gitee.com/h79/gothird/result"
	"gitee.com/h79/gothird/token"
	"gitee.com/h79/gothird/weixin/errors"
	"gitee.com/h79/gothird/weixin/media"
	"gitee.com/h79/gothird/weixin/oauth2"
	"gitee.com/h79/gothird/weixin/offia/ticket"
	"gitee.com/h79/gothird/weixin/session"
	"gitee.com/h79/goutils/common/data"
	"mime/multipart"
	"net/http"
	"reflect"
)

var firstService *acsReq
var webService *acsReq

func init() {
	firstService = &acsReq{
		name: token.KWxType,
		get:  GetAccessToken,
		ref:  token.GetEmpty,
		auth: oauth2.GetAccessToken,
	}

	webService = &acsReq{
		name: token.KWxWebType,
		get:  token.GetEmpty,
		ref:  oauth2.RefreshToken,
		auth: token.GetEmpty,
	}
}

func GetService() token.Service {
	return firstService
}

func GetWebService() token.Service {
	return webService
}

func NewToken(app token.App) token.Token {
	return token.New(&app, firstService)
}

func NewWebToken(app token.App) token.Token {
	return token.New(&app, webService)
}

type acsReq struct {
	name  string
	check token.CheckErrorFunc
	get   token.GenFunc
	ref   token.GenFunc
	auth  token.GenFunc
}

func (req *acsReq) GetName() string {
	return req.name
}

// Execute token.Service interface
func (req *acsReq) Execute(tk token.Token, cmd string, d data.D) (interface{}, error) {

	if cmd == token.NTicket {
		return ticket.GetTicket(tk, d)
	}
	if cmd == token.NAccessToken {
		return req.get(tk, d)
	}
	if cmd == token.NRefreshToken {
		return req.ref(tk, d)
	}
	if cmd == token.NOauth2 { // 网页，个人授权，返回一个 openid
		acs, err := req.auth(tk, d)
		if err != nil {
			return nil, err
		}
		if se, ok := acs.(*session.Session); ok {
			ch := &token.Child{
				App: token.App{
					ParentId: tk.GetId(),
					IsCache:  tk.IsCache(),
					Type:     token.KWxWebType,
					Id:       token.GenId(tk.GetAppId(), se.Openid),
					AppId:    se.Openid,
					Name:     "web",
				},
				VMap: token.VMap{},
			}
			token.SyncCreateChild(tk, webService, ch, acs, []string{se.Openid}, func() {
			}) // 需要把个人openid 与 appid 对应
		}
		return acs, err
	}
	return nil, result.ErrNotSupported
}

func (req *acsReq) GetUrl(uri string, acsKey string, d data.D) string {
	return token.DefaultUrl(acsKey, uri)
}

func (req *acsReq) SetHead(h *http.Header, acsKey string) {
}

func (req *acsReq) CreateForm(w *multipart.Writer, field string, form interface{}) error {
	img, ok := form.(*media.Image)
	if !ok {
		return result.Result{Code: -1, Msg: "file object not is Image"}
	}
	val := reflect.ValueOf(img)
	if val.CanInterface() && val.Type().Implements(token.FormType) {
		fm := val.Interface().(token.Form)
		return fm.CreateForm(w, field)
	}
	return token.DefaultForm(w, field, img.FileName)
}

func (req *acsReq) SetCheckError(check token.CheckErrorFunc) {
	req.check = check
}

func (req *acsReq) CheckError(err error) error {
	if res, ok := err.(result.Result); ok {
		if req.check != nil {
			return req.check(&res)
		}
		if errors.IsExpired(res.Code) {
			return result.ErrExpired
		}
	}
	return err
}