package service

import (
	"crypto/md5"
	"encoding/hex"
	"errors"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/global"
	"regexp"
	"strconv"
)

type UserService struct {
}

// AddUser 新增用户
func (r *UserService) AddUser(c *gin.Context, AddUserRequest requests.AddUser) (bool, error) {
	// 当前登陆用户id
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		return false, errors.New("新增失败")
	}

	loginRoleId := c.GetInt64("RoleId")
	if loginRoleId == 0 {
		return false, errors.New("新增失败")
	}

	// 获取当前登陆用户角色数据
	adminRoleDao := dao.AdminRoleDao{}

	adminUserDao := dao.AdminUserDao{}
	AdminDeptDao := dao.AdminDeptDao{}
	AdminPostDao := dao.AdminPostDao{}

	// 检测账号名
	AdminUser, err := adminUserDao.GetAdminUserFirstByAccess(AddUserRequest.Access)
	if AdminUser != nil {
		return false, errors.New("账号名重复")
	}

	// 检测手机号
	AdminUser, err = adminUserDao.GetAdminUserFirstByPhone(AddUserRequest.Phone)
	if AdminUser != nil {
		return false, errors.New("手机号重复")
	}

	// 检测角色
	roleID, err := strconv.ParseInt(AddUserRequest.RoleID, 10, 64)
	if err != nil {
		return false, errors.New("角色错误")
	}

	adminRole, err := adminRoleDao.GetAdminRoleFirstById(roleID)
	if err != nil || adminRole == nil {
		return false, errors.New("角色错误")
	}

	// 检测部门
	deptID, err := strconv.ParseInt(AddUserRequest.DeptID, 10, 64)
	if err != nil {
		return false, errors.New("部门错误")
	}

	adminDept, err := AdminDeptDao.GetAdminDeptById(deptID)
	if err != nil || adminDept == nil {
		return false, errors.New("部门错误")
	}

	// 检测岗位
	postID, err := strconv.ParseInt(AddUserRequest.PostID, 10, 64)
	if err != nil {
		return false, errors.New("岗位错误")
	}

	adminPost, err := AdminPostDao.GetAdminPostById(postID)
	if err != nil || adminPost == nil {
		return false, errors.New("岗位错误")
	}

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

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

	// 新增用户
	AdminUserModel := &model.AdminUser{
		Access:     AddUserRequest.Access,
		Password:   passwordString,
		Salt:       salt,
		Status:     AddUserRequest.Status,
		IsDeleted:  AddUserRequest.IsDeleted,
		IsDisabled: AddUserRequest.IsDisabled,
		NickName:   AddUserRequest.NickName,
		Phone:      AddUserRequest.Phone,
		Avatar:     AddUserRequest.Avatar,
		Sex:        AddUserRequest.Sex,
		Email:      AddUserRequest.Email,
		RoleID:     roleID,
		DeptID:     deptID,
		PostID:     postID,
		CreateBy:   loginUserId,
	}

	adminUser, _ := adminUserDao.AddAdminUser(tx, AdminUserModel)
	if adminUser == nil {
		tx.Rollback()
		return false, errors.New("新增失败")
	}

	tx.Commit()

	return true, nil
}

// DeleteUser 删除用户-批量
func (r *UserService) DeleteUser(c *gin.Context, DeleteUserRequest requests.DeleteUser) (bool, error) {
	// 获取当前登陆用户数据
	userId := c.GetInt64("UserId")
	if userId == 0 {
		return false, errors.New("数据错误")
	}

	AdminUserDao := dao.AdminUserDao{}
	adminUser, err := AdminUserDao.GetAdminUserFirstById(userId)
	if err != nil || adminUser == nil {
		return false, errors.New("用户数据错误")
	}

	// 获取当前登陆用户角色数据
	roleId := c.GetInt64("RoleId")
	if roleId == 0 {
		return false, errors.New("数据错误")
	}

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

	for _, v := range DeleteUserRequest.UserIds {
		// 将字符串转换为int64类型
		v, err := strconv.ParseInt(v, 10, 64)
		if err != nil {
			tx.Rollback()
			return false, errors.New("菜单错误")
		}

		if v == adminUser.UserID {
			tx.Rollback()
			return false, errors.New("非法操作，请勿删除自己")
		}

		// 检测删除用户
		adminUser, err := AdminUserDao.GetAdminUserFirstById(userId)
		if err != nil || adminUser == nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}

		// 删除用户
		err = AdminUserDao.DeleteAdminUserById(tx, v)
		if err != nil {
			tx.Rollback()
			return false, errors.New("删除失败")
		}
	}

	tx.Commit()

	return true, nil
}

// PutUser 修改用户
func (r *UserService) PutUser(c *gin.Context, requestUserId int64, putUserRequest requests.PutUser) (bool, error) {
	// 获取当前登陆用户数据
	loginUserId := c.GetInt64("UserId")
	if loginUserId == 0 {
		return false, errors.New("数据错误")
	}

	adminUserDao := dao.AdminUserDao{}
	loginAdminUser, err := adminUserDao.GetAdminUserFirstById(loginUserId)
	if err != nil || loginAdminUser == nil {
		return false, errors.New("用户数据错误")
	}

	if loginUserId == requestUserId && putUserRequest.IsDisabled == 1 {
		return false, errors.New("不可把自己置为禁用")
	}

	if loginUserId == requestUserId && putUserRequest.IsDeleted == 1 {
		return false, errors.New("不可把自己置为删除")
	}

	// 获取需修改用户数据
	adminUser, err := adminUserDao.GetAdminUserFirstById(requestUserId)
	if err != nil || adminUser == nil {
		return false, errors.New("用户数据错误")
	}

	// 获取当前登陆用户角色数据
	loginRoleId := c.GetInt64("RoleId")
	if loginRoleId == 0 {
		return false, errors.New("数据错误")
	}

	adminRoleDao := dao.AdminRoleDao{}
	adminRole, err := adminRoleDao.GetAdminRoleFirstById(loginRoleId)
	if err != nil || adminRole == nil {
		return false, errors.New("非法操作")
	}

	if adminRole.IsAdmin == 0 && loginUserId != requestUserId {
		return false, errors.New("普通用户只可修改自己的用户数据")
	}

	if putUserRequest.Access != adminUser.Access {
		// 检测账号名
		res, err := adminUserDao.GetAdminUserFirstByAccess(putUserRequest.Access)
		if res != nil || err != nil {
			return false, errors.New("账号名重复")
		}
	}

	if putUserRequest.Phone != adminUser.Phone {
		// 检测手机号
		res, err := adminUserDao.GetAdminUserFirstByPhone(putUserRequest.Phone)
		if res != nil || err != nil {
			return false, errors.New("手机号重复")
		}
	}

	// 检测角色
	roleID, err := strconv.ParseInt(putUserRequest.RoleID, 10, 64)
	if err != nil {
		return false, errors.New("角色错误")
	}

	if roleID != adminUser.RoleID {
		res, err := adminRoleDao.GetAdminRoleFirstById(roleID)
		if err != nil || res == nil {
			return false, errors.New("角色错误")
		}
	}

	// 检测部门
	deptID, err := strconv.ParseInt(putUserRequest.DeptID, 10, 64)
	if err != nil {
		return false, errors.New("部门错误")
	}

	if deptID != adminUser.DeptID {
		adminDeptDao := dao.AdminDeptDao{}
		res, err := adminDeptDao.GetAdminDeptById(deptID)
		if err != nil || res == nil {
			return false, errors.New("部门错误")
		}
	}

	// 检测岗位
	postID, err := strconv.ParseInt(putUserRequest.PostID, 10, 64)
	if err != nil {
		return false, errors.New("岗位错误")
	}

	if postID != adminUser.PostID {
		adminPostDao := dao.AdminPostDao{}
		res, err := adminPostDao.GetAdminPostById(postID)
		if err != nil || res == nil {
			return false, errors.New("岗位错误")
		}
	}

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

	// 修改角色
	data := make(map[string]interface{})
	data["access"] = putUserRequest.Access
	data["is_deleted"] = putUserRequest.IsDeleted
	data["is_disabled"] = putUserRequest.IsDisabled
	data["nick_name"] = putUserRequest.NickName
	data["phone"] = putUserRequest.Phone
	data["avatar"] = putUserRequest.Avatar
	data["sex"] = putUserRequest.Sex
	data["email"] = putUserRequest.Email
	data["role_id"] = roleID
	data["dept_id"] = deptID
	data["post_id"] = postID
	data["update_by"] = loginUserId
	err = adminUserDao.EditAdminUserById(tx, requestUserId, data)
	if err != nil {
		tx.Rollback()
		return false, errors.New("修改失败")
	}

	tx.Commit()

	return true, nil
}

// PutUserPassword 修改用户密码
func (r *UserService) PutUserPassword(requestUserId int64, putUserPasswordRequest requests.PutUserPassword) (bool, error) {
	adminUserDao := dao.AdminUserDao{}

	// 获取需修改用户数据
	adminUser, err := adminUserDao.GetAdminUserFirstById(requestUserId)
	if err != nil || adminUser == nil {
		return false, errors.New("用户数据错误")
	}

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

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

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

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

	// 密码校验
	if len(putUserPasswordRequest.NewPassword) < 8 {
		return false, errors.New("密码小于8位数")
	}

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

	// 开始事务
	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, requestUserId, data)
	if err != nil {
		tx.Rollback()
		return false, errors.New("修改失败")
	}

	tx.Commit()

	return true, nil
}

// GetUserCardNum 获取用户身份证号
func (r *UserService) GetUserCardNum(userId, familyId int64) (string, error) {
	var cardNum string

	// 获取用户数据
	userDao := dao.UserDao{}
	user, err := userDao.GetUserById(userId)
	if err != nil || user == nil {
		return "", errors.New("用户错误")
	}

	// 判断用户类型
	if user.UserType == 1 {
		// 患者
		if familyId == 0 {
			return "", errors.New("获取失败")
		}

		patientFamilyDao := dao.PatientFamilyDao{}
		patientFamily, err := patientFamilyDao.GetPatientFamilyById(familyId)
		if err != nil || patientFamily == nil {
			return "", errors.New("获取失败")
		}

		cardNum = patientFamily.IdNumber
	} else if user.UserType == 2 {
		// 医生
		userDoctorInfoDao := dao.UserDoctorInfoDao{}
		userDoctorInfo, err := userDoctorInfoDao.GetUserDoctorInfoByUserId(userId)
		if err != nil || userDoctorInfo == nil {
			return "", errors.New("获取失败")
		}

		cardNum = userDoctorInfo.CardNum
	} else if user.UserType == 3 {
		// 药师
		cardNum = "暂时未做"
	}

	return cardNum, nil
}

// GetUserBankNumByDoctorId 获取银行卡号
func (r *UserService) GetUserBankNumByDoctorId(doctorId int64) (string, error) {
	// 获取用户数据
	doctorBankCardDao := dao.DoctorBankCardDao{}
	doctorBankCard, err := doctorBankCardDao.GetDoctorBankCardByDoctorId(doctorId)
	if err != nil || doctorBankCard == nil {
		return "", errors.New("错误数据")
	}

	return doctorBankCard.BankCardCode, nil
}