package backend

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

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

func (s *StoreEntry) PregnantCheckList(ctx context.Context, req *pasturePb.SearchEventRequest, pagination *pasturePb.PaginationModel) (*pasturePb.PregnantCheckEventResponse, error) {
	pregnantCheckList := make([]*model.EventPregnantCheck, 0)
	var count int64 = 0
	pref := s.DB.Table(new(model.EventPregnantCheck).TableName())
	if len(req.CowId) > 0 {
		cowIds := strings.Split(req.CowId, ",")
		pref.Where("cow_id IN ?", cowIds)
	}

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

	pregnantCheckResultMap := s.PregnantCheckResultMap()
	pregnantCheckMethodMap := s.PregnantCheckMethodMap()
	return &pasturePb.PregnantCheckEventResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchPregnantCheckData{
			List:     model.EventPregnantCheckSlice(pregnantCheckList).ToPB(pregnantCheckResultMap, pregnantCheckMethodMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) PregnantCheckCreateBatch(ctx context.Context, req *pasturePb.EventPregnantCheckBatch) error {
	pregnantCheckBatchModelList, err := s.PregnantCheckDataCheck(ctx, req)
	if err != nil {
		return xerr.WithStack(err)
	}
	currentUser, err := s.GetCurrentSystemUser(ctx)
	if err != nil {
		return xerr.Customf("获取当前用户失败: %s", err.Error())
	}

	penMap := s.PenMap(ctx)
	// 新增孕检牛只
	newEventPregnantCheckList := make([]*model.EventPregnantCheck, 0)
	// 更新孕检牛只
	newPregnantCheckBatchModelList := make([]*PregnantCheckBatchModel, 0)
	for _, item := range pregnantCheckBatchModelList {
		itemEventPregnantCheck, err := s.GetEventPregnantCheckIsExIstByCowId(ctx, item.Cow)
		if err != nil {
			return xerr.WithStack(err)
		}

		// 孕检清单里面没有的，需要新增孕检事件
		eventCheckModel := model.NewEventPregnantCheck2(&model.EventPregnantCheck2{
			Cow:                 item.Cow,
			OperationUser:       item.OperationUser,
			CurrentUser:         currentUser,
			PregnantCheckAt:     int64(item.PregnantCheckAt),
			PregnantCheckMethod: item.PregnantCheckMethod,
			PregnantCheckResult: item.PregnantCheckResult,
			Remarks:             item.Remarks,
		}, penMap)
		if itemEventPregnantCheck.Id <= 0 {
			newEventPregnantCheckList = append(newEventPregnantCheckList, eventCheckModel)
		} else {
			item.EventPregnancyCheck = itemEventPregnantCheck
			newPregnantCheckBatchModelList = append(newPregnantCheckBatchModelList, item)
		}
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		// 新增孕检事件
		if len(newEventPregnantCheckList) > 0 {
			if err = tx.Create(newEventPregnantCheckList).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

		for _, item := range newPregnantCheckBatchModelList {
			breedStatus := pasturePb.BreedStatus_Pregnant
			isPregnant := pasturePb.IsShow_Ok
			if item.PregnantCheckResult == pasturePb.PregnantCheckResult_UnPregnant {
				breedStatus = pasturePb.BreedStatus_Empty
				isPregnant = pasturePb.IsShow_No
			}

			// 更新上一次配种结果数据,如何是复检无胎则更新为流产
			if item.EventPregnancyCheck.PregnantCheckName == model.PregnantCheckForSecond {
				breedStatus = pasturePb.BreedStatus_Abort
			}

			// 更新牛只基本信息
			if err = tx.Model(&model.Cow{}).
				Where("cow_id = ?", item.Cow.Id).
				Updates(map[string]interface{}{
					"breed_status":           breedStatus,
					"last_pregnant_check_at": item.PregnantCheckAt,
					"is_pregnant":            isPregnant,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}

			if err = tx.Model(new(model.EventMating)).
				Where("id = (?)", fmt.Sprintf(`
					SELECT id FROM event_mating where cow_id = %d AND status = %d ORDER BY id DESC LIMIT 1
				`, item.Cow.Id, pasturePb.IsShow_Ok)).
				Updates(map[string]interface{}{
					"mating_result":    breedStatus,
					"mating_result_at": item.PregnantCheckAt,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}

			// 更新孕检事件表
			if err = tx.Model(new(model.EventPregnantCheck)).
				Where("id = ?", item.EventPregnancyCheck.Id).
				Updates(map[string]interface{}{
					"reality_day":           item.PregnantCheckAt,
					"pregnant_check_result": item.PregnantCheckResult,
					"pregnant_check_method": item.PregnantCheckMethod,
					"operation_id":          item.OperationUser.Id,
					"operation_name":        item.OperationUser.Name,
					"message_id":            currentUser.Id,
					"message_name":          currentUser.Name,
					"remarks":               item.Remarks,
					"status":                pasturePb.IsShow_Ok,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

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

func (s *StoreEntry) AbortionCreate(ctx context.Context, req *pasturePb.EventAbortionRequest) error {
	cow, err := s.GetCowInfoByCowId(ctx, int64(req.CowId))
	if err != nil {
		return xerr.WithStack(err)
	}

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

	req.OperationName = systemUser.Name
	abortionReasonsMap := s.AbortionReasonsMap()
	newEventAbortion := model.NewEventAbortion(cow, req, abortionReasonsMap)

	lastCowMating := &model.EventMating{}
	if err = s.DB.Model(new(model.EventMating)).Where("cow_id = ?", cow.Id).
		Where("mating_result = ?", pasturePb.MatingResult_Pregnant).
		Order("id desc").First(lastCowMating).Error; err != nil {
		return xerr.WithStack(err)
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		// 创建牛只流产事件数据
		if err = tx.Create(newEventAbortion).Error; err != nil {
			return xerr.WithStack(err)
		}
		// 更新牛只状态
		if err = tx.Model(new(model.Cow)).Where("id = ?", req.CowId).
			Updates(map[string]interface{}{
				"is_pregnant":      pasturePb.IsShow_No,
				"last_abortion_at": req.AbortionAt,
				"breed_status":     pasturePb.BreedStatus_Abort,
			}).Error; err != nil {
			return xerr.WithStack(err)
		}

		// 更新最近一次配种结果为流产
		if err = tx.Model(new(model.EventMating)).
			Where("id = ?", lastCowMating.Id).
			Updates(map[string]interface{}{
				"mating_result":    pasturePb.MatingResult_Abort,
				"mating_result_at": req.AbortionAt,
			}).Error; err != nil {
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

func (s *StoreEntry) AbortionCreateBatch(ctx context.Context, req *pasturePb.EventAbortionBatch) error {
	if len(req.Item) <= 0 {
		return xerr.WithStack(xerr.New("流产数据不能为空"))
	}
	errors := make(map[int32]error)
	for _, v := range req.Item {
		if err := s.AbortionCreate(ctx, v); err != nil {
			errors[v.CowId] = err
		}
	}

	if len(errors) > 0 {
		b, _ := json.Marshal(errors)
		return xerr.WithStack(xerr.Customf("部分流产数据创建失败: %s", string(b)))
	}
	return nil
}

func (s *StoreEntry) AbortionList(
	ctx context.Context,
	req *pasturePb.SearchEventRequest,
	pagination *pasturePb.PaginationModel,
) (*pasturePb.EventAbortionResponse, error) {
	abortionList := make([]*model.EventAbortion, 0)
	var count int64 = 0
	pref := s.DB.Model(new(model.EventAbortion))
	if len(req.CowId) > 0 {
		cowIds := strings.Split(req.CowId, ",")
		pref.Where("cow_id IN ?", cowIds)
	}

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

	return &pasturePb.EventAbortionResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.EventAbortionData{
			List:     model.AbortionSlice(abortionList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}