package controllers

import (
	"encoding/json"
	"fmt"
	"sort"
	"strings"
	"time"

	"server/models"
)

// scPatternDay 排班方案周期规则的每日快照。
//
// AlignMode=1/2/3 时，Plan.Pattern 保存该结构的 JSON 数组：模板的规则在
// 「调用模板」时复制进方案，之后平台模板怎么改都不影响已保存的方案。
// 发布方案时按自然周 / 开始日滚动 / 自然月推算每天命中哪一天规则。
type scPatternDay struct {
	DayIndex  int     `json:"day_index"`
	DayType   int8    `json:"day_type"`
	ShiftID   uint64  `json:"shift_id"`
	ShiftName string  `json:"shift_name"`
	ShortName string  `json:"short_name"`
	Color     string  `json:"color"`
	WorkStart string  `json:"work_start"`
	WorkEnd   string  `json:"work_end"`
	RestStart string  `json:"rest_start"`
	RestEnd   string  `json:"rest_end"`
	WorkHours float64 `json:"work_hours"`
	Remark    string  `json:"remark"`
}

// scPatternFromBody 解析前端提交的 pattern；兼容数组与 JSON 字符串两种形式。
func scPatternFromBody(body map[string]interface{}) []scPatternDay {
	raw, ok := body["pattern"]
	if !ok || raw == nil {
		return nil
	}
	list := []scPatternDay{}
	switch value := raw.(type) {
	case string:
		if strings.TrimSpace(value) == "" {
			return nil
		}
		if err := json.Unmarshal([]byte(value), &list); err != nil {
			return nil
		}
	case []interface{}:
		buf, err := json.Marshal(value)
		if err != nil {
			return nil
		}
		if err := json.Unmarshal(buf, &list); err != nil {
			return nil
		}
	default:
		return nil
	}
	return list
}

func scPatternToJSON(days []scPatternDay) string {
	if len(days) == 0 {
		return ""
	}
	buf, err := json.Marshal(days)
	if err != nil {
		return ""
	}
	return string(buf)
}

func scPatternFromJSON(raw string) []scPatternDay {
	days := []scPatternDay{}
	if strings.TrimSpace(raw) == "" {
		return days
	}
	if err := json.Unmarshal([]byte(raw), &days); err != nil {
		return []scPatternDay{}
	}
	return days
}

// scValidatePattern 校验周期规则，返回补齐默认值并按 day_index 排序后的规则。
func scValidatePattern(days []scPatternDay, alignMode int8, cycleDays int) ([]scPatternDay, string) {
	if alignMode < models.SchedTplAlignWeek || alignMode > models.SchedTplAlignMonth {
		return nil, "排班方式不合法"
	}
	if len(days) == 0 {
		return nil, "缺少排班规则，请重新选择模板或班次"
	}
	if alignMode == models.SchedTplAlignMonth {
		// 月休按自然月计算，周期天数无意义
		cycleDays = 0
	} else {
		if cycleDays < 2 || cycleDays > 31 {
			return nil, "周期天数需在 2~31 天之间"
		}
		if alignMode == models.SchedTplAlignWeek && cycleDays%7 != 0 {
			return nil, "按自然周排班时，周期天数必须是 7 的倍数（7 / 14 / 21 / 28）"
		}
		if len(days) != cycleDays {
			return nil, fmt.Sprintf("周期为 %d 天，需要配置 %d 天的规则", cycleDays, cycleDays)
		}
	}

	seen := map[int]bool{}
	workCount := 0
	result := make([]scPatternDay, 0, len(days))
	for _, item := range days {
		index := item.DayIndex
		if alignMode == models.SchedTplAlignMonth {
			index = len(result)
		}
		if index < 0 || (alignMode != models.SchedTplAlignMonth && index >= cycleDays) {
			return nil, "规则的天序号不合法"
		}
		if seen[index] {
			return nil, "规则的天序号重复"
		}
		seen[index] = true
		if item.DayType != models.SchedTplDayWork && item.DayType != models.SchedTplDayRest {
			return nil, "规则类型不合法（1=上班 2=休息）"
		}

		row := scPatternDay{DayIndex: index, DayType: item.DayType, Remark: strings.TrimSpace(item.Remark)}
		if item.DayType == models.SchedTplDayWork {
			workCount++
			row.ShiftID = item.ShiftID
			row.ShiftName = strings.TrimSpace(item.ShiftName)
			row.ShortName = strings.TrimSpace(item.ShortName)
			row.Color = strings.TrimSpace(item.Color)
			row.WorkStart = strings.TrimSpace(item.WorkStart)
			row.WorkEnd = strings.TrimSpace(item.WorkEnd)
			row.RestStart = strings.TrimSpace(item.RestStart)
			row.RestEnd = strings.TrimSpace(item.RestEnd)
			row.WorkHours = item.WorkHours
			if row.ShiftName == "" {
				return nil, fmt.Sprintf("第 %d 天选择上班，班次不能为空", index+1)
			}
			if row.ShortName == "" {
				row.ShortName = row.ShiftName
			}
			if row.Color == "" {
				row.Color = "#409EFF"
			}
			if !isValidOaTime(row.WorkStart) || !isValidOaTime(row.WorkEnd) {
				return nil, fmt.Sprintf("第 %d 天的上下班时间格式应为 HH:mm", index+1)
			}
			if row.WorkStart == row.WorkEnd {
				return nil, fmt.Sprintf("第 %d 天的上下班时间不能相同", index+1)
			}
			if (row.RestStart == "") != (row.RestEnd == "") {
				return nil, fmt.Sprintf("第 %d 天的休息开始与结束时间需要同时填写", index+1)
			}
			if row.RestStart != "" && (!isValidOaTime(row.RestStart) || !isValidOaTime(row.RestEnd)) {
				return nil, fmt.Sprintf("第 %d 天的休息时间格式应为 HH:mm", index+1)
			}
			if row.WorkHours <= 0 {
				row.WorkHours = scCalcWorkHours(row.WorkStart, row.WorkEnd, row.RestStart, row.RestEnd)
			}
		}
		result = append(result, row)
	}
	if workCount == 0 {
		return nil, "排班规则至少需要一天上班"
	}
	sort.Slice(result, func(i, j int) bool { return result[i].DayIndex < result[j].DayIndex })
	return result, ""
}

// scPrimaryPatternShift 取规则里第一个上班日，用于方案列表展示班次名 / 颜色。
func scPrimaryPatternShift(days []scPatternDay) (scPatternDay, bool) {
	for _, item := range days {
		if item.DayType == models.SchedTplDayWork {
			return item, true
		}
	}
	return scPatternDay{}, false
}

// scPlanPatternDays 取方案中保存的周期规则。
func scPlanPatternDays(plan *models.OaSchedulePlan) []scPatternDay {
	return scPatternFromJSON(plan.Pattern)
}

// scPlanWorkRules 计算方案在日期区间内「需要上班」的日期与对应的班次规则。
//
// fallback 是按星期模式（AlignMode=0）使用的固定班次；模板模式下可为 nil。
// 返回的 map 以日期字符串为键，workdays 为升序的上班日期列表。
func scPlanWorkRules(plan *models.OaSchedulePlan, fallback *models.OaShift, dates []string) (map[string]scPatternDay, []string, string) {
	pattern := scPlanPatternDays(plan)
	if len(pattern) == 0 && fallback == nil {
		return nil, nil, "排班规则为空，请重新选择模板或班次"
	}
	start, ok := scParseDate(normalizeOaDate(plan.StartDate))
	if !ok {
		return nil, nil, "开始日期格式错误"
	}

	rules := make(map[int]scPatternDay, len(pattern))
	for _, item := range pattern {
		rules[item.DayIndex] = item
	}
	weekdays := map[int]bool{}
	if strings.TrimSpace(plan.Weekdays) != "" {
		list := []int{}
		if err := json.Unmarshal([]byte(plan.Weekdays), &list); err == nil {
			for _, day := range list {
				weekdays[day] = true
			}
		}
	}

	result := make(map[string]scPatternDay, len(dates))
	workdays := make([]string, 0, len(dates))
	for _, date := range dates {
		day, valid := scParseDate(date)
		if !valid {
			continue
		}
		rule, work := scRuleForDate(plan, rules, fallback, start, day, weekdays)
		if !work {
			continue
		}
		result[date] = rule
		workdays = append(workdays, date)
	}
	return result, workdays, ""
}

// scRuleForDate 推算某一天命中的规则；第二个返回值表示当天是否上班。
func scRuleForDate(plan *models.OaSchedulePlan, rules map[int]scPatternDay, fallback *models.OaShift,
	start, day time.Time, weekdays map[int]bool) (scPatternDay, bool) {
	switch plan.AlignMode {
	case models.SchedTplAlignWeek:
		weeks := plan.CycleDays / 7
		if weeks < 1 {
			weeks = 1
		}
		startMonday := start.AddDate(0, 0, -scWeekdayOffset(start))
		curMonday := day.AddDate(0, 0, -scWeekdayOffset(day))
		diffWeeks := int(curMonday.Sub(startMonday).Hours()/24) / 7
		weekIndex := scMod(diffWeeks+int(plan.WeekOffset), weeks)
		return scRuleOfDay(rules, weekIndex*7+scWeekdayOffset(day))

	case models.SchedTplAlignRoll:
		cycle := plan.CycleDays
		if cycle < 1 {
			cycle = 1
		}
		diffDays := int(day.Sub(start).Hours() / 24)
		return scRuleOfDay(rules, scMod(diffDays, cycle))

	case models.SchedTplAlignMonth:
		if scMonthRestDay(plan, day) {
			return scPatternDay{}, false
		}
		index := 0
		if rule, ok := rules[0]; ok && rule.DayType != models.SchedTplDayWork {
			for _, item := range rules {
				if item.DayType == models.SchedTplDayWork {
					index = item.DayIndex
					break
				}
			}
		}
		return scRuleOfDay(rules, index)
	}

	// 按星期模式（AlignMode=0）：weekdays 为空表示每天都上班
	weekday := int(day.Weekday())
	if weekday == 0 {
		weekday = 7
	}
	if len(weekdays) > 0 && !weekdays[weekday] {
		return scPatternDay{}, false
	}
	if fallback == nil {
		return scPatternDay{}, false
	}
	return scPatternDay{
		DayType:   models.SchedTplDayWork,
		ShiftID:   fallback.ID,
		ShiftName: fallback.Name,
		ShortName: fallback.ShortName,
		Color:     fallback.Color,
		WorkStart: fallback.WorkStart,
		WorkEnd:   fallback.WorkEnd,
		RestStart: fallback.RestStart,
		RestEnd:   fallback.RestEnd,
		WorkHours: fallback.WorkHours,
	}, true
}

func scRuleOfDay(rules map[int]scPatternDay, index int) (scPatternDay, bool) {
	rule, ok := rules[index]
	if !ok || rule.DayType != models.SchedTplDayWork {
		return scPatternDay{}, false
	}
	return rule, true
}

// scWeekdayOffset 返回相对本周周一的天数（周一=0 ... 周日=6）。
func scWeekdayOffset(day time.Time) int {
	return (int(day.Weekday()) + 6) % 7
}

func scMod(value, base int) int {
	if base <= 0 {
		return 0
	}
	result := value % base
	if result < 0 {
		result += base
	}
	return result
}

// scMonthRestDay 判断自然月排班中某天是否休息。
//
// 指定休息周几时，先取当月该周几的前 N 天；不足 N 天时从月末向前补齐。
// 未指定周几（0）时直接取月末最后 N 天。
func scMonthRestDay(plan *models.OaSchedulePlan, day time.Time) bool {
	restDays := int(plan.MonthRestDays)
	if restDays <= 0 {
		return false
	}
	year, month := day.Year(), day.Month()
	first := time.Date(year, month, 1, 0, 0, 0, 0, time.Local)
	daysInMonth := first.AddDate(0, 1, -1).Day()
	if restDays >= daysInMonth {
		return true
	}

	restSet := map[int]bool{}
	weekday := int(plan.MonthRestWeekday)
	if weekday >= 1 && weekday <= 7 {
		for d := 1; d <= daysInMonth && len(restSet) < restDays; d++ {
			w := int(time.Date(year, month, d, 0, 0, 0, 0, time.Local).Weekday())
			if w == 0 {
				w = 7
			}
			if w == weekday {
				restSet[d] = true
			}
		}
	}
	for d := daysInMonth; d >= 1 && len(restSet) < restDays; d-- {
		restSet[d] = true
	}
	return restSet[day.Day()]
}