package controller

import (
	"case-admin-api/api/dao"
	"case-admin-api/api/dto"
	"case-admin-api/api/model"
	"case-admin-api/api/requests"
	"case-admin-api/api/responses"
	"case-admin-api/api/service"
	"case-admin-api/extend/app"
	"case-admin-api/global"
	"case-admin-api/utils"
	"github.com/gin-gonic/gin"
	"strconv"
)

type ProjectPlatformDoctor struct{}

// GetProjectPlatformDoctorPage 获取列表-分页
func (b *ProjectPlatformDoctor) GetProjectPlatformDoctorPage(c *gin.Context) {
	ProjectPlatformDoctorRequest := requests.ProjectPlatformDoctorRequest{}
	req := ProjectPlatformDoctorRequest.GetProjectPlatformDoctorPage
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	if req.Page == 0 {
		req.Page = 1
	}

	if req.PageSize == 0 {
		req.PageSize = 20
	}

	// 获取数据
	ProjectPlatformDoctorDao := dao.ProjectPlatformDoctorDao{}
	projectPlatformDoctors, total, err := ProjectPlatformDoctorDao.GetProjectPlatformDoctorPageSearch(req, req.Page, req.PageSize)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	g := dto.GetProjectPlatformDoctorListDto(projectPlatformDoctors)

	result := make(map[string]interface{})
	result["page"] = req.Page
	result["page_size"] = req.PageSize
	result["total"] = total
	result["data"] = g
	responses.OkWithData(result, c)
}

// PutProjectPlatformDoctorStatus 操作状态
func (b *ProjectPlatformDoctor) PutProjectPlatformDoctorStatus(c *gin.Context) {
	ProjectPlatformDoctorRequest := requests.ProjectPlatformDoctorRequest{}
	req := ProjectPlatformDoctorRequest.PutProjectPlatformDoctorStatus
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	id := c.Param("white_doctor_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	whiteDoctorId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	ProjectPlatformDoctorDao := dao.ProjectPlatformDoctorDao{}
	projectPlatformDoctor, err := ProjectPlatformDoctorDao.GetProjectPlatformDoctorById(whiteDoctorId)
	if err != nil {
		responses.FailWithMessage("数据异常", c)
		return
	}

	// 检测状态
	if projectPlatformDoctor.Status == req.Status {
		responses.Ok(c)
		return
	}

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

	projectPlatformDoctorData := make(map[string]interface{})
	projectPlatformDoctorData["status"] = req.Status
	err = ProjectPlatformDoctorDao.EditProjectPlatformDoctorById(tx, whiteDoctorId, projectPlatformDoctorData)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// AddProjectPlatformDoctor 新增
func (b *ProjectPlatformDoctor) AddProjectPlatformDoctor(c *gin.Context) {
	ProjectPlatformDoctorRequest := requests.ProjectPlatformDoctorRequest{}
	req := ProjectPlatformDoctorRequest.AddProjectPlatformDoctor
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 检测项目
	// 将 id 转换为 int64 类型
	projectPlatformId, err := strconv.ParseInt(req.ProjectPlatformId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	projectPlatformDao := dao.ProjectPlatformDao{}
	_, err = projectPlatformDao.GetProjectPlatformById(projectPlatformId)
	if err != nil {
		responses.FailWithMessage("项目未绑定该平台", c)
		return
	}

	// 检测关联医院
	// 将 id 转换为 int64 类型
	userId, err := strconv.ParseInt(req.UserId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	userDao := dao.UserDao{}
	_, err = userDao.GetUserById(userId)
	if err != nil {
		responses.FailWithMessage("用户数据异常", c)
		return
	}

	// 检测是否重复
	projectPlatformDoctorDao := dao.ProjectPlatformDoctorDao{}

	maps := make(map[string]interface{})
	maps["project_platform_id"] = projectPlatformId
	maps["user_id"] = userId
	projectPlatformDoctors, _ := projectPlatformDoctorDao.GetProjectPlatformDoctorList(maps)
	if len(projectPlatformDoctors) > 0 {
		responses.FailWithMessage("重复添加", c)
		return
	}

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

	projectPlatformDoctor := &model.ProjectPlatformDoctor{
		ProjectPlatformId: projectPlatformId,
		UserId:            userId,
		Status:            *req.Status,
	}

	projectPlatformDoctor, err = projectPlatformDoctorDao.AddProjectPlatformDoctor(tx, projectPlatformDoctor)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// DeleteProjectPlatformDoctor 删除
func (b *ProjectPlatformDoctor) DeleteProjectPlatformDoctor(c *gin.Context) {
	id := c.Param("white_doctor_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	whiteDoctorId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	projectPlatformDoctorDao := dao.ProjectPlatformDoctorDao{}
	_, err = projectPlatformDoctorDao.GetProjectPlatformDoctorById(whiteDoctorId)
	if err != nil {
		responses.FailWithMessage("数据异常", c)
		return
	}

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

	err = projectPlatformDoctorDao.DeleteProjectPlatformDoctorById(tx, whiteDoctorId)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// GetProjectPlatformDoctorList 查询app医生-列表
func (b *ProjectPlatformDoctor) GetProjectPlatformDoctorList(c *gin.Context) {
	ProjectPlatformDoctorRequest := requests.ProjectPlatformDoctorRequest{}
	req := ProjectPlatformDoctorRequest.GetProjectPlatformDoctorList
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	var g []*dto.UserDto

	// 获取医院信息-Name
	doctors, err := app.GetDoctorInfoByName(req.UserName)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if len(doctors.Data) <= 0 {
		responses.OkWithData(g, c)
		return
	}

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

	var users []*model.User

	userDao := dao.UserDao{}
	for _, v := range doctors.Data {
		maps := make(map[string]interface{})
		maps["user_iden"] = v.Uuid
		maps["register_source"] = 2
		user, _ := userDao.GetUser(maps)
		if user != nil {
			users = append(users, user)

			continue
		}

		user = &model.User{
			UserIden:         v.Uuid,
			UserName:         v.RealName,
			UserMobile:       v.Mobile,
			MobileEncryption: utils.GenerateMD5(v.Mobile),
			Status:           1,
			RegisterSource:   2,
			OpenId:           "",
			UnionId:          "",
			Sex:              0,
			Avatar:           "",
			Title:            utils.DoctorTitleToInt(v.PositionName),
			DepartmentName:   v.OfficeName,
			Address:          v.ProvName,
		}
		user, err = userDao.AddUser(tx, user)
		if err != nil {
			tx.Rollback()
			responses.OkWithData(g, c)
			return
		}

		users = append(users, user)

		// 检测医院是否存在
		basicHospitalDao := dao.BasicHospitalDao{}
		maps = make(map[string]interface{})
		maps["source"] = 2
		maps["hospital_iden"] = v.HospitalUuid
		basicHospital, _ := basicHospitalDao.GetBasicHospital(maps)
		if basicHospital == nil {
			// 获取医院数据
			hospitalData, err := app.GetHospitalByUuid(v.HospitalUuid)
			if err != nil {
				tx.Rollback()
				responses.OkWithData(g, c)
				return
			}

			// 添加医院
			hospital := &model.BasicHospital{
				HospitalIden:  v.HospitalUuid,
				HospitalName:  hospitalData.Data.Name,
				Source:        2,
				HospitalLevel: hospitalData.Data.Level,
				DoctorNumber:  hospitalData.Data.ExpertNum,
				Province:      hospitalData.Data.ProvName,
				City:          "",
				County:        "",
				Address:       "",
			}

			basicHospital, err = basicHospitalDao.AddBasicHospital(tx, hospital)
			if err != nil {
				tx.Rollback()
				responses.OkWithData(g, c)
				return
			}

			// 修改用户所属医院
			dataMaps := make(map[string]interface{})
			dataMaps["hospital_id"] = basicHospital.HospitalId
			err = userDao.EditUserById(tx, user.UserId, dataMaps)
			if err != nil {
				tx.Rollback()
				responses.OkWithData(g, c)
				return
			}
		}
	}

	g = dto.GetUserListDto(users)

	tx.Commit()
	responses.OkWithData(g, c)
}

// ExportProjectPlatformDoctor 导出
func (r *ProjectPlatformDoctor) ExportProjectPlatformDoctor(c *gin.Context) {
	ProjectPlatformDoctorRequest := requests.ProjectPlatformDoctorRequest{}
	req := ProjectPlatformDoctorRequest.ExportProjectPlatformDoctor
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 获取数据
	projectPlatformDoctorDao := dao.ProjectPlatformDoctorDao{}
	projectPlatformDoctors, err := projectPlatformDoctorDao.GetProjectPlatformDoctorExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if len(projectPlatformDoctors) <= 0 {
		responses.FailWithMessage("无数据，不可导出", c)
		return
	}

	// 业务处理
	exportService := service.ExportService{}
	ossAddress, err := exportService.ProjectPlatformDoctor(projectPlatformDoctors)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	responses.OkWithData(ossAddress, c)
}