package backend

import (
	"context"
	"fmt"
	"kpt-pasture/model"
	"net/http"
	"strings"
	"time"

	"gorm.io/gorm"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	"gitee.com/xuyiping_admin/pkg/xerr"
)

// CowDiseaseCreate 牛只发病提交
func (s *StoreEntry) CowDiseaseCreate(ctx context.Context, req *pasturePb.EventCowDiseaseRequest) error {
	cow, err := s.GetCowInfoByCowId(ctx, int64(req.CowId))
	if err != nil {
		return xerr.WithStack(err)
	}

	operationUser, err := s.GetSystemUserById(ctx, int64(req.OperationId))
	if err != nil {
		return xerr.WithStack(err)
	}

	currUser, err := s.GetCurrentSystemUser(ctx)
	if err != nil {
		return xerr.Custom("登录信息错误")
	}

	disease, err := s.GetDiseaseById(ctx, req.DiseaseId)
	if err != nil {
		return xerr.WithStack(err)
	}
	prescription := &model.Prescription{}
	if req.PrescriptionId > 0 {
		prescription, err = s.GetPrescriptionById(ctx, req.PrescriptionId)
		if err != nil {
			return xerr.WithStack(err)
		}
	}

	defer func() {
		if req.PenId > 0 {
			s.UpdateCowPenId(ctx, int64(req.CowId), int64(req.PenId))
		}
	}()

	newEventCowDisease := model.NewEventCowDisease(cow, disease, req, operationUser, currUser)
	if prescription.Id > 0 {
		newEventCowDisease.HealthStatus = pasturePb.HealthStatus_Treatment
	}

	var newEventCowTreatment *model.EventCowTreatment
	var newCowTreatmentRequest *pasturePb.CowTreatmentRequest
	unitMap := s.UnitMap()
	diseaseTypeMap := s.DiseaseTypeMap()
	if prescription.Id > 0 {
		prescriptionDrugs, err := s.PrescriptionDrugsByPrescriptionId(ctx, prescription.Id)
		if err != nil {
			return xerr.WithStack(err)
		}
		prescriptionDetail := make([]*pasturePb.TreatmentDrugs, len(prescriptionDrugs))
		for i, v := range prescriptionDrugs {
			prescriptionDetail[i] = &pasturePb.TreatmentDrugs{
				DrugsId:   int32(v.DrugsId),
				DrugsName: v.DrugsName,
				Unit:      v.Unit,
				UnitName:  unitMap[v.Unit],
				UseNum:    float32(v.Dosages),
			}
		}

		newCowTreatmentRequest = &pasturePb.CowTreatmentRequest{
			CowId:              req.CowId,
			PrescriptionId:     prescription.Id,
			DiseaseId:          req.DiseaseId,
			DiseaseName:        disease.Name,
			PrescriptionDetail: prescriptionDetail,
			TreatmentResult:    pasturePb.TreatmentResult_GoOn,
			Remarks:            req.Remarks,
			TreatmentAt:        req.DiseaseAt,
		}
	} else {
		if len(req.PrescriptionDetail) <= 0 {
			return xerr.Custom("请填写治疗处方详情")
		}
		prescriptionDetail := make([]*pasturePb.TreatmentDrugs, len(req.PrescriptionDetail))
		for i, v := range req.PrescriptionDetail {
			if v.DrugsId <= 0 {
				return xerr.Custom("请选择药方中的药品")
			}
			drugsData, err := s.GetDrugsById(ctx, int64(v.DrugsId))
			if err != nil {
				return xerr.WithStack(err)
			}
			prescriptionDetail[i] = &pasturePb.TreatmentDrugs{
				DrugsId:   v.DrugsId,
				DrugsName: drugsData.Name,
				Unit:      v.Unit,
				UnitName:  unitMap[v.Unit],
				UseNum:    float32(v.UseNum),
			}
		}
		req.PrescriptionDetail = prescriptionDetail
		newCowTreatmentRequest = &pasturePb.CowTreatmentRequest{
			CowId:              req.CowId,
			PrescriptionId:     prescription.Id,
			DiseaseId:          req.DiseaseId,
			DiseaseName:        disease.Name,
			PrescriptionDetail: req.PrescriptionDetail,
			TreatmentResult:    pasturePb.TreatmentResult_GoOn,
			Remarks:            req.Remarks,
			TreatmentAt:        req.DiseaseAt,
		}
	}

	newEventCowTreatment = model.NewEventCowTreatment(prescription, newCowTreatmentRequest, diseaseTypeMap, operationUser)
	newEventCowDisease.DiagnosedAt = int64(req.DiseaseAt)

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if err = tx.Model(new(model.EventCowDisease)).Create(newEventCowDisease).Error; err != nil {
			return xerr.WithStack(err)
		}

		// 创建治疗记录
		if err = tx.Model(new(model.EventCowTreatment)).Create(newEventCowTreatment).Error; err != nil {
			return xerr.WithStack(err)
		}

		// 创建新的处方
		if req.PrescriptionId <= 0 {
			newPrescriptionRequest := &pasturePb.PrescriptionRequest{
				Name:                 fmt.Sprintf("%s-%s-%s", disease.Name, time.Now().Format("20060102"), operationUser.Name),
				ApplicableDiseaseIds: []int32{req.DiseaseId},
			}
			newPrescription := model.NewPrescription(newPrescriptionRequest, disease.Name, 1, 0, 0, currUser)
			if err = tx.Create(newPrescription).Error; err != nil {
				return xerr.WithStack(err)
			}
			// 创建处方药品
			drugsList := make([]*pasturePb.PrescriptionDrugsList, len(req.PrescriptionDetail))
			for _, v := range req.PrescriptionDetail {
				drugsList = append(drugsList, &pasturePb.PrescriptionDrugsList{
					DrugsId:   v.DrugsId,
					DrugsName: v.DrugsName,
					Dosages:   int32(v.UseNum),
					Unit:      v.Unit,
					UnitName:  v.UnitName,
					UseDays:   1,
				})
			}
			newPrescriptionDrugs := model.NewPrescriptionDrugs(newPrescription.Id, drugsList)
			if err = tx.Create(&newPrescriptionDrugs).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

		if err = tx.Model(new(model.Cow)).
			Where("id = ?", req.CowId).
			Updates(map[string]interface{}{
				"health_status": pasturePb.HealthStatus_Disease,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}

		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

// CowDiseaseList 发病牛只清单
func (s *StoreEntry) CowDiseaseList(ctx context.Context, req *pasturePb.SearchEventCowTreatmentRequest, pagination *pasturePb.PaginationModel) (*pasturePb.EventCowDiseaseResponse, error) {
	cowDiseaseList := make([]*model.EventCowDisease, 0)
	var count int64 = 0
	pref := s.DB.Select("a.*,b.name").Table(fmt.Sprintf("%s as a", new(model.EventCowDisease).TableName())).
		Joins(fmt.Sprintf("JOIN %s AS b on a.pen_id = b.id", new(model.Pen).TableName())).
		Where("a.diagnosed_result < ?", pasturePb.IsShow_No)

	if len(req.CowIds) > 0 {
		pref.Where("a.cow_id IN ?", req.CowIds)
	}

	if req.DiseaseId > 0 {
		pref.Where("a.disease_id = ?", req.DiseaseId)
	}

	if req.PenId > 0 {
		pref.Where("a.pen_id = ?", req.PenId)
	}

	if req.Lact > 0 {
		pref.Where("a.lact = ?", req.Lact)
	}

	if req.MinDayAge > 0 && req.MaxDayAge > 0 && req.MaxDayAge >= req.MinDayAge {
		pref.Where("a.day_age BETWEEN ? AND ?", req.MinDayAge, req.MaxDayAge)
	}

	if req.HealthStatus > 0 {
		pref.Where("a.health_status = ?", req.HealthStatus)
	}

	if req.DiseasedStartAt > 0 && req.DiseaseEndAt > 0 && req.DiseaseEndAt >= req.DiseasedStartAt {
		pref.Where("a.disease_at BETWEEN ? AND ?", req.DiseasedStartAt, req.DiseaseEndAt)
	}

	if err := pref.Order("a.id desc").
		Count(&count).Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&cowDiseaseList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	healthStatusMap := s.HealthStatusMap()
	return &pasturePb.EventCowDiseaseResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.EventCowDiseaseData{
			List:     model.EventCowDiseaseSlice(cowDiseaseList).ToPB(healthStatusMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

// CowDiseaseDiagnose 发病牛只诊断
func (s *StoreEntry) CowDiseaseDiagnose(ctx context.Context, req *pasturePb.CowDiagnosedRequest) error {
	eventCowDisease := &model.EventCowDisease{}
	if err := s.DB.Where("cow_id = ?", req.CowId).
		Where("id = ?", req.Id).
		First(eventCowDisease).Error; err != nil {
		return xerr.WithStack(err)
	}

	if eventCowDisease.HealthStatus != pasturePb.HealthStatus_Health {
		return xerr.Custom("异常牛只数据")
	}

	currentUser, err := s.GetCurrentSystemUser(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	// 未发病
	if req.DiagnosedResult == pasturePb.IsShow_No {
		if err = s.DB.Model(eventCowDisease).
			Where("id = ?", req.Id).
			Where("cow_id = ?", req.CowId).
			Updates(map[string]interface{}{
				"diagnosed_result":        pasturePb.IsShow_No,
				"diagnose_operation_id":   currentUser.Id,
				"diagnose_operation_name": currentUser.Name,
				"remarks":                 req.Remarks,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}

	// 已发病
	disease, err := s.GetDiseaseById(ctx, req.DiseaseId)
	if err != nil {
		return xerr.WithStack(err)
	}
	systemUser, err := s.GetSystemUserById(ctx, int64(req.OperationId))
	if err != nil {
		return xerr.WithStack(err)
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if err = tx.Model(eventCowDisease).
			Where("id = ?", req.Id).
			Where("cow_id = ?", req.CowId).
			Updates(map[string]interface{}{
				"health_status":           pasturePb.HealthStatus_Disease,
				"diagnosed_result":        pasturePb.IsShow_Ok,
				"diagnose_id":             req.DiseaseId,
				"diagnose_name":           disease.Name,
				"temperature":             int32(req.Temperature * 100),
				"diagnose_operation_id":   req.OperationId,
				"diagnose_operation_name": systemUser.Name,
				"diagnosed_at":            time.Now().Unix(),
			}).Error; err != nil {
			return xerr.WithStack(err)
		}

		if err = tx.Model(new(model.Cow)).
			Where("id = ?", req.CowId).
			Updates(map[string]interface{}{
				"health_status": pasturePb.HealthStatus_Disease,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

// CowDiseaseTreatment 发病牛只治疗
func (s *StoreEntry) CowDiseaseTreatment(ctx context.Context, req *pasturePb.CowTreatmentRequest) error {
	eventCowDisease := &model.EventCowDisease{}
	if err := s.DB.Where("cow_id = ?", req.CowId).
		Where("id = ?", req.Id).
		First(eventCowDisease).Error; err != nil {
		return xerr.WithStack(err)
	}

	if eventCowDisease.HealthStatus != pasturePb.HealthStatus_Disease &&
		eventCowDisease.HealthStatus != pasturePb.HealthStatus_Treatment {
		return xerr.Custom("异常牛只数据")
	}

	systemUser, _ := s.GetSystemUserById(ctx, int64(req.OperationId))
	prescription, err := s.GetPrescriptionById(ctx, req.PrescriptionId)
	if err != nil {
		return xerr.WithStack(err)
	}

	disease, err := s.GetDiseaseById(ctx, eventCowDisease.DiagnoseId)
	if err != nil {
		return xerr.WithStack(err)
	}
	req.DiseaseName = disease.Name
	req.DiseaseType = disease.DiseaseType
	prescriptionDrugs, err := s.PrescriptionDrugsByPrescriptionId(ctx, prescription.Id)
	if err != nil {
		return xerr.WithStack(err)
	}

	unitMap := s.UnitMap()
	prescriptionDetail := make([]*pasturePb.TreatmentDrugs, len(prescriptionDrugs))
	for i, v := range prescriptionDrugs {
		prescriptionDetail[i] = &pasturePb.TreatmentDrugs{
			DrugsId:   int32(v.DrugsId),
			DrugsName: v.DrugsName,
			Unit:      v.Unit,
			UnitName:  unitMap[v.Unit],
			UseNum:    float32(v.Dosages),
		}
	}
	req.PrescriptionDetail = prescriptionDetail
	healthStatus := pasturePb.HealthStatus_Treatment
	if req.TreatmentResult == pasturePb.TreatmentResult_Curable {
		healthStatus = pasturePb.HealthStatus_Curable
	}

	if req.TreatmentResult == pasturePb.TreatmentResult_Out {
		healthStatus = pasturePb.HealthStatus_Out
	}

	if req.TreatmentResult == pasturePb.TreatmentResult_Dead {
		healthStatus = pasturePb.HealthStatus_Dead
	}
	diseaseTypeMap := s.DiseaseTypeMap()
	newEventCowTreatment := model.NewEventCowTreatment(prescription, req, diseaseTypeMap, systemUser)
	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if err = tx.Create(newEventCowTreatment).Error; err != nil {
			return xerr.WithStack(err)
		}

		if err = tx.Model(eventCowDisease).
			Where("id = ?", req.Id).
			Where("cow_id = ?", req.CowId).
			Updates(map[string]interface{}{
				"health_status": healthStatus,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}

		if err = tx.Model(new(model.Cow)).
			Where("id = ?", req.CowId).
			Updates(map[string]interface{}{
				"health_status": healthStatus,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}

		if err = tx.Model(new(model.Prescription)).
			Where("id = ?", prescription.Id).
			Updates(map[string]interface{}{
				"use_count": prescription.UseCount + 1,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

func (s *StoreEntry) DiseaseSuggestPrescription(ctx context.Context, diseaseId int64) (*pasturePb.ConfigOptionsListResponse, error) {
	res := make([]*pasturePb.ConfigOptionsList, 0)
	prescriptionList := make([]*model.Prescription, 0)
	if err := s.DB.Model(new(model.Prescription)).Where("is_show = ?", pasturePb.IsShow_Ok).Find(&prescriptionList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	for _, v := range prescriptionList {
		disabled := false
		if strings.Contains(v.ApplicableDisease, fmt.Sprintf("%d", diseaseId)) {
			disabled = true
		}
		res = append(res, &pasturePb.ConfigOptionsList{
			Value:    v.Id,
			Label:    v.Name,
			Disabled: disabled,
		})
	}

	return &pasturePb.ConfigOptionsListResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data:    res,
	}, nil

}

// CowDiseaseTreatmentDetail 发病牛只治疗详情列表
func (s *StoreEntry) CowDiseaseTreatmentDetail(
	ctx context.Context,
	req *pasturePb.EventCowTreatmentDetailRequest,
	pagination *pasturePb.PaginationModel,
) (*pasturePb.EventCowTreatmentDetailResponse, error) {
	eventCowDiseaseList := make([]*model.EventCowDisease, 0)
	var count int64 = 0
	pref := s.DB.Model(new(model.EventCowDisease)).Where("cow_id = ?", req.CowId)

	if req.DiseaseId > 0 {
		pref.Where("disease_id = ?", req.DiseaseId)
	}

	if req.DiseaseStartAt > 0 && req.DiseaseEndAt > 0 && req.DiseaseStartAt <= req.DiseaseEndAt {
		pref.Where("disease_at BETWEEN ? AND ?", req.DiseaseStartAt, req.DiseaseEndAt)
	}

	if err := pref.Count(&count).
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Order("id desc").
		Find(&eventCowDiseaseList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	eventCowTreatmentList := make([]*model.EventCowTreatment, 0)
	cowDiseaseIds := make([]int64, len(eventCowDiseaseList))
	for i, v := range eventCowDiseaseList {
		cowDiseaseIds[i] = v.Id
	}

	if err := s.DB.Model(new(model.EventCowTreatment)).
		Select("*").Where("cow_disease_id IN ?", cowDiseaseIds).
		Where("cow_id = ?", req.CowId).
		Group("cow_disease_id").
		Order("id desc").
		Find(&eventCowTreatmentList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.EventCowTreatmentDetailResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.EventCowTreatmentDetail{
			List:     model.EventCowTreatmentSlice(eventCowTreatmentList).ToPB(eventCowDiseaseList),
			Total:    int32(count),
			PageSize: pagination.Page,
			Page:     pagination.PageSize,
		},
	}, nil
}

func (s *StoreEntry) CowDiseaseCurable(ctx context.Context, req *pasturePb.EventCowCurableRequest) error {
	eventCowDiseaseList := make([]*model.EventCowDisease, 0)
	if err := s.DB.Where("id IN ?", req.Ids).
		Where("health_status = ?", pasturePb.HealthStatus_Treatment).
		Find(&eventCowDiseaseList).Error; err != nil {
		return xerr.WithStack(err)
	}

	if len(eventCowDiseaseList) == 0 {
		return nil
	}
	if len(eventCowDiseaseList) != len(req.Ids) {
		return xerr.New("id 参数错误")
	}
	operationUser, err := s.GetSystemUserById(ctx, int64(req.OperationId))
	if err != nil {
		return xerr.WithStack(err)
	}
	eventCowTreatmentList := make([]*model.EventCowTreatment, 0)
	for _, v := range eventCowDiseaseList {
		eventCowTreatmentList = append(eventCowTreatmentList, &model.EventCowTreatment{
			CowId:              v.CowId,
			CowDiseaseId:       v.Id,
			DiseaseId:          int64(v.DiseaseId),
			DiseaseName:        v.DiseaseName,
			PrescriptionId:     0,
			PrescriptionName:   "",
			PrescriptionDetail: "",
			TreatmentResult:    pasturePb.TreatmentResult_Curable,
			OperationId:        operationUser.Id,
			OperationName:      operationUser.Name,
			Remarks:            req.Remarks,
			TreatmentAt:        int64(req.CurableAt),
		})
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if err = tx.Model(model.EventCowDisease{}).Where("id IN ?", req.Ids).
			Where("health_status = ?", pasturePb.HealthStatus_Treatment).Updates(map[string]interface{}{
			"health_status":    pasturePb.HealthStatus_Curable,
			"diagnosed_result": pasturePb.IsShow_Ok,
			"curable_at":       req.CurableAt,
		}).Error; err != nil {
			return xerr.WithStack(err)
		}
		if err = tx.Model(model.Cow{}).Where("id IN ?", req.Ids).Updates(map[string]interface{}{
			"health_status": pasturePb.HealthStatus_Curable,
		}).Error; err != nil {
			return xerr.WithStack(err)
		}

		if err = tx.Model(model.EventCowTreatment{}).Create(eventCowTreatmentList).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}