package user

import (
	"authService/model"
	"authService/response"
	"authService/service/role"
	"authService/util"
	"authService/validators"
	"errors"

	jsoniter "github.com/json-iterator/go"
	"github.com/samber/lo"
	"gorm.io/gorm"
)

var json = jsoniter.ConfigCompatibleWithStandardLibrary

// 获取用户信息
func Find(id int64) (*model.User, *response.ErrCode) {
	var user model.User
	err := model.DB.Where("id = ?", id).Preload("Roles").First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, &response.ErrCode{
				Code: response.DATA_NOT_FOUND,
				Msg:  "用户不存在",
			}
		}
		return nil, response.Err
	}
	return &user, nil
}

// 根据账号查找
func FindByAccount(account string) *model.User {
	var existUser *model.User
	model.DB.Where("account = ?", account).Preload("Roles").First(&existUser)
	return existUser
}

// 创建账号
func Create(user *validators.User, password string) *response.ErrCode {
	status := model.UserStatusDisable
	if user.Status != 0 {
		status = user.Status
	}
	if ExistUserAccount(user.Account, 0) {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "账户名已存在",
		}
	}

	var createUser = &model.User{
		Account:  user.Account,
		Nickname: user.Nickname,
		Status:   status,
		Password: password,
	}

	// 创建
	err := model.DB.Create(&createUser).Error
	if err != nil {
		return response.Err
	}

	// 创建用户角色
	var roles = make([]*model.UserRole, 0)
	for _, roleId := range user.RoleIds {
		roles = append(roles, &model.UserRole{
			UserId: createUser.ID,
			RoleId: roleId,
		})

	}
	model.DB.CreateInBatches(roles, 100)

	return nil
}

// 修改账号
func Update(user *validators.User, password string) *response.ErrCode {
	existsUser, findErr := Find(user.ID)
	if findErr != nil {
		return findErr
	}
	if existsUser.IsSuper == model.UserIsSuperTrue {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "该用户禁止被修改",
		}
	}
	// 更新
	err := model.DB.Where("id = ?", user.ID).Updates(&model.User{
		Nickname: user.Nickname,
		Status:   user.Status,
		Password: password,
	}).Error
	if err != nil {
		return response.Err
	}

	// 删除用户角色
	model.DB.Where("user_id = ?", user.ID).Delete(&model.UserRole{})
	// 创建用户角色
	var roles = make([]*model.UserRole, 0)
	for _, roleId := range user.RoleIds {
		roles = append(roles, &model.UserRole{
			UserId: user.ID,
			RoleId: roleId,
		})

	}

	model.DB.CreateInBatches(roles, 100)

	// 移除登录缓存
	Logout(user.ID)

	return nil
}

// 修改备注信息
func UpdateRemark(id int64, remark string) *response.ErrCode {
	existsUser, findErr := Find(id)
	if findErr != nil {
		return findErr
	}
	if existsUser.IsSuper == model.UserIsSuperTrue {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "该用户禁止被修改",
		}
	}

	// 更新
	err := model.DB.Where("id = ?", id).Update("remark", remark).Error
	if err != nil {
		return response.Err
	}

	return nil
}

// 修改或创建
func UpdateOrCreate(user *validators.User, password string) *response.ErrCode {
	if password != "" {
		password = util.Md5(password)
	}
	var err *response.ErrCode
	if user.ID != 0 {
		err = Update(user, password)
	} else {
		err = Create(user, password)
	}

	return err
}

// 检查账户名是否重复
func ExistUserAccount(account string, userId int64) bool {
	var existUser *model.User
	model.DB.Where("account = ?", account).First(&existUser)
	if existUser != nil {
		if existUser.ID != 0 && existUser.ID != userId {
			return true
		}
	}
	return false
}

// 修改自己的信息
func UpdateMySelf(user *validators.User, oldPassword string, password string, userId int64) *response.ErrCode {
	if password != "" {
		password = util.Md5(password)
		if oldPassword == "" {
			return &response.ErrCode{
				Code: response.ERROR,
				Msg:  "请输入原密码",
			}
		}
		oldPassword = util.Md5(oldPassword)
	}
	existsUser, findErr := Find(userId)
	if findErr != nil {
		return findErr
	}
	// 如果不是超级管理员，禁止被修改账户名
	if existsUser.IsSuper == model.UserIsSuperFalse {
		user.Account = ""
	}

	// 检查原密码是否正确
	if oldPassword != existsUser.Password {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "原密码不正确",
		}
	}

	// 检查账户名是否重复
	if user.Account != "" && ExistUserAccount(user.Account, userId) {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "账户名已存在",
		}
	}

	// 更新
	err := model.DB.Where("id = ?", userId).Updates(&model.User{
		Account:  user.Account,
		Nickname: user.Nickname,
		Password: password,
	}).Error
	if err != nil {
		return response.Err
	}

	return nil
}

// 删除
func Delete(id int64) *response.ErrCode {

	existsUser, findErr := Find(id)
	if findErr != nil {
		return findErr
	}

	if existsUser.IsSuper == model.UserIsSuperTrue {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "该用户禁止被修改",
		}
	}

	model.DB.Where("id = ?", id).Delete(&model.User{})

	// 移除登录缓存
	Logout(id)

	return nil
}

// 获取分页列表
func Paginate(page, pageSize int, key string) (list []*model.User, total int64) {
	query := model.DB.Model(&model.User{}).Where("is_super = ?", model.UserIsSuperFalse)
	if key != "" {
		query = query.Where("account like ? or nickname like ?", "%"+key+"%", "%"+key+"%")
	}
	query.Count(&total)
	query.Scopes(model.Paginate(page, pageSize)).Preload("Roles").Order("id desc").Find(&list)
	return list, total
}

// 格式化用户
func Format(user *model.User) *validators.User {
	var roleIds = make([]int64, 0)
	var roles = make([]*validators.Role, 0)
	var permissions = make([]string, 0)
	for _, currentRole := range user.Roles {
		roleIds = append(roleIds, currentRole.ID)
		formatedRole := role.FormatRole(&currentRole)
		roles = append(roles, formatedRole)
		permissions = append(permissions, formatedRole.Permissions...)
	}
	permissions = lo.Uniq(permissions)
	return &validators.User{
		ID:          user.ID,
		Account:     user.Account,
		Nickname:    user.Nickname,
		Status:      user.Status,
		IsSuper:     user.IsSuper,
		Permissions: permissions,
		RoleIds:     roleIds,
		Roles:       roles,
		Remark:      user.Remark,
	}
}