package logic

import (
	"context"
	"lone-services/pkg/redis"
	"lone-services/pkg/utils"
	user "lone-services/rpc/user/pb"
	"lone-services/services/user/internal/dao"
	"strconv"
	"time"

	jsoniter "github.com/json-iterator/go"
)

func okResponse(data any) *user.Response {
	buf, _ := jsoniter.Marshal(data)
	return &user.Response{
		Code: utils.Ok.Code,
		Msg:  utils.Ok.Msg,
		Data: string(buf),
	}
}

func failResponse(status utils.Status) *user.Response {
	return &user.Response{
		Code: status.Code,
		Msg:  status.Msg,
	}
}

func outResponse(status utils.Status, msg string) *user.Response {
	return &user.Response{
		Code: status.Code,
		Msg:  msg,
	}
}

func decryptMobile(mobile string) string {
	if mobile == utils.StringEmpty {
		return utils.StringEmpty
	}
	plain, err := utils.Crypto{}.AESDecryptECB(mobile)
	if err != nil {
		return utils.StringEmpty
	}
	return plain
}

func toSession(info dao.UserInfo, mobilePlain string) dao.UserLoginSession {
	return dao.UserLoginSession{
		Id:       info.Id,
		Openid:   info.Openid,
		Username: info.Username,
		Nickname: info.Nickname,
		Avatar:   info.Avatar,
		Mobile:   mobilePlain,
		Gender:   info.Gender,
		Birthday: info.Birthday,
		Type:     info.Type,
		Account:  info.Account,
		AppId:    info.AppId,
		LastTime: utils.Now(),
	}
}

func buildToken(session dao.UserLoginSession) dao.Token {
	seed := session.Mobile + session.Openid + utils.Now().String()
	token := utils.MD5Encrypt(seed)
	return dao.Token{
		Token:   token,
		Refresh: utils.MD5Encrypt(seed + token),
		Info:    session,
	}
}

func setLogin(token, refresh string, session dao.UserLoginSession) utils.Status {
	expireMin := utils.GetConfigInt("base.login_out_time")
	expire := time.Duration(expireMin) * time.Minute
	refreshMin := utils.GetConfigInt("base.login_refresh_out_time")
	refreshExpire := time.Duration(refreshMin) * time.Minute

	ctx := context.Background()
	userStr, _ := jsoniter.Marshal(session)

	redisKey := utils.GetLoginKey(utils.LoginTypeUser, token)
	if err := redis.Client.Set(ctx, redisKey, userStr, expire).Err(); err != nil {
		return utils.Fail
	}

	redisKeysKey := utils.GetLoginKeysKey(utils.LoginTypeUser, strconv.FormatInt(session.Id, utils.NumberTen))
	var loginInfo utils.LoginRedis
	if oldAuth, err := redis.Client.Get(ctx, redisKeysKey).Result(); err == nil {
		_ = jsoniter.Unmarshal([]byte(oldAuth), &loginInfo)
		if len(loginInfo.Token) > utils.NumberOne {
			redis.Client.Del(ctx, utils.GetLoginKey(utils.LoginTypeUser, loginInfo.Token))
		}
		if len(loginInfo.Refresh) > utils.NumberOne {
			redis.Client.Del(ctx, utils.GetLoginRefreshKey(utils.LoginTypeUser, loginInfo.Refresh))
		}
	}

	loginInfo.Token = token
	loginInfo.Refresh = refresh
	loginInfo.Info = userStr
	newStr, _ := jsoniter.Marshal(loginInfo)
	if err := redis.Client.Set(ctx, redisKeysKey, newStr, refreshExpire).Err(); err != nil {
		return utils.Fail
	}
	refreshKey := utils.GetLoginRefreshKey(utils.LoginTypeUser, refresh)
	if err := redis.Client.Set(ctx, refreshKey, strconv.FormatInt(session.Id, utils.NumberTen), refreshExpire).Err(); err != nil {
		return utils.Fail
	}
	return utils.Ok
}