package agency

import (
	"errors"
	"reflect"

	"gitee.com/jackly-chao/joy-admin-server/src/global"
	"gitee.com/jackly-chao/joy-admin-server/src/global/request"
	"gitee.com/jackly-chao/joy-admin-server/src/model/agency"
	"gitee.com/jackly-chao/joy-admin-server/src/util"
	"gorm.io/gorm"
)

type UserService struct{}

func (s *UserService) Login(request agency.LoginRequest) (userInfo agency.LoginUserInfo, token string, err error) {
	if request.UserName == "" {
		err = errors.New("用户名不可为空")
		return
	}
	if request.Password == "" {
		err = errors.New("密码不可为空")
		return
	}
	if request.Captcha == "" {
		err = errors.New("验证码不可为空")
		return
	}
	if request.CaptchaId == "" {
		err = errors.New("验证码Id不可为空")
		return
	}
	if !util.CheckCaptcha(request.CaptchaId, request.Captcha) {
		err = errors.New("验证码不正确")
		return
	}
	db := global.DbMap[dbName].Model(&agency.User{})
	var user agency.User
	err = db.Where("user_name = ?", request.UserName).Preload("Menu").First(&user).Error
	if errors.Is(err, gorm.ErrRecordNotFound) {
		err = errors.New("用户名不正确")
		return
	}
	if !*user.IsEnable {
		err = errors.New("用户禁止登录")
		return
	}
	if user.Password != request.Password {
		err = errors.New("密码不正确")
		return
	}
	claim := util.Claim{
		Id:       user.Id,
		UserName: user.UserName,
		Name:     user.Name,
	}
	token, err = util.CreateToken(claim)
	if err != nil {
		return
	}
	userInfo = agency.LoginUserInfo{
		Id:       user.Id,
		UserName: user.UserName,
		Name:     user.Name,
		Menu:     user.Menu,
	}
	return
}

func (s *UserService) GetUser(request request.IdRequest) (result agency.User, err error) {
	err = global.DbMap[dbName].Preload("Roles").Preload("Menu").First(&result, request.Id).Error
	return
}

func (s *UserService) GetUsers(request agency.UserRequest) (result []agency.User, total int64, err error) {
	db := global.DbMap[dbName].Model(&agency.User{})
	handleUserRequest(db, request)
	err = db.Count(&total).Error
	if err != nil {
		return
	}
	db = db.Limit(request.PageSize).Offset(request.PageSize * (request.Page - 1))
	db = db.Preload("Roles")
	db = db.Preload("Menu")
	err = db.Find(&result).Error
	return
}

func (s *UserService) GetAllUsers(request agency.UserRequest) (result []agency.User, err error) {
	db := global.DbMap[dbName].Model(&agency.User{})
	handleUserRequest(db, request)
	db = db.Preload("Roles")
	db = db.Preload("Menu")
	err = db.Find(&result).Error
	return
}

func (s *UserService) CreateUser(request agency.User) (result agency.User, err error) {
	err = checkAddOrModUser(request)
	if err != nil {
		return
	}
	roleIds := request.RoleIds
	err = global.DbMap[dbName].Omit("Menu").Create(&request).Error
	if err != nil {
		return
	}
	var roles []agency.Role
	global.DbMap[dbName].Model(&roles).Where("id in ?", roleIds).Find(&roles)
	err = global.DbMap[dbName].Model(&request).Association("Roles").Replace(roles)
	if err != nil {
		err = errors.New("新增用户角色失败")
		return
	}
	return request, err
}

func (s *UserService) UpdateUser(request agency.User) (result agency.User, err error) {
	err = checkAddOrModUser(request)
	if err != nil {
		return
	}
	roleIds := request.RoleIds
	err = global.DbMap[dbName].Omit("Menu").Save(&request).Error
	if err != nil {
		return
	}
	var roles []agency.Role
	global.DbMap[dbName].Model(&roles).Where("id in ?", roleIds).Find(&roles)
	err = global.DbMap[dbName].Model(&request).Association("Roles").Replace(roles)
	if err != nil {
		err = errors.New("修改用户角色失败")
		return
	}
	return request, err
}

func (s *UserService) DeleteUsers(request request.IdsRequest) (err error) {
	err = global.DbMap[dbName].Delete(&agency.User{}, request.Ids).Error
	return
}

func (s *UserService) SwitchUsers(request request.SwitchRequest) (err error) {
	err = global.DbMap[dbName].Model(&agency.User{}).Where("id in ?", request.Ids).Update("is_enable", request.IsEnable).Error
	return
}

func handleUserRequest(db *gorm.DB, request agency.UserRequest) {
	if request.Name != "" {
		db = db.Where("name Like ?", "%"+request.Name+"%")
	}
	if !reflect.ValueOf(request.IsEnable).IsNil() {
		db = db.Where("is_enable = ?", request.IsEnable)
	}
	if !reflect.ValueOf(request.MenuId).IsNil() {
		db = db.Where("menu_id = ?", request.MenuId)
	}
	if !reflect.ValueOf(request.AgencyId).IsNil() {
		db = db.Where("agency_id = ?", request.AgencyId)
	}
	if !reflect.ValueOf(request.PaymentAccountId).IsNil() {
		db = db.Where("payment_account_id = ?", request.PaymentAccountId)
	}
	if !reflect.ValueOf(request.EnterpriseCodeEmployeeId).IsNil() {
		db = db.Where("enterprise_code_employee_id = ?", request.EnterpriseCodeEmployeeId)
	}
	if !reflect.ValueOf(request.IsProcessPassportTicket).IsNil() {
		db = db.Where("is_process_passport_ticket = ?", request.IsProcessPassportTicket)
	}
	if !reflect.ValueOf(request.IsProcessOrdinaryTicket).IsNil() {
		db = db.Where("is_process_ordinary_ticket = ?", request.IsProcessOrdinaryTicket)
	}
	if !reflect.ValueOf(request.IsProcessRescheduleTicket).IsNil() {
		db = db.Where("is_process_reschedule_ticket = ?", request.IsProcessRescheduleTicket)
	}
	if !reflect.ValueOf(request.IsProcessRefundTicket).IsNil() {
		db = db.Where("is_process_refund_ticket = ?", request.IsProcessRefundTicket)
	}
	if !reflect.ValueOf(request.IsProcessChildTicket).IsNil() {
		db = db.Where("is_process_child_ticket = ?", request.IsProcessChildTicket)
	}
	if !reflect.ValueOf(request.ClassType).IsNil() {
		db = db.Where("class_type = ?", request.ClassType)
	}
	db = db.Order("is_enable desc")
	db = db.Order("sort")
}

func checkAddOrModUser(request agency.User) (err error) {
	var result agency.User
	db := global.DbMap[dbName].Model(&result)
	db = db.Where("id != ?", request.Id)
	db = db.Where("user_name = ?", request.UserName)
	err = db.First(&result).Error
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		err = errors.New("存在相同用户名的用户")
		return
	}
	return nil
}