package logic

import (
	"admin/admin"
	"admin/internal/dao"
	"admin/internal/model"
	"admin/internal/svc"
	"admin/validator"
	"context"
	"strconv"
	"time"

	jsoniter "github.com/json-iterator/go"
	"github.com/zeromicro/go-zero/core/logx"
	"pkg.local/modelbase"
	"pkg.local/redis"
	"pkg.local/utils"
)

type AdminLoginLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
	BaseLogic
}

func NewAdminLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminLoginLogic {
	return &AdminLoginLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *AdminLoginLogic) AdminLogin(in *admin.AdminLoginRequest) (*admin.Response, error) {
	l.Logger.Error("u:", in.Username, "p:", in.Password, "|")
	var v validator.LoginValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}

	phone, dErr := utils.EncryptPhone(in.Username)
	if dErr != nil {
		l.Logger.Error(dErr)
		return l.fail(utils.Fail), nil
	}

	var info dao.Admin
	w := modelbase.Params{Eq: map[string]string{"phone": phone}}
	modelObj := model.AdminModel{}.Init()
	err := modelObj.GetOne(w, &info)
	if err != nil {
		l.Logger.Error(err)
		return l.fail(utils.Fail), nil
	}
	if info.Id < utils.NumberOne {
		return l.fail(utils.ErrorNotFund), nil
	}

	pwd := utils.GetSaltPassword(info.Salt, in.Password)
	eq := utils.EqualsPassword(pwd, info.Password)
	if !eq {
		return l.fail(utils.ErrorPwdError), nil
	}

	data := dao.JwtInfo{
		Id:     info.Id,
		Name:   info.Name,
		Email:  info.Email,
		Phone:  info.Phone,
		Avatar: info.Avatar,
		//Roles:    info.Roles,
		LastTime: utils.Now(),
	}
	retData := dao.Token{
		Token: utils.MD5Encrypt(data.Phone + utils.Now().String()),
	}

	l.setLogin(retData.Token, data)

	return l.ok(retData), nil
}

func (l *AdminLoginLogic) setLogin(token string, data dao.JwtInfo) {
	expireMin := utils.GetConfigInt("base.login_out_time")
	var expire time.Duration
	// 默认使用配置时长
	expire = time.Duration(expireMin) * time.Minute
	// 如果用户自定义了过期时间则覆盖
	if data.Time > utils.NumberZero {
		expire = time.Duration(data.Time) * time.Minute
	}

	redisKey := utils.GetLoginKey(utils.LoginTypeAdmin, token)
	l.Logger.Error(redisKey)
	userStr, _ := jsoniter.Marshal(data)
	ctx := context.Background()
	redis.Client.Set(ctx, redisKey, userStr, expire).Result()
	redisKeysKey := utils.GetLoginKeysKey(utils.LoginTypeAdmin)
	oldAuth, oldErr := redis.Client.HGet(ctx, redisKeysKey, strconv.Itoa(int(data.Id))).Result()
	if oldErr == nil {
		redis.Client.Del(ctx, utils.GetLoginKey(utils.LoginTypeAdmin, oldAuth)).Result()
	}
	redis.Client.HSet(ctx, redisKeysKey, strconv.Itoa(int(data.Id)), token).Result()
}