package common

import (
	"fmt"
	"math"
	"time"
)

//时间相关处理类
var (
	timeLayoutMap = map[string]string{
		"y": "2006",
		"m": "2006-01",
		"d": "2006-01-02",
		"h": "2006-01-02 15",
		"i": "2006-01-02 15:04",
		"s": "2006-01-02 15:04:05",
	}

	weekDay = map[string]int{
		"Monday":    1,
		"Tuesday":   2,
		"Wednesday": 3,
		"Thursday":  4,
		"Friday":    5,
		"Saturday":  6,
		"Sunday":    7,
	}
)

/**
获取本周周一的日期
*/
func GetDateOfWeek() (weekMonday string) {
	now := time.Now()

	offset := int(time.Monday - now.Weekday())
	if offset > 0 {
		offset = -6
	}

	weekStartDate := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
	weekMonday = weekStartDate.Format("2006-01-02")
	return
}

/**
获取本周周日的日期
*/
func GetLastWeekDate() (weekMonday string) {
	thisWeekMonday := GetDateOfWeek()
	TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
	lastWeekMonday := TimeMonday.AddDate(0, 0, +6)
	weekMonday = lastWeekMonday.Format("2006-01-02")
	return
}

/**
获取上周的周一日期
*/
func GetFirstWeekDate() (weekMonday string) {
	thisWeekMonday := GetDateOfWeek()
	TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
	lastWeekMonday := TimeMonday.AddDate(0, 0, -7)
	weekMonday = lastWeekMonday.Format("2006-01-02")
	return
}

/**
获取上周的周日日期
*/
func GetFirstWeekLastDate() (weekMonday string) {
	thisWeekMonday := GetFirstWeekDate()
	TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
	lastWeekMonday := TimeMonday.AddDate(0, 0, +6)
	weekMonday = lastWeekMonday.Format("2006-01-02")
	return
}

/**
获取指定日期的上周的周一日期
*/
func GetFirstWeekDateSet(thisWeekMonday string) (weekMonday string) {
	TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
	lastWeekMonday := TimeMonday.AddDate(0, 0, -7)
	weekMonday = lastWeekMonday.Format("2006-01-02")
	return
}

/*
获取今天时间
*/
func GetToDay() (yesterday string) {
	now := time.Now()
	yesTime := now.AddDate(0, 0, 0).Format("2006-01-02") // 获取昨天的时间
	return yesTime
}

/*
获取昨天时间
*/
func GetYesterDay() (yesterday string) {
	now := time.Now()
	yesTime := now.AddDate(0, 0, -1).Format("2006-01-02") // 获取昨天的时间
	return yesTime
}

/*
日期转时间戳
*/
func DateToTimeStamp(dataStr string) (timeStamp int64) {
	tmp := "2006-01-02 15:04:05"
	res, _ := time.ParseInLocation(tmp, dataStr, time.Local)
	timeStamp = res.Unix()
	return
}

/*
时间戳转日期
*/
func TimeStampToDate(timeStamp int64, timeType int) (dateStr string) {
	timeTemplate := "2006-01-02 15:04:05" //常规类型
	switch timeType {
	case 1:
		timeTemplate = "2006/01/02 15:04:05"
	case 2:
		timeTemplate = "2006/01/02 15:04"
	case 3:
		timeTemplate = "2006/01/02 15"
	case 4:
		timeTemplate = "2006/01/02"
	case 5:
		timeTemplate = "15:04:05"
	case 6:
		timeTemplate = "2006-01-02"
	case 7:
		timeTemplate = "2006-01-02 15"
	case 8:
		timeTemplate = "2006-01-02 15:04"
	case 9:
		timeTemplate = "02"
	default:
		timeTemplate = "2006-01-02 15:04:05" //常规类型
	}
	dateStr = time.Unix(timeStamp, 0).Format(timeTemplate)
	return
}

/*
指定日期起止时间戳
@startTime
@endTime
*/
func GetStartAndEndTimeStamp(startTime, endTime string) (startTimeStamp, endTimeStamp int64) {
	startTimeStr := startTime + " 00:00:00"
	endTimeStr := endTime + " 23:59:59"
	startTimeStamp = DateToTimeStamp(startTimeStr)
	endTimeStamp = DateToTimeStamp(endTimeStr)
	return
}

// 获取两个时间相差的天数，0表同一天，正数表t1>t2，负数表t1<t2
func GetDiffDays(t1, t2 time.Time) int64 {
	t1 = time.Date(t1.Year(), t1.Month(), t1.Day(), 0, 0, 0, 0, time.Local)
	t2 = time.Date(t2.Year(), t2.Month(), t2.Day(), 0, 0, 0, 0, time.Local)

	return int64(t1.Sub(t2).Hours() / 24)

}

// 获取t1和t2的相差天数，单位：秒，0表同一天，正数表t1>t2，负数表t1<t2
func GetDiffDaysBySecond(t1, t2 int64) int64 {
	time1 := time.Unix(t1, 0)
	time2 := time.Unix(t2, 0)

	// 调用上面的函数
	return GetDiffDays(time1, time2)
}

//获取时间段内每天的开始结束时间
func StartAndEndTimeOREveryDay(startTime, endTime int64) []map[string]interface{} {
	tianshu := GetDiffDaysBySecond(endTime, startTime)
	var i int64
	timeMapAry := []map[string]interface{}{}
	for i = 0; i <= tianshu; i++ {
		timeStampVal := startTime + (86400 * i)
		dateVal := TimeStampToDate(timeStampVal, 6)
		beginTimg, endDateTime := GetStartAndEndTimeStamp(dateVal, dateVal)
		var timeMap = make(map[string]interface{})
		timeMap["starttime"] = beginTimg
		timeMap["endtime"] = endDateTime
		timeMapAry = append(timeMapAry, timeMap)
	}
	return timeMapAry
}

//日期字符串转换成time格式
func StringToTimeIng(unit, str string) (res time.Time) {
	loc, _ := time.LoadLocation("Local")
	// str := t.ToString()
	layout, ok := timeLayoutMap[unit]
	if !ok {
		layout = timeLayoutMap["s"]
	}
	res, _ = time.ParseInLocation(layout, str, loc)
	return
}

//获取传入的时间所在月份的第一天，即某月第一天的0点。如传入time.Now(), 返回当前月份的第一天0点时间。
func GetFirstDateOfMonth(d time.Time) time.Time {
	d = d.AddDate(0, 0, -d.Day()+1)
	return GetZeroTime(d)
}

//获取传入的时间所在月份的第一天，即某月第一天的0点。如传入time.Now(), 返回当前月份的第一天0点时间戳。
func GetFirstDateOfMonthStamp(d time.Time) (monthStartTimeShamp int64) {
	monthStartTimeShamp = GetFirstDateOfMonth(d).Unix()
	return
}

//获取传入的时间所在月份的最后一天，即某月最后一天的0点。如传入time.Now(), 返回当前月份的最后一天0点时间。
func GetLastDateOfMonth(d time.Time) time.Time {
	return GetFirstDateOfMonth(d).AddDate(0, 1, -1)
}

//获取传入的时间所在月份的最后一天，即某月最后一天的23点59分59秒。如传入time.Now(), 返回当前月份的最后一天23点59分59秒的时间戳。
func GetLastDateMonthAll(d time.Time) (monthEndTimeShamp int64) {
	monthEndTimeShamp = GetLastDateOfMonth(d).Unix() + 86399
	return
}

//获取某一天的0点时间
func GetZeroTime(d time.Time) time.Time {
	return time.Date(d.Year(), d.Month(), d.Day(), 0, 0, 0, 0, d.Location())
}

//指定日期月起止时间戳
func GetMonthStartOrEndTime(d time.Time) (monthStartTimgStamp, monthEndTimeStamp int64) {
	monthStartTimgStamp = GetFirstDateOfMonthStamp(d)
	monthEndTimeStamp = GetLastDateMonthAll(d)
	return
}

//获取一周开始结束时间
/*
@t 时间
callback
@strarTime			指定周开始时间
@endTime			指定周结束时间
@weekInt			本月第几周
*/
func WeekStartAdnEndTime(t time.Time) (strarTime, endTime int64, weekInt int) {
	endStr := t.Weekday().String()              //周几
	firstInt := (weekDay[endStr] - 1)           //前边有几天
	lastInt := 7 - weekDay[endStr]              //后边有几天
	plus := int64(86400 * lastInt)              //计算结束时间加量
	owe := int64(86400 * firstInt)              //计算开始时间加量
	endDay := time.Unix(t.Unix()+plus+86399, 0) //结束时间
	startDay := time.Unix(t.Unix()-owe, 0)      //开始时间
	//开始与结束时间转换时间戳
	strarTime = startDay.Unix()
	endTime = endDay.Unix()
	monthStartTimgStamp, monthEndTimeStamp := GetMonthStartOrEndTime(t) //计算本月开始与结束时间（时间戳）
	//判断指定日期所在月周的开始与结束日期
	if monthStartTimgStamp-strarTime > 0 {
		strarTime = monthStartTimgStamp
	}
	if monthEndTimeStamp-endTime < 0 {
		endTime = monthEndTimeStamp
	}

	monthFirstDay := time.Unix(monthStartTimgStamp, 0).Weekday().String() //指定日期所在月第一天是周几

	todayInt := t.Local().Day()            //今天几号
	currentWeek := weekDay[monthFirstDay]  //指定日期所在月第一天是周几（转换成int定量）
	daySet := todayInt - (8 - currentWeek) //日期差量
	if daySet <= 0 {
		weekInt = 1
	} else {
		weekInt = int(math.Ceil(float64(daySet)/7.0)) + 1 //计算周
	}
	return
}

//计算指定日期周一
func SetDateWeekFirstTime(t time.Time) (weekInt string) {
	offset := int(time.Monday - t.Weekday())
	if offset > 0 {
		offset = -6
	}
	weekStartDate := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
	weekInt = weekStartDate.Format("2006-01-02")
	return
}

/*
获取上周起止时间
*/
func FirstWeekStartAdnEndTime(t time.Time) (strarTime, endTime int64, weekInt int) {
	//计算周一
	firstWeekDay := SetDateWeekFirstTime(t) //指定日期所在周的周一日期
	firstWeekDayStringToTime := StringToTimeIng("d", firstWeekDay)
	monthFirst := int64(firstWeekDayStringToTime.Month()) //获取周一所在月
	monthSet := int64(t.Month())                          //当前日期所在月
	// fmt.Printf("%v=>%v=>%v\n", firstWeekDay, int(t.Month()), t)

	strarTime = monthFirst
	endTime = monthSet
	weekInt = 250
	//判断是否在同一个月
	if monthFirst == monthSet {
		firstWeekDay = firstWeekDay + " 00:00:00"
		weekFirstDayTime := DateToTimeStamp(firstWeekDay) - 43200
		weekFirstDayTimeToStr := TimeStampToDate(weekFirstDayTime, 6)
		weekDayStrToTime := StringToTimeIng("d", weekFirstDayTimeToStr)
		strarTime, endTime, weekInt = WeekStartAdnEndTime(weekDayStrToTime)
	} else {
		strarTime, endTime, weekInt = WeekStartAdnEndTime(firstWeekDayStringToTime)
	}
	return
}

//获取指定时间当月第一周起止时间
func GetSetUpDayTimeToMonthStartAndEndTime(monthStartTime int64) (strarTime, endTime int64) {
	t := time.Unix(monthStartTime, 0)
	fmt.Println(time.Unix(monthStartTime, 0))

	endStr := t.Weekday().String()
	firstInt := (weekDay[endStr] - 1)
	lastInt := 7 - weekDay[endStr]
	plus := int64(86400 * lastInt)              //计算结束时间加量
	owe := int64(86400 * firstInt)              //计算开始时间加量
	endDay := time.Unix(t.Unix()+plus+86399, 0) //结束时间
	startDay := time.Unix(t.Unix()-owe, 0)      //开始时间
	strarTime = startDay.Unix()
	endTime = endDay.Unix()
	monthStartTimgStamp, monthEndTimeStamp := GetMonthStartOrEndTime(t)
	if monthStartTimgStamp-strarTime > 0 {
		strarTime = monthStartTimgStamp
	}
	if monthEndTimeStamp-endTime < 0 {
		endTime = monthEndTimeStamp
	}
	return
}

/*
获取季度的起止时间
*/
func GetQuarterDay(t time.Time) (string, int, int64, int64) {
	year := t.Format("2006")
	month := int(t.Month())
	var firstOfQuarter string
	var lastOfQuarter string
	var currentQuarter int

	if month >= 1 && month <= 3 {
		//1月1号
		firstOfQuarter = year + "-01-01 00:00:00"
		lastOfQuarter = year + "-03-31 23:59:59"
		currentQuarter = 1
	} else if month >= 4 && month <= 6 {
		firstOfQuarter = year + "-04-01 00:00:00"
		lastOfQuarter = year + "-06-30 23:59:59"
		currentQuarter = 2
	} else if month >= 7 && month <= 9 {
		firstOfQuarter = year + "-07-01 00:00:00"
		lastOfQuarter = year + "-09-30 23:59:59"
		currentQuarter = 3
	} else {
		firstOfQuarter = year + "-10-01 00:00:00"
		lastOfQuarter = year + "-12-31 23:59:59"
		currentQuarter = 4
	}
	quarterStartTime := DateToTimeStamp(firstOfQuarter)
	quarterEndTime := DateToTimeStamp(lastOfQuarter)
	return year, currentQuarter, quarterStartTime, quarterEndTime
}