package crontab

import (
	"context"
	"encoding/json"
	"errors"
	"kpt-pasture/model"
	"kpt-pasture/module/backend"
	"kpt-pasture/util"
	"time"

	"gorm.io/gorm"

	"gitee.com/xuyiping_admin/pkg/xerr"

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"go.uber.org/zap"

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

// GenerateAsynqWorkOrder 异步生成工作单
func (e *Entry) GenerateAsynqWorkOrder() error {
	workOrderList := make([]*model.WorkOrderMaster, 0)
	if err := e.DB.Where("is_show = ?", pasturePb.IsShow_Ok).Find(&workOrderList).Error; err != nil {
		return err
	}
	for _, workOrder := range workOrderList {
		timeUnix, err := util.ConvertParseLocalUnix(workOrder.ExecTime)
		if timeUnix <= 0 || err != nil {
			zaplog.Error("crontab", zap.Any("GenerateWorkOrder", err), zap.Any("execTime", workOrder.ExecTime))
			continue
		}
		execTime := time.Now().Unix() - timeUnix

		if _, err = e.AsynqClient.CtxEnqueue(
			context.Background(),
			model.NewTaskWorkOrderPayload(workOrder.Id, time.Duration(execTime)*time.Second),
		); err != nil {
			zaplog.Error("PushMessage CtxEnqueue", zap.Any("Err", err))
		}
	}
	return nil
}

// GenerateCalendarBySameTimePlan 生成同期计划工作单
func (e *Entry) GenerateCalendarBySameTimePlan(cowList []*model.Cow, sameTime *model.SameTime) error {
	if len(cowList) <= 0 {
		return nil
	}

	cowSameTimeList := make([]*model.SameTimeCow, 0)
	for _, cow := range cowList {
		newCowSameTime, err := e.createNewCowSameTime(cow, sameTime)
		if err != nil {
			zaplog.Error("crontab", zap.Any("GenerateCalendarBySameTimePlan", err), zap.Any("cow", cow))
		}
		cowSameTimeList = append(cowSameTimeList, newCowSameTime)
	}

	calendarName := backend.CalendarTypeMap()[pasturePb.CalendarType_Immunisation]
	workOrderCalendarList := make([]*model.WorkOrderCalendar, 0)
	if len(sameTime.CollateNodes) > 0 {
		collateNodes := make([]*pasturePb.CollateNode, 0)
		var _ = json.Unmarshal([]byte(sameTime.CollateNodes), &collateNodes)
		nowTime := time.Now()
		for i, collateNode := range collateNodes {
			showDay := nowTime.Format(model.LayoutDate2)
			if i > 0 {
				showDay = nowTime.Add(time.Hour * 24 * time.Duration(collateNode.NextNodeDay)).Format(model.LayoutDate2)
			}

			histCount := e.GetTowardSameTimeCowSum(sameTime.Id, showDay)
			workOrderCalendarList = append(workOrderCalendarList, &model.WorkOrderCalendar{
				Name:         calendarName,
				CalendarType: pasturePb.CalendarType_Immunisation,
				Count:        int32(len(cowSameTimeList)) + int32(histCount),
				ShowDay:      showDay,
				IsShow:       pasturePb.IsShow_Ok,
			})
		}
	}

	if err := e.DB.Transaction(func(tx *gorm.DB) error {
		// 创建新的牛只同期计划详情
		if err := tx.Create(cowSameTimeList).Error; err != nil {
			return xerr.WithStack(err)
		}
		for _, v := range workOrderCalendarList {
			if err := tx.Model(&model.WorkOrderCalendar{}).Where(map[string]interface{}{
				"calendar_type": v.CalendarType,
				"show_day":      v.ShowDay,
			}).Assign(map[string]interface{}{
				"name":          v.Name,
				"calendar_type": v.CalendarType,
				"count":         v.Count,
				"show_day":      v.ShowDay,
				"is_show":       v.IsShow,
			}).FirstOrCreate(&model.Pen{}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

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

	return nil
}

func (e *Entry) createNewCowSameTime(cow *model.Cow, sameTime *model.SameTime) (*model.SameTimeCow, error) {
	cowSameTime := &model.SameTimeCow{}
	if err := e.DB.Where("cow_id = ?", cow.Id).
		Where("lact = ?", cow.Lact).
		Where("same_time_id = ?", sameTime.Id).
		First(cowSameTime).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return &model.SameTimeCow{
				CowId:      cow.Id,
				SameTimeId: sameTime.Id,
				Status:     pasturePb.SameTimeStatus_No_Start,
				StartAt:    time.Now().Unix(),
				EndAt:      0,
			}, nil
		} else {
			zaplog.Error("crontab", zap.Error(err), zap.Any("GenerateCalendarBySameTimePlan", "error"), zap.Any("cow", cow.Id), zap.Any("lact", cow.Lact))
			return nil, xerr.WithStack(err)
		}
	}
	return cowSameTime, nil
}

func (e *Entry) getWorkOrderCalendar(name string) []*model.WorkOrderCalendar {
	res := make([]*model.WorkOrderCalendar, 0)
	if err := e.DB.Where("name = ?", name).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Find(&res).Error; err != nil {
		zaplog.Error("getWorkOrderCalendar", zap.Any("err", err))
	}
	return res
}

// PregnancyCheck 妊娠期检查
func (e *Entry) PregnancyCheck() error {

	return nil
}