package logic

import (
	"context"
	"strconv"
	"time"

	"lone-services/pkg/redis"
	"lone-services/pkg/utils"
	user "lone-services/rpc/user/pb"
	"lone-services/services/user/internal/config"
	"lone-services/services/user/internal/dao"

	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.DecryptPhone(mobile)
	if err != nil {
		return utils.StringEmpty
	}
	return plain
}

func subjectTypeToUserType(subjectType string) uint8 {
	switch subjectType {
	case dao.SubjectTypeSale:
		return dao.TypeSale
	case dao.SubjectTypeStore:
		return dao.TypeStore
	case dao.SubjectTypeUser:
		return dao.TypeUser
	default:
		return dao.TypeUser
	}
}

func toSession(info dao.UserRow, mobilePlain string, client *dao.Client, saleId int64) dao.UserLoginSession {
	userType := dao.TypeUser
	clientCode := utils.StringEmpty
	if client != nil {
		clientCode = client.Code
		userType = subjectTypeToUserType(client.SubjectType)
	}
	return dao.UserLoginSession{
		Id:         info.Id,
		Name:       info.Name,
		Avatar:     info.Avatar,
		Mobile:     mobilePlain,
		Gender:     info.Gender,
		Birthday:   info.Birthday.DateString(),
		Type:       userType,
		ClientCode: clientCode,
		SaleId:     saleId,
	}
}

func sessionClaims(session dao.UserLoginSession, tokenType string) utils.Claims {
	return utils.Claims{
		UserID:     session.Id,
		Name:       session.Name,
		Avatar:     session.Avatar,
		Mobile:     session.Mobile,
		Gender:     session.Gender,
		Birthday:   session.Birthday,
		Type:       session.Type,
		ClientCode: session.ClientCode,
		SaleId:     session.SaleId,
		StoreId:    session.StoreId,
		TokenType:  tokenType,
	}
}

func buildJwtToken(jwtAuth *config.JWTAuth, session dao.UserLoginSession) (dao.Token, error) {
	accessToken, err := jwtAuth.Access.Sign(sessionClaims(session, utils.TokenTypeAccess))
	if err != nil {
		return dao.Token{}, err
	}
	refreshToken, err := jwtAuth.Refresh.Sign(sessionClaims(session, utils.TokenTypeRefresh))
	if err != nil {
		return dao.Token{}, err
	}
	return dao.Token{
		AccessToken:  accessToken,
		RefreshToken: refreshToken,
		Info:         session,
	}, nil
}

func setLogin(jwtAuth *config.JWTAuth, accessToken, refreshToken string, session dao.UserLoginSession) utils.Status {
	accessExpire := time.Duration(jwtAuth.Access.TTL) * time.Second
	refreshExpire := time.Duration(jwtAuth.Refresh.TTL) * time.Second

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

	redisKey := utils.GetLoginKey(utils.LoginTypeUser, accessToken)
	if err := redis.Client.Set(ctx, redisKey, userStr, accessExpire).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 = accessToken
	loginInfo.Refresh = refreshToken
	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, refreshToken)
	if err := redis.Client.Set(ctx, refreshKey, strconv.FormatInt(session.Id, utils.NumberTen), refreshExpire).Err(); err != nil {
		return utils.Fail
	}
	return utils.Ok
}