package token

import (
	"errors"
	"fmt"
	"gitee.com/h79/gothird/token/access"
	"gitee.com/h79/gothird/token/validate"
	"gitee.com/h79/goutils/common/coder"
	"gitee.com/h79/goutils/common/data"
	"gitee.com/h79/goutils/common/logger"
	"go.uber.org/zap"
)

var _ Token = (*tokenImpl)(nil)
var _ Base = (*tokenImpl)(nil)

type tokenImpl struct {
	App     *App
	parent  Token
	service Service
}

func (t *tokenImpl) IsCache() bool {
	if t == nil {
		return false
	}
	return t.App.IsCache
}

func (t *tokenImpl) GetParentId() string {
	if t == nil {
		return ""
	}
	return t.App.ParentId
}

func (t *tokenImpl) GetId() string {
	if t == nil {
		return ""
	}
	return t.App.Id
}

func (t *tokenImpl) GetAppType() string {
	if t == nil {
		return ""
	}
	return t.App.Type
}

func (t *tokenImpl) GetAppId() string {
	if t == nil {
		return ""
	}
	return t.App.AppId
}

func (t *tokenImpl) GetName() string {
	if t == nil {
		return ""
	}
	return t.App.Name
}

func (t *tokenImpl) GetSecret() string {
	if t == nil {
		return ""
	}
	return t.App.Secret
}

func (t *tokenImpl) SetSecret(secret string) {
	if t == nil {
		return
	}
	t.App.Secret = secret
}

func (t *tokenImpl) Parent() Token {
	if t.parent != nil {
		return t.parent
	}
	if len(t.App.ParentId) == 0 {
		return t
	}
	if tk, err := Mgr().GetToken(t.App.ParentId); err == nil {
		t.parent = tk
		return tk
	}
	return t
}

func (t *tokenImpl) CreateChild(app *App, service Service) Token {
	if t == nil {
		return nil
	}
	tk := &tokenImpl{
		parent:  t,
		App:     app,
		service: service,
	}
	return tk
}

func (t *tokenImpl) GetRequest() Request {
	if t == nil {
		return nil
	}
	return t.service
}

func (t *tokenImpl) Execute(cmd string, data data.D) (interface{}, error) {
	if t == nil {
		return nil, ErrObjectNil
	}
	if cmd == NGetOwner {
		var p Token = nil
		if data.String(Parent) == True {
			if pp := t.Parent(); pp != t {
				//确实有父结点
				p = pp
			}
		}
		var secret = false
		if data.String(Secret) == True {
			secret = true
		}
		var encoder coder.Encoder = nil
		var en = data.Value(Encoder)
		if cdr, ok := en.(coder.Encoder); ok {
			encoder = cdr
		}
		var res = struct {
			Apps map[string]*App `json:"apps"`
		}{
			Apps: make(map[string]*App, 0),
		}
		if app := getApp(t, secret, encoder); app != nil {
			res.Apps[Owner] = app
		}
		if app := getApp(p, secret, encoder); app != nil {
			res.Apps[Parent] = app
		}
		return &res, nil
	}
	return t.service.Execute(t, cmd, data)
}

func (t *tokenImpl) GetCode(name string) (string, error) {
	if t == nil {
		return "", ErrObjectNil
	}
	return Mgr().Read(t.App.Id, name)
}

func (t *tokenImpl) ClearCode(name string) error {
	if t == nil {
		return ErrObjectNil
	}
	return Mgr().Clear(t.App.Id, name)
}

func (t *tokenImpl) SetCode(name, code string, expire int64) error {
	if t == nil {
		return ErrObjectNil
	}
	ex := validate.New(name, code, expire)
	return Mgr().Write(t.App.Id, ex.Key, ex)
}

func (t *tokenImpl) SetAccessTokenWithAcs(acs access.Token) string {
	if !t.App.IsCache {
		return acs.GetAccessToken().Data
	}
	return Mgr().SetAccessToken(t.App.Id, acs)
}

func (t *tokenImpl) SetAccessToken(acs string, expire int64) error {
	if t == nil {
		return ErrObjectNil
	}
	if !t.App.IsCache {
		return nil
	}
	ex := validate.New(NAccessToken, acs, expire)
	return Mgr().Write(t.App.Id, ex.Key, ex)
}

func (t *tokenImpl) ClearAccessToken() {
	if t == nil {
		return
	}
	if err := t.ClearCode(NAccessToken); err != nil {
		zap.L().Error("tokenImpl", zap.String("id", t.App.AppId), zap.Error(err))
	}
	return
}

func (t *tokenImpl) GetAccessToken(options ...data.OptionsFunc) (string, error) {
	if t == nil {
		return "", ErrObjectNil
	}
	if v, err := Mgr().Read(t.App.Id, NAccessToken); err == nil && v != "" {
		return v, nil
	}

	opts := data.Options{Data: data.D{"appid": t.App.AppId}}
	for i := range options {
		options[i](&opts)
	}
	d, err := t.service.Execute(t, NAccessToken, opts.Data)

	if errors.Is(err, ErrTokenExpired) {
		if ref, er := t.GetRefreshAccessToken(); er == nil {
			return t.RefreshAccessToken(ref)
		}
	}
	if errors.Is(err, ErrTokenInvalid) {
		t.ClearAccessToken()
	}
	if err != nil {
		zap.L().Error("tokenImpl", zap.String("id", t.App.Id), zap.String("appId", t.App.AppId), zap.Error(err))
		return "", err
	}
	return t.SetAccessTokenWithAcs(d.(access.Token)), nil
}

func (t *tokenImpl) SetRefreshAccessToken(tk string, expire int64) error {
	if t == nil {
		return ErrObjectNil
	}
	if !t.App.IsCache {
		return nil
	}
	ex := validate.New(NRefreshToken, tk, expire)
	return Mgr().Write(t.App.Id, ex.Key, ex)
}

func (t *tokenImpl) GetRefreshAccessToken() (string, error) {
	if t == nil {
		return "", ErrObjectNil
	}
	return Mgr().Read(t.App.Id, NRefreshToken)
}

func (t *tokenImpl) RefreshAccessToken(refToken string) (string, error) {
	if refToken == "" {
		ref, er := t.GetRefreshAccessToken()
		if er != nil {
			zap.L().Error("tokenImpl", logger.ZLog("the refresh token not found"), zap.String("appId", t.App.AppId), zap.Error(er))
			return "", er
		}
		refToken = ref
	}
	da := data.D{}
	da["appid"] = t.App.AppId
	da["refToken"] = refToken
	d, err := t.service.Execute(t, NRefreshToken, da)

	if err == nil {
		return t.SetAccessTokenWithAcs(d.(access.Token)), nil
	}
	zap.L().Error("tokenImpl", zap.String("appId", t.App.AppId), zap.Error(err))
	if errors.Is(ErrTokenExpired, t.service.CheckError(err)) {
		if er := Mgr().Clear(t.App.Id, NRefreshToken); er != nil {
			zap.L().Error("tokenImpl", logger.ZLog("clear refresh token"), zap.String("appId", t.App.AppId), zap.Error(er))
		}
	}
	return "", err
}

func (t *tokenImpl) String() string {
	return fmt.Sprintf("App: {id='%v', appId='%v', parentId='%v', type='%v'}", t.App.Id, t.App.AppId, t.App.ParentId, t.App.Type)
}

func getApp(t Token, secret bool, encoder coder.Encoder) *App {
	if t == nil {
		return nil
	}
	res := &App{ParentId: t.GetParentId(), Id: t.GetId(), AppId: t.GetAppId(), Type: t.GetAppType(), Name: t.GetName()}
	if secret {
		res.Secret = t.GetSecret()
		if encoder != nil {
			res.Secret = encoder.Encode(res.Secret)
		}
	}
	return res
}