package core

import (
	"fmt"
	"log"
	"strconv"
	"strings"
)

type RuleHourRange struct {
	Min uint32 // seconds
	Max uint32 // seconds
}

type RuleDateRange struct {
	Min string //
	Max string //
}

type RuleDay struct {
	Op    RULE_OP
	Value int16 // 0-6
}

type RuleDayComplex RuleComplex[RuleDay]

// Value和ts选一个
type RuleTime struct {
	Op    RULE_OP
	Value string // 2019-06-06 17:20:20
	Ts    int64  // unix timestamp
}

type RuleTimeComplex RuleComplex[RuleTime]

// value/ts/h 三个选一个， 优先级从前往后
type RuleHour struct {
	Op     RULE_OP
	Value  string // 17:00:01
	Ts     int64  // total seconds, parse to string
	Hour   int16  // 0-24
	Minute int16  // 0-59
	Second int16  // 0-59
}

type RuleHourComplex RuleComplex[RuleHour]

type TimeOption struct {
	UTC       *bool
	HourRange *RuleHourRange // seconds, 00:01, TimeStart/TimeStop
	DateRange *RuleDateRange // DateStart/DateStop
	// for nftables: Sunday=0, Saturday=6;
	// for iptables, Mon=1,Sun=7;
	// 字符格式两个都支持,但是iptables支持的字符格式严格
	// 1-6表示的是一样，区别是0/7， 也就是0=7=Sunday
	WeekDays  []uint16
	MonthDays []uint16 // iptables 支持，我们暂时不需要

	// TODO: BELLOWs, nftables may be support, but iptables not support
	Time        *RuleTime // uint64 // timestamp of packet reception,
	TimeComplex *RuleTimeComplex
	Day         *RuleDay         // day of week
	DayComplex  *RuleDayComplex  // TODO:
	Hour        *RuleHour        // uint16 // hour of day
	HourComplex *RuleHourComplex // TODO:
}

func (a *RuleHourRange) Equal(b *RuleHourRange) bool {
	return a.Min == b.Min && a.Max == b.Max
}
func (a *RuleDateRange) Equal(b *RuleDateRange) bool {
	return a.Min == b.Min && a.Max == b.Max
}

func (a *TimeOption) IsEmpty() bool {
	return a.HourRange == nil && a.DateRange == nil && len(a.WeekDays) == 0
}

func (o *TimeOption) EnsureDateRange() {
	if o.DateRange == nil {
		o.DateRange = &RuleDateRange{}
	}
}
func (o *TimeOption) EnsureHourRange() {
	if o.HourRange == nil {
		o.HourRange = &RuleHourRange{}
	}
}

// both a,b not nil
func (a *TimeOption) Equal(b *TimeOption) bool {
	if !EqualDateRange(a.DateRange, b.DateRange) {
		return false
	}
	if !EqualHourRange(a.HourRange, b.HourRange) {
		return false
	}
	if !EqualSlice(a.WeekDays, b.WeekDays) {
		return false
	}

	// 全空配置
	// if a.IsEmpty() && b.IsEmpty {
	// 	return true
	// }

	return true
}

func EqualDateRange(a, b *RuleDateRange) bool {
	if a == nil && b == nil {
		return true
	}
	return a != nil && b != nil && a.Equal(b)
}

func EqualHourRange(a, b *RuleHourRange) bool {
	if a == nil && b == nil {
		return true
	}
	return a != nil && b != nil && a.Equal(b)
}

func EqualTimeOption(a, b *TimeOption) bool {
	if a == nil && b == nil { // 0/0
		return true
	}
	if a != nil && b != nil { // 1/1
		return a.Equal(b)
	}

	if a != nil {
		return a.IsEmpty() // 1/0
	} else {
		return b.IsEmpty() // 0/1
	}
}

// ts is seconds
func SplitTs(ts uint32) (h uint32, m uint32, s uint32) {
	h = ts / 3600 // 计算小时
	left := ts - h*3600
	m = left / 60
	s = left - m*60
	// m = (ts % 3600) / 60 // 计算剩余分钟,
	// s = ts % 60 // 计算剩余秒数
	return
}

// fmtHour, 00:00, hour:min, without second
func FmtHour(ts uint32) string {
	h, m, _ := SplitTs(ts)
	return fmt.Sprintf("%02d:%02d", h, m)
}

// 00:00:00
func FmtHour2Second(ts uint32) string {
	if ts == 0 {
		return "00:00:00"
	}
	h, m, _ := SplitTs(ts)
	return fmt.Sprintf("%02d:%02d:00", h, m)
}

// Sun,Mon,Tue,Wed,Thu,Fri,Sat
func FmtWeekDayShort(day uint16) string {
	days := []string{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}
	if day <= 6 {
		return days[day]
	}
	if day == 7 {
		return "Sun"
	}
	return ""
}

func FmtWeekDaysShort(days []uint16) string {
	arr := []string{}
	for _, v := range days {
		r := FmtWeekDayShort(v)
		if r != "" {
			arr = append(arr, r)
		}
	}
	return strings.Join(arr, ",")
}

// short days
func ToUInt16WeekDays(days []string) []uint16 {
	arr := []uint16{}
	for _, v := range days {
		switch v {
		case "Sun":
			arr = append(arr, 0)
		case "Mon":
			arr = append(arr, 1)
		case "Tue":
			arr = append(arr, 2)
		case "Wed":
			arr = append(arr, 3)
		case "Thu":
			arr = append(arr, 4)
		case "Fri":
			arr = append(arr, 5)
		case "Sat":
			arr = append(arr, 6)
		}
	}
	return arr
}

// 为了更完整，我们还可以添加一个专门处理时间格式的辅助函数
// parseTimeRange 解析时间范围参数（可选）
func ParseTimeRange(value string) map[string]string {
	// 时间格式可能是: HH:MM, HH:MM:SS, 或者时间范围 HH:MM-HH:MM
	result := make(map[string]string)

	if strings.Contains(value, "-") {
		parts := strings.Split(value, "-")
		if len(parts) == 2 {
			result["start"] = parts[0]
			result["end"] = parts[1]
		}
	} else {
		result["single"] = value
	}

	return result
}

// remove " from start and end
func TrimStr(str string) string {
	// strings.Trim(str, "\"")
	if strings.HasPrefix(str, "\"") {
		return str[1 : len(str)-1]
	}
	return str
}

// h:m
// "01:00" or 01:00
// get seconds
func ParseHourStr(str string) uint32 {
	str = TrimStr(str)
	arr := strings.Split(str, ":")
	h, err := strconv.ParseUint(arr[0], 10, 16)
	if err != nil {
		log.Printf("parse hour-0[%s] err: %+v\n", arr[0], err)
		return 0
	}
	m, err := strconv.ParseUint(arr[1], 10, 16)
	if err != nil {
		log.Printf("parse hour-1[%s] err: %+v\n", arr[1], err)
		return 0
	}
	return uint32(3600*h + m*60)
}