package user

import (
	"fmt"
	"git.echol.cn/loser/lckt/global"
	r "git.echol.cn/loser/lckt/model/common/response"
	"git.echol.cn/loser/lckt/model/user/request"
	"git.echol.cn/loser/lckt/utils"
	"git.echol.cn/loser/lckt/utils/user_jwt"
	"git.echol.cn/loser/lckt/utils/wechat"
	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
	"go.uber.org/zap"
	"time"
)

type APPUserApi struct{}

// SendCode 发送验证码
func (*APPUserApi) SendCode(ctx *gin.Context) {
	var p request.SendCodeReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,发送验证码失败", zap.Error(err))
		return
	}
	if err := userService.SendCode(p); err != nil {
		r.FailWithMessage("发送验证码失败", ctx)
		return
	}

	r.OkWithMessage("发送验证码成功", ctx)
}

// Login 用户登录
func (*APPUserApi) Login(ctx *gin.Context) {
	var p request.CodeLoginReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,登录失败", zap.Error(err))
		return
	}

	if result, _ := global.GVA_REDIS.Get(ctx, fmt.Sprintf("VerifyCode:%s", p.Phone)).Result(); result != p.Code {
		global.GVA_LOG.Error("验证码错误", zap.String("phone", p.Phone))
		r.FailWithMessage("验证码错误", ctx)
		return
	}

	user, err := userService.Login(p)
	if err != nil {
		r.FailWithMessage("登录失败", ctx)
		return
	}

	// 生成token
	token, claims, err := user_jwt.LoginToken(user)
	if err != nil {
		global.GVA_LOG.Error("获取token失败!", zap.Error(err))
		r.FailWithMessage("获取token失败", ctx)
		return
	}

	if _, err = global.GVA_REDIS.Get(ctx, user.Phone).Result(); err == redis.Nil {
		// 此处过期时间等于jwt过期时间
		dr, err := utils.ParseDuration(global.GVA_CONFIG.JWT.ExpiresTime)
		if err != nil {
			return
		}
		timer := dr
		if err := global.GVA_REDIS.Set(ctx, user.Phone, token, timer).Err(); err != nil {
			global.GVA_LOG.Error("设置登录状态失败!", zap.Error(err))
			r.FailWithMessage("设置登录状态失败", ctx)
			return
		}
		user_jwt.SetToken(ctx, token, int(claims.RegisteredClaims.ExpiresAt.Unix()-time.Now().Unix()))
		r.OkWithDetailed(gin.H{
			"User":      user,
			"Token":     token,
			"ExpiresAt": claims.RegisteredClaims.ExpiresAt.Unix() * 1000,
		}, "登录成功", ctx)
	} else if err != nil {
		global.GVA_LOG.Error("设置登录状态失败!", zap.Error(err))
		r.FailWithMessage("设置登录状态失败", ctx)
	}
}

// WechatLogin 微信登录
func (*APPUserApi) WechatLogin(ctx *gin.Context) {
	var p request.CodeLoginReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,登录失败", zap.Error(err))
		return
	}

	//Todo 待完善微信登录
	info := wechat.GetUserInfo(p.Code)
	if info == nil {
		r.FailWithMessage("获取用户信息失败", ctx)
		return
	}

	user, err := userService.WechatLogin(info)
	if err != nil {
		r.FailWithMessage("登录失败", ctx)
		return
	}
	// 生成token
	token, claims, err := user_jwt.LoginToken(user)
	if err != nil {
		global.GVA_LOG.Error("获取token失败!", zap.Error(err))
		r.FailWithMessage("获取token失败", ctx)
		return
	}
	if _, err = global.GVA_REDIS.Get(ctx, user.Phone).Result(); err == redis.Nil {
		// 此处过期时间等于jwt过期时间
		dr, err := utils.ParseDuration(global.GVA_CONFIG.JWT.ExpiresTime)
		if err != nil {
			return
		}
		timer := dr
		if err := global.GVA_REDIS.Set(ctx, user.Phone, token, timer).Err(); err != nil {
			global.GVA_LOG.Error("设置登录状态失败!", zap.Error(err))
			r.FailWithMessage("设置登录状态失败", ctx)
			return
		}
		user_jwt.SetToken(ctx, token, int(claims.RegisteredClaims.ExpiresAt.Unix()-time.Now().Unix()))
		r.OkWithDetailed(gin.H{
			"User":      user,
			"Token":     token,
			"ExpiresAt": claims.RegisteredClaims.ExpiresAt.Unix() * 1000,
		}, "登录成功", ctx)
	}
}

// GetUserList 获取用户列表
func (*APPUserApi) GetUserList(ctx *gin.Context) {
	var p request.GetUserListReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,获取用户列表失败", zap.Error(err))
		return
	}
	userList, total, err := userService.GetUserList(p)
	if err != nil {
		r.FailWithMessage("获取用户列表失败", ctx)
		return
	}
	r.OkWithDetailed(r.PageResult{
		List:     userList,
		Total:    total,
		Page:     p.Page,
		PageSize: p.PageSize,
	}, "获取用户列表成功", ctx)
}

// SetBalance 设置用户余额
func (*APPUserApi) SetBalance(ctx *gin.Context) {
	var p request.SetBalanceReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,设置用户余额失败", zap.Error(err))
		return
	}
	if err := userService.SetBalance(p); err != nil {
		r.FailWithMessage("设置用户余额失败", ctx)
		return
	}
	r.OkWithMessage("设置用户余额成功", ctx)
}

// PwdLogin 密码登录
func (*APPUserApi) PwdLogin(ctx *gin.Context) {
	var p request.PwdLoginReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,登录失败", zap.Error(err))
		return
	}

	user, err := userService.PwdLogin(p)
	if err != nil {
		r.FailWithMessage("手机号或密码错误！", ctx)
		return
	}

	// 生成token
	token, claims, err := user_jwt.LoginToken(user)
	if err != nil {
		global.GVA_LOG.Error("获取token失败!", zap.Error(err))
		r.FailWithMessage("获取token失败", ctx)
		return
	}

	// 此处过期时间等于jwt过期时间
	dr, err := utils.ParseDuration(global.GVA_CONFIG.JWT.ExpiresTime)
	if err != nil {
		return
	}
	timer := dr
	if err := global.GVA_REDIS.Set(ctx, user.Phone, token, timer).Err(); err != nil {
		global.GVA_LOG.Error("设置登录状态失败!", zap.Error(err))
		r.FailWithMessage("设置登录状态失败", ctx)
		return
	}
	user_jwt.SetToken(ctx, token, int(claims.RegisteredClaims.ExpiresAt.Unix()-time.Now().Unix()))
	r.OkWithDetailed(gin.H{
		"User":      user,
		"Token":     token,
		"ExpiresAt": claims.RegisteredClaims.ExpiresAt.Unix() * 1000,
	}, "登录成功", ctx)
}

// Register 注册-后台用
func (*APPUserApi) Register(ctx *gin.Context) {
	var p request.RegisterReq
	if err := ctx.ShouldBind(&p); err != nil {
		r.FailWithMessage(err.Error(), ctx)
		global.GVA_LOG.Error("参数错误,注册失败", zap.Error(err))
		return
	}

	if err := userService.Register(p); err != nil {
		r.FailWithMessage("注册失败", ctx)
		return
	}

	r.OkWithMessage("注册成功", ctx)
}

// SetUserStatus 设置用户状态
func (*APPUserApi) SetUserStatus(ctx *gin.Context) {
	id := ctx.Param("id")
	if id == "" {
		r.FailWithMessage("参数错误", ctx)
		return
	}

	if err := userService.SetUserStatus(id); err != nil {
		r.FailWithMessage("设置用户状态失败", ctx)
		return
	}
	r.OkWithMessage("设置用户状态成功", ctx)
}

// GetUserById 根据id获取用户信息
func (*APPUserApi) GetUserById(ctx *gin.Context) {
	id := ctx.Param("id")
	if id == "" {
		r.FailWithMessage("参数错误", ctx)
		return
	}
	user, err := userService.GetUserById(id)
	if err != nil {
		r.FailWithMessage("获取用户信息失败", ctx)
		return
	}
	r.OkWithDetailed(user, "获取用户信息成功", ctx)
}