package service

import (
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"gorm.io/gorm"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/dto"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/extend/aliyun"
	"hospital-admin-api/extend/ca"
	"strconv"
	"strings"
	"time"
)

type UserCaCertService struct {
}

// AddUserCloudCert 申请云证书-个人
func (r *UserCaCertService) AddUserCloudCert(tx *gorm.DB, userId int64) (bool, error) {
	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert != nil {
		return false, errors.New("医生存在正常使用的云证书，请注销后重新申请")
	}

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

	// 定义所需变量
	var departmentCustomId int64 // 自定义科室id
	var cardName string          // 身份证名称
	var cardNum string           // 身份证号码

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

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

		if userDoctor.IdenAuthStatus != 1 {
			return false, errors.New("请先通过身份认证")
		}

		departmentCustomId = userDoctor.DepartmentCustomId // 自定义科室id
		cardName = userDoctorInfo.CardName                 // 身份证名称
		cardNum = userDoctorInfo.CardNum                   // 身份证号码
	}

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

	// 获取标准科室数据
	hospitalDepartmentDao := dao.HospitalDepartment{}
	hospitalDepartment, err := hospitalDepartmentDao.GetHospitalDepartmentById(hospitalDepartmentCustom.DepartmentId)
	if err != nil || hospitalDepartment == nil {
		return false, errors.New("科室错误")
	}

	// 申请云证书
	cloudCertRequestData := &ca.AddCloudCertRequest{
		EntityId:         fmt.Sprintf("%d", userId),
		EntityType:       "Personal",
		PersonalPhone:    user.Mobile,
		PersonalName:     cardName,
		PersonalIdNumber: cardNum,
		OrgName:          "成都金牛欣欣相照互联网医院有限公司",
		OrgNumber:        "91510106MABTJY4K9R",
		Pin:              fmt.Sprintf("%d", userId),
		OrgDept:          hospitalDepartment.DepartmentName, //  // 卫生证书:医院部门
		Province:         "四川省",
		Locality:         "成都市",
		AuthType:         "实人认证",
		AuthTime:         strconv.FormatInt(time.Now().Unix(), 10),
		AuthResult:       "认证通过",
		AuthNoticeType:   "数字证书申请告知",
	}

	cloudCertResponse, err := ca.AddCloudCert(cloudCertRequestData)
	if err != nil || cloudCertResponse == nil {
		return false, errors.New(err.Error())
	}

	// 新增ca监管证书表
	userCaCert = &model.UserCaCert{
		UserId:              &userId,
		IsSystem:            0,
		IsLatest:            1,
		Type:                2,
		CertBase64:          cloudCertResponse.CertBase64,
		CertChainP7:         cloudCertResponse.CertP7,
		CertSerialNumber:    cloudCertResponse.CertSerialnumber,
		CaPin:               fmt.Sprintf("%d", userId),
		IsSignConfig:        0,
		SignConfig:          "",
		CertApplicationTime: model.LocalTime(time.Now()),
		CertExpireTime:      model.LocalTime(time.Now().AddDate(0, 0, 180)), // 180天以后的时间
	}

	userCaCert, err = userCaCertDao.AddUserCaCert(tx, userCaCert)
	if err != nil || userCaCert == nil {
		return false, errors.New(err.Error())
	}

	return true, nil
}

// AddHospitalCloudCert 申请云证书-医院
func (r *UserCaCertService) AddHospitalCloudCert(tx *gorm.DB) (bool, error) {
	var userId int64 = 5345345461
	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["ca_pin"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert != nil {
		return false, errors.New("医院存在正常使用的云证书，请注销后重新申请")
	}

	// 申请云证书
	cloudCertRequestData := &ca.AddCloudCertRequest{
		EntityId:       fmt.Sprintf("%d", userId),
		EntityType:     "Organizational",
		PersonalPhone:  "18221234167",
		OrgName:        "成都金牛欣欣相照互联网医院有限公司",
		OrgNumber:      "91510106MABTJY4K9R",
		Pin:            fmt.Sprintf("%d", userId),
		Province:       "四川省",
		Locality:       "成都市",
		AuthType:       "实人认证",
		AuthTime:       strconv.FormatInt(time.Now().Unix(), 10),
		AuthResult:     "认证通过",
		AuthNoticeType: "数字证书申请告知",
	}

	cloudCertResponse, err := ca.AddCloudCert(cloudCertRequestData)
	if err != nil || cloudCertResponse == nil {
		return false, errors.New(err.Error())
	}

	// 新增ca监管证书表
	userCaCert = &model.UserCaCert{
		UserId:              &userId,
		IsSystem:            1,
		IsLatest:            1,
		Type:                2,
		CertBase64:          cloudCertResponse.CertBase64,
		CertChainP7:         cloudCertResponse.CertP7,
		CertSerialNumber:    cloudCertResponse.CertSerialnumber,
		CaPin:               fmt.Sprintf("%d", userId),
		IsSignConfig:        0,
		SignConfig:          "",
		CertApplicationTime: model.LocalTime(time.Now()),
		CertExpireTime:      model.LocalTime(time.Now().AddDate(0, 0, 180)), // 180天以后的时间
	}

	userCaCert, err = userCaCertDao.AddUserCaCert(tx, userCaCert)
	if err != nil || userCaCert == nil {
		return false, errors.New(err.Error())
	}

	return true, nil
}

// EditUserCloudCert 修改云证书-个人
func (r *UserCaCertService) EditUserCloudCert(tx *gorm.DB, userId int64) (bool, error) {
	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert == nil {
		return false, errors.New("用户未申请云证书，无法修改")
	}

	if userCaCert.IsLatest == 1 {
		return false, errors.New("用户云证书为最新证书，无法修改")
	}

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

	// 定义所需变量
	var departmentCustomId int64 // 自定义科室id
	var cardName string          // 身份证名称
	var cardNum string           // 身份证号码

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

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

		if userDoctor.IdenAuthStatus != 1 {
			return false, errors.New("请先通过身份认证")
		}

		if userDoctor.MultiPointStatus != 1 {
			return false, errors.New("请先完成多点执业认证")
		}

		// 检测是否存在正在审核中的处方
		orderPrescriptionDao := dao.OrderPrescriptionDao{}

		maps := make(map[string]interface{})
		maps["doctor_id"] = userDoctor.DoctorId
		maps["prescription_status"] = 1
		orderPrescription, err := orderPrescriptionDao.GetList(maps)
		if err != nil {
			return false, errors.New("更新云证书失败")
		}

		if len(orderPrescription) > 0 {
			return false, errors.New("存在审核中的处方，请勿更新云证书")
		}

		departmentCustomId = userDoctor.DepartmentCustomId // 自定义科室id
		cardName = userDoctorInfo.CardName                 // 身份证名称
		cardNum = userDoctorInfo.CardNum                   // 身份证号码
	}

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

	// 获取标准科室数据
	hospitalDepartmentDao := dao.HospitalDepartment{}
	hospitalDepartment, err := hospitalDepartmentDao.GetHospitalDepartmentById(hospitalDepartmentCustom.DepartmentId)
	if err != nil || hospitalDepartment == nil {
		return false, errors.New("科室错误")
	}

	// 修改云证书
	cloudCertRequestData := &ca.EditCloudCertRequestData{
		EntityId:         fmt.Sprintf("%d", userId),
		EntityType:       "Personal",
		PersonalPhone:    user.Mobile,
		PersonalName:     cardName,
		PersonalIdNumber: cardNum,
		OrgName:          "成都金牛欣欣相照互联网医院有限公司",
		OrgNumber:        "91510106MABTJY4K9R",
		Pin:              fmt.Sprintf("%d", userId),
		OrgDept:          hospitalDepartment.DepartmentName, //  // 卫生证书:医院部门
		Province:         "四川省",
		Locality:         "成都市",
		AuthType:         "实人认证",
		AuthTime:         strconv.FormatInt(time.Now().Unix(), 10),
		AuthResult:       "认证通过",
		AuthNoticeType:   "数字证书变更告知",
	}

	cloudCertResponse, err := ca.EditCloudCert(cloudCertRequestData)
	if err != nil || cloudCertResponse == nil {
		return false, errors.New(err.Error())
	}

	// 修改ca监管证书表
	data := make(map[string]interface{})
	data["cert_base64"] = cloudCertResponse.CertBase64
	data["cert_chain_p7"] = cloudCertResponse.CertP7
	data["cert_serial_number"] = cloudCertResponse.CertSerialnumber
	err = userCaCertDao.EditUserCaCertById(tx, userCaCert.CertId, data)
	if err != nil {
		return false, errors.New("审核失败")
	}

	return true, nil
}

// RenewUserCloudCert 更新云证书-个人-续约
func (r *UserCaCertService) RenewUserCloudCert(tx *gorm.DB, userId int64) (bool, error) {
	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert == nil {
		return false, errors.New("医生未申请云证书，无法操作")
	}

	if userCaCert.IsLatest == 0 {
		return false, errors.New("医生云证书非最新，请执行更新")
	}

	if !userCaCert.CertExpireTime.IsEmpty() {
		timeDifference := time.Time(userCaCert.CertExpireTime).Sub(time.Now())

		if timeDifference > 60*24*time.Hour {
			return false, errors.New("云证书有效期大于60天，无法更新")
		}
	}

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

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

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

		if userDoctor.IdenAuthStatus != 1 {
			return false, errors.New("请先通过身份认证")
		}

		if userDoctor.MultiPointStatus != 1 {
			return false, errors.New("请先完成多点执业认证")
		}
	}

	// 修改云证书
	cloudCertRequestData := &ca.RenewCloudCertRequest{
		EntityId:       fmt.Sprintf("%d", userId),
		Pin:            fmt.Sprintf("%d", userId),
		AuthType:       "实人认证",
		AuthTime:       strconv.FormatInt(time.Now().Unix(), 10),
		AuthResult:     "认证通过",
		AuthNoticeType: "数字证书更新告知",
	}

	cloudCertResponse, err := ca.RenewCloudCert(cloudCertRequestData)
	if err != nil || cloudCertResponse == nil {
		return false, errors.New(err.Error())
	}

	// 修改ca监管证书表
	data := make(map[string]interface{})
	data["cert_base64"] = cloudCertResponse.CertBase64
	data["cert_chain_p7"] = cloudCertResponse.CertP7
	data["cert_serial_number"] = cloudCertResponse.CertSerialnumber
	err = userCaCertDao.EditUserCaCertById(tx, userCaCert.CertId, data)
	if err != nil {
		return false, errors.New("审核失败")
	}

	return true, nil
}

// RenewHospitalCloudCert 更新云证书-医院-续约
func (r *UserCaCertService) RenewHospitalCloudCert(tx *gorm.DB) (bool, error) {
	var userId int64 = 5345345461

	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["ca_pin"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert == nil {
		return false, errors.New("医院未申请云证书，无法操作")
	}

	if userCaCert.IsLatest == 0 {
		return false, errors.New("医院云证书非最新，无法操作")
	}

	if !userCaCert.CertExpireTime.IsEmpty() {
		timeDifference := time.Time(userCaCert.CertExpireTime).Sub(time.Now())

		if timeDifference > 60*24*time.Hour {
			return false, errors.New("云证书有效期大于60天，无法更新")
		}
	}

	// 修改云证书
	cloudCertRequestData := &ca.RenewCloudCertRequest{
		EntityId:       fmt.Sprintf("%d", userId),
		Pin:            fmt.Sprintf("%d", userId),
		AuthType:       "实人认证",
		AuthTime:       strconv.FormatInt(time.Now().Unix(), 10),
		AuthResult:     "认证通过",
		AuthNoticeType: "数字证书更新告知",
	}

	cloudCertResponse, err := ca.RenewCloudCert(cloudCertRequestData)
	if err != nil || cloudCertResponse == nil {
		return false, errors.New(err.Error())
	}

	// 修改ca监管证书表
	data := make(map[string]interface{})
	data["cert_base64"] = cloudCertResponse.CertBase64
	data["cert_chain_p7"] = cloudCertResponse.CertP7
	data["cert_serial_number"] = cloudCertResponse.CertSerialnumber
	err = userCaCertDao.EditUserCaCertById(tx, userCaCert.CertId, data)
	if err != nil {
		return false, errors.New("更新失败")
	}

	return true, nil
}

// RemoveUserCloudCert 注销云证书-个人
func (r *UserCaCertService) RemoveUserCloudCert(tx *gorm.DB, userId int64) (bool, error) {
	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert == nil {
		return false, errors.New("用户未申请云证书，无法操作")
	}

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

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

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

		if userDoctor.IdenAuthStatus != 1 {
			return false, errors.New("请先通过身份认证")
		}

		if userDoctor.MultiPointStatus != 1 {
			return false, errors.New("请先完成多点执业认证")
		}
	}

	// 注销云证书
	cloudCertRequestData := &ca.RemoveCloudCertRequest{
		EntityId:       fmt.Sprintf("%d", userId),
		Pin:            fmt.Sprintf("%d", userId),
		AuthType:       "实人认证",
		AuthTime:       strconv.FormatInt(time.Now().Unix(), 10),
		AuthResult:     "认证通过",
		AuthNoticeType: "数字证书吊销告知",
	}

	_, err = ca.RemoveCloudCert(cloudCertRequestData)
	if err != nil {
		return false, errors.New(err.Error())
	}

	// 修改ca监管证书表-注销
	err = userCaCertDao.DeleteUserCaCertById(tx, userCaCert.CertId)
	if err != nil {
		return false, errors.New("注销失败")
	}

	return true, nil
}

// AddUserSignConfig 添加用户签章配置
func (r *UserCaCertService) AddUserSignConfig(tx *gorm.DB, req requests.AddUserSignConfig) (bool, error) {
	userCaCertDao := dao.UserCaCertDao{}

	var entityId string      // 唯一标识
	var cardNum string       // 身份证号/信用代码
	var signImagePath string // 签名图片地址

	// 医院-固定
	if req.Type == 1 {
		entityId = "5345345461"
		cardNum = "91510106MABTJY4K9R"
		signImagePath = "basic/file/hospital_signature.png"
	}

	// 医生
	if req.Type == 2 {
		if req.UserId == "" {
			return false, errors.New("缺少用户标识")
		}

		entityId = req.UserId

		// 将 id 转换为 int64 类型
		userId, err := strconv.ParseInt(req.UserId, 10, 64)
		if err != nil {
			return false, errors.New("用户标识错误")
		}

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

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

		if userDoctor.IdenAuthStatus != 1 {
			return false, errors.New("请先通过身份认证")
		}

		if userDoctor.MultiPointStatus != 1 {
			return false, errors.New("请先完成多点执业认证")
		}

		cardNum = userDoctorInfo.CardNum
		signImagePath = strings.TrimLeft(userDoctorInfo.SignImage, "/")
	}

	// 药师
	if req.Type == 3 {
		if req.UserId == "" {
			return false, errors.New("缺少用户标识")
		}

		entityId = req.UserId

		// 将 id 转换为 int64 类型
		userId, err := strconv.ParseInt(req.UserId, 10, 64)
		if err != nil {
			return false, errors.New("用户标识错误")
		}

		// 获取药师详情数据
		userPharmacistInfoDao := dao.UserPharmacistInfoDao{}
		userPharmacistInfo, err := userPharmacistInfoDao.GetUserPharmacistInfoByUserId(userId)
		if err != nil || userPharmacistInfo == nil {
			return false, errors.New("药师详情数据错误")
		}

		cardNum = userPharmacistInfo.CardNum
		signImagePath = strings.TrimLeft(userPharmacistInfo.SignImage, "/")
	}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["ca_pin"] = entityId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	if userCaCert == nil {
		return false, errors.New("医生未申请云证书，请申请后添加签章配置")
	}

	if userCaCert.IsSignConfig == 1 {
		return false, errors.New("医生已存在签章配置，请勿重复添加")
	}

	// 下载签章图片
	var style string
	if req.Type == 1 {
		style = "image/resize,w_300,h_300"
	} else {
		style = "image/resize,m_lfit,w_100,h_350"
	}

	signImage, err := aliyun.GetCusTomObjectToRAM(signImagePath, style)
	if err != nil {
		return false, err
	}

	signImage = base64.StdEncoding.EncodeToString([]byte(signImage))

	// 签章配置,JSON
	var signParam map[string]interface{}
	var signParams []map[string]interface{}

	// 医院
	if req.Type == 1 {
		signParam = map[string]interface{}{
			"llx": "370",
			"lly": "210",
			"urx": "520",
			"ury": "360",
		}
	}

	// 医生
	if req.Type == 2 {
		signParam = map[string]interface{}{
			"llx": "120",
			"lly": "190",
			"urx": "190",
			"ury": "140",
		}
	}

	// 药师
	if req.Type == 2 {
		signParam = map[string]interface{}{
			"llx": "350",
			"lly": "190",
			"urx": "440",
			"ury": "140",
		}
	}

	signParam["pageList"] = []int{1}
	signParam["sealImg"] = signImage

	signParams = append(signParams, signParam)

	signParamJson, err := json.Marshal(signParams)
	if err != nil {
		return false, err
	}

	// 添加签章配置
	cloudCertRequestData := &ca.AddUserSignConfigRequest{
		UserId:    fmt.Sprintf("%d", entityId),
		ConfigKey: fmt.Sprintf("%d", entityId),
		CertSn:    cardNum,
		SignParam: string(signParamJson),
		SealImg:   signImage,
	}

	_, err = ca.AddUserSignConfig(cloudCertRequestData)
	if err != nil {
		return false, errors.New(err.Error())
	}

	// 修改ca监管证书表
	data := make(map[string]interface{})
	data["is_sign_config"] = 1
	data["sign_config"] = string(signParamJson)
	err = userCaCertDao.EditUserCaCertById(tx, userCaCert.CertId, data)
	if err != nil {
		return false, errors.New("修改签证配置失败")
	}

	return true, nil
}

// GetHospitalCloudCert 获取医院云证书数据
func (r *UserCaCertService) GetHospitalCloudCert() (g *dto.UserCaCertDto, err error) {
	var userId int64 = 5345345461
	userCaCertDao := dao.UserCaCertDao{}

	// 检测是否存在云证书
	maps := make(map[string]interface{})
	maps["is_system"] = 1
	maps["ca_pin"] = userId
	maps["type"] = 2
	userCaCert, _ := userCaCertDao.GetUserCaCert(maps)
	g = dto.GetUserCaCertDto(userCaCert)

	return g, nil
}