package controller

import (
	"encoding/json"
	"github.com/gin-gonic/gin"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/model"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/api/responses"
	"hospital-admin-api/api/service"
	"hospital-admin-api/global"
	"hospital-admin-api/utils"
)

// Export 导出
type Export struct{}

// DoctorWithdrawal 提现记录
func (r *Export) DoctorWithdrawal(c *gin.Context) {
	doctorWithdrawalRequest := requests.DoctorWithdrawalRequest{}
	req := doctorWithdrawalRequest.DoctorWithdrawalExportList
	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
	}

	// 获取数据
	doctorWithdrawalDao := dao.DoctorWithdrawalDao{}
	doctorWithdrawals, err := doctorWithdrawalDao.GetDoctorWithdrawalExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "提现记录",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// DoctorWithdrawalOrder 提现记录-关联订单
func (r *Export) DoctorWithdrawalOrder(c *gin.Context) {
	doctorWithdrawalRequest := requests.DoctorWithdrawalRequest{}
	req := doctorWithdrawalRequest.DoctorWithdrawalOrderExportList
	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
	}

	// 获取数据
	doctorWithdrawalOrderDao := dao.DoctorWithdrawalOrderDao{}
	doctorWithdrawalOrders, err := doctorWithdrawalOrderDao.GetDoctorWithdrawalOrderExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "提现记录-关联订单",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// UserDoctor 医生列表
func (r *Export) UserDoctor(c *gin.Context) {
	userDoctorRequest := requests.UserDoctorRequest{}
	req := userDoctorRequest.UserDoctorExportList

	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
	}

	// 获取数据
	userDoctorDao := dao.UserDoctorDao{}
	userDoctors, err := userDoctorDao.GetUserDoctorExportListSearch(req)

	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "医生列表",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// UserDoctorBankCard 医生银行卡列表
func (r *Export) UserDoctorBankCard(c *gin.Context) {
	userDoctorRequest := requests.UserDoctorRequest{}
	req := userDoctorRequest.UserDoctorBankCardExportList
	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
	}

	// 获取数据
	doctorBankCardDao := dao.DoctorBankCardDao{}
	doctorBankCards, err := doctorBankCardDao.GetDoctorBankCardExportListSearch(req)

	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "医生银行卡列表",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// DoctorAccount 医生账户
func (r *Export) DoctorAccount(c *gin.Context) {
	doctorAccountRequest := requests.DoctorAccountRequest{}
	req := doctorAccountRequest.DoctorAccountExportList
	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
	}

	// 获取数据
	doctorAccountDao := dao.DoctorAccountDao{}
	doctorAccounts, err := doctorAccountDao.GetDoctorAccountExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "医生账户",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// OrderInquiryForAccount 医生账户-关联订单
func (r *Export) OrderInquiryForAccount(c *gin.Context) {
	orderInquiryRequest := requests.OrderInquiryRequest{}
	req := orderInquiryRequest.OrderInquiryForAccountExportList
	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
	}

	// 获取数据
	orderInquiryDao := dao.OrderInquiryDao{}
	orderInquirys, err := orderInquiryDao.GetOrderInquiryForAccountExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "医生账户-关联订单",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// UserPatient 患者列表
func (r *Export) UserPatient(c *gin.Context) {
	userPatientRequest := requests.UserPatientRequest{}
	req := userPatientRequest.UserPatientExportList
	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
	}

	// 获取数据
	userPatientDao := dao.UserPatientDao{}
	userPatients, err := userPatientDao.GetUserPatientExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "患者列表",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// PatientFamily 就诊人列表
func (r *Export) PatientFamily(c *gin.Context) {
	userPatientRequest := requests.PatientFamilyRequest{}
	req := userPatientRequest.PatientFamilyExportList
	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
	}

	// 获取数据
	patientFamilyDao := dao.PatientFamilyDao{}
	patientFamilys, err := patientFamilyDao.GetPatientFamilyExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "就诊人列表",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// OrderInquiry 问诊订单
func (r *Export) OrderInquiry(c *gin.Context) {
	orderInquiryRequest := requests.OrderInquiryRequest{}
	req := orderInquiryRequest.OrderInquiryExportList
	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
	}

	// 获取数据
	orderInquiryDao := dao.OrderInquiryDao{}
	orderInquirys, err := orderInquiryDao.GetOrderInquiryExportListSearch(req)

	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "问诊订单",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// OrderProduct 药品订单
func (r *Export) OrderProduct(c *gin.Context) {
	orderProductRequest := requests.OrderProductRequest{}
	req := orderProductRequest.OrderProductExportList
	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
	}

	// 获取数据
	orderProductDao := dao.OrderProductDao{}
	orderProducts, err := orderProductDao.GetOrderProductExportListSearch(req)

	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	jsonStr, err := json.Marshal(orderProducts)
	utils.LogJsonInfo("打印", string(jsonStr))

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "药品订单",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// OrderPrescription 处方
func (r *Export) OrderPrescription(c *gin.Context) {
	orderPrescriptionRequest := requests.OrderPrescriptionRequest{}
	req := orderPrescriptionRequest.OrderPrescriptionExportList
	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
	}

	// 获取数据
	orderPrescriptionDao := dao.OrderPrescriptionDao{}
	orderPrescriptions, err := orderPrescriptionDao.GetOrderPrescriptionExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "处方",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// Product 系统药品
func (r *Export) Product(c *gin.Context) {
	productRequest := requests.ProductRequest{}
	req := productRequest.ProductExportList
	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
	}

	// 获取数据
	productDao := dao.ProductDao{}
	products, err := productDao.GetProductExportListSearch(req)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "处方",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}

// OrderService 服务包订单
func (r *Export) OrderService(c *gin.Context) {
	orderServicePackageRequest := requests.OrderServicePackageRequest{}
	req := orderServicePackageRequest.OrderServicePackageExportList
	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
	}

	// 获取数据
	orderServicePackageDao := dao.OrderServicePackageDao{}
	orderServicePackage, err := orderServicePackageDao.GetOrderServicePackageExportListSearch(req)

	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 获取当前登陆用户id
	userId := c.GetInt64("UserId")
	if userId != 0 {
		// 记录日志
		logExport := &model.LogExport{
			AdminUserId:  userId,
			ExportModule: "服务包订单",
			ExportFile:   utils.RemoveOssDomain(ossAddress),
		}

		logExportDao := dao.LogExportDao{}
		_, _ = logExportDao.AddLogExportUnTransaction(logExport)
	}

	responses.OkWithData(ossAddress, c)
}