package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"dashoo.cn/opms_libary/myerrors"
	"dashoo.cn/opms_libary/request"
	"dashoo.cn/opms_libary/utils"
	"database/sql"
	"errors"
	"github.com/gogf/gf/container/gset"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
	"github.com/gogf/gf/util/grand"
)

type UserService struct {
	*contextService
	Dao          *dao.SysUserDao
	userRoleDao  *dao.SysUserRoleDao
	userPostDao  *dao.SysUserPostDao
	userGroupDao *dao.SysUserGroupDao
}

func NewUserService(ctx context.Context) (svc *UserService, err error) {
	svc = new(UserService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysUserDao(svc.Tenant)
	svc.Table = svc.Dao.Table
	//svc.userRoleDao = dao.NewSysUserRoleDao(svc.Tenant)
	//svc.userPostDao = dao.NewSysUserPostDao(svc.Tenant)
	//svc.userGroupDao = dao.NewSysUserGroupDao(svc.Tenant)
	return svc, nil
}

// Login 用户登录，成功返回用户UUID，否则返回空字符串;
func (s *UserService) Login(username, password string) (*request.UserInfo, error) {
	record, err := s.Dao.Where("user_name", username).Where("status='10'").FindOne()
	if err != nil {
		return nil, gerror.New("系统异常")
	}
	if record == nil {
		return nil, gerror.New("账号或密码错误,或限制登录")
	}
	// 验证密码
	if utils.EncryptPassword(password, record.UserSalt) != record.Password {
		return nil, gerror.New("账号密码错误")
	}
	//账号状态
	if record.Status == "20" {
		return nil, gerror.New("账号已被冻结")
	}
	userInfo := new(request.UserInfo)
	if err = gconv.Struct(record, userInfo); err != nil {
		return nil, err
	}
	// 权限
	userInfo.Roles, userInfo.Posts, userInfo.Groups, err = s.GetUserPermission(userInfo.Id)
	if err != nil {
		return nil, gerror.New("获取用户权限失败")
	}
	return userInfo, nil
}

func (s *UserService) GetUserList(req *model.SysUserSearchReq) (total int, userList []*model.SysUserRes, err error) {
	userModel := s.Dao.M.LeftJoin(dao.SysDept.Table, "dept", "sys_user.dept_id=dept.id").Fields(dao.SysDept.Columns.DeptName)
	if req.KeyWords != "" {
		keyWords := "%" + req.KeyWords + "%"
		userModel = userModel.Where("sys_user.user_name like ? or  sys_user.nick_name like ?", keyWords, keyWords)
	}
	if req.DeptId != 0 {
		userModel = userModel.Where("sys_user.dept_id", req.DeptId)
	}
	if len(req.DeptIds) != 0 {
		userModel = userModel.WhereIn("sys_user.dept_id", req.DeptIds)
	}
	if req.Status != "" {
		userModel = userModel.Where("sys_user.status", gconv.Int(req.Status))
	}
	if req.Phone != "" {
		userModel = userModel.WhereLike("sys_user.phone", "%"+req.Phone+"%")
	}
	if req.BeginTime != "" {
		userModel = userModel.WhereGTE("sys_user.created_time", req.BeginTime)
	}
	if req.EndTime != "" {
		userModel = userModel.WhereLTE("sys_user.created_time", req.EndTime)
	}
	if len(req.Roles) > 0 {
		insql := dao.NewSysRoleDao(s.Tenant).Fields(dao.SysRole.Columns.Id).WhereIn(dao.SysRole.Columns.RoleKey, req.Roles)
		userModel = userModel.LeftJoin(dao.SysUserRole.Table, "ur", "sys_user.id=ur.user_id").WhereIn("ur.role_id", insql)
	}
	if len(req.Posts) > 0 {
		insql := dao.NewSysPostDao(s.Tenant).Fields(dao.SysPost.Columns.Id).WhereIn(dao.SysPost.Columns.PostCode, req.Posts)
		userModel = userModel.LeftJoin(dao.SysUserPost.Table, "up", "sys_user.id=up.user_id").WhereIn("up.post_id", insql)
	}
	if len(req.Groups) > 0 {
		insql := dao.NewSysGroupDao(s.Tenant).Fields(dao.SysGroup.Columns.Id).WhereIn(dao.SysGroup.Columns.GroupCode, req.Groups)
		userModel = userModel.LeftJoin(dao.SysUserGroup.Table, "ug", "sys_user.id=ug.user_id").WhereIn("ug.group_id", insql)
	}
	if userModel, err = s.SetDataScopeWhere(userModel); err != nil {
		return 0, nil, err
	}

	total, err = userModel.Count()
	if err != nil {
		return
	}
	err = userModel.Fields("sys_user.*").FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).
		Group("sys_user.id").Page(req.PageNum, req.PageSize).Order("sys_user.id asc").Scan(&userList)
	return
}

// GetUserByDept 获取部门下用户
func (s *UserService) GetUserByDept(deptId int) (userList []*model.SysUser, err error) {
	count, err := dao.NewSysDeptDao(s.Tenant).Where(dao.SysDept.Columns.Id, deptId).Where(dao.SysDept.Columns.Status, "10").Count()
	if err != nil {
		return nil, err
	}
	if count == 0 {
		return nil, gerror.New("部门不存在或已停用")
	}
	err = s.Dao.Where(s.Dao.Columns.DeptId, deptId).FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).Scan(&userList)
	return userList, err
}

// GetUserByRole 获取角色关联的用户
func (s *UserService) GetUserByRole(roleId int) (userList []*model.SysUser, err error) {
	count, err := dao.NewSysRoleDao(s.Tenant).Where(dao.SysRole.Columns.Id, roleId).Where(dao.SysRole.Columns.Status, "10").Count()
	if err != nil {
		return nil, err
	}
	if count == 0 {
		return nil, gerror.New("角色不存在或已停用")
	}
	userList = make([]*model.SysUser, 0)
	err = s.Dao.FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).Where(s.Dao.Columns.Status, "10").
		WhereIn(s.Dao.Columns.Id, dao.NewSysUserRoleDao(s.Tenant).Fields(dao.SysUserRole.Columns.UserId).WhereIn(dao.SysUserRole.Columns.RoleId, roleId)).
		Scan(&userList)
	return userList, err
}

// GetAdminUserByUsernamePassword 后台登陆验证
func (s *UserService) GetAdminUserByUsernamePassword(ctx context.Context, req *model.LoginParamsReq) (user *model.LoginUserRes, err error) {
	user, err = s.GetUserByUsernamePassword(ctx, req)
	if err != nil {
		return
	}
	//判断是否后台用户
	//if user.IsAdmin != 1 {
	//	return nil, gerror.New("抱歉!您不属于后台管理员!")
	//}
	return
}

// GetUserByUsernamePassword 登陆验证
func (s *UserService) GetUserByUsernamePassword(ctx context.Context, req *model.LoginParamsReq) (user *model.LoginUserRes, err error) {
	user, err = s.GetUserByUsername(ctx, req.Username)
	if err != nil {
		return
	}
	if user == nil {
		return nil, gerror.New("账号密码错误")
	}
	//验证密码
	if utils.EncryptPassword(req.Password, user.UserSalt) != user.UserPassword {
		return nil, gerror.New("账号密码错误")
	}
	//账号状态
	if user.UserStatus == "20" {
		return nil, gerror.New("账号已被冻结")
	}
	return
}

// GetUserByUsername 通过用户名获取用户信息
func (s *UserService) GetUserByUsername(ctx context.Context, userName string) (user *model.LoginUserRes, err error) {
	user = &model.LoginUserRes{}
	err = s.Dao.Ctx(ctx).Fields(user).Where(s.Dao.Columns.UserName, userName).Scan(user)
	if err != nil {
		return nil, err
	}
	if err == sql.ErrNoRows {
		return nil, myerrors.TipsError("用户信息不存在")
	}
	return user, nil
}

// GetUserInfoById 通过Id获取用户信息
func (s *UserService) GetUserInfoById(id int, withPwd ...bool) (user *model.SysUser, err error) {
	if len(withPwd) > 0 && withPwd[0] {
		//用户用户信息
		err = s.Dao.Where(s.Dao.Columns.Id, id).Scan(&user)
	} else {
		//用户用户信息
		err = s.Dao.Where(s.Dao.Columns.Id, id).FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).Scan(&user)
	}
	if err != nil {
		g.Log().Error(err)
		return nil, errors.New("获取用户数据失败")
	}
	return
}

// GetUserPermission 获取用户权限字符（角色、岗位、用户组）
func (s *UserService) GetUserPermission(userId int) ([]string, []string, []string, error) {
	s.userRoleDao = dao.NewSysUserRoleDao(s.Tenant)
	s.userPostDao = dao.NewSysUserPostDao(s.Tenant)
	s.userGroupDao = dao.NewSysUserGroupDao(s.Tenant)
	roleList, err := s.userRoleDao.As("user_role").LeftJoin(dao.SysRole.Table, "role", "user_role.role_id=role.id").
		Fields(dao.SysRole.Columns.RoleKey).Where(s.userRoleDao.Columns.UserId, userId).Array()
	if err != nil {
		g.Log().Error(err)
		return nil, nil, nil, err
	}
	postList, err := s.userPostDao.As("user_post").LeftJoin(dao.SysPost.Table, "post", "user_post.post_id=post.id").
		Fields(dao.SysPost.Columns.PostCode).Where(s.userPostDao.Columns.UserId, userId).Array()
	if err != nil {
		g.Log().Error(err)
		return nil, nil, nil, err
	}
	groupList, err := s.userGroupDao.As("user_group").LeftJoin(dao.SysGroup.Table, "group", "user_group.group_id=group.id").
		Fields(dao.SysGroup.Columns.GroupCode).Where(s.userGroupDao.Columns.UserId, userId).Array()
	if err != nil {
		g.Log().Error(err)
		return nil, nil, nil, err
	}

	return gconv.Strings(roleList), gconv.Strings(postList), gconv.Strings(groupList), err
}

// GetUserRoleIds 获取用户角色
func (s *UserService) GetUserRoleIds(userId int) (roleIds []int, err error) {
	s.userRoleDao = dao.NewSysUserRoleDao(s.Tenant)
	list, err := s.userRoleDao.Where(dao.SysUserRole.Columns.UserId, userId).All()
	if err != nil {
		g.Log().Error(err)
		return nil, gerror.New("获取用户岗位信息失败")
	}
	roleIds = make([]int, 0)
	for _, entity := range list {
		roleIds = append(roleIds, entity.RoleId)
	}
	return
}

// GetUserPostIds 获取用户岗位
func (s *UserService) GetUserPostIds(userId int) (postIds []int, err error) {
	s.userPostDao = dao.NewSysUserPostDao(s.Tenant)
	list, err := s.userPostDao.Where(dao.SysUserPost.Columns.UserId, userId).All()
	if err != nil {
		g.Log().Error(err)
		return nil, gerror.New("获取用户岗位信息失败")
	}
	postIds = make([]int, 0)
	for _, entity := range list {
		postIds = append(postIds, entity.PostId)
	}
	return
}

// GetUserGroupIds 获取用户的用户组
func (s *UserService) GetUserGroupIds(userId int) (postIds []int, err error) {
	s.userGroupDao = dao.NewSysUserGroupDao(s.Tenant)
	list, err := s.userGroupDao.Where(dao.SysUserGroup.Columns.UserId, userId).All()
	if err != nil {
		g.Log().Error(err)
		return nil, gerror.New("获取用户岗位信息失败")
	}
	postIds = make([]int, 0)
	for _, entity := range list {
		postIds = append(postIds, entity.GroupId)
	}
	return
}

// GetRolesByUserId 根据用户id获取岗位信息详情
func (s *UserService) GetRolesByUserId(userId int) ([]*model.SysRole, error) {
	roleIds, err := s.GetUserRoleIds(userId)
	if err != nil {
		return nil, err
	}
	roles, err := dao.NewSysRoleDao(s.Tenant).Where(dao.SysRole.Columns.Id+" in (?)", roleIds).All()
	return roles, err
}

// GetPostsByUserId 根据用户id获取岗位信息详情
func (s *UserService) GetPostsByUserId(userId int) ([]*model.SysPost, error) {
	postIds, err := s.GetUserPostIds(userId)
	if err != nil {
		return nil, err
	}
	posts, err := dao.NewSysPostDao(s.Tenant).Where(dao.SysPost.Columns.Id+" in (?)", postIds).All()
	return posts, err
}

func (s *UserService) CreateUser(req *model.AddUserReq) (err error) {
	var tx *gdb.TX
	tx, err = g.DB().Begin()
	if err != nil {
		err = gerror.New("事务开启失败")
		return
	}
	Model := s.Dao.TX(tx)
	if i, _ := Model.Where("user_name=?", req.UserName).Count(); i != 0 {
		err = gerror.New("用户名已经存在")
		tx.Rollback()
		return
	}
	if i, _ := Model.Where("phone=?", req.Phone).Count(); i != 0 {
		err = gerror.New("手机号已经存在")
		tx.Rollback()
		return
	}
	userData := new(model.SysUser)
	if err = gconv.Struct(req, userData); err != nil {
		tx.Rollback()
		return
	}
	userData.UserSalt = grand.S(10)
	userData.Password = utils.EncryptPassword(userData.Password, userData.UserSalt)
	g.Log("xxxxpassword", userData.Password)
	SetCreatedInfo(userData, s.GetCxtUserId(), s.GetCxtUserName())
	res, err := Model.Insert(userData)
	if err != nil {
		tx.Rollback()
		return
	}
	insertId, _ := res.LastInsertId()
	if err := s.AddUserOtherInfo(req.SetUserReq, insertId, tx); err != nil {
		return err
	}
	tx.Commit()
	return
}

// AddUserOtherInfo 重新设置用户相关其他表信息
func (s *UserService) AddUserOtherInfo(req model.SetUserReq, insertId int64, tx *gdb.TX) (err error) {
	// 设置用户角色信息
	err = s.AddUserRole(req.RoleIds, insertId, tx)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("设置用户权限失败")
		tx.Rollback()
		return
	}
	// 设置用户岗位信息
	err = s.AddUserPost(req.PostIds, insertId, tx)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("设置用户岗位信息失败")
		tx.Rollback()
		return
	}
	// 设置用户的用户组信息
	err = s.AddUserGroup(req.GroupIds, insertId, tx)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("设置用户组信息失败")
		tx.Rollback()
		return
	}
	return
}

// AddUserRole 添加用户角色信息
func (s *UserService) AddUserRole(roleIds []int, userId int64, tx *gdb.TX) (err error) {
	s.userRoleDao = dao.NewSysUserRoleDao(s.Tenant)
	//删除旧用户角色信息
	_, err = s.userRoleDao.TX(tx).Where(dao.SysUserPost.Columns.UserId, userId).Delete()
	if err != nil {
		g.Log().Error(err)
		return
	}
	if len(roleIds) == 0 {
		return
	}
	//添加用户岗位信息
	data := g.List{}
	for _, v := range roleIds {
		data = append(data, g.Map{
			dao.SysUserRole.Columns.UserId: userId,
			dao.SysUserRole.Columns.RoleId: v,
		})
	}
	_, err = s.userRoleDao.TX(tx).Data(data).Insert()
	if err != nil {
		g.Log().Error(err)
		return
	}
	return
}

// AddUserPost 添加用户岗位信息
func (s *UserService) AddUserPost(postIds []int, userId int64, tx *gdb.TX) (err error) {
	s.userPostDao = dao.NewSysUserPostDao(s.Tenant)
	//删除旧岗位信息
	_, err = s.userPostDao.TX(tx).Where(dao.SysUserPost.Columns.UserId, userId).Delete()
	if err != nil {
		g.Log().Error(err)
		return
	}
	if len(postIds) == 0 {
		return
	}
	//添加用户岗位信息
	data := g.List{}
	for _, v := range postIds {
		data = append(data, g.Map{
			dao.SysUserPost.Columns.UserId: userId,
			dao.SysUserPost.Columns.PostId: v,
		})
	}
	_, err = s.userPostDao.TX(tx).Data(data).Insert()
	if err != nil {
		g.Log().Error(err)
		return
	}
	return
}

// AddUserGroup 添加用户的用户组信息
func (s *UserService) AddUserGroup(groupIds []int, userId int64, tx *gdb.TX) (err error) {
	s.userGroupDao = dao.NewSysUserGroupDao(s.Tenant)
	//删除旧用户组信息
	_, err = s.userGroupDao.TX(tx).Where(dao.SysUserGroup.Columns.UserId, userId).Delete()
	if err != nil {
		g.Log().Error(err)
		return
	}
	if len(groupIds) == 0 {
		return
	}
	//添加用户的用户组信息
	data := g.List{}
	for _, v := range groupIds {
		data = append(data, g.Map{
			dao.SysUserGroup.Columns.UserId:      userId,
			dao.SysUserGroup.Columns.GroupId:     v,
			dao.SysUserGroup.Columns.CreatedBy:   userId,
			dao.SysUserGroup.Columns.CreatedName: v,
		})
	}
	_, err = s.userGroupDao.TX(tx).Data(data).Insert()
	if err != nil {
		g.Log().Error(err)
		return
	}
	return
}

// UpdateUser 修改用户
func (s *UserService) UpdateUser(req *model.EditUserReq) (err error) {
	if i, _ := s.Dao.Where("id!=? and phone=?", req.Id, req.Phone).Count(); i != 0 {
		err = gerror.New("手机号已经存在")
		return
	}
	var tx *gdb.TX
	tx, err = g.DB().Begin()
	//保存管理员信息
	var userData *model.SysUser
	err = s.Dao.Where("id", req.Id).Scan(&userData)
	if err != nil || userData == nil {
		g.Log().Error(err)
		err = gerror.New("获取用户信息失败")
		return
	}
	if err = gconv.Struct(req, userData); err != nil {
		tx.Rollback()
		return
	}
	SetUpdatedInfo(userData, s.GetCxtUserId(), s.GetCxtUserName())
	_, err = s.Dao.TX(tx).FieldsEx(s.Dao.Columns.Id, s.Dao.Columns.CreatedTime,
		s.Dao.Columns.DeletedTime, s.Dao.Columns.LoginDate).
		WherePri(userData.Id).Update(userData)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("修改用户信息失败")
		tx.Rollback()
		return
	}
	if err := s.AddUserOtherInfo(req.SetUserReq, int64(req.Id), tx); err != nil {
		return err
	}
	tx.Commit()
	return
}

// ResetUserPwd 重置用户密码
func (s *UserService) ResetUserPwd(req *model.SysUserResetPwdReq) error {
	salt := grand.S(10)
	password := utils.EncryptPassword(req.Password, salt)
	data := g.Map{
		s.Dao.Columns.UserSalt: salt,
		s.Dao.Columns.Password: password,
	}
	SetCurrentUpdatedInfo(data, s.CxtUser)
	_, err := s.Dao.WherePri(req.Id).Update()
	return err
}

func (s *UserService) ChangeUserStatus(req *model.SysUserStatusReq) error {
	data := g.Map{
		s.Dao.Columns.Status: req.UserStatus,
	}
	SetCurrentUpdatedInfo(data, s.CxtUser)
	_, err := s.Dao.WherePri(req.Id).Update()
	return err
}

// DeleteUserByIds 删除用户信息
func (s *UserService) DeleteUserByIds(ctx context.Context, ids []int64) error {
	return g.DB().Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
		_, err := s.Dao.Ctx(ctx).TX(tx).Where(s.Dao.Columns.Id+" in(?)", ids).Delete()
		//删除用户对应的岗位
		_, err = dao.SysUserPost.Ctx(ctx).TX(tx).Delete(dao.SysUserPost.Columns.UserId+" in (?)", ids)
		return err
	})
}

// SetAvatar 修改用户头像
func (s *UserService) SetAvatar(userId int, avatarUrl string) error {
	_, err := s.Dao.WherePri(userId).Unscoped().Update(g.Map{
		s.Dao.Columns.Avatar: avatarUrl,
	})
	return err
}

// ProfileEdit 修改个人资料
func (s *UserService) ProfileEdit(req *model.ProfileUpReq) error {
	_, err := s.Dao.WherePri(req.UserId).Unscoped().Update(req)
	return err
}

// ProfileUpdatePwd 修改个人密码
func (s *UserService) ProfileUpdatePwd(req *model.ProfileUpdatePwdReq) error {
	userInfo, err := s.GetUserInfoById(req.UserId, true)
	if err != nil {
		return err
	}
	oldPassword := utils.EncryptPassword(req.OldPassword, userInfo.UserSalt)
	if oldPassword != userInfo.Password {
		return errors.New("原始密码错误!")
	}
	salt := grand.S(10)
	newPassword := utils.EncryptPassword(req.NewPassword, salt)
	data := g.Map{
		s.Dao.Columns.UserSalt: salt,
		s.Dao.Columns.Password: newPassword,
	}
	SetCurrentUpdatedInfo(data, s.CxtUser)
	_, err = s.Dao.WherePri(req.UserId).Unscoped().Update(data)
	return err
}

// GetUsersNickName 通过用户ids查询多个用户信息
func (s *UserService) GetUsersNickName(ids []int) (users []*model.SysUserNickNameRes, err error) {
	if len(ids) == 0 {
		return
	}
	idsSet := gset.NewIntSetFrom(ids).Slice()
	err = s.Dao.Where(s.Dao.Columns.Id+" in(?)", idsSet).Fields(model.SysUserNickNameRes{}).
		Order(s.Dao.Columns.Id + " ASC").Scan(&users)
	return
}