package backend

import (
	"context"
	"errors"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"net/http"
	"strconv"
	"strings"
	"time"

	"gorm.io/gorm"

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

	"gitee.com/xuyiping_admin/pkg/xerr"

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

func (s *StoreEntry) Bar(ctx context.Context) (*pasturePb.BarCowStructResponse, error) {
	barCowStructList := make([]*model.BarCowStruct, 0)
	var count int32 = 0
	if err := s.DB.Model(new(model.Cow)).
		Select("COUNT(*) AS number ,cow_type").
		Where("admission_status = ?", pasturePb.AdmissionStatus_Admission).
		Group("cow_type").
		Find(&barCowStructList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	cowTypeMap := s.CowTypeMap()

	for _, v := range barCowStructList {
		count += v.Number
	}
	return &pasturePb.BarCowStructResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.BarCowStructData{
			List:  model.BarCowStructSlice(barCowStructList).ToPB(cowTypeMap, count),
			Total: 38563,
		},
	}, nil
}

func (s *StoreEntry) NeckRingWarning(ctx context.Context) (*pasturePb.IndexNeckRingResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	estrusWarningCowList := make([]*model.NeckRingEstrus, 0)
	estrusWarningLevelItems := map[int32]int32{
		int32(pasturePb.EstrusLevel_Low):    0,
		int32(pasturePb.EstrusLevel_Middle): 0,
		int32(pasturePb.EstrusLevel_High):   0,
	}
	if err = s.DB.Model(new(model.EventEstrus)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Group("cow_id").Find(&estrusWarningCowList).Error; err != nil {
		zaplog.Error("NeckRingWarning", zap.Any("estrusWarningNumber", err))
	}

	for _, v := range estrusWarningCowList {
		estrusWarningLevelItems[int32(v.Level)] += estrusWarningLevelItems[int32(v.Level)]
	}

	healthWarningNumber := int64(0)
	if err = s.DB.Model(new(model.NeckRingHealthWarning)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Group("cow_id").
		Count(&healthWarningNumber).Error; err != nil {
		zaplog.Error("NeckRingWarning", zap.Any("estrusWarningNumber", err))
	}

	return &pasturePb.IndexNeckRingResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.NeckRingData{
			EstrusWarningNumber:     int32(len(estrusWarningCowList)),
			HealthWarningNumber:     int32(healthWarningNumber),
			AbortionWarningNumber:   0,
			StressWarningNumber:     0,
			EstrusWarningLevelItems: estrusWarningLevelItems,
		},
	}, nil

}

func (s *StoreEntry) FocusIndicatorsList(ctx context.Context, dimension string) (*pasturePb.IndexFocusIndicatorsResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	userFocusIndicators := userModel.SystemUser.IndicatorsKinds
	if len(userFocusIndicators) <= 0 {
		userFocusIndicators = model.DefaultFocusIndicators
	}
	userFocusIndicatorsList := strings.Split(userFocusIndicators, ",")
	indicatorsDataList := make([]*model.IndicatorsData, 0)
	pref := s.DB.Model(new(model.IndicatorsData)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("kind in (?)", userFocusIndicatorsList)

	/*if dimension == "Year" {
		pref.Where("date = ?", time.Now().Format(model.LayoutMonth))
	}*/

	nowTime := time.Now()
	if dimension == "Month" {
		pref.Where("date = ?", nowTime.Format(model.LayoutMonth))
	}

	if err = pref.Find(&indicatorsDataList).Error; err != nil {
		zaplog.Error("FocusIndicators", zap.Any("err", err))
	}

	indicatorsDetailsMap, err := s.GetIndicatorsDetailsMap(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	focusIndicatorsList := make([]*pasturePb.FocusIndicators, 0)
	for _, v := range indicatorsDataList {
		indicatorsDetails, ok := indicatorsDetailsMap[v.Kind]
		if !ok {
			continue
		}
		onYear, onMonth := "", ""
		if dimension == "Year" {
			return nil, xerr.Custom("暂不支持该维度")
		}

		if dimension == "Month" {
			lastMonth := nowTime.AddDate(0, -1, 0).Format(model.LayoutMonth)
			oldIndicators, _ := s.GetIndicatorsDataByDate(userModel.AppPasture.Id, v.Kind, lastMonth)
			if oldIndicators != nil {
				if oldIndicators.Value != "" && oldIndicators.Value != "0" {
					oldValue, _ := strconv.ParseFloat(oldIndicators.Value, 64)
					currValue, _ := strconv.ParseFloat(v.Value, 64)
					onMonthValue := (oldValue - currValue) / oldValue * 100
					omv := util.RoundToTwoDecimals(onMonthValue)
					onMonth = strconv.FormatFloat(omv, 'f', 2, 64) + "%"
				}
			}
		}
		focusIndicatorsList = append(focusIndicatorsList, &pasturePb.FocusIndicators{
			Kind:     indicatorsDetails.Kind,
			Name:     indicatorsDetails.Name,
			Value:    v.Value,
			Describe: indicatorsDetails.Zh,
			UnitName: indicatorsDetails.Unit,
			OnMonth:  onMonth,
			OnYear:   onYear,
		})
	}

	indicatorsDetailsList, _ := s.FindIndicatorsDetailsList(ctx)

	return &pasturePb.IndexFocusIndicatorsResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.FocusData{
			FocusIndicators: focusIndicatorsList,
			IndicatorsSet:   model.IndicatorsDetailsSlice(indicatorsDetailsList).ToPB(userFocusIndicatorsList),
		},
	}, err
}

func (s *StoreEntry) FocusIndicatorsSet(ctx context.Context, req *pasturePb.IndexFocusIndicatorsSetRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	if len(req.IndicatorsKind) <= 0 {
		return nil
	}

	userFocusIndicators := strings.Join(req.IndicatorsKind, ",")
	if err = s.DB.Model(new(model.SystemUser)).Where("id = ?", userModel.SystemUser.Id).Update("indicators_kinds", userFocusIndicators).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) DataWarningSet(ctx context.Context, req *pasturePb.IndexDataWarningSetRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	if len(req.WarningDataSet) <= 0 {
		return nil
	}
	userDataWarningList := make([]*model.DataWarning, 0)
	if err = s.DB.Model(new(model.DataWarning)).
		Where("user_id = ?", userModel.SystemUser.Id).
		Find(&userDataWarningList).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {

		} else {
			return xerr.WithStack(err)
		}
	}
	/*for _, v := range userDataWarningList {

	}*/
	return nil
}

func (s *StoreEntry) DataWarningList(ctx context.Context) (*pasturePb.IndexDataWarningResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	defaultUserDataWarningList, err := s.DefaultDataWarning(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	currentUserDataWarningList := make([]*model.DataWarning, 0)
	if err = s.DB.Model(new(model.DataWarning)).
		Where("user_id = ?", userModel.SystemUser.Id).
		Find(&currentUserDataWarningList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	// 如果用户没有配置自己的预警数据，则使用默认数据
	if len(currentUserDataWarningList) <= 0 {
		currentUserDataWarningList = defaultUserDataWarningList
	}

	if len(currentUserDataWarningList) <= 0 {
		return nil, xerr.Custom("当前用户未配置预警数据，请联系管理员！")
	}

	warningIds := make([]int64, 0)
	warningMap := make(map[int64]*model.DataWarning)
	dataShow := make([]*pasturePb.WarningDataShow, 0)
	for _, warningData := range currentUserDataWarningList {
		dataUpdateTimeFormat := ""
		if warningData.DataUpdateAt > 0 {
			dataUpdateTimeFormat = time.Unix(warningData.DataUpdateAt, 0).Format(model.LayoutTime)
		}
		dataShow = append(dataShow, &pasturePb.WarningDataShow{
			Name:                 warningData.Name,
			Number:               warningData.DataValue,
			Describe:             warningData.Description,
			DataUpdateTimeFormat: dataUpdateTimeFormat,
		})
		warningMap[warningData.Id] = warningData
		// 如果预警数据更新时间大于预警条件更新时间，则跳过
		if warningData.DataUpdateAt > warningData.ConditionUpdateAt {
			continue
		}
		warningIds = append(warningIds, warningData.Id)

	}

	dataWaningItems := make([]*model.DataWarningItems, 0)
	if err = s.DB.Model(new(model.DataWarningItems)).
		Where("warning_id in (?)", warningIds).
		Find(&dataWaningItems).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	dataSet := make([]*pasturePb.WarningDataSet, 0)
	for _, v := range dataWaningItems {
		warningData := warningMap[v.WarningId]
		dataSet = append(dataSet, &pasturePb.WarningDataSet{
			WarningId: int32(v.WarningId),
			GroupId:   v.GroupId,
			Name:      warningData.Name,
			FieldDesc: v.FieldDesc,
			Operator:  v.Operator,
			Value:     v.Value,
			Kind:      warningData.Kind,
			IsShow:    pasturePb.IsShow_Ok,
		})
	}

	return &pasturePb.IndexDataWarningResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.DataWarning{
			DataSet:  dataSet,
			DataShow: dataShow,
		},
	}, nil
}

func (s *StoreEntry) DefaultDataWarning(ctx context.Context) ([]*model.DataWarning, error) {
	defaultUserDataWarningList := make([]*model.DataWarning, 0)
	if err := s.DB.Model(new(model.DataWarning)).
		Where("user_id = ?", model.DefaultUserId).
		Find(&defaultUserDataWarningList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return defaultUserDataWarningList, nil
}