package controllers

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

	"server/models"
	"server/pkg/holiday"
)

// 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
			}
		}
	}

	// 周期类方案：构造基准周期之外的顺延上下文（节假日 / 调休修正 + 星期节奏）
	var rollExt *scRollExt
	if plan.AlignMode == models.SchedTplAlignRoll || plan.AlignMode == models.SchedTplAlignWeek {
		rollExt = scBuildRollExt(pattern, start, dates)
	}

	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, rollExt)
		if !work {
			continue
		}
		result[date] = rule
		workdays = append(workdays, date)
	}
	return result, workdays, ""
}

// scRollExt 周期滚动方案（AlignMode=2，按月涂排）在基准周期之外的顺延上下文。
//
// 涂刷基准月里的节假日安排属于「基准月的特殊规则」，不应该跟着日序号平移到
// 后续月份——否则 10 月的国庆假期会错位落到 11 月的普通工作日上。周期之外的
// 推算规则：
//  1. 目标日期是法定节假日 → 休息；
//  2. 目标日期是调休上班日 → 上班（取涂刷里的班次）；
//  3. 该星期在涂刷周期内呈现严格 休/班 交替（如大小周的周六）→ 按周序奇偶交替顺延；
//  4. 其余按涂刷月的星期节奏顺延（同星期几在周期内的多数状态）。
type scRollExt struct {
	weekdayRules [8]scPatternDay // 下标 1-7（周一~周日）：该星期的顺延规则
	altRules     [8]bool         // 该星期是否隔周交替（严格 休/班 交替）
	altEven      [8]scPatternDay // 交替星期：周序为偶数时的规则
	altOdd       [8]scPatternDay // 交替星期：周序为奇数时的规则
	defaultWork  scPatternDay    // 涂刷里的首个上班规则，供调休上班日使用
	holidays     map[string]int8 // 目标日期 → holiday.Type（0 调休上班 / 1 法定放假）
}

// scBuildRollExt 从涂刷周期构造顺延上下文。星期节奏取多数状态（work 数 - rest 数
// ≥ 0 视为上班，班次取该星期首个上班规则）；若某星期在周期内严格 休/班 交替，
// 记录交替规则，顺延按周序奇偶保持交替（周序锚点 = start 所在周的周一）。
// 节假日数据按目标区间涉及的年份拉取，拉取失败只是少了节假日修正，不阻断发布。
func scBuildRollExt(pattern []scPatternDay, start time.Time, dates []string) *scRollExt {
	ext := &scRollExt{holidays: map[string]int8{}}
	workCount := [8]int{}
	shiftBy := [8]scPatternDay{}
	type weekSeqItem struct {
		week int
		work bool
		item scPatternDay
	}
	byWeekday := [8][]weekSeqItem{}
	startMonday := start.AddDate(0, 0, -scWeekdayOffset(start))
	for _, item := range pattern {
		day := start.AddDate(0, 0, item.DayIndex)
		w := scWeekdayOffset(day) + 1
		if item.DayType == models.SchedTplDayWork {
			workCount[w]++
			if shiftBy[w].ShiftID == 0 {
				shiftBy[w] = item
			}
			if ext.defaultWork.ShiftID == 0 {
				ext.defaultWork = item
			}
		} else {
			workCount[w]--
		}
		weekSeq := int(day.AddDate(0, 0, -scWeekdayOffset(day)).Sub(startMonday).Hours()/24) / 7
		byWeekday[w] = append(byWeekday[w], weekSeqItem{week: weekSeq, work: item.DayType == models.SchedTplDayWork, item: item})
	}
	for w := 1; w <= 7; w++ {
		if workCount[w] >= 0 && shiftBy[w].ShiftID != 0 {
			ext.weekdayRules[w] = shiftBy[w]
		} else {
			ext.weekdayRules[w] = scPatternDay{DayIndex: w - 1, DayType: models.SchedTplDayRest}
		}
		// 隔周交替检测：该星期在涂刷周期内严格 休/班 交替（如大小周的周六，
		// 一周上班一周休息），顺延时按周序奇偶保持交替，而不是取多数
		list := byWeekday[w]
		if len(list) < 2 {
			continue
		}
		alternating := true
		for i := 1; i < len(list); i++ {
			if list[i].work == list[i-1].work {
				alternating = false
				break
			}
		}
		if !alternating {
			continue
		}
		ext.altRules[w] = true
		if list[0].week%2 == 0 {
			ext.altEven[w] = list[0].item
			ext.altOdd[w] = list[1].item
		} else {
			ext.altOdd[w] = list[0].item
			ext.altEven[w] = list[1].item
		}
	}
	years := map[int]bool{}
	for _, date := range dates {
		if y := holidayYear(date); y > 0 {
			years[y] = true
		}
	}
	for y := range years {
		items, _, err := holiday.FetchYear(y)
		if err != nil {
			continue
		}
		for _, d := range items {
			ext.holidays[d.Date] = d.Type
		}
	}
	return ext
}

// scRuleForDate 推算某一天命中的规则；第二个返回值表示当天是否上班。
// ext 是周期滚动方案（AlignMode=2）在基准周期之外的顺延上下文，可为 nil。
func scRuleForDate(plan *models.OaSchedulePlan, rules map[int]scPatternDay, fallback *models.OaShift,
	start, day time.Time, weekdays map[int]bool, ext *scRollExt) (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
		// 首个周期内原样回放；周期之外目标月的节假日 / 调休优先修正
		//（大小周等模板按自然周循环，周序永远交替不串位）
		if ext != nil && diffWeeks >= weeks {
			if hType, ok := ext.holidays[day.Format("2006-01-02")]; ok {
				if hType == holiday.TypeHoliday {
					return scPatternDay{}, false
				}
				if hType == holiday.TypeWorkday && ext.defaultWork.ShiftID != 0 {
					return ext.defaultWork, true
				}
			}
		}
		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)
		// 基准周期内：按涂刷结果原样回放（涂刷月自己的节假日 / 周末已在保存时处理）
		if diffDays < cycle || ext == nil {
			return scRuleOfDay(rules, scMod(diffDays, cycle))
		}
		// 周期之外：先看目标日的节假日 / 调休特殊规则
		if hType, ok := ext.holidays[day.Format("2006-01-02")]; ok {
			if hType == holiday.TypeHoliday {
				return scPatternDay{}, false
			}
			if hType == holiday.TypeWorkday && ext.defaultWork.ShiftID != 0 {
				return ext.defaultWork, true
			}
		}
		// 整月涂刷方案（周期=开始月天数）：按星期节奏顺延，规避节假日 / 周末错位；
		// 其他滚动周期（三班倒 / 做一休一等模板原生周期）：保持相位纯滚动
		daysInStartMonth := time.Date(start.Year(), start.Month()+1, 0, 0, 0, 0, 0, start.Location()).Day()
		if cycle == daysInStartMonth {
			w := scWeekdayOffset(day) + 1
			rule := ext.weekdayRules[w]
			// 隔周交替的星期（如大小周的周六）：按周序奇偶保持交替
			if ext.altRules[w] {
				startMonday := start.AddDate(0, 0, -scWeekdayOffset(start))
				curMonday := day.AddDate(0, 0, -scWeekdayOffset(day))
				weekSeq := int(curMonday.Sub(startMonday).Hours()/24) / 7
				if weekSeq%2 == 0 {
					rule = ext.altEven[w]
				} else {
					rule = ext.altOdd[w]
				}
			}
			if rule.DayType != models.SchedTplDayWork {
				return scPatternDay{}, false
			}
			return rule, true
		}
		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()]
}