package service

import (
	"github.com/druidcaesa/gotool"
	"ulink-admin/frame"
	dao2 "ulink-admin/modules/system/dao"
	"ulink-admin/modules/system/models/model"
	"ulink-admin/modules/system/models/req"
	"ulink-admin/modules/system/models/response"
	"ulink-admin/pkg/base"
	"xorm.io/xorm"
)

// UserService 系统用户操作业务逻辑
type UserService struct {
	UserDao     *dao2.UserDao     `inject:""`
	UserRoleDao *dao2.UserRoleDao `inject:""`
}

// FindList 查询用户集合业务方法
func (s UserService) Page(query *req.UserQuery) ([]*response.UserResponse, int64) {
	return s.UserDao.Page(query)
}

// GetUserById 根据id查询用户数据
func (s UserService) GetById(parseInt int64, record interface{}) {
	s.UserDao.GetById(parseInt, record)
}

// GetUserByUserName 根据用户名查询用户
func (s UserService) GetUserByUserName(name string) *model.SysUser {
	user := model.SysUser{}
	user.UserName = name
	return s.UserDao.GetUserByUserName(user)
}

// CheckEmailUnique 校验邮箱是否存在
func (s UserService) CheckEmailUnique(user *req.UserBody) *model.SysUser {
	return s.UserDao.CheckEmailUnique(user)
}

// CheckPhoneNumUnique 校验手机号是否存在
func (s UserService) CheckPhoneNumUnique(body *req.UserBody) *model.SysUser {
	return s.UserDao.CheckPhoneNumUnique(body)
}

// Insert 添加用户业务逻辑
func (s UserService) Insert(body *req.UserBody) {
	//根据用户名查询用户
	user := s.GetUserByUserName(body.UserName)
	if user != nil {
		frame.Throw(frame.BUSINESS_CODE, "失败，登录账号已存在")
	}
	if s.UserDao.Exist(body.TableName(), "phone_number=?", body.PhoneNumber) {
		frame.Throw(frame.BUSINESS_CODE, "手机号已存在")
	}
	if s.UserDao.Exist(body.TableName(), "Email=?", body.Email) {
		frame.Throw(frame.BUSINESS_CODE, "邮箱已存在")
	}
	//进行密码加密
	body.Password = gotool.BcryptUtils.Generate(body.Password)
	base.Transaction(func(session *xorm.Session) {
		//添加用户数据库操作
		s.UserDao.Insert(body)
		s.insertUserRole(body)
	})
}

// 新增用户角色信息
func (s UserService) insertUserRole(user *req.UserBody) {
	roleIds := user.RoleIds
	if len(roleIds) > 0 {
		roles := make([]model.SysUserRole, 0)
		for i := 0; i < len(roleIds); i++ {
			role := model.SysUserRole{
				RoleId: roleIds[i],
				UserId: user.Id,
			}
			roles = append(roles, role)
		}
		s.UserRoleDao.BatchUserRole(roles)
	}
}

// Edit 修改用户数据
func (s UserService) Edit(body *req.UserBody) {
	if s.UserDao.Exist(body.TableName(), "phone_number=? and id!=?", body.PhoneNumber, body.Id) {
		frame.Throw(frame.BUSINESS_CODE, "手机号已存在")
	}
	if s.UserDao.Exist(body.TableName(), "email=? and id!=? ", body.Email, body.Id) {
		frame.Throw(frame.BUSINESS_CODE, "邮箱已存在")
	}
	base.Transaction(func(session *xorm.Session) {
		//删除原有用户和角色关系
		s.UserRoleDao.RemoveUserRole(body.Id)
		//重新添加用具角色关系
		s.insertUserRole(body)
		//修改用户数据
		s.UserDao.Update(body)
	})
}

// Remove 根据用户id删除用户相关数据
func (s UserService) Remove(id int64) {
	base.Transaction(func(session *xorm.Session) {
		//删除原有用户和角色关系
		s.UserRoleDao.RemoveUserRole(id)
		//删除用户数据
		s.UserDao.Delete(&req.UserBody{}, id)
	})
}

// CheckUserAllowed 校验是否可以修改用户密码
func (s UserService) CheckUserAllowed(body *req.UserBody) bool {
	user := model.SysUser{}
	return user.IsAdmin(body.Id)
}

// ResetPwd 修改用户密码
func (s UserService) ResetPwd(body *req.UserBody) int64 {
	return s.UserDao.ResetPwd(body)
}

// GetAllocatedList 查询未分配用户角色列表
func (s UserService) GetAllocatedList(query *req.UserQuery) ([]*response.UserResponse, int64) {
	return s.UserDao.GetAllocatedList(query)
}

// GetUnallocatedList 查询未分配用户角色列表
func (s UserService) GetUnallocatedList(query *req.UserQuery) ([]*response.UserResponse, int64) {
	return s.UserDao.GetUnallocatedList(query)
}

// EditProfile 修改数据
func (s UserService) EditProfile(body *req.UserBody) {
	if s.UserDao.Exist(body.TableName(), "phone_number=? and id!=?", body.PhoneNumber, body.Id) {
		frame.Throw(frame.BUSINESS_CODE, "手机号已存在")
	}
	if s.UserDao.Exist(body.TableName(), "Email=? and id!=? ", body.Email, body.Id) {
		frame.Throw(frame.BUSINESS_CODE, "邮箱已存在")
	}
	s.UserDao.Update(body)
}

// UpdatePwd 修改密码
func (s UserService) UpdatePwd(id int64, hash string) {
	s.UserDao.UpdatePwd(id, hash)
}

// UpdateAvatar 修改头像
func (s UserService) UpdateAvatar(info *model.SysUser) {
	s.UserDao.UpdateAvatar(info)
}

func (s UserService) UpdateStatus(id int64, status string) {
	s.UserDao.UpdateStatus(id, status)
}

func (s UserService) UpdateAuthRole(user *req.UserBody) {
	roleIds := user.RoleIds
	if len(roleIds) > 0 {
		roles := make([]model.SysUserRole, 0)
		for i := 0; i < len(roleIds); i++ {
			role := model.SysUserRole{
				RoleId: roleIds[i],
				UserId: user.Id,
			}
			roles = append(roles, role)
		}
		s.UserRoleDao.UpdateAuthRole(user.Id, roles)
	} else {
		//删除原有用户和角色关系
		s.UserRoleDao.RemoveUserRole(user.Id)
	}

}

func (s UserService) List(query *req.UserQuery, list *[]model.SysUser) {
	s.UserDao.List(query, list)
}