package service

import (
	"errors"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/config"
	"hospital-admin-api/extend/ca"
	"hospital-admin-api/extend/tencentIm"
	"hospital-admin-api/global"
	"hospital-admin-api/utils"
	"strconv"
	"strings"
)

type UserDoctorService struct {
}

// PutUserDoctor 修改医生
func (r *UserDoctorService) PutUserDoctor(doctorId int64, putUserDoctorRequest requests.PutUserDoctor) (bool, error) {

	// 获取医生数据
	userDoctorDao := dao.UserDoctorDao{}
	userDoctor, err := userDoctorDao.GetUserDoctorById(doctorId)
	if err != nil || userDoctor == nil {
		return false, errors.New("医生数据错误")
	}

	// 获取医生详情数据
	userDoctorInfoDao := dao.UserDoctorInfoDao{}
	userDoctorInfo, err := userDoctorInfoDao.GetUserDoctorInfoByDoctorId(doctorId)
	if err != nil {
		return false, errors.New("医生详情数据错误")
	}

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

	userDoctorData := make(map[string]interface{})     // 医生数据
	userDoctorInfoData := make(map[string]interface{}) // 医生详情数据
	userData := make(map[string]interface{})           // 用户数据

	// 处理头像
	avatar := strings.Replace(putUserDoctorRequest.Avatar, config.C.Oss.OssCustomDomainName, "", 1)
	if userDoctor.Avatar != avatar {
		userDoctorData["avatar"] = avatar
		userData["avatar"] = avatar
	}

	// 处理职称
	if userDoctor.DoctorTitle != putUserDoctorRequest.DoctorTitle {
		userDoctorData["doctor_title"] = putUserDoctorRequest.DoctorTitle
	}

	// 处理科室
	departmentCustomId, err := strconv.ParseInt(putUserDoctorRequest.DepartmentCustomId, 10, 64)
	if err != nil {
		return false, errors.New("科室错误")
	}

	if departmentCustomId == 0 && userDoctor.DepartmentCustomId != 0 {
		return false, errors.New("未选择新的科室")
	}
	if userDoctor.DepartmentCustomId != departmentCustomId || userDoctor.DepartmentCustomName != putUserDoctorRequest.DepartmentCustomName {
		// 获取科室数据
		hospitalDepartmentCustomDao := dao.HospitalDepartmentCustom{}
		hospitalDepartmentCustom, err := hospitalDepartmentCustomDao.GetHospitalDepartmentCustomById(departmentCustomId)
		if err != nil || hospitalDepartmentCustom == nil {
			return false, errors.New("科室错误")
		}

		userDoctorData["department_custom_id"] = putUserDoctorRequest.DepartmentCustomId
		userDoctorData["department_custom_name"] = hospitalDepartmentCustom.DepartmentCustomName

		if putUserDoctorRequest.DepartmentCustomName != "" {
			userDoctorData["department_custom_name"] = putUserDoctorRequest.DepartmentCustomName
		}
	}

	// 处理科室电话
	if userDoctor.DepartmentCustomMobile != putUserDoctorRequest.DepartmentCustomMobile {
		userDoctorData["department_custom_id"] = putUserDoctorRequest.DepartmentCustomMobile
	}

	// 处理医院
	hospitalId, err := strconv.ParseInt(putUserDoctorRequest.HospitalId, 10, 64)
	if err != nil {
		return false, errors.New("科室错误")
	}

	if userDoctor.HospitalID != hospitalId {
		// 获取医院数据
		hospitalDao := dao.Hospital{}
		hospital, err := hospitalDao.GetHospitalById(hospitalId)
		if err != nil || hospital == nil {
			return false, errors.New("医院错误")
		}
		userDoctorData["department_custom_id"] = putUserDoctorRequest.HospitalId
	}

	// 处理擅长
	if userDoctor.BeGoodAt != putUserDoctorRequest.BeGoodAt {
		userDoctorData["be_good_at"] = putUserDoctorRequest.BeGoodAt
	}

	// 医生简介
	if userDoctor.BriefIntroduction != putUserDoctorRequest.BriefIntroduction {
		userDoctorData["brief_introduction"] = putUserDoctorRequest.BriefIntroduction
	}

	// 处理医师执业证
	var licenseCert string
	if len(putUserDoctorRequest.LicenseCert) > 0 {
		result := make([]string, len(putUserDoctorRequest.LicenseCert))
		for i, url := range putUserDoctorRequest.LicenseCert {
			result[i] = strings.TrimPrefix(url, config.C.Oss.OssCustomDomainName)
		}

		licenseCert = strings.Join(result, ",")
	}

	if userDoctorInfo != nil {
		if userDoctorInfo.LicenseCert != licenseCert {
			userDoctorInfoData["license_cert"] = licenseCert
		}
	} else {
		userDoctorInfoData["license_cert"] = licenseCert
	}

	// 处理医师资格证
	var qualificationCert string
	if len(putUserDoctorRequest.QualificationCert) > 0 {
		result := make([]string, len(putUserDoctorRequest.QualificationCert))
		for i, url := range putUserDoctorRequest.QualificationCert {
			result[i] = strings.TrimPrefix(url, config.C.Oss.OssCustomDomainName)
		}

		qualificationCert = strings.Join(result, ",")
	}

	if userDoctorInfo != nil {
		if userDoctorInfo.QualificationCert != qualificationCert {
			userDoctorInfoData["qualification_cert"] = qualificationCert
		}
	} else {
		userDoctorInfoData["qualification_cert"] = qualificationCert
	}

	// 处理医师资格证号
	if userDoctorInfo != nil {
		if userDoctorInfo.QualificationCertNum != putUserDoctorRequest.QualificationCertNum {
			userDoctorInfoData["qualification_cert_num"] = putUserDoctorRequest.QualificationCertNum
		}
	} else {
		userDoctorInfoData["qualification_cert_num"] = putUserDoctorRequest.QualificationCertNum
	}

	// 处理医师工作证
	var workCert string
	if len(putUserDoctorRequest.WorkCert) > 0 {
		result := make([]string, len(putUserDoctorRequest.WorkCert))
		for i, url := range putUserDoctorRequest.WorkCert {
			result[i] = strings.TrimPrefix(url, config.C.Oss.OssCustomDomainName)
		}

		workCert = strings.Join(result, ",")
	}

	if userDoctorInfo != nil {
		if userDoctorInfo.WorkCert != workCert {
			userDoctorInfoData["work_cert"] = workCert
		}
	} else {
		userDoctorInfoData["work_cert"] = workCert
	}

	// 处理身份证正面图片
	if userDoctorInfo.IdCardFront != "" && putUserDoctorRequest.IdCardFront == "" {
		return false, errors.New("未上传新的身份证图片")
	}

	if putUserDoctorRequest.IdCardFront != "" {
		idCardFront := strings.Replace(putUserDoctorRequest.IdCardFront, "https://img.applets.igandanyiyuan.com", "", 1)
		if idCardFront != userDoctorInfo.IdCardFront {
			userDoctorInfoData["id_card_front"] = idCardFront
		}
	}

	// 身份证背面图片
	if userDoctorInfo.IdCardBack != "" && putUserDoctorRequest.IdCardBack == "" {
		return false, errors.New("未上传新的身份证图片")
	}
	if putUserDoctorRequest.IdCardBack != "" {
		idCardBack := strings.Replace(putUserDoctorRequest.IdCardBack, "https://img.applets.igandanyiyuan.com", "", 1)
		if idCardBack != userDoctorInfo.IdCardBack {
			userDoctorInfoData["id_card_back"] = idCardBack
		}
	}

	// 签名图片
	if userDoctorInfo.SignImage != "" && putUserDoctorRequest.SignImage == "" {
		return false, errors.New("未上传新的签名图片")
	}
	if putUserDoctorRequest.SignImage != "" {
		signImage := strings.Replace(putUserDoctorRequest.SignImage, "https://img.applets.igandanyiyuan.com", "", 1)
		if signImage != userDoctorInfo.SignImage {
			userDoctorInfoData["sign_image"] = signImage
		}
	}

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

	// 修改医生数据
	if len(userDoctorData) != 0 {
		err = userDoctorDao.EditUserDoctorById(tx, doctorId, userDoctorData)
		if err != nil {
			tx.Rollback()
			return false, errors.New("修改失败")
		}
	}

	// 修改医生详情数据
	if userDoctorInfo == nil {
		// 新增医生详情表
		if len(userDoctorInfoData) != 0 {
			userDoctorInfo, err := userDoctorInfoDao.AddUserDoctorInfoByMap(tx, userDoctorInfoData)
			if userDoctorInfo == nil || err != nil {
				tx.Rollback()
				return false, errors.New("修改失败")
			}
		}
	} else {
		if len(userDoctorInfoData) != 0 {
			err = userDoctorInfoDao.EditUserDoctorInfoById(tx, userDoctorInfo.DoctorInfoId, userDoctorInfoData)
			if err != nil {
				tx.Rollback()
				return false, errors.New("修改失败")
			}
		}
	}

	// 修改医生数据
	if len(userDoctorData) != 0 {
		err = userDao.EditUserById(tx, userDoctor.UserId, userData)
		if err != nil {
			tx.Rollback()
			return false, errors.New("修改失败")
		}
	}

	// 判断头像是否修改，同步修改im
	if userDoctor.Avatar != avatar {
		profileItem := []tencentIm.ProfileItem{
			{
				Tag:   "Tag_Profile_IM_Image",
				Value: putUserDoctorRequest.Avatar,
			},
		}
		res, err := tencentIm.SetProfile(strconv.FormatInt(userDoctor.UserId, 10), profileItem)
		if err != nil || res != true {
			tx.Rollback()
			return false, errors.New("头像设置失败")
		}
	}

	// 判断科室是否修改，同步修改ca平台
	if userDoctor.DepartmentCustomId != departmentCustomId {
		// 获取科室数据
		hospitalDepartmentCustomDao := dao.HospitalDepartmentCustom{}
		hospitalDepartmentCustom, err := hospitalDepartmentCustomDao.GetHospitalDepartmentCustomById(departmentCustomId)
		if err != nil || hospitalDepartmentCustom == nil {
			tx.Rollback()
			return false, errors.New("科室错误")
		}

		// 获取云证书数据
		userCaCertDao := dao.UserCaCert{}
		userCaCerts, err := userCaCertDao.GetUserCaCertListByUserId(userDoctor.UserId)
		if err != nil {
			tx.Rollback()
			return false, errors.New("修改失败")
		}

		if userCaCerts != nil && len(userCaCerts) > 0 {
			// 修改云证书
			editCloudCertRequestData := &ca.EditCloudCertRequestData{
				EntityId:         strconv.FormatInt(userDoctor.UserId, 10),
				EntityType:       "Personal",
				PersonalPhone:    user.Mobile,
				PersonalName:     userDoctorInfo.CardName,
				PersonalIdNumber: userDoctorInfo.CardNum,
				OrgName:          "",
				OrgNumber:        "",
				Pin:              strconv.FormatInt(userDoctor.UserId, 10),
				OrgDept:          hospitalDepartmentCustom.DepartmentName, //  // 卫生证书:医院部门
				Province:         "四川省",
				Locality:         "成都市",
				AuthType:         "实人认证",
				// AuthTime:         strconv.FormatInt(time.Now().Unix(), 10),
				AuthTime:       "1688694270",
				AuthResult:     "认证通过",
				AuthNoticeType: "数字证书变更告知",
			}

			editCloudCertResponse, err := ca.EditCloudCert(editCloudCertRequestData)
			if err != nil || editCloudCertResponse == nil {
				tx.Rollback()
				return false, errors.New(err.Error())
			}

			// 修改ca监管证书表
			userCaCertDao := dao.UserCaCert{}
			data := make(map[string]interface{})
			data["cert_base64"] = editCloudCertResponse.CertBase64
			data["cert_chain_p7"] = editCloudCertResponse.CertP7
			data["cert_serial_number"] = editCloudCertResponse.CertP7
			err = userCaCertDao.EditUserCaCertById(tx, userCaCerts[0].CertId, data)
			if err != nil {
				tx.Rollback()
				return false, errors.New("删除失败")
			}
		}
	}

	// 判断签名图片是否修改，同步修改ca平台
	// 1、新用户，未存在证书
	if putUserDoctorRequest.SignImage != "" {
		signImage := strings.Replace(putUserDoctorRequest.SignImage, "https://img.applets.igandanyiyuan.com", "", 1)
		if signImage != userDoctorInfo.SignImage {
			// 检测是否存在云证书
			userCaCertDao := dao.UserCaCert{}
			userCaCerts, err := userCaCertDao.GetUserCaCertListByUserId(userDoctor.UserId)
			if err != nil {
				tx.Rollback()
				return false, errors.New("修改失败")
			}

			if userCaCerts != nil && len(userCaCerts) > 0 {
				userCaCert := userCaCerts[0]
				// 检测是否已经添加签章配置
				if userCaCert.IsSignConfig == 1 {
					// 修改签章配置为未添加
					data := make(map[string]interface{})
					data["is_sign_config"] = 0
					err = userCaCertDao.EditUserCaCertById(tx, userCaCert.CertId, data)
					if err != nil {
						tx.Rollback()
						return false, errors.New(err.Error())
					}

					// 删除签章配置
					deleteUserSignConfigRequestData := &ca.DeleteUserSignConfigRequestData{
						UserId:    strconv.FormatInt(userDoctor.UserId, 10),
						ConfigKey: strconv.FormatInt(userDoctor.UserId, 10),
					}

					_, err := ca.DeleteUserSignConfig(deleteUserSignConfigRequestData)
					if err != nil {
						tx.Rollback()
						return false, errors.New(err.Error())
					}
				}
			}

		}
	}

	tx.Commit()
	return true, nil
}

// AddUserDoctor 新增医生
func (r *UserDoctorService) AddUserDoctor(userId string, a requests.AddUserDoctor) (bool, error) {
	userDoctorDao := dao.UserDoctorDao{}
	userDao := dao.UserDao{}
	userDoctorInfoDao := dao.UserDoctorInfoDao{}

	// 检测手机号是否重复
	maps := make(map[string]interface{})
	maps["mobile"] = a.Mobile
	users, err := userDao.GetUserList(maps)
	if err != nil {
		return false, errors.New("新增失败")
	}

	if len(users) != 0 {
		return false, errors.New("手机号重复")
	}

	// 检测身份证号码
	res, err := utils.CheckCardNum(a.CardNum)
	if !res || err != nil {
		return false, errors.New("身份证号错误")
	}

	// 检测身份证号是否重复
	maps = make(map[string]interface{})
	maps["card_num"] = a.CardNum
	userDoctorInfos, err := userDoctorInfoDao.GetUserDoctorInfoList(maps)
	if err != nil {
		return false, errors.New("新增失败")
	}

	if len(userDoctorInfos) != 0 {
		return false, errors.New("证件号码重复")
	}

	// 处理年龄
	age, err := utils.GetCardAge(a.CardNum)
	if err != nil {
		return false, errors.New(err.Error())
	}

	// 处理性别
	sex, err := utils.GetCardSex(a.CardNum)
	if err != nil {
		return false, errors.New(err.Error())
	}

	// 身份证号码脱敏
	cardNumMask := utils.GetMaskCardNum(a.CardNum)

	// 身份证名称脱敏
	cardNameMask := utils.GetMaskCardName(a.CardName)

	// 检测科室
	departmentCustomId, err := strconv.ParseInt(a.DepartmentCustomId, 10, 64)
	if err != nil {
		return false, errors.New("科室错误")
	}

	// 获取科室数据
	hospitalDepartmentCustomDao := dao.HospitalDepartmentCustom{}
	hospitalDepartmentCustom, err := hospitalDepartmentCustomDao.GetHospitalDepartmentCustomById(departmentCustomId)
	if err != nil || hospitalDepartmentCustom == nil {
		return false, errors.New("科室错误")
	}

	// 检测医院
	hospitalId, err := strconv.ParseInt(a.HospitalId, 10, 64)
	if err != nil {
		return false, errors.New("医院错误")
	}

	// 获取医院数据
	hospitalDao := dao.Hospital{}
	hospital, err := hospitalDao.GetHospitalById(hospitalId)
	if err != nil || hospital == nil {
		return false, errors.New("医院错误")
	}

	// 处理头像
	avatar := utils.RemoveOssDomain(a.Avatar)

	// 处理医师执业证
	var licenseCert string
	if len(a.LicenseCert) > 0 {
		result := make([]string, len(a.LicenseCert))
		for i, url := range a.LicenseCert {
			result[i] = utils.RemoveOssDomain(url)
		}

		licenseCert = strings.Join(result, ",")
	}

	// 处理医师资格证
	var qualificationCert string
	if len(a.QualificationCert) > 0 {
		result := make([]string, len(a.QualificationCert))
		for i, url := range a.QualificationCert {
			result[i] = utils.RemoveOssDomain(url)
		}

		qualificationCert = strings.Join(result, ",")
	}

	// 处理医师资格证
	var workCert string
	if len(a.WorkCert) > 0 {
		result := make([]string, len(a.WorkCert))
		for i, url := range a.WorkCert {
			result[i] = utils.RemoveOssDomain(url)
		}

		workCert = strings.Join(result, ",")
	}

	// 处理身份证图片
	var idCardFront string
	var idCardBack string

	if a.IdCardFront != "" {
		idCardFront = utils.RemoveOssDomain(a.IdCardFront)
	}
	if a.IdCardBack != "" {
		idCardBack = utils.RemoveOssDomain(a.IdCardBack)
	}

	// 处理签名图片
	var signImage string
	if a.SignImage != "" {
		signImage = utils.RemoveOssDomain(a.SignImage)
	}

	// 多点执业状态
	var multiPointStatus int
	if a.IdCardFront != "" && a.IdCardBack != "" && a.SignImage != "" {
		multiPointStatus = 2
	}

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

	// 新增用户表数据
	user := &model.User{
		UserName:       a.CardName,
		Mobile:         a.Mobile,
		WxMobile:       a.Mobile,
		UserType:       2,
		UserStatus:     1,
		RegisterMethod: 2,
		Age:            uint(age),
		Sex:            sex,
		Avatar:         avatar,
		CreatedBy:      userId,
	}
	user, err = userDao.AddUser(tx, user)
	if err != nil || user == nil {
		tx.Rollback()
		return false, err
	}

	// 新增医生表
	userDoctor := &model.UserDoctor{
		UserId:                    user.UserId,
		UserName:                  a.CardName,
		Status:                    1,
		IdcardStatus:              1, // 身份证默认审核通过
		IdenAuthStatus:            2,
		MultiPointStatus:          multiPointStatus,
		IsBindBank:                0,
		IsRecommend:               a.IsRecommend,
		Avatar:                    avatar,
		DoctorTitle:               a.DoctorTitle,
		DepartmentCustomId:        departmentCustomId,
		DepartmentCustomName:      a.DepartmentCustomName,
		DepartmentCustomMobile:    a.DepartmentCustomMobile,
		HospitalID:                hospitalId,
		IsPlatformDeepCooperation: a.IsPlatformDeepCooperation,
		BeGoodAt:                  a.BeGoodAt,
		BriefIntroduction:         a.BriefIntroduction,
	}

	userDoctor, err = userDoctorDao.AddUserDoctor(tx, userDoctor)
	if err != nil || userDoctor == nil {
		tx.Rollback()
		return false, err
	}

	// 新增医生详情表
	userDoctorInfo := &model.UserDoctorInfo{
		UserId:               user.UserId,
		DoctorId:             userDoctor.DoctorId,
		CardType:             1,
		CardName:             a.CardName,
		CardNameMask:         cardNameMask,
		CardNum:              a.CardNum,
		CardNumMask:          cardNumMask,
		LicenseCert:          licenseCert,
		QualificationCert:    qualificationCert,
		QualificationCertNum: a.QualificationCertNum,
		WorkCert:             workCert,
		IdCardFront:          idCardFront,
		IdCardBack:           idCardBack,
		SignImage:            signImage,
	}

	userDoctorInfo, err = userDoctorInfoDao.AddUserDoctorInfo(tx, userDoctorInfo)
	if err != nil || userDoctor == nil {
		tx.Rollback()
		return false, err
	}

	tx.Commit()
	return true, nil
}