package common_models

import (
	"encoding/json"
	"strconv"
	"time"
)

// AggThresholdItem 阈值项模型
type AggThresholdItem struct {
	Item        int     `json:"item"` // item -> t_factor_proto_item(id)
	FieldName   string  `json:"field_name"`
	Name        string  `json:"name"`
	Level       int     `json:"level"`
	Lower       float64 `json:"lower"`
	Upper       float64 `json:"upper"`
	Begin       *int    `json:"begin"`                  // 分时阈值起始时间(24小时制 0~24)
	End         *int    `json:"end"`                    // 分时阈值结束时间(24小时制 0~24)
	AggCategory *int    `json:"agg_category,omitempty"` // 在JSON编码时，如果此字段为空，则忽略该字段
	FuncType    *int    `json:"func_type,omitempty"`    // 在JSON编码时，如果此字段为空，则忽略该字段
}

func (t *AggThresholdItem) IsTimeSegmented() bool {
	return t.Begin != nil && t.End != nil
}

func (t *AggThresholdItem) RangeText() string {
	lowerText := "-"
	if t.Lower > -100000.0 {
		lowerText = strconv.FormatFloat(t.Lower, 'f', -1, 64)
	}

	upperText := "+"
	if t.Upper < 100000.0 {
		upperText = strconv.FormatFloat(t.Upper, 'f', -1, 64)
	}

	return lowerText + "~" + upperText
}

// AggThresholdItems 自定义类型，[]AggThresholdItem 的别名
type AggThresholdItems []AggThresholdItem

func (t *AggThresholdItems) MarshalBinary() (data []byte, err error) {
	return json.Marshal(t)
}

func (t *AggThresholdItems) UnmarshalBinary(data []byte) error {
	return json.Unmarshal(data, t)
}

// AggThreshold 阈值模型
type AggThreshold struct {
	Items AggThresholdItems
}

// FindThresholdInRange 阈值判断
func (t *AggThreshold) FindThresholdInRange(items []AggThresholdItem, m float64) *AggThresholdItem {
	for _, th := range items {
		if m > th.Lower && m <= th.Upper {
			return &th
		}
	}
	return nil
}

// GetThresholdsByItem 根据监测项ID获取阈值
func (t *AggThreshold) GetThresholdsByItem(items []AggThresholdItem, itemID int) []AggThresholdItem {
	var filtered []AggThresholdItem
	for _, th := range items {
		if th.Item == itemID {
			filtered = append(filtered, th)
		}
	}
	return filtered
}

// GetThresholdsByTime 根据时间获取阈值
func (t *AggThreshold) GetThresholdsByTime(date time.Time) []AggThresholdItem {
	if t.Items == nil || len(t.Items) == 0 {
		return nil
	}

	if !t.Items[0].IsTimeSegmented() {
		return t.Items
	}

	hour := date.Hour()
	minute := date.Minute()
	sec := date.Second()

	if hour == 0 && minute == 0 && sec == 0 {
		return t.filterByZero(t.Items, hour)
	} else if minute == 0 && sec == 0 {
		return t.filterByHour(t.Items, hour)
	} else {
		return t.filterByNormal(t.Items, hour)
	}
}

// 0点时间的阈值模型
func (t *AggThreshold) filterByZero(items []AggThresholdItem, hour int) []AggThresholdItem {
	var filteredItems []AggThresholdItem
	for _, item := range items {
		if item.Begin != nil && *item.Begin == hour {
			filteredItems = append(filteredItems, item)
		}
	}
	return filteredItems
}

// 整点时间的阈值模型
func (t *AggThreshold) filterByHour(items []AggThresholdItem, hour int) []AggThresholdItem {
	var filteredItems []AggThresholdItem
	for _, item := range items {
		if item.Begin != nil && item.End != nil && *item.Begin < hour && *item.End >= hour {
			filteredItems = append(filteredItems, item)
		}
	}
	return filteredItems
}

// 常规时间的阈值模型
func (t *AggThreshold) filterByNormal(items []AggThresholdItem, hour int) []AggThresholdItem {
	var filteredItems []AggThresholdItem
	for _, item := range items {
		if item.Begin != nil && item.End != nil && *item.Begin <= hour && *item.End > hour {
			filteredItems = append(filteredItems, item)
		}
	}
	return filteredItems
}