package controllers

import (
	"github.com/beego/beego/v2/server/web/context"
	"github.com/linmadan/egglib-go/web/beego"
	"github.com/linmadan/egglib-go/web/beego/utils"
	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/constant"
	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/api/authlib"
	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/cache"
	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
	"net/http"
	"strconv"
	"strings"
)

func ResponseGrid(c beego.BaseController, total int64, data interface{}, err error) {
	var response utils.JsonResponse
	if err != nil {
		response = utils.ResponseError(c.Ctx, err)
	} else {
		response = ResponseGridData(c.Ctx, total, data)
	}
	c.Data["json"] = response
	c.ServeJSON()
}

func ResponseGridData(ctx *context.Context, total int64, data interface{}) utils.JsonResponse {
	jsonResponse := utils.JsonResponse{}
	jsonResponse["code"] = 0
	jsonResponse["msg"] = "ok"
	jsonResponse["data"] = map[string]interface{}{"grid": map[string]interface{}{
		"total": total,
		"list":  data,
	}}
	ctx.Input.SetData("outputData", jsonResponse)
	return jsonResponse
}

func Must(err error) {
	if err != nil {
		log.Logger.Error(err.Error())
	}
}

func ParseAppKey(c beego.BaseController) string {
	appKey := c.Ctx.Input.GetData("AppKey")
	if appKey == nil {
		return ""
	}
	return appKey.(string)
}

func ParseAccessToken(c beego.BaseController) string {
	token := c.Ctx.Input.GetData("Accesstoken")
	if token == nil {
		return ""
	}
	return token.(string)
}

func ParseContext(c beego.BaseController) *domain.Context {
	var companyId int = 1598224576532189184
	var userId int = 1
	var userName string = "管理员"
	if token := c.Ctx.Input.GetData("UserToken"); token != nil {
		userToken, ok := token.(*domain.UserToken)
		if ok {
			// cache user info
			key := cache.KeyCompanyUser(int(userToken.CompanyId), int(userToken.UserId))
			if userToken.CheckUserInfo() {
				if cacheItem, ok := cache.DefaultCache.Get(key); ok {
					v := cacheItem.(*authlib.DataUserMe)
					userName = v.User.NickName
				} else {
					//requestToken, _ := userToken.GenerateToken()
					requestToken, ok := c.Ctx.Input.GetData("Accesstoken").(string)
					if !ok {
						goto END
					}
					authLib := authlib.NewApiAuthLib(constant.AUTH_SERVER_HOST).WithToken(requestToken)
					userInfo, err := authLib.MeInfo(authlib.RequestUserMeQuery{
						UserId:    int(userToken.UserId),
						CompanyId: int(userToken.CompanyId),
					})
					if err != nil || userInfo == nil || userInfo.User == nil {
						goto END
					}
					userName = userInfo.User.NickName
					cache.DefaultCache.SetDefault(key, userInfo)
				}
			}
			// assign user
			companyId = int(userToken.CompanyId)
			userId = int(userToken.UserId)
		}
	}
END:
	ctx := &domain.Context{
		CompanyId:    companyId,
		OperatorId:   userId,
		OperatorName: userName,
		AccessToken:  ParseAccessToken(c),
		TenantId:     1,
	}
	return ctx
}

func header(c beego.BaseController, key string) int {
	if len(c.Ctx.Input.Header(key)) == 0 {
		return 0
	}
	res, err := strconv.Atoi(c.Ctx.Input.Header(key))
	if err != nil {
		log.Logger.Error(err.Error())
		return 0
	}
	return res
}

var BlacklistRouters = map[string]bool{
	"/data/files":                  true,
	"/data/edit-data-table":        true,
	"/data/flush-data-table":       true,
	"/data/generate-main-table":    true,
	"/data/append-data-to-table":   true,
	"/data/tables/copy-data-table": true,
	"/data/tables/apply-on":        true,
	"/data/tables/add-sub-table":   true,
	"/data/tables/row-edit":        true,
	"/data/mapping-rules":          true,

	"/data/query-sets":               true,
	"/data/query-sets/copy":          true,
	"/data/query-sets/move":          true,
	"/data/query-sets/rename":        true,
	"/data/query-sets/change-status": true,

	"/data/query-sets/formula":               true,
	"/data/query-sets/formula/change-status": true,
	"/data/query-sets/formula/move":          true,
	"/data/query-sets/formula/copy":          true,
	"/data/query-sets/formula/rename":        true,
}

func BlacklistFilter(black map[string]bool) func(ctx *context.Context) {
	return func(ctx *context.Context) {
		if token := ctx.Input.GetData("UserToken"); token != nil {
			userToken, ok := token.(*domain.UserToken)
			if !ok {
				return
			}
			if userToken.UserId > 0 && userToken.UserId == constant.BLACK_LIST_USER {
				goto CheckBlackList
			} else if userToken.CompanyId > 0 && userToken.UserId == 0 && userToken.CompanyId == constant.BLACK_LIST_COMPANY {
				goto CheckBlackList
			} else {
				return
			}
		CheckBlackList:
			var notAllow = false
			defer func() {
				if notAllow {
					ctx.Output.SetStatus(http.StatusOK)
					ctx.Output.JSON(map[string]interface{}{
						"msg":  "测试账户不允许修改数据",
						"code": 801,
						"data": struct{}{},
					}, false, false)
				}
			}()
			if ctx.Request.Method == http.MethodDelete || ctx.Request.Method == http.MethodPut {
				notAllow = true
				return
			}
			url := ctx.Request.URL.Path
			if v, ok := black[url]; ok && v {
				notAllow = true
				return
			}
			if strings.HasSuffix(url, "/") {
				url = strings.TrimSuffix(url, "/")
			}
			if v, ok := black[url]; ok && v {
				notAllow = true
				return
			}
		}
	}
}