import { xDateDayInfoType } from "../../interface.uts"
import { getCurrentLocale, getLocaleData, setLocale, xDateLanguage } from "./xDateI18n.uts"
export type xDateTypeTime = 'y' | 'm' | 'd' | 'h' | 'M' | 's' | 'ms' | 'w'
export type xDateTypeQuarter = {
	quarter : number,
	start : string,
	end : string
}
export type DateFormat = 'RFC2822' | 'ISO8601' | 'CUSTOM';

/**
 * 用来解析非标准时间以及各种奇怪的时间格式。
 */
export function createDate(dateStrs : string) : Date {
	const dateStr = dateStrs.replace(/\//g, '-')
	const result = new Date();

	// YYYY,YYYY-MM,YYYY-MM-DD,YYYY-MM-DD HH,YYYY-MM-DD HH:mm,YYYY-MM-DD HH:mm:ss

	let regxyy = /^(\d{4})$/
	let regxyymm = /^(\d{4})[-/](\d{1,2})$/
	let regxyymmdd = /^(\d{4})[-/](\d{1,2})[-/](\d{1,2})$/
	let regxyymmddhh = /^(\d{4})[-/](\d{1,2})[-/](\d{1,2}) (\d{1,2})$/
	let regxyymmddhhmm = /^(\d{4})[-/](\d{1,2})[-/](\d{1,2}) (\d{1,2}):(\d{1,2})$/
	let regxyymmddhhmmss = /^(\d{4})[-/](\d{1,2})[-/](\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/

	let year = result.getFullYear();
	let month = result.getMonth() - 1
	let day = result.getDate()
	let hour = result.getHours()
	let minute = result.getMinutes()
	let second = result.getSeconds()

	result.setSeconds(59);
	result.setMinutes(59);
	result.setHours(59);
	result.setDate(1);
	if (regxyymmddhhmmss.test(dateStr)) {
		const match = dateStr.match(regxyymmddhhmmss)!;
		year = (parseInt(match[1] as string));
		month = (parseInt(match[2] as string) - 1);
		day = (parseInt(match[3] as string));
		hour = (parseInt(match[4] as string));
		minute = (parseInt(match[5] as string));
		second = (parseInt(match[6] as string));
	} else if (regxyymmddhhmm.test(dateStr)) {
		const match = dateStr.match(regxyymmddhhmm)!;
		year = (parseInt(match[1] as string));
		month = (parseInt(match[2] as string) - 1);
		day = (parseInt(match[3] as string));
		hour = (parseInt(match[4] as string));
		minute = (parseInt(match[5] as string));

	} else if (regxyymmddhh.test(dateStr)) {
		const match = dateStr.match(regxyymmddhh)!;
		year = (parseInt(match[1] as string));
		month = (parseInt(match[2] as string) - 1);
		day = (parseInt(match[3] as string));
		hour = (parseInt(match[4] as string));
	} else if (regxyymmdd.test(dateStr)) {
		const match = dateStr.match(regxyymmdd)!;
		year = (parseInt(match[1] as string));
		month = (parseInt(match[2] as string) - 1);
		day = (parseInt(match[3] as string));

	} else if (regxyymm.test(dateStr)) {
		const match = dateStr.match(regxyymm)!;
		year = (parseInt(match[1] as string));
		month = (parseInt(match[2] as string) - 1);
	} else if (regxyy.test(dateStr)) {
		const match = dateStr.match(regxyy)!;
		year = (parseInt(match[1] as string));
	}

	result.setSeconds(second);
	result.setMinutes(minute);
	result.setHours(hour);
	result.setFullYear(year);
	result.setMonth(month);
	result.setDate(day);
	return result;
}

/**
 * 日期库 xDate
 */
export class xDate {
	date : Date;
	/**
	 * dateStr,可能是数字，字符串，Date对象
	 */
	constructor(dateStr : string | number | Date | null = null) {
		this.date = this.checkDate(dateStr)
	}
	private checkDate(dateStr : string | number | Date | null = null) : Date {
		let tempDate = new Date();
		if (dateStr == null) {
			return tempDate;
		}
		if (typeof dateStr == 'number') {
			return new Date(dateStr! as number);
		} else if (typeof dateStr == 'string') {
			if (dateStr == '') {
				return tempDate;
			}
			const dateformatStr = this.detectDateFormat(dateStr!)

			if (dateformatStr == 'CUSTOM') {
				let str = dateStr! as string;
				str = str.replace(/-/g, '/')
				let isNumberStr = /^\d+$/.test(str)
				if (!isNumberStr) {
					return createDate(dateStr!)
				} else {
					return new Date(parseInt(str!));
				}

			} else {
				return new Date(dateStr! as string);
			}

		} else if (dateStr instanceof Date) {
			return dateStr! as Date;
		}

		return tempDate;
	}
	/**
	 * 检测字符串的日期格式类型
	 * @param dateStr - 日期字符串
	 * @returns 日期格式类型
	 */
	detectDateFormat(dateStr : string) : DateFormat {
		// RFC2822 格式检测
		if (/^(?:\w{3},\s)?(?:\d{1,2}\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}(?::\d{2})?(?:\sGMT)?)|(?:\w{3}\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{1,2}\s\d{2}:\d{2}(?::\d{2})?\s\d{4})/.test(dateStr)) {
			return 'RFC2822';
		}

		// ISO8601 格式检测
		if (/^\d{4}(-\d\d(-\d\d(T\d\d:\d\d(:\d\d)?(\.\d+)?(([+-]\d\d:\d\d)|Z)?)?)?)?$/.test(dateStr)) {
			return 'ISO8601';
		}

		return 'CUSTOM';
	}
	/**
	 * 给数字添加前缀0
	 */
	translateFullDate(d : number, w : number) : string {
		let dstr = d.toString();
		if (dstr.length < w) {
			let dar : number[] = new Array(w - dstr.length).fill(0);
			dstr = dar.join('') + dstr
		}
		return dstr;
	}
	/**
	 * 格式化日期
	 * @param {string} s 模板，比如YYYY/MM/DD hh:mm:ss
	 * @returns {string} 格式化后的日期字符串
	 */
	format(s : string | null = null) : string {
		let str = "YYYY/MM/DD hh:mm:ss"
		if (s != null) {
			str = s;
		}
		str = str.replace(/YYYY/g, this.translateFullDate(this.date.getFullYear(), 2))
		str = str.replace(/MM/g, this.translateFullDate(this.date.getMonth() + 1, 2))
		str = str.replace(/DD/g, this.translateFullDate(this.date.getDate(), 2))
		str = str.replace(/hh/g, this.translateFullDate(this.date.getHours(), 2))
		str = str.replace(/mm/g, this.translateFullDate(this.date.getMinutes(), 2))
		str = str.replace(/ss/g, this.translateFullDate(this.date.getSeconds(), 2))
		return str;
	}
	/**
	 * 获取当前年
	 * @return — 根据当地时间，返回一个对应于给定日期的年份数字。
	 */
	getYear() : number {
		return this.date.getFullYear()
	}
	/**
	 * 获取当前月
	 * @description 是从0开始，1-11月
	 * @return — 一个 0 到 11 的整数值：0 代表一月份，1 代表二月份，2 代表三月份，依次类推
	 */
	getMonth() : number {
		return this.date.getMonth()
	}

	/**
	 * 获取当前月份的名称
	 * @param {boolean} useShort - 是否使用短名称
	 * @return — 返回当前语言环境下的月份名称
	 */
	getMonthName(useShort : boolean = false) : string {
		const monthIndex = this.date.getMonth();
		return useShort ?
			getLocaleData().monthsShort[monthIndex] :
			getLocaleData().months[monthIndex];
	}
	/**
	 * 获取当前天
	 * @return — 返回一个 1 到 31 的整数值。
	 */
	getDate() : number {
		return this.date.getDate()
	}
	/**
	 * 获取当前小时
	 * @return — 返回一个 0 到 23 之间的整数值。
	 */
	getHours() : number {
		return this.date.getHours()
	}
	/**
	 * 获取当前分钟
	 * @return — 返回一个 0 到 59 的整数值。
	 */
	getMinutes() : number {
		return this.date.getMinutes()
	}
	/**
	 * 获取当前秒
	 * @return — 返回一个 0 到 59 的整数值。
	 */
	getSeconds() : number {
		return this.date.getSeconds()
	}
	/**
	 * 获取指定是数据
	 * @param {xDateTypeTime} d - 'y' 年 'm' 月 'd' 日 'h' 时 'M' 分 's' 秒 'ms' 毫秒
	 * @returns - 指定类型的数值
	 */
	getDateOf(d : xDateTypeTime = 'd') : number {
		if (d == 'y') {
			return this.date.getFullYear()
		}
		else if (d == 'm') {
			return this.date.getMonth()
		}
		else if (d == 'd') {
			return this.date.getDate()
		}
		else if (d == 'h') {
			return this.date.getHours()
		}
		else if (d == 'M') {
			return this.date.getMinutes()
		}
		else if (d == 's') {
			return this.date.getSeconds()
		}
		return this.date.getMilliseconds()
	}
	/**
	 * 设定日期
	 * @param {number} n - 设定的数据,
	 * @param {string} d - 比如d=y，那么就是设置本日期的年份数据,'y' 年 'm' 月 'd' 日 'h' 时 'M' 分 's' 秒 'ms' 毫秒
	 * @returns - xDate对象实例
	 */
	setDateOf(n : number, d : xDateTypeTime = 'd') : xDate {
		if (d == 'y') {
			this.date.setFullYear(n)
		}
		else if (d == 'm') {
			this.date.setMonth(n)
		}
		else if (d == 'd') {
			this.date.setDate(n)
		}
		else if (d == 'h') {
			this.date.setHours(n)
		}
		else if (d == 'M') {
			this.date.setMinutes(n)
		}
		else if (d == 's') {
			this.date.setSeconds(n)
		}
		else if (d == 'ms') {
			this.date.setMilliseconds(n)
		}
		return this;
	}

	/**
	 * @param {string} - d:'y' 年 'm' 月 'd' 日 'h' 时 'M' 分 's' 秒 'ms' 毫秒
	 * @returns - 返回从UTC时间1970年1月1日午夜开始以毫秒为单位存储的时间值。
	 * @description 注意，如果不提供d就默认返回毫秒，比如设置d=m那么后面的h,M,s,ms会被设置为0
	 */
	getTime(d : xDateTypeTime) : number {
		let date = new Date(this.date.getTime())

		if (d == 'y') {
			date.setMonth(0)
			date.setDate(1)
			date.setHours(0)
			date.setMinutes(0)
			date.setSeconds(0)
			date.setMilliseconds(0)
			return date.getTime()
		}
		else if (d == 'm') {
			date.setDate(1)
			date.setHours(0)
			date.setMinutes(0)
			date.setSeconds(0)
			date.setMilliseconds(0)
			return date.getTime()
		}
		else if (d == 'd') {
			date.setHours(0)
			date.setMinutes(0)
			date.setSeconds(0)
			date.setMilliseconds(0)
			return date.getTime()
		}
		else if (d == 'h') {
			date.setMinutes(0)
			date.setSeconds(0)
			date.setMilliseconds(0)
			return date.getTime()
		}
		else if (d == 'M') {
			date.setSeconds(0)
			date.setMilliseconds(0)
			return date.getTime()
		}
		else if (d == 's') {
			date.setMilliseconds(0)
			return date.getTime()
		}
		return date.getTime()
	}

	/**
	 * 当前时间的副本
	 */
	getClone() : xDate {

		return new xDate(this.format());
	}
	/**
	 * 本年的第几周
	 * @return 周次
	 */
	getWeek() : number {
		let target = new Date(this.format())
		target.setDate(target.getDate() - (target.getDay() == 0 ? 7 : target.getDay()));
		let firstDayOfYear = new Date(target.getFullYear(), 0, 1);
		firstDayOfYear.setDate(firstDayOfYear.getDate() - (firstDayOfYear.getDay() == 0 ? 7 : firstDayOfYear.getDay()));
		return Math.ceil((((target.getTime() - firstDayOfYear.getTime()) / 86400000) + 1) / 7);
	}
	/**
	 * 取时间的第一天
	 * @param {m,w,y} - m表示取本月的第一天，w取本周的第一天,y表示本年的第一天
	 * @returns {xDate} - 返回xDate对象
	 */
	getDateStartOf(d : 'm' | 'w' | 'y' = 'm') : xDate {
		// 获取当前日期对象
		let now = new Date(this.format())
		if (d == 'w') {
			// 将日期设置为所在周的周一（遵循ISO 8601标准，周一开始于周一）
			let dayOfWeek = now.getDay();
			if (dayOfWeek === 0) { // 如果是星期日，则向前推一天至上周的周一
				now.setDate(now.getDate() - 7);
			}
			now.setDate(now.getDate() - dayOfWeek + 1);
		}
		if (d == 'm' || d == 'y') {
			now.setDate(1);
		}
		if (d == 'y') {
			now.setMonth(0);
		}
		now.setHours(0);
		now.setMinutes(0);
		now.setSeconds(0);
		return dateCovertXdate(now);
	}

	/**
	 * 取时间的最后一天
	 * @param {string} - m,w,y m表示取本月的最后一天，w取本周的最后一天,y表示本年的最后一天
	 * @returns {xDate} - 返回xDate对象
	 */
	getDateEndOf(d : 'm' | 'w' | 'y' = 'm') : xDate {
		// 获取当前日期对象
		let now = new Date(this.format())
		if (d == 'w') {
			// 将日期设置为所在周的周一（遵循ISO 8601标准，周一开始于周一）
			let dayOfWeek = now.getDay();
			if (dayOfWeek === 0) { // 如果是星期日，则向前推一天至上周的周一
				return dateCovertXdate(now);
			}
			now.setDate(now.getDate() + (7 - dayOfWeek));
		}
		if (d == 'm') {
			now.setDate(this.getMonthCountDay());
		}
		if (d == 'y') {
			// 先设置月份为12月，再设置为该月的最后一天
			now.setMonth(11);
			// 设置为12月的最后一天
			now.setDate(31);
		}
		now.setHours(23);
		now.setMinutes(59);
		now.setSeconds(59);
		return dateCovertXdate(now);
	}


	/**
	 * 根据本地时间，返回一个具体日期中一周的第几天，0 表示星期天。 
	 * @return — 根据本地时间，返回一个 0 到 6 之间的整数值，代表星期几：0 代表星期日，1 代表星期一，2 代表星期二，依次类推。
	 */
	getWeekDay() : number {
		return this.date.getDay()
	}
	/**
	 * 根据本地时间，返回一个具体日期中一周的第几天，0 表示星期天。 
	 * @param {string[]} model 具有星期的中文模板，请按照顺序放置如["周日","周一","周二","周三","周四","周五","周六"]
	 * @param {boolean} useShort 是否使用短名称
	 * @return — 返回一个当前语言环境下的星期名称
	 */
	getWeekDayCn(model : string[] | null = null, useShort : boolean = true) : string {
		let ml = useShort ? getLocaleData().weekdaysShort : getLocaleData().weekdays;
		if (model != null && model?.length == 7) {
			ml = model!;
		}
		return ml[this.getWeekDay()]!
	}
	/**
	 * 返回当前日期本月的最大天数
	 * @returns - 当前月份的最大天数
	 */
	getMonthCountDay() : number {
		let nextDate = new Date(this.format())
		// 先设置为1号，避免后面设置月份时超过月的天数。
		nextDate.setDate(1)
		nextDate.setMonth(this.getMonth() + 1)
		// 设置为上月的最后一天。
		nextDate.setDate(0)
		return nextDate.getDate()
	}

	/**
	 * 返回当日的信息
	 * @returns - 返回一个包含年月日周次，星期，农历等的对象
	 */
	getDateInfo(str : string | null = null) : xDateDayInfoType {
		let date = this as xDate
		if (str != null) {
			date = new xDate(str)
		}
		let info = {
			year: date.getYear(),
			month: date.getMonth(),
			day: date.getDate(),
			hours: date.getHours(),
			minutes: date.getMinutes(),
			seconds: date.getSeconds(),
			week: date.getWeekDay(),
			weeks: date.getWeek(),
			weekCn: date.getWeekDayCn(),
			date: ""
		} as xDateDayInfoType
		info.date = info.year + '/' + (info.month + 1) + '/' + info.day
		return info
	}

	/**
	 * 返回日期数组
	 * @param {string}  - m,w,m表示返回本月的日期数据，w表示返回本周的日期数据
	 * @returns - 返回一个日期数组
	 */
	getDaysOf(d : 'm' | 'w' = 'm') : xDateDayInfoType[] {
		let dates = [] as xDateDayInfoType[]
		if (d == 'w') {
			let first = this.getDateStartOf('w')

			for (let i = 0; i < 7; i++) {
				let date = first.getClone()
				date.date.setDate(date.date.getDate() + i)
				dates.push(date.getDateInfo())
			}
		}
		if (d == 'm') {
			let first = this.getDateStartOf('m')
			let maxDay = this.getMonthCountDay()
			for (let i = 1; i <= maxDay; i++) {
				let date = first.getClone()
				date.date.setDate(i)
				dates.push(date.getDateInfo())
			}

		}

		return dates;
	}
	/**
	 * 按指定天数返回日期数组
	 * @param {string} d - 返回多少天的日期数组
	 * @param {string} type - after表示返回当前日期之后的日期，before表示返回当前日期之前的日期
	 */
	getDaysOfNum(d : number = 0, type : 'after' | 'before') : xDateDayInfoType[] {
		let ar = [] as xDateDayInfoType[];
		let nowdate = this.getClone()
		if (type == 'after') {
			for (let i = 0; i < d; i++) {
				nowdate.add(1, 'd')
				ar.push(nowdate.getDateInfo())
			}
		} else if (type == 'before') {
			for (let i = 0; i < d; i++) {
				nowdate.subtraction(1, 'd')
				ar.push(nowdate.getDateInfo())
			}
			ar.reverse()
		}

		return ar;
	}

	/**
	 * 为当前日期进行加操作
	 * @param {string}  - y,m,d,h,M,s,w，代表的是年份，月份，日期，小时，分钟，秒数,周
	 */
	add(count : number, d : xDateTypeTime = 'd') : xDate {
		if (d == 'y') {
			this.date.setFullYear(this.getYear() + count)
		}
		else if (d == 'm') {
			this.date.setMonth(this.getMonth() + count)
		}
		else if (d == 'd') {
			this.date.setDate(this.getDate() + count)
		}
		else if (d == 'h') {
			this.date.setHours(this.getHours() + count)
		}
		else if (d == 'M') {
			this.date.setMinutes(this.getMinutes() + count)
		}
		else if (d == 's') {
			this.date.setSeconds(this.getSeconds() + count)
		}
		// 添加一周
		else if (d == 'w') {
			this.date.setDate(this.getDate() + count * 7)

		}

		return this;
	}
	/**
	 * 为当前日期进行减操作
	 * @param {string}  - y,m,d,h,M,s,w，代表的是年份，月份，日期，小时，分钟，秒数,周
	 */
	subtraction(count : number, d : xDateTypeTime = 'd') : xDate {
		if (d == 'y') {
			this.date.setFullYear(this.getYear() - count)
		}
		else if (d == 'm') {
			this.date.setMonth(this.getMonth() - count)
		}
		else if (d == 'd') {
			this.date.setDate(this.getDate() - count)
		}
		else if (d == 'h') {
			this.date.setHours(this.getHours() - count)
		}
		else if (d == 'M') {
			this.date.setMinutes(this.getMinutes() - count)
		}
		else if (d == 's') {
			this.date.setSeconds(this.getSeconds() - count)
		}
		// 添加一周
		else if (d == 'w') {
			this.date.setDate(this.getDate() - count * 7)
		}

		return this;
	}


	/**
	 * 日期是否在一个区间内
	 * @param {xDate} start 开始日期
	 * @param {xDate} end 结束日期
	 * @param {string} - type要比较的单位，默认为ms,'y' 年 'm' 月 'd' 日 'h' 时 'M' 分 's' 秒 'ms' 毫秒
	 * @param {string} - d,默认为[] 区间类型，'()'不含起始'[]'包含起始'(]'不包含开始，但包含结束'[)'包含开始，但不包含结束
	 * @returns {boolean} 是否在区间内
	 */
	isBetween(start : xDate, end : xDate, type : xDateTypeTime = 'ms', d : '()' | '[]' | '(]' | '[)' = '[]') : boolean {
		let startTime = start.getTime(type)

		// new Date('1970-1-1 8:0:0').getTime()
		let endTime = end.getTime(type)
		let nowTime = this.getTime(type)
		if (d == '()') {
			return nowTime > startTime && nowTime < endTime
		}
		else if (d == '[]') {
			return nowTime >= startTime && nowTime <= endTime
		}
		else if (d == '(]') {
			return nowTime > startTime && nowTime <= endTime
		}
		else if (d == '[)') {
			return nowTime >= startTime && nowTime < endTime
		}
		return nowTime >= startTime && nowTime <= endTime
	}

	/**
	 * 与目标日期比较
	 * @param {xDate} targetDate 要比较的日期
	 * @param {string} - d,默认为> 比较类型，'>'大于目标日期，'>='大于等于目标'<'小于目标，'<='小于等于目标,'='全等
	 * @param {string} - type要比较的单位，默认为ms,'y' 年 'm' 月 'd' 日 'h' 时 'M' 分 's' 秒 'ms' 毫秒
	 * @returns {boolean} 比较结果
	 */
	isBetweenOf(targetDate : xDate, d : '>' | '>=' | '<' | '<=' | '=' = '>', type : xDateTypeTime = 'ms') : boolean {
		let startTime = targetDate.getTime(type)
		let nowTime = this.getTime(type)
		if (d == '>') {
			return nowTime > startTime
		}
		else if (d == '>=') {
			return nowTime >= startTime
		}
		else if (d == '<') {
			return nowTime < startTime
		}
		else if (d == '<=') {
			return nowTime <= startTime
		}
		else if (d == '=') {
			return nowTime == startTime
		}
		return nowTime > startTime
	}
	/**
	 * 与目标时间过了多久
	 * @param {string|xDate|null} target 要对比的相对时间，如果填写null就表示当前时间以来的的多久
	 * @param {Map<number,string>} model 如果为null或者为空的map采用默认值,map格式key表示以秒为单位的时间，value为对应的文本
	 * 比如60,1分钟前
	 * @param {string} format 超过最大值最使用格式化日期，如果为null默认为YYYY-MM-DD
	 * @returns {string} 返回对应的时间文本
	 */
	fromBetweenLongTime(target : any, model : Map<number, string> | null, format : string | null) : string {
		let bijiaodate : xDate = new xDate()
		if (target instanceof xDate) {
			bijiaodate = (target as xDate)
		} else if (typeof target == 'string') {
			bijiaodate = new xDate(target as string)
		} else if (target == null) {
			bijiaodate = new xDate()
		}

		// 使用国际化相对时间配置
		let relativeTime = getLocaleData().relativeTime;
		let mapmodel = new Map<number, string>([
			[30, relativeTime.s],
			[60, relativeTime.m],
			[60 * 5, '5' + relativeTime.mm.replace('%d', '')],
			[60 * 10, '10' + relativeTime.mm.replace('%d', '')],
			[60 * 30, '30' + relativeTime.mm.replace('%d', '')],
			[60 * 60, relativeTime.h],
			[60 * 60 * 2, '2' + relativeTime.hh.replace('%d', '')],
			[60 * 60 * 3, '3' + relativeTime.hh.replace('%d', '')],
			[60 * 60 * 5, '5' + relativeTime.hh.replace('%d', '')],
			[60 * 60 * 23, '23' + relativeTime.hh.replace('%d', '')],
			[60 * 60 * 24 * 1, relativeTime.d],
			[60 * 60 * 24 * 2, '2' + relativeTime.dd.replace('%d', '')],
			[60 * 60 * 24 * 7, '7' + relativeTime.dd.replace('%d', '')],
			[60 * 60 * 24 * 30, relativeTime.M],
			[60 * 60 * 24 * 30 * 2, '2' + relativeTime.MM.replace('%d', '')],
			[60 * 60 * 24 * 30 * 3, '3' + relativeTime.MM.replace('%d', '')],
			[60 * 60 * 24 * 30 * 4, '4' + relativeTime.MM.replace('%d', '')],
			[60 * 60 * 24 * 30 * 5, '5' + relativeTime.MM.replace('%d', '')],
			[60 * 60 * 24 * 30 * 6, '6' + relativeTime.MM.replace('%d', '')],
			[60 * 60 * 24 * 30 * 12, relativeTime.y],
			[60 * 60 * 24 * 30 * 12 + 60 * 60 * 24 * 30, '']
		])
		let fmt = format == null ? 'YYYY-MM-DD' : (format!)

		if (model != null) {
			if (model!.size > 0) {
				mapmodel = model!
			}
		}
		let str = ""
		let fanzhumap = [] as number[];
		mapmodel.forEach((value : string, key : number) => {
			fanzhumap.push(key)
		})
		fanzhumap.reverse()

		try {
			let startTime = bijiaodate.getTime('s')
			let nowTime = this.getTime('s')
			let diff = (nowTime - startTime) / 1000


			if (diff > 0) {
				for (let i = 0; i < fanzhumap.length; i++) {
					let key = fanzhumap[i];

					if (diff >= key) {
						console.log(diff, key, 5 * 60 * 60, '---', fanzhumap)
						str = mapmodel.get(key)!
						break;
					}
				}

			} else {
				str = mapmodel.get(fanzhumap[fanzhumap.length - 1])!
			}
			if (str == '') {
				str = bijiaodate.format(fmt)
			}


		} catch (e) {
			//TODO handle the exception
		}



		return str
	}
	/**
	 * 与目标时间相差多少个单位
	 * @param {string|xDate|null} target 目标时间
	 * @param {xDateTypeTime} type 相差的单位，默认：s秒
	 * @returns {string} 反返回以xDateTypeTime为单位相关的时间数
	 */
	diffTime(target : any, type : xDateTypeTime = 's') : number {
		let startTime = 0
		let typed : xDateTypeTime = (type == 'w' ? 'd' : type)
		if (target instanceof xDate) {
			startTime = (target as xDate).getTime(typed)
		} else if (typeof target == 'string') {
			startTime = new xDate(target as string).getTime(typed)

		} else if (target == null) {
			startTime = new xDate().getTime(typed)
		}

		let nowTime = this.getTime(typed)
		let diff = Math.abs(nowTime - startTime);
		let d = 0
		if (type == 's') {
			d = diff
		} else if (type == 'M') {
			d = diff / 60 / 1000
		} else if (type == 'h') {
			d = diff / 60 / 60 / 1000
		} else if (type == 'd') {
			d = diff / 60 / 60 / 24 / 1000
		} else if (type == 'm') {
			d = diff / 60 / 60 / 24 / 30 / 1000
		} else if (type == 'y') {
			d = diff / 60 / 60 / 24 / 30 / 12 / 1000
		} else if (type == 'w') {
			let ondate = (1000 * 60 * 60 * 24 * 7);
			d = diff / ondate
		}

		return Math.floor(d)
	}
	/**
	 * 获取季度
	 * @param {string} type y表示获取本年的4个季度，空值表示获取当前时间所在的季度
	 * @returns {xDateTypeQuarter[]} 返回一个季度数组{quarter:number,start:string,end:string}
	 */
	getQuarter(type : string = '') : xDateTypeQuarter[] {
		let q1 = [1, 2, 3]
		let q2 = [4, 5, 6]
		let q3 = [7, 8, 9]
		let q4 = [10, 11, 12]
		let nowMonth = this.getMonth() + 1
		let qall = [q1, q2, q3, q4] as number[][]
		let qmap = [] as xDateTypeQuarter[]
		if (type == 'y') {
			for (let i = 0; i < qall.length; i++) {
				let item = qall[i]
				let sdate = new xDate(this.getYear() + '/' + item[0] + '/1')
				let edate = new xDate(this.getYear() + '/' + item[item.length - 1] + '/1')
				let start = sdate.format('YYYY/MM/DD')
				let end = edate.getDateEndOf('m').format('YYYY/MM/DD')
				qmap.push({
					quarter: i,
					start,
					end
				} as xDateTypeQuarter)
			}
		} else {
			for (let i = 0; i < qall.length; i++) {
				let item = qall[i]
				if (item.includes(nowMonth)) {
					let sdate = new xDate(this.getYear() + '/' + item[0] + '/1')
					let edate = new xDate(this.getYear() + '/' + item[item.length - 1] + '/1')
					let start = sdate.format('YYYY/MM/DD')
					let end = edate.getDateEndOf('m').format('YYYY/MM/DD')
					qmap.push({
						quarter: i,
						start,
						end
					} as xDateTypeQuarter)
					break;
				}
			}
		}
		return qmap;
	}

	/**
	 * 设置xDate的语言
	 * @param {xDateLanguage} locale - 语言代码
	 */
	setDateLocale(locale : xDateLanguage) : void {
		setLocale(locale);
	}

	/**
	 * 获取当前xDate使用的语言
	 * @returns {xDateLanguage} - 当前语言代码
	 */
	getDateLocale() : xDateLanguage {
		return getCurrentLocale();
	}
	/**
	 * 根据开始和结束时间取之间的时间（含起始）
	 * @param {string|xDate|null} start 目标时间
	 * @param {string|xDate|null} end 目标时间
	 */
	getBetweenDate(start : string | number | Date, end : string | number | Date, minx : 'min' | 'max' | 'auto' = 'auto') : Date {
		let _start = this.checkDate(start);
		let _end = this.checkDate(end);
		let startDiff = _start.getTime()
		let endDiff = _end.getTime()
		let nowDiff = this.getTime('ms')
		if(nowDiff>=startDiff&&nowDiff<=endDiff){
			return this.date;
		}
		if (minx == 'min') {
			return _start;
		}
		if (minx == 'max') {
			return _end;
		}
		if (startDiff < endDiff) {
			return _end;
		}
		return _start;
	}

}




/**
 * 将一个日期转换为xDate对象
 */
export const dateCovertXdate = function (date : Date) : xDate {
	return new xDate(date)
}