package controller

import (
	"crypto/md5"
	"encoding/hex"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"knowledge/api/dao"
	"knowledge/api/dto"
	"knowledge/api/model"
	"knowledge/api/requests"
	"knowledge/api/responses"
	"knowledge/api/service"
	"knowledge/config"
	"knowledge/global"
	"knowledge/utils"
	"regexp"
	"strconv"
	"strings"
	"time"
)

type AdminUser struct{}

// Login 登陆
func (r *AdminUser) Login(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.Login
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 验证验证码
	if config.C.Env == "prod" {
		isValid := utils.VerifyCaptcha(req.CaptchaId, req.Captcha)
		if !isValid {
			// 验证码错误
			responses.FailWithMessage("验证码错误", c)
			return
		}
	}

	// 登陆
	adminUserService := service.AdminUserService{}
	token, err := adminUserService.Login(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	responses.OkWithData(token, c)
}

// GetAdminUserPage 获取列表-分页
func (r *AdminUser) GetAdminUserPage(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.GetAdminUserPage
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	if req.Page == 0 {
		req.Page = 1
	}

	if req.PageSize == 0 {
		req.PageSize = 20
	}

	adminUserDao := dao.AdminUserDao{}
	adminUser, total, err := adminUserDao.GetAdminUserPageSearch(req, req.Page, req.PageSize)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	g := dto.GetAdminUserListDto(adminUser)

	result := make(map[string]interface{})
	result["page"] = req.Page
	result["page_size"] = req.PageSize
	result["total"] = total
	result["data"] = g
	responses.OkWithData(result, c)
}

// AddAdminUser 新增
func (r *AdminUser) AddAdminUser(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.AddAdminUser
	if err := c.ShouldBindJSON(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		responses.FailWithMessage("数据错误", c)
		return
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil && loginAdminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if loginAdminUser.IsAdmin == 0 {
		responses.FailWithMessage("非管理员用户不可添加", c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 检测账号名
	maps := make(map[string]interface{})
	maps["access"] = req.Access
	maps["is_deleted"] = 0
	adminUser, _ := adminUserDao.GetAdminUser(maps)
	if adminUser != nil {
		tx.Rollback()
		responses.FailWithMessage("账号名重复", c)
		return
	}

	// 检测手机号
	maps = make(map[string]interface{})
	maps["phone"] = req.Phone
	maps["is_deleted"] = 0
	adminUser, _ = adminUserDao.GetAdminUser(maps)
	if adminUser != nil {
		tx.Rollback()
		responses.FailWithMessage("手机号重复", c)
		return
	}

	// 处理密码
	salt := uuid.New().String()
	password := md5.Sum([]byte(req.Password + salt))
	// 将哈希值转换为16进制字符串
	passwordString := hex.EncodeToString(password[:])

	// 新增用户
	AdminUserModel := &model.AdminUser{
		Access:     req.Access,
		Password:   passwordString,
		Salt:       salt,
		NickName:   req.NickName,
		IsAdmin:    req.IsAdmin,
		Status:     *req.Status,
		IsDeleted:  *req.IsDeleted,
		IsDisabled: *req.IsDisabled,
		Phone:      req.Phone,
		Avatar:     utils.RemoveOssDomain(req.Avatar),
		Sex:        req.Sex,
		Email:      req.Email,
	}

	adminUser, err = adminUserDao.AddAdminUser(tx, AdminUserModel)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("新增失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// PutAdminUser 修改用户
func (r *AdminUser) PutAdminUser(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.PutAdminUser
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	id := c.Param("user_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	userId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		responses.FailWithMessage("数据错误", c)
		return
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil && loginAdminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if loginUserId == userId && req.IsDisabled == 1 {
		responses.FailWithMessage("不可把自己置为禁用", c)
		return
	}

	if loginUserId == userId && req.IsDeleted == 1 {
		responses.FailWithMessage("不可把自己置为删除", c)
		return
	}

	if loginUserId != userId && loginAdminUser.IsAdmin != 1 {
		responses.FailWithMessage("非管理员用户只可修改自己数据", c)
		return
	}

	// 获取需修改用户数据
	adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
	if err != nil && adminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if req.Access != adminUser.Access {
		// 检测账号名
		maps := make(map[string]interface{})
		maps["access"] = req.Access
		maps["is_deleted"] = 0
		adminUser, _ = adminUserDao.GetAdminUser(maps)
		if adminUser != nil {
			responses.FailWithMessage("账号名重复", c)
			return
		}

	}

	if req.Phone != adminUser.Phone {
		// 检测手机号
		maps := make(map[string]interface{})
		maps["phone"] = req.Phone
		maps["is_deleted"] = 0
		adminUser, _ = adminUserDao.GetAdminUser(maps)
		if adminUser != nil {
			responses.FailWithMessage("手机号重复", c)
			return
		}
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	data := make(map[string]interface{})
	data["access"] = req.Access
	data["is_deleted"] = req.IsDeleted
	data["is_disabled"] = req.IsDisabled
	data["nick_name"] = req.NickName
	data["is_admin"] = req.IsAdmin
	data["phone"] = req.Phone
	data["avatar"] = req.Avatar
	data["sex"] = req.Sex
	data["email"] = req.Email
	err = adminUserDao.EditAdminUserById(tx, userId, data)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("修改失败", c)
		return
	}

	tx.Commit()

	responses.Ok(c)
}

// PutAdminUserStatus 修改状态
func (r *AdminUser) PutAdminUserStatus(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.PutAdminUserStatus
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	id := c.Param("user_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	userId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		responses.FailWithMessage("数据错误", c)
		return
	}

	if loginUserId == userId {
		responses.FailWithMessage("非法操作，请勿修改自己", c)
		return
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil && loginAdminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if loginAdminUser.IsAdmin != 1 {
		responses.FailWithMessage("非管理员用户不可操作", c)
		return
	}

	// 获取需修改用户数据
	adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
	if err != nil && adminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if adminUser.Status == req.Status {
		responses.Ok(c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	data := make(map[string]interface{})
	data["status"] = req.Status
	err = adminUserDao.EditAdminUserById(tx, userId, data)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("修改失败", c)
		return
	}

	tx.Commit()

	responses.Ok(c)
}

// PutUserDisabled 修改禁用状态
func (r *AdminUser) PutAdminUserDisabled(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.PutAdminUserDisabled
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	id := c.Param("user_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	userId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		responses.FailWithMessage("数据错误", c)
		return
	}

	if loginUserId == userId {
		responses.FailWithMessage("非法操作，请勿修改自己", c)
		return
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil && loginAdminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if loginAdminUser.IsAdmin != 1 {
		responses.FailWithMessage("非管理员用户不可操作", c)
		return
	}

	// 获取需修改用户数据
	adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
	if err != nil && adminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if adminUser.IsDisabled == req.IsDisabled {
		responses.Ok(c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	data := make(map[string]interface{})
	data["is_disabled"] = req.IsDisabled
	err = adminUserDao.EditAdminUserById(tx, userId, data)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("修改失败", c)
		return
	}

	tx.Commit()

	responses.Ok(c)
}

// PutAdminUserPassword 修改用户密码
func (r *AdminUser) PutAdminUserPassword(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.PutAdminUserPassword
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		responses.FailWithMessage("数据错误", c)
		return
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil && loginAdminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if loginAdminUser.IsAdmin != 1 {
		responses.FailWithMessage("非管理员用户只可修改自己数据", c)
		return
	}

	// 获取需修改用户数据
	userId, err := strconv.ParseInt(req.UserId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
	if err != nil || adminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	// 加密旧密码
	newPassword := md5.Sum([]byte(req.NewPassword + adminUser.Salt))
	// 将哈希值转换为16进制字符串
	newPasswordString := hex.EncodeToString(newPassword[:])

	// 检测密码是否相同
	if adminUser.Password == newPasswordString {
		responses.FailWithMessage("新密码请不要和原密码相同", c)
		return
	}

	// 检测旧密码是否正确
	// 检测用户密码
	password := md5.Sum([]byte(req.Password + adminUser.Salt))
	// 将哈希值转换为16进制字符串
	passwordString := hex.EncodeToString(password[:])

	if passwordString != adminUser.Password {
		responses.FailWithMessage("原密码错误，请重新输入", c)
		return
	}

	// 密码校验
	if len(req.NewPassword) < 8 {
		responses.FailWithMessage("密码小于8位数", c)
		return
	}

	num := `[0-9]{1}`
	a_z := `[a-z]{1}`
	A_Z := `[A-Z]{1}`
	symbol := `[!@#.~$%^&*()+|_]{1}`
	if b, err := regexp.MatchString(num, req.NewPassword); !b || err != nil {
		responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
		return
	}
	if b, err := regexp.MatchString(a_z, req.NewPassword); !b || err != nil {
		responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
		return
	}
	if b, err := regexp.MatchString(A_Z, req.NewPassword); !b || err != nil {
		responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
		return
	}
	if b, err := regexp.MatchString(symbol, req.NewPassword); !b || err != nil {
		responses.FailWithMessage("密码强度必须为字⺟⼤⼩写+数字+符号", c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	data := make(map[string]interface{})
	data["password"] = newPasswordString
	err = adminUserDao.EditAdminUserById(tx, userId, data)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("修改失败", c)
		return
	}

	tx.Commit()

	responses.Ok(c)
}

// LoginOut 退出登陆
func (b *AdminUser) LoginOut(c *gin.Context) {
	userId := c.GetInt64("UserId")
	if userId == 0 {
		responses.FailWithMessage("用户错误", c)
		return
	}

	// 获取用户信息
	adminUserDao := dao.AdminUserDao{}
	adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
	if err != nil || adminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	// token加入黑名单
	authorization := c.Request.Header.Get("Authorization")
	if authorization == "" || !strings.HasPrefix(authorization, "Bearer ") {
		responses.FailWithMessage("退出登陆失败", c)
		return
	}

	// 去除Bearer
	authorization = authorization[7:] // 截取字符

	// 增加缓存
	_, err = global.Redis.Set(c, "jwt_black_"+authorization, time.Now().Unix(), 60*time.Second).Result()
	if err != nil {
		responses.FailWithMessage("退出登陆失败", c)
		return
	}

	responses.Ok(c)
}

// DeleteAdminUser 删除用户-批量
func (r *AdminUser) DeleteAdminUser(c *gin.Context) {
	adminUserRequest := requests.AdminUserRequest{}
	req := adminUserRequest.DeleteAdminUser
	if err := c.ShouldBindJSON(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		responses.FailWithMessage("数据错误", c)
		return
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil && loginAdminUser == nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	if loginAdminUser.IsAdmin != 1 {
		responses.FailWithMessage("非管理员用户不可操作", c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	for _, id := range req.UserIds {
		userId, err := strconv.ParseInt(id, 10, 64)
		if err != nil {
			tx.Rollback()
			responses.Fail(c)
			return
		}

		if userId == loginUserId {
			tx.Rollback()
			responses.FailWithMessage("不可把自己删除", c)
			return
		}

		// 检测删除用户
		adminUser, err := adminUserDao.GetAdminUserFirstById(userId)
		if err != nil || adminUser == nil {
			tx.Rollback()
			responses.FailWithMessage("删除失败", c)
			return
		}

		// 删除用户
		data := make(map[string]interface{})
		data["is_deleted"] = 1
		err = adminUserDao.EditAdminUserById(tx, userId, data)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("修改失败", c)
			return
		}
	}

	tx.Commit()

	responses.Ok(c)
}