package service

import (
	"ai-gateway/common/constant"
	"ai-gateway/common/dto"
	"ai-gateway/common/utils"
	"ai-gateway/infrastructure/redis"
	"ai-gateway/infrastructure/repository"
	"code.freebrio.com/fb-go/lib/context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"github.com/google/uuid"
	"github.com/labstack/echo/v4"
	"strings"
	"time"
)

type login struct {
}

var Login login

func (l login) Login(ctx context.GormWithZap, req dto.ThirdLoginReq) (string, error) {
	//1. 验证账号密码
	h := sha256.Sum256([]byte(req.Password))
	passHash := hex.EncodeToString(h[:])

	acUser := repository.ThirdCorpUserAccount.FindThirdAccountBy(ctx, req.BizId, req.CorpID, req.Account)
	if acUser == nil || acUser.Deleted == 1 {
		return "", errors.New("user not exist")
	}
	if passHash != acUser.Pwd {
		return "", errors.New("password is error")
	}

	//生成token
	token := uuid.New().String()
	token = strings.ReplaceAll(token, "-", "")
	var thirdUserToken = repository.FThirdUserTokenDO{
		CorpId:      req.CorpID,
		BizId:       req.BizId,
		CorpUid:     acUser.Id,
		AccessToken: token,
		ExpireTime:  time.Now().Add(time.Duration(24*365*100) * time.Hour).UnixMilli(),
	}

	loginUserToken := repository.ThirdUserToken.FindByBizAndCorpId(ctx, req.BizId, acUser.Id)
	if loginUserToken == nil {
		repository.ThirdUserToken.SaveUserLoginToken(ctx, &thirdUserToken)
		return l.GenAccessToken(&thirdUserToken), nil
	}

	loginUserToken.AccessToken = thirdUserToken.AccessToken
	loginUserToken.ExpireTime = thirdUserToken.ExpireTime
	repository.ThirdUserToken.UpdateUserLoginToken(ctx, loginUserToken)
	return l.GenAccessToken(loginUserToken), nil
}

func (l login) GetLoginResult(ctx context.GormWithZap, c *echo.Context) *dto.ThirdUserLoginToken {
	accessToken := utils.GetAccessToken(c)
	if accessToken == "" {
		return nil
	}

	thirdLoginToken := l.ParseThirdUserLoginTokenByToken(accessToken)
	if thirdLoginToken == nil {
		return nil
	}

	//redis
	redisStr, err := redis.Get(constant.THIRD_LOGIN_TOKEN + thirdLoginToken.AccessToken)
	if err != nil && redisStr != "" {
		var loginInfo dto.ThirdUserLoginToken
		if redisErr := json.Unmarshal([]byte(redisStr), &loginInfo); redisErr == nil {
			return &loginInfo
		}
	}

	//repository
	dbData := repository.ThirdUserToken.FindByToken(ctx, thirdLoginToken.AccessToken)
	if dbData == nil {
		return nil
	}

	var finalData = dto.ThirdUserLoginToken{
		CorpId:      dbData.CorpId,
		BizId:       dbData.BizId,
		Uid:         dbData.CorpUid,
		AccessToken: l.GenAccessToken(dbData),
	}

	//save into redis
	if bytes, saveErr := json.Marshal(finalData); saveErr == nil {
		redis.Set(constant.THIRD_LOGIN_TOKEN+accessToken, string(bytes), time.Duration(6)*time.Hour)
	}

	return &finalData
}

func (login) ParseThirdUserLoginTokenByToken(accessToken string) *dto.ThirdUserLoginToken {
	splits := strings.Split(accessToken, "_")
	if len(splits) != 4 {
		return nil
	}

	return &dto.ThirdUserLoginToken{
		CorpId:      utils.ToUint64(splits[0]),
		BizId:       utils.ToUint64(splits[1]),
		Uid:         utils.ToUint64(splits[2]),
		AccessToken: splits[3],
	}
}

func (login) GenAccessToken(data *repository.FThirdUserTokenDO) string {
	var buf strings.Builder
	buf.WriteString(utils.ToString(data.CorpId))
	buf.WriteString("_")
	buf.WriteString(utils.ToString(data.BizId))
	buf.WriteString("_")
	buf.WriteString(utils.ToString(data.CorpUid))
	buf.WriteString("_")
	buf.WriteString(data.AccessToken)
	return buf.String()
}