package util

import (
	"fmt"
	"math"
	"math/rand"
	"regexp"
	"time"

	"gitee.com/xuyiping_admin/pkg/xerr"
)

const (
	LayoutTime  = "2006-01-02 15:04:05"
	Layout      = "2006-01-02"
	LayoutMonth = "2006-01"
)

// GenerateRandomNumberString 生成指定长度的数字串
func GenerateRandomNumberString(length int) string {
	const charset = "0123456789"
	seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))
	result := make([]byte, length)
	for i := range result {
		result[i] = charset[seededRand.Intn(len(charset))]
	}
	return string(result)
}

// TimeParseLocalUnix 获取当天零点的时间戳
// eg 2023-02-22 => 1676995200
func TimeParseLocalUnix(DayTime string) int64 {
	value := DayTime
	if len(DayTime) <= 11 {
		value = fmt.Sprintf("%s 00:00:00", DayTime)
	}

	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(LayoutTime, value, loc)
	return theTime.Unix()
}

// TimeParseLocalEndUnix 获取当天24点的时间戳
// eg 2023-02-22  => 1676995200
func TimeParseLocalEndUnix(DayTime string) int64 {
	value := DayTime
	if len(DayTime) <= 11 {
		value = fmt.Sprintf("%s 23:59:59", DayTime)
	}

	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(LayoutTime, value, loc)
	return theTime.Unix()
}

// ConvertParseLocalUnix 字符串转换当天时间戳
// eg 15:04:05 => 1676998245
func ConvertParseLocalUnix(timeParse string) (int64, error) {
	loc, err := time.LoadLocation("Local")
	if err != nil {
		return 0, err
	}
	value := fmt.Sprintf("%s %s", time.Now().Format(Layout), timeParse)
	theTime, err := time.ParseInLocation(LayoutTime, value, loc)
	if err != nil {
		return 0, err
	}
	return theTime.Unix(), nil
}

// GetMonthRemainDay 获取当前月还剩几天
func GetMonthRemainDay() int {
	now := time.Now()
	lastDayOfMonth := time.Date(now.Year(), now.Month()+1, 0, 23, 59, 59, 999999999, now.Location())
	return int(lastDayOfMonth.Sub(now).Hours()/24) + 1
}

// Ceil 向上取整函数
func Ceil(x float64) float64 {
	// 使用 math.Floor 计算小于或等于 x 的最大整数
	// 然后检查 x 是否为整数，如果不是，则结果加 1
	// 注意：math.Floor 返回的是 float64 类型，所以我们需要进行比较
	// 来确定是否需要加 1
	intPart := math.Floor(x)
	if x-intPart > 0 {
		return intPart + 1
	}
	return intPart
}

// GetLastDayOfMonth
// 接受一个字符串形式的月份（如 "2024-12"），
// 并返回该月份的最后一天的日期（2024-12-31）
func GetLastDayOfMonth(month string) (string, error) {
	t, err := time.Parse(LayoutMonth, month)
	if err != nil {
		return "", err // 如果解析失败，返回错误
	}

	// 获取下个月的第一天
	nextMonth := t.AddDate(0, 1, 0)

	// 返回上个月的最后一天
	lastDay := nextMonth.AddDate(0, 0, -1)
	return lastDay.Format(Layout), nil
}

// GetMonthsInRange
// 接受两个字符串形式的月份（如 "2024-01" 到 "2024-12"），
// 并返回一个包含这两个月份之间所有月份的字符串切片。
func GetMonthsInRange(startMonth, endMonth string) ([]string, error) {
	// 解析起始月份
	startTime, err := time.Parse(LayoutMonth, startMonth)
	if err != nil {
		return nil, err
	}

	// 解析结束月份
	endTime, err := time.Parse(LayoutMonth, endMonth)
	if err != nil {
		return nil, err
	}

	// 初始化结果切片
	var months []string

	// 循环添加每个月份直到达到或超过结束月份
	for curr := startTime; curr.Before(endTime) || curr.Equal(endTime); curr = curr.AddDate(0, 1, 0) {
		months = append(months, curr.Format(LayoutMonth))
	}

	return months, nil
}

// RoundToTwoDecimals 四舍五入并保留两位小数
func RoundToTwoDecimals(num float64) float64 {
	// 使用 math.Round 函数进行四舍五入
	// 先乘以 100，然后四舍五入，最后除以 100
	return math.Round(num*100) / 100
}

// Get21DayPeriods 获取范围时间内21天周期的切片
// 从结束时间开始往前推算，超过开始时间，继续向前推算，直至凑整21天
func Get21DayPeriods(startDay, endDay string) ([][]string, error) {
	startDate, err := time.Parse(Layout, startDay)
	if err != nil {
		return nil, err
	}

	endDate, err := time.Parse(Layout, endDay)
	if err != nil {
		return nil, err
	}

	if startDate.After(endDate) {
		return nil, xerr.Custom("start date is after end date")
	}

	var periods [][]string
	for date := endDate; date.After(startDate); {
		// Calculate the end of the current period
		periodEnd := date.AddDate(0, 0, -20)
		// Append the current period to the result slice
		periods = append(periods, []string{periodEnd.Format(Layout), date.Format(Layout)})
		// Move on to the next day
		date = periodEnd.AddDate(0, 0, -1)
	}
	reverseRows(periods)
	return periods, nil
}

func reverseRows(matrix [][]string) {
	// 获取矩阵的行数
	rows := len(matrix)
	if rows == 0 {
		return // 如果矩阵为空，则直接返回
	}
	// 初始化两个指针，一个指向开始，一个指向末尾
	for i, j := 0, rows-1; i < j; i, j = i+1, j-1 {
		// 交换当前行和对应行
		matrix[i], matrix[j] = matrix[j], matrix[i]
	}
}

// GetRangeDayMiddleDay 获取指定日期范围中间的某一天
func GetRangeDayMiddleDay(dateRange []string, middleDay int32) (string, error) {
	if len(dateRange) < 2 {
		return "", xerr.Custom("date range is not enough")
	}
	if middleDay < 0 {
		return "", xerr.Custom("middle day is not enough")
	}
	startDate, _ := time.Parse(Layout, dateRange[0])
	return startDate.AddDate(0, 0, int(middleDay)-1).Format(Layout), nil
}

// GetRangeDayByDays 获取指定范围日期内按照指定天数来切割
// （2024-10-01 ~ 2024-10-31,5）=> [[2024-10-01,2024-10-05], [2024-10-06,2024-10-10], [2024-10-11,2024-10-15], [2024-10-16,2024-10-20], [2024-10-21,2024-10-25], [2024-10-26,2024-10-30],[2024-10-31,2024-10-31]]
func GetRangeDayByDays(startDay, endDay string, days int32) ([][]string, error) {
	var res [][]string
	if days <= 0 {
		return res, nil
	}
	startDate, err := time.Parse(Layout, startDay)
	if err != nil {
		return nil, err
	}
	endDate, err := time.Parse(Layout, endDay)
	if err != nil {
		return nil, err
	}
	if startDate.After(endDate) {
		return nil, xerr.Custom("start date is after end date")
	}

	if startDate == endDate {
		return [][]string{{startDay, endDay}}, nil
	}

	for date := startDate; date.Before(endDate) || date.Equal(endDate); date = date.AddDate(0, 0, int(days)) {
		if date.AddDate(0, 0, int(days)-1).After(endDate) {
			res = append(res, []string{date.Format(Layout), endDate.Format(Layout)})
			break
		}
		res = append(res, []string{date.Format(Layout), date.AddDate(0, 0, int(days)-1).Format(Layout)})
	}
	return res, nil
}

// 计算样本均值
func mean(data []float64) float64 {
	sum := 0.0
	for _, v := range data {
		sum += v
	}
	return sum / float64(len(data))
}

// 计算样本标准差
func stddev(data []float64, mean float64) float64 {
	sum := 0.0
	for _, v := range data {
		sum += (v - mean) * (v - mean)
	}
	variance := sum / float64(len(data)-1)
	return math.Sqrt(variance)
}

// ConfidenceInterval 计算95%置信区间
func ConfidenceInterval(data []float64) (float64, float64) {
	n := float64(len(data))
	meanVal := mean(data)
	stdDev := stddev(data, meanVal)
	z := 1.96 // 95%置信水平对应的Z值

	marginOfError := z * (stdDev / math.Sqrt(n))
	lowerBound := meanVal - marginOfError
	upperBound := meanVal + marginOfError

	return lowerBound, upperBound
}

// ConfidenceInterval2 计算95%置信区间
func ConfidenceInterval2(p float64, total float64) (min, max float64) {
	if p <= 0 || total <= 0 {
		return 0, 0
	}
	z := 1.96 // 95%置信水平对应的Z值
	marginOf := z * math.Sqrt(p*(1-p)/total) * 100
	return math.Max(0, p*100-math.Ceil(marginOf)), math.Max(1, p*100+math.Ceil(marginOf))
}

// RemoveDuplicates 去除切片中的重复元素
func RemoveDuplicates(slice []string) []string {
	if len(slice) <= 0 {
		return slice
	}
	// 创建一个map来跟踪已经遇到的元素
	seen := make(map[string]struct{})
	// 创建一个新的切片来存储不重复的元素
	var result []string

	// 遍历原始切片
	for _, v := range slice {
		// 如果元素尚未在map中，则将其添加到结果切片和map中
		if _, exists := seen[v]; !exists {
			seen[v] = struct{}{}
			result = append(result, v)
		}
	}
	// 返回不重复的切片
	return result
}

func DaysBetween(startDayUnix int64, endDayUnix int64) int64 {
	time1 := time.Unix(startDayUnix, 0)
	time2 := time.Unix(endDayUnix, 0)
	// Truncate to the start of the day (00:00:00)
	startOfDay1 := time.Date(time1.Year(), time1.Month(), time1.Day(), 0, 0, 0, 0, time1.Location())
	startOfDay2 := time.Date(time2.Year(), time2.Month(), time2.Day(), 0, 0, 0, 0, time2.Location())

	// Calculate the difference in days
	daysDiff := int64(startOfDay2.Sub(startOfDay1).Hours() / 24)
	// Adjust sign if time2 is before time1
	if startOfDay2.Before(startOfDay1) {
		daysDiff = -daysDiff
	}

	return daysDiff
}

// MsgFormat 格式化消息字符串 字符串里面有多个冒号，仅删除冒号前后的空格（如果存在）
func MsgFormat(input string) string {
	// 定义正则表达式，用于匹配冒号两边的空格
	re := regexp.MustCompile(`\s*:\s*`)

	// 使用正则表达式替换所有匹配的部分
	return re.ReplaceAllString(input, ":")
}

/*
GetNeckRingActiveTimer
1. frameId值如果是：1到6代表每天的0点到2点，11-16 代表每天的2点到4点， 21-26 代表每天的4点到6点，31-36代表每天的6点到8点，
41-46 代表每天的8点到10点，51-56代表每天的10点到12点，61-66代表每天的12-14点，71-76代表每天的14-16点，81-86代表每天的16-18点，
91-96代表每天的18-20点，101-106代表每天的20-22点，111-116代表每天的22-24点。其中每天数字代表20分钟。如果frameId大于接受时间点，就代表frameId是昨天的。
2. 如果farmId取值出现8,18,28,3848,58,68,78,88,98,108,118数字分别代表2个小时，从0-2点开始，以此类推。
帮我根据frameId值，获取对应的时间点
todo 116和118有问题，需要处理
*/
func GetNeckRingActiveTimer(frameId int32) (dateTime string, hours int) {
	if frameId < 0 || frameId > 118 {
		return "", 0
	}
	nowTime := time.Now()
	currHour := nowTime.Hour()
	// 处理2小时的特殊 farmId
	specialHours := map[int]int{
		8: 2, 18: 4, 28: 6, 38: 8, 48: 10, 58: 12, 68: 14, 78: 16, 88: 18, 98: 20, 108: 22, 118: 0,
	}
	hours, ok := specialHours[int(frameId)]
	startHour := hours
	if ok {
		if hours > currHour {
			startHour -= 24
		}
		dateTime = time.Date(nowTime.Year(), nowTime.Month(), nowTime.Day(), startHour, 0, 0, 0, nowTime.Location()).Format(Layout)
		return
	}

	hours = int(math.Floor(float64(frameId)/10) * 2)
	units := int(frameId % 10)
	hours += units / 3
	startHour = hours
	if hours > currHour {
		startHour -= 24
	}
	dateTime = time.Date(nowTime.Year(), nowTime.Month(), nowTime.Day(), startHour, 0, 0, 0, nowTime.Location()).Format(Layout)
	return
}