import { DateFormat, LunarType, DiffUnit, FromToOptions, DatetimeOptions, IsBetweenContains, DatetimeUnit } from "../utssdk/interface.uts";
import { Lunar } from './calendar';
import { DateType, DateUtil } from './date';
import { MONTHS, WEEKDAYS, MONTH_DAYS } from './constant';

class KuxDayjs {
	private d: Date
	private dd: DateType
	private lunar: Lunar
	private dateUtil: DateUtil
	private dateStr: string
	constructor (date: string = '') {
		this.dateStr = date;
		this.lunar = new Lunar();
		this.dateUtil = new DateUtil();
		const dd = this.dateUtil.getDate(date);
		this.dd = dd;
		this.d = new Date(dd.year, dd.month - 1, dd.date, dd.hour, dd.minute, dd.second, dd.millisecond);
	}
	
	/**
	 * 当前时间对象
	 * @description 返回一个基于指定日期和时间的 KuxDayjs 对象
	 * @param {string} date 日期时间字符串，比如：'2023-12-12 19:35:35'
	 */
	dayjs (date: string): KuxDayjs {
		this.dateStr = date;
		this.lunar = new Lunar();
		this.dateUtil = new DateUtil();
		const dd = this.dateUtil.getDate(date);
		this.dd = dd;
		this.d = new Date(dd.year, dd.month - 1, dd.date, dd.hour, dd.minute, dd.second, dd.millisecond);
		
		return this;
	}
	
	/**
	 * 基于当前时间复制一个 KuxDayjs 对象
	 * @returns {KuxDayjs}
	 * @example
	 * const a = dayjs();
	 * const b = a.clone();
	 * // a 和 b 是两个独立的 KuxDayjs 对象
	 */
	clone (): KuxDayjs {
		return new KuxDayjs();
	}
	
	/**
	 * 日期格式化
	 * @description 根据传入的占位符返回格式化后的日期
	 * @param format 格式，如 'YYYY-MM-DD HH:mm:ss'
	 * @returns string
	 */
	format (format: string): string {
		const YYYY = `${this.d.getFullYear()}`;
		const M = `${this.d.getMonth() + 1}`;
		const MM = M.padStart(2, '0');
		const DD = `${this.d.getDate()}`.padStart(2, '0');
		const HH = `${this.d.getHours()}`.padStart(2, '0');
		const mm = `${this.d.getMinutes()}`.padStart(2, '0');
		const ss = `${this.d.getSeconds()}`.padStart(2, '0');
		const SSS = `${this.d.getMilliseconds()}`.padStart(3, '0');
		
		// 上午/下午
		let ampm = 'AM';
		let ampmCN = '上午';
		let ampmZN = 'am';
		let formattedHours = HH;
		if (Math.abs(parseInt(HH)) >= 12 && (format.includes('A') || format.includes('a') || format.includes('AA'))) {
			ampm = 'PM';
			ampmCN = '下午';
			ampmZN = 'pm';
			formattedHours = `${(Math.abs(parseInt(HH)) - 12)}`.padStart(2, '0');
		}
		
		return format
			.replace('YYYY', YYYY)
			.replace('MM', MM)
			.replace('DD', DD)
			.replace('HH', formattedHours)
			.replace('mm', mm)
			.replace('ss', ss)
			.replace('SSS', SSS)
			.replace('A', ampm)
			.replace('a', ampmZN)
			.replace('AA', ampmCN)
	}
	
	/**
	 * 差异
	 * @description 返回指定单位下两个日期时间之间的差异
	 * @param {string} date 比较的日期
	 * @param {DiffUnit} unit 单位，默认为 `day`
	 * + week 周，缩写 `w`
	 * + day 天，缩写 `d`
	 * + month 月份，缩写 `M`
	 * + year 年，缩写 `y`
	 * + hour 小时，缩写 `h`
	 * + minute 分钟，缩写 `m`
	 * + second 秒，缩写 `s`
	 * + millisecond 毫秒，缩写 `ms`
	 * @param {boolean} strict 严格模式，设置为 `true` 时，会保持浮点数格式
	 * @returns number
	 */
	diff (date: string, unit: DiffUnit = 'day', strict: boolean = false): number {
		// 将日期转换为毫秒数
		const time1 = this.d.getTime();
		const dd = this.dateUtil.getDate(date);
		const time2 = new Date(dd.year, dd.month - 1, dd.date).getTime();
		
		// 计算两个日期的毫秒数差
		const diffInMilliseconds = Math.abs(time1 - time2);
		// 秒数差
		const diffSeconds = diffInMilliseconds / 1000;
		// 分钟差
		const diffMinutes = diffSeconds / 60;
		// 小时差
		const diffHours = diffMinutes / 60;
		// 天数差
		const diffDays = diffHours / 24;
		// 周数差
		// const diffWeeks = diffDays / 7;
		const week1 = Math.ceil((new Date(dd.year, dd.month, dd.date).getDate() - 1) / 7);
		const week2 = Math.ceil((this.d.getDate() - 1) / 7);
		const diffWeeks = Math.abs(week1 - week2);
		// 月数差
		const year1 = dd.year;
		const year2 = this.d.getFullYear();
		const month1 = dd.month;
		const month2 = this.d.getMonth() + 1;
		
		const diffMonths = (year1 - year2) * 12 + (month1 - month2);
		
		// 判断单位
		let data: number;
		
		switch (unit) {
			case 'millisecond':
				data = diffInMilliseconds;
				break;
			case 'ms':
				data = diffInMilliseconds;
				break;
			case 'second':
				data = diffSeconds;
				break;
			case 's':
				data = diffSeconds;
				break;
			case 'minute':
				data = diffMinutes;
				break;
			case 'M':
				data = diffMinutes;
				break;
			case 'hour':
				data = diffHours;
				break;
			case 'h':
				data = diffHours;
				break;
			case 'week':
				data = diffWeeks;
				break;
			case 'w':
				data = diffWeeks;
				break;
			case 'month':
				data = diffMonths;
				break;
			case 'm':
				data = diffMonths;
				break;
			default:
				data = diffDays;
				break;
		}
		
		if (!strict) {
			data = Math.floor(data);
		}
		
		return data;
	}
	
	/**
	 * 日历时间
	 * @description 获取指定年月的日历面板数据
	 * @param {number} 年
	 * @param {number} 月
	 * @returns {DateFormat} 返回数据
	 */
	calendar (year: number = 0, month: number = 0): DateFormat[] {
		let outDate: DateFormat[] = [];
		let date = new Date();
		let curYear = year;
		let curMonth = month;
		
		if (isNaN(curYear) || curYear < 1900) {
			curYear = date.getFullYear();
		}
		
		if (isNaN(curMonth) || curMonth < 1) {
			curMonth = date.getMonth() + 1;
		}
		
		// 获取当月第一天
		const firstDayOfThisMonth = new Date(curYear, curMonth - 1, 1);
		const preMonthDay = firstDayOfThisMonth.getDay();
		// 获取上月的最后一天，即本月第0天
		const lastDayOfPreMonth = new Date(curYear, curMonth - 1, 0);
		const lastDateOfLastMonth = lastDayOfPreMonth.getDate();
		// 获取本月最后一天，即下月第0天
		const lastDayOfThisMonth = new Date(curYear, curMonth, 0);
		const lastDateOfThisMonth = lastDayOfThisMonth.getDate();
		
		// 获取周日期数据，一个月最多跨6周，即6 * 7格式排版
		for (let i = 0; i < 6 * 7; i++) {
			// 获取当前排序日期
			let thisYear: number = curYear,
			thisMonth: number = curMonth,
			dateN: number = i + 1 - preMonthDay,
			cursorDate: number = dateN;
			
			if (dateN <= 0) {
				thisMonth -= 1;
				cursorDate = dateN + lastDateOfLastMonth;
			} else if (dateN > lastDateOfThisMonth) {
				// date大于本月最后一天为下月预留天数
				thisMonth += 1;
				cursorDate = dateN - lastDateOfThisMonth;
			}
			
			if (thisMonth == 13) {
				thisMonth = 1;
				thisYear += 1;
			}
			if (thisMonth == 0) {
				thisMonth = 12;
				thisYear -= 1;
			}
			
			// 计算该日期与当前时间的天数差
			// const diffInDays = this.diff()
			const startDate = new Date(thisYear, thisMonth - 1, cursorDate);
			const endDate = new Date(this.d.getFullYear(), this.d.getMonth(), this.d.getDate());
			const fullDate = `${thisYear}-${`${thisMonth}`.padStart(2, '0')}-${`${cursorDate}`.padStart(2, '0')}`;
			
			let diffInDays = this.diff(fullDate);
			// let diffInDays = 0;
			
			if (startDate.getTime() < endDate.getTime()) {
				diffInDays *= -1;
			}
			
			outDate.push({
				year: thisYear,
				month: thisMonth,
				date: cursorDate,
				isToday: this.dateUtil.getlunar(thisYear, thisMonth, cursorDate).isToday,
				diffDays: diffInDays,
				render: {},
				lunar: {
					month: this.lunar.toChinaMonth(this.lunar.solar_date(thisYear, thisMonth, cursorDate).lunarM),
					date: this.lunar.toChinaDay(this.lunar.solar_date(thisYear, thisMonth, cursorDate).lunarD)
				} as LunarType,
				fullLunar: this.lunar.solar_date(thisYear, thisMonth, cursorDate),
				fullDate
			} as DateFormat)
		}
		
		return outDate;
	}
	
	/**
	 * 获取/设置毫秒数
	 * @description 获取或设置毫秒
	 * @param {number} ms 0-999的毫秒数，如果大于-1就是设置操作，否则为获取操作
	 * @returns {number} 返回0-999的毫秒数
	 */
	millisecond (ms: number = -1): number {
		if (ms > -1) {
			return this.d.getTime();
		}
		
		return this.d.setMilliseconds(ms);
	}
	
	/**
	 * 获取/设置秒数
	 * @description 获取或设置秒
	 * @param {number} s 0-59的秒数，如果大于-1就是设置操作，否则为获取操作
	 * @returns {number} 返回0-59的秒数
	 */
	second (s: number = -1): number {
		if (s > -1) {
			return this.d.setSeconds(s);
		}
		
		return this.d.getSeconds();
	}
	
	/**
	 * 获取/设置分钟
	 * @description 获取或设置分钟
	 * @param {number} M 0-59的分钟数，如果大于-1就是设置操作，否则为获取操作
	 * @returns {number} 返回0-59的分钟数
	 */
	minute (M: number = -1): number {
		if (M > -1) {
			return this.d.setMinutes(M);
		}
		
		return this.d.getMinutes();
	}
	
	/**
	 * 获取/设置小时
	 * @description 获取或设置小时
	 * @param {number} h 0-23的小时数，如果大于-1就是设置操作，否则为获取操作
	 * @returns {number} 返回0-23的小时数
	 */
	hour (h: number = -1): number {
		if (h > -1) {
			return this.d.setHours(h);
		}
		
		return this.d.getHours();
	}
	
	/**
	 * 获取/设置日期
	 * @description 获取或设置日期
	 * @param {number} d 日期数，传入参数就是设置操作，否则为获取操作。如果为 d 指定 0，那么日期就会被设置为上个月的最后一天。如果 d 被设置为负数，日期会设置为上个月最后一天往前数这个负数绝对值天数后的日期。-1 会设置为上月最后一天的前一天（译者注：例如当前为 4 月，如果 date(-2),则为 3 月 29 日）
	 * @returns {number} 返回1-31的日期数
	 */
	date (d?: number): number {
		if (!isNaN(parseInt(`${d}`))) {
			return this.d.setDate(parseInt(`${d}`));
		}
		
		return this.d.getDate();
	}
	
	/**
	 * 获取星期几，0 表示星期天。目前仅支持获取，不支持设置操作
	 * @description 获取或设置星期
	 * @returns {number} 返回0-6的整数，0代表星期日，1代表星期一，以此类推。
	 */
	day (): number {
		return this.d.getDay();
	}
	
	/**
	 * 获取/设置时间
	 * @description 获取或设置毫秒
	 * @param {number} t 一个整数，表示从 1970-1-1 00:00:00 UTC 开始计时的毫秒数。 传入参数就是设置操作，否则为获取操作。
	 * @returns {number} 返回UTC 1970 年 1 月 1 日 00:00:00 与更新日期之间的毫秒数（实际上是自变量的值）。
	 */
	time (t: number): number {
		if (!isNaN(parseInt(`${t}`))) {
			return this.d.setTime(parseInt(`${t}`));
		}
		
		return this.d.getTime();
	}
	
	/**
	 * 获取/设置月份
	 * @description 获取或设置月份
	 * @param {number} m 0-11的整数，如果m大于0则为设置操作，否则为获取操作
	 * @returns {number} n 
	 * + 获取操作返回0-11的整数（表示一月到十二月）。
	 * + 设置操作返回基于 1 January 1970 00:00:00 UTC 开始计算的毫秒数。
	 */
	month (m: number = -1): number {
		if (m > -1) {
			return this.d.setMonth(m);
		}
		
		return this.d.getMonth();
	}
	
	/**
	 * 获取/设置年
	 * @description 获取或设置年份
	 * @param {number} y 大于1969的整数，如果大于1969则为设置操作，否则为获取操作
	 * @returns {number} 返回操作后的年份数
	 */
	year (y: number = 1969): number {
		if (y > 1969) {
			return this.d.setFullYear(y);
		}
		
		return this.d.getFullYear();
	}
	
	/**
	 * 增加
	 * @description 返回增加一定时间的复制的 KuxDayjs 对象
	 * @param {string} count 需要增加的整数，支持配合单位操作
	 * @param {DiffUnit} unit 单位，默认为 `day`
	 * + week 周，缩写 `w`
	 * + day 天，缩写 `d`
	 * + month 月份，缩写 `M`
	 * + year 年，缩写 `y`
	 * + hour 小时，缩写 `h`
	 * + minute 分钟，缩写 `m`
	 * + second 秒，缩写 `s`
	 * + millisecond 毫秒，缩写 `ms`
	 * @returns {Date} d 操作后的Date对象
	 */
	add (count: number = 0, unit: DiffUnit = 'day'): KuxDayjs {
		if (count < 0) {
			console.warn('【kux-dayjs:add】请输入大于0的数字');
			return this;
		}
		if (unit === 'day' || unit === 'd') {
			this.d.setDate(this.d.getDate() + count);
		} else if (unit === 'month' || unit === 'M') {
			this.d.setMonth(this.d.getMonth() + count);
		} else if (unit === 'year' || unit === 'y') {
			this.d.setFullYear(this.d.getFullYear() + count);
		} else if (unit === 'week' || unit === 'w') {
			this.d.setDate((this.d.getDate() + 7) * count);
		} else if (unit === 'hour' || unit === 'h') {
			this.d.setHours(this.d.getHours() + count);
		} else if (unit === 'minute' || unit === 'm') {
			this.d.setMinutes(this.d.getMinutes() + count);
		} else if (unit === 'second' || unit === 's') {
			this.d.setSeconds(this.d.getSeconds() + count);
		} else if (unit === 'millisecond' || unit === 'ms') {
			this.d.setMilliseconds(this.d.getMilliseconds() + count);
		}
		
		return this;
	}
	
	/**
	 * 减去
	 * @description 返回减去一定时间的复制的 KuxDayjs 对象
	 * @param {string} count 需要减去的整数，支持配合单位操作
	 * @param {DiffUnit} unit 单位，默认为 `day`
	 * + week 周，缩写 `w`
	 * + day 天，缩写 `d`
	 * + month 月份，缩写 `M`
	 * + year 年，缩写 `y`
	 * + hour 小时，缩写 `h`
	 * + minute 分钟，缩写 `m`
	 * + second 秒，缩写 `s`
	 * + millisecond 毫秒，缩写 `ms`
	 * @returns {Date} d 操作后的Date对象
	 */
	subtract (count: number = 0, unit: DiffUnit = 'day'): KuxDayjs {
		if (count < 0) {
			console.warn('【kux-dayjs:subtract】请输入大于0的数字');
			return this;
		}
		if (unit === 'day' || unit === 'd') {
			this.d.setDate(this.d.getDate() - count);
		} else if (unit === 'month' || unit === 'M') {
			this.d.setMonth(this.d.getMonth() - count);
		} else if (unit === 'year' || unit === 'y') {
			this.d.setFullYear(this.d.getFullYear() - count);
		} else if (unit === 'week' || unit === 'w') {
			this.d.setDate((this.d.getDate() - 7) * count);
		} else if (unit === 'hour' || unit === 'h') {
			this.d.setHours(this.d.getHours() - count);
		} else if (unit === 'minute' || unit === 'm') {
			this.d.setMinutes(this.d.getMinutes() - count);
		} else if (unit === 'second' || unit === 's') {
			this.d.setSeconds(this.d.getSeconds() - count);
		} else if (unit === 'millisecond' || unit === 'ms') {
			this.d.setMilliseconds(this.d.getMilliseconds() - count);
		}
		
		return this;
	}
	
	/**
	 * 设置时间为0时0分0秒0毫秒
	 */
	private _setTimeStart (): KuxDayjs {
		this.d.setHours(0);
		this.d.setMinutes(0);
		this.d.setSeconds(0);
		this.d.setMilliseconds(0);
		
		return this;
	}
	
	/**
	 * 设置时间为23时59分59秒999毫秒
	 */
	private _setTimeEnd () {
		this.d.setHours(23);
		this.d.setMinutes(59);
		this.d.setSeconds(59);
		this.d.setMilliseconds(999);
	}
	
	/**
	 * 设置时间为今天
	 */
	today (): KuxDayjs {
		this.d = new Date();
		
		return this;
	}
	
	/**
	 * 时间的开始
	 * @description 返回复制的 KuxDayjs 对象，并设置到一个时间的开始。
	 * @param {DiffUnit} unit 单位
	 * + week 周，缩写 `w`
	 * + day 天，缩写 `d`
	 * + month 月份，缩写 `M`
	 * + year 年，缩写 `y`
	 * + hour 小时，缩写 `h`
	 * + minute 分钟，缩写 `m`
	 * + second 秒，缩写 `s`
	 * @returns {Date} d 操作后的Date对象
	 */
	startOf (unit: DiffUnit): KuxDayjs {
		this.today();
		
		if (unit === 'week' || unit === 'w') {
			const day = this.d.getDay();
			this.d.setDate((this.d.getDate() - day + (day == 0 ? -6 : 1)));
			this._setTimeStart();
		} else if (unit === 'day' || unit === 'd') {
			this._setTimeStart();
		} else if (unit === 'month' || unit === 'M') {
			this.d.setDate(1);
			this._setTimeStart();
		} else if (unit === 'year' || unit === 'y') {
			this.d.setMonth(0);
			this.d.setDate(1);
			this._setTimeStart();
		} else if (unit === 'hour' || unit === 'h') {
			this.d.setMinutes(0);
			this.d.setSeconds(0);
			this.d.setMilliseconds(0);
		} else if (unit === 'minute' || unit === 'm') {
			this.d.setSeconds(0);
			this.d.setMilliseconds(0);
		} else if (unit === 'second' || unit === 's') {
			this.d.setMilliseconds(0);
		}
		
		return this;
	}
	
	/**
	 * 时间的结束
	 * @description 返回复制的 KuxDayjs 对象，并设置到一个时间的末尾。
	 * @param {DiffUnit} unit 单位
	 * + week 周，缩写 `w`
	 * + day 天，缩写 `d`
	 * + month 月份，缩写 `M`
	 * + year 年，缩写 `y`
	 * + hour 小时，缩写 `h`
	 * + minute 分钟，缩写 `m`
	 * + second 秒，缩写 `s`
	 * @returns {Date} d 操作后的Date对象
	 */
	endOf (unit: DiffUnit): KuxDayjs {
		this.today();
		
		if (unit === 'week' || unit === 'w') {
			const day = this.d.getDay();
			this.d.setDate(this.d.getDate() + (7 - day));
			this._setTimeEnd();
		} else if (unit === 'day' || unit === 'd') {
			this._setTimeEnd();
		} else if (unit === 'month' || unit === 'M') {
			const year = this.d.getFullYear();
			const month = this.d.getMonth() + 1;
			this.d = new Date(year, month, 0);
			this._setTimeEnd();
		} else if (unit === 'year' || unit === 'y') {
			const year = this.d.getFullYear();
			this.d = new Date(year, 11, 31);
			this._setTimeEnd();
		} else if (unit === 'hour' || unit === 'h') {
			this.d.setMinutes(59);
			this.d.setSeconds(59);
			this.d.setMilliseconds(999);
		} else if (unit === 'minute' || unit === 'm') {
			this.d.setSeconds(59);
			this.d.setMilliseconds(999);
		} else if (unit === 'second' || unit === 's') {
			this.d.setMilliseconds(999);
		}
		
		return this;
	};
	
	private _fromOrto (date: Date, options: FromToOptions = {
		isSuffix: false,
		relativeTime: {
			s: '',
			m: '',
			mm: '',
			h: '',
			hh: '',
			d: '',
			dd: '',
			mon: '',
			mons: '',
			y: '',
			yy: ''
		}
	} as FromToOptions, type: 'from' | 'to' = 'from'): string {
		const now = date.getTime();
		let diff = now - this.d.getTime();
		const diffSeconds = Math.floor(diff / 1000);
		const diffMinutes = Math.floor(diffSeconds / 60);
		const diffHours = Math.floor(diffMinutes / 60);
		const diffDays = Math.floor(diffHours / 24);
		const diffMonths = Math.floor(diffDays / 30.44);
		const diffYears = Math.floor(diffMonths / 12);
		
		const isSuffix = options.isSuffix ?? false;
		const s = options.relativeTime?.s ?? '';
		const m = options.relativeTime?.m ?? '';
		const mm = options.relativeTime?.mm ?? '';
		const h = options.relativeTime?.h ?? '';
		const hh = options.relativeTime?.hh ?? '';
		const d = options.relativeTime?.d ?? '';
		const dd = options.relativeTime?.dd ?? '';
		const mon = options.relativeTime?.mon ?? '';
		const mons = options.relativeTime?.mons ?? '';
		const y = options.relativeTime?.y ?? '';
		const yy = options.relativeTime?.yy ?? '';
		
		let outStr = '';
		let suffix = isSuffix ? '' : (type === 'from' ? '前' : '后');
		
		if (diffSeconds > 0 && diffSeconds < 45) {
			outStr = `${diffSeconds}秒${suffix}`;
			if (s.includes('%s')) {
				outStr = s;
				outStr = outStr.replace('%s', `${diffSeconds}`);
			}
		} else if (diffSeconds >= 45 &&  diffSeconds <= 89) {
			outStr = `1分钟${suffix}`;
			if (m.includes('%m')) {
				outStr = m;
				outStr = outStr.replace('%m', `1`);
			}
		} else if (diffSeconds >= 90 && diffMinutes <= 44) {
			outStr = `${diffMinutes}分钟${suffix}`;
			if (mm.includes('%mm')) {
				outStr = mm;
				outStr = outStr.replace('%mm', `${diffMinutes}`);
			}
		} else if (diffMinutes >= 45 && diffMinutes <= 89) {
			outStr = `1小时${suffix}`;
			if (h.includes('%h')) {
				outStr = h;
				outStr = outStr.replace('%h', '1');
			}
		} else if (diffMinutes >= 90 && diffHours <= 21) {
			outStr = `${diffHours}小时${suffix}`;
			if (hh.includes('%hh')) {
				outStr = hh;
				outStr = outStr.replace('%hh', `${diffHours}`);
			}
		} else if (diffHours >= 22 && diffHours <= 35) {
			outStr = `1天${suffix}`;
			if (d.includes('%d')) {
				outStr = d;
				outStr = outStr.replace('%d', `1`);
			}
		} else if (diffHours >= 36 && diffDays <= 25) {
			outStr = `${diffDays}天${suffix}`;
			if (dd.includes('%dd')) {
				outStr = dd;
				outStr = outStr.replace('%dd', `${diffDays}`);
			}
		} else if (diffDays >= 26 && diffDays <= 45) {
			outStr = `1个月${suffix}`;
			if (mon.includes('%mon')) {
				outStr = mon;
				outStr = outStr.replace('%mon', '1');
			}
		} else if (diffDays >= 46 && diffMonths <= 10) {
			outStr = `${diffMonths}个月${suffix}`;
			if (mons.includes('%mons')) {
				outStr = mons;
				outStr = outStr.replace('%mons', `${diffMonths}`);
			}
		} else if (diffMonths >= 11 && diffMonths <= 17) {
			outStr = `1年${suffix}`;
			if (y.includes('%y')) {
				outStr = y;
				outStr = outStr.replace('%y', '1');
			}
		} else if (diffMonths >= 18) {
			outStr = `${diffYears}年${suffix}`;
			if (yy.includes('%yy')) {
				outStr = yy;
				outStr = outStr.replace('%yy', `${diffYears}`);
			}
		}
		
		return outStr;
	};
	
	/**
	 * 相对当前时间（前）
	 * @description 返回现在到当前实例的相对时间
	 * @param {FromNowOptions} options 配置项
	 * + isSuffix - boolean类型，是否自动携带后缀，为true的时候会自动添加“前”后缀，如 1年前；手动指定 `relativeTime` 时该项不生效
	 * + relativeTime - RelativeTime类型，自定义格式，支持变量见下方说明
	 * | 范围 | 键量 | 使用变量 | 说明 | 示例 |
	 * | --- | --- | --- | --- | --- |
	 * | 0 to 44seconds | s | %s | 几秒前 | %s seconds ago |
	 * | 45 to 89 seconds | m | %m | 1分钟前 | %m minute ago |
	 * | 90 seconds to 44 minutes | mm | %mm | 几分钟前 | %mm minutes ago |
	 * | 45 to 89 minutes | h | %h | 1小时前 | %h hour ago |
	 * | 90 minutes to 21 hours | hh | %hh | 几小时前 | %hh hours ago |
	 * | 22 to 35 hours | d | d | %d | 1天前 | %d day ago |
	 * | 36 hours to 25 days | dd | %dd | 几天前 | %dd days ago |
	 * | 26 to 45 days | mon | %mon | 1个月前 | %mon month ago |
	 * | 46 days to 10 months | mons | %mons | 几个月前 | %mons months ago |
	 * | 11 months to 17 months | y | %y | 1年前 | %y year ago |
	 * | 18 months + | yy | %yy | 几年前 | %yy years ago |
	 * 
	 * @returns string
	 * 
	 * @example 
	 * ### 基本示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * console.log(datetime.fromNow()); // 输出 1年前
	 * 
	 * ### 自定义格式示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * const options: FromNowOptions = {
	 *	 isSuffix: false,
	 *   relativeTime: {
	 *      y: '%s year ago'	 
	 *   } as RelativeTime
	 * };
	 * console.log(datetime.fromNow(options)); // 输出 1 year ago
	 */
	fromNow (options: FromToOptions = {
		isSuffix: false,
		relativeTime: {
			s: '',
			m: '',
			mm: '',
			h: '',
			hh: '',
			d: '',
			dd: '',
			mon: '',
			mons: '',
			y: '',
			yy: ''
		}
	} as FromToOptions): string {
		return this._fromOrto(new Date(), options);
	};
	
	/**
	 * 相对指定时间（前）
	 * @description 返回 X 到当前实例的相对时间
	 * @param {FromNowOptions} options 配置项
	 * + isSuffix - boolean类型，是否自动携带后缀，为true的时候会自动添加“前”后缀，如 1年前；手动指定 `relativeTime` 时该项不生效
	 * + relativeTime - RelativeTime类型，自定义格式，支持变量见下方说明
	 * | 范围 | 键量 | 使用变量 | 说明 | 示例 |
	 * | --- | --- | --- | --- | --- |
	 * | 0 to 44seconds | s | %s | 几秒前 | %s seconds ago |
	 * | 45 to 89 seconds | m | %m | 1分钟前 | %m minute ago |
	 * | 90 seconds to 44 minutes | mm | %mm | 几分钟前 | %mm minutes ago |
	 * | 45 to 89 minutes | h | %h | 1小时前 | %h hour ago |
	 * | 90 minutes to 21 hours | hh | %hh | 几小时前 | %hh hours ago |
	 * | 22 to 35 hours | d | d | %d | 1天前 | %d day ago |
	 * | 36 hours to 25 days | dd | %dd | 几天前 | %dd days ago |
	 * | 26 to 45 days | mon | %mon | 1个月前 | %mon month ago |
	 * | 46 days to 10 months | mons | %mons | 几个月前 | %mons months ago |
	 * | 11 months to 17 months | y | %y | 1年前 | %y year ago |
	 * | 18 months + | yy | %yy | 几年前 | %yy years ago |
	 * 
	 * @returns string
	 * 
	 * @example 
	 * ### 基本示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * const a = dayjs('2022-12-12');
	 * console.log(datetime.from(a)); // 输出 1年前
	 * 
	 * ### 自定义格式示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * const a = dayjs('2022-12-12');
	 * const options: FromNowOptions = {
	 *	 isSuffix: false,
	 *   relativeTime: {
	 *      y: '%s year ago'	 
	 *   } as RelativeTime
	 * };
	 * console.log(datetime.from(a, options)); // 输出 1 year ago
	 */
	from (dayjs: KuxDayjs, options: FromToOptions = {
		isSuffix: false,
		relativeTime: {
			s: '',
			m: '',
			mm: '',
			h: '',
			hh: '',
			d: '',
			dd: '',
			mon: '',
			mons: '',
			y: '',
			yy: ''
		}
	} as FromToOptions): string {
		return this._fromOrto(dayjs.d, options);
	}
	
	/**
	 * 相对当前时间（后）
	 * @description 返回当前实例到现在的相对时间
	 * @param {FromNowOptions} options 配置项
	 * + isSuffix - boolean类型，是否自动携带后缀，为true的时候会自动添加“后”后缀，如 1年后；手动指定 `relativeTime` 时该项不生效
	 * + relativeTime - RelativeTime类型，自定义格式，支持变量见下方说明
	 * | 范围 | 键量 | 使用变量 | 说明 | 示例 |
	 * | --- | --- | --- | --- | --- |
	 * | 0 to 44seconds | s | %s | 几秒后 | %s seconds after |
	 * | 45 to 89 seconds | m | %m | 1分钟后 | %m minute after |
	 * | 90 seconds to 44 minutes | mm | %mm | 几分钟后 | %mm minutes after |
	 * | 45 to 89 minutes | h | %h | 1小时后 | %h hour after |
	 * | 90 minutes to 21 hours | hh | %hh | 几小时后 | %hh hours after |
	 * | 22 to 35 hours | d | d | %d | 1天后 | %d day after |
	 * | 36 hours to 25 days | dd | %dd | 几天后 | %dd days after |
	 * | 26 to 45 days | mon | %mon | 1个月后 | %mon month after |
	 * | 46 days to 10 months | mons | %mons | 几个月后 | %mons months after |
	 * | 11 months to 17 months | y | %y | 1年后 | %y year after |
	 * | 18 months + | yy | %yy | 几年后 | %yy years after |
	 * 
	 * @returns string
	 * 
	 * @example 
	 * ### 基本示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * console.log(datetime.toNow()); // 输出 1年后
	 * 
	 * ### 自定义格式示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * const options: FromToOptions = {
	 *	 isSuffix: false,
	 *   relativeTime: {
	 *      y: '%s year after'	 
	 *   } as RelativeTime
	 * };
	 * console.log(datetime.toNow(options)); // 输出 1 year after
	 */
	toNow (options: FromToOptions = {
		isSuffix: false,
		relativeTime: {
			s: '',
			m: '',
			mm: '',
			h: '',
			hh: '',
			d: '',
			dd: '',
			mon: '',
			mons: '',
			y: '',
			yy: ''
		}
	} as FromToOptions): string {
		return this._fromOrto(new Date(), options);
	}
	
	/**
	 * 相对指定时间（后）
	 * @description 返回当前实例到 X 的相对时间
	 * @param {FromNowOptions} options 配置项
	 * + isSuffix - boolean类型，是否自动携带后缀，为true的时候会自动添加“前”后缀，如 1年后；手动指定 `relativeTime` 时该项不生效
	 * + relativeTime - RelativeTime类型，自定义格式，支持变量见下方说明
	 * | 范围 | 键量 | 使用变量 | 说明 | 示例 |
	 * | --- | --- | --- | --- | --- |
	 * | 0 to 44seconds | s | %s | 几秒后 | %s seconds after |
	 * | 45 to 89 seconds | m | %m | 1分钟后 | %m minute after |
	 * | 90 seconds to 44 minutes | mm | %mm | 几分钟后 | %mm minutes after |
	 * | 45 to 89 minutes | h | %h | 1小时后 | %h hour after |
	 * | 90 minutes to 21 hours | hh | %hh | 几小时后 | %hh hours after |
	 * | 22 to 35 hours | d | d | %d | 1天后 | %d day after |
	 * | 36 hours to 25 days | dd | %dd | 几天后 | %dd days after |
	 * | 26 to 45 days | mon | %mon | 1个月后 | %mon month after |
	 * | 46 days to 10 months | mons | %mons | 几个月后 | %mons months after |
	 * | 11 months to 17 months | y | %y | 1年后 | %y year after |
	 * | 18 months + | yy | %yy | 几年后 | %yy years after |
	 * 
	 * @returns string
	 * 
	 * @example 
	 * ### 基本示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * const a = dayjs('2022-12-12');
	 * console.log(datetime.to(a)); // 输出 1年后
	 * 
	 * ### 自定义格式示例
	 * const datetime = dayjs('2021-12-12 15:43:58');
	 * const a = dayjs('2022-12-12');
	 * const options: FromToOptions = {
	 *	 isSuffix: false,
	 *   relativeTime: {
	 *      y: '%s year after'	 
	 *   } as RelativeTime
	 * };
	 * console.log(datetime.to(a, options)); // 输出 1 year after
	 */
	to (date: KuxDayjs, options: FromToOptions = {
		isSuffix: false,
		relativeTime: {
			s: '',
			m: '',
			mm: '',
			h: '',
			hh: '',
			d: '',
			dd: '',
			mon: '',
			mons: '',
			y: '',
			yy: ''
		}
	} as FromToOptions): string {
		return this._fromOrto(date.d, options);
	}
	
	/**
	 * Unix时间戳（毫秒）
	 * @description 返回当前实例的 UNIX 时间戳，13位数字，毫秒
	 */
	valueOf (): number {
		return this.d.getTime();
	}
	
	/**
	 * Unix时间戳
	 * @description 返回当前实例的 UNIX 时间戳，10位数字，秒。
	 */
	unix (): number {
		return Math.floor(this.valueOf() / 1000);
	}
	
	/**
	 * 是否闰年
	 * @description 查询 KuxDayjs 对象的年份是否是闰年
	 * @returns {boolean}
	 * @example
	 * const date = dayjs('2000-01-01');
	 * console.log(date.isLeapYear()); // 输出 true
	 */
	isLeapYear (): boolean {
		return (this.dd.year % 4 == 0 && this.dd.year % 100 != 0) || this.dd.year % 400 == 0;
	}
	
	/**
	 * 获取月天数
	 * @description 获取当前月份包含的天数
	 * @example
	 * const date = dayjs('2023-12-12');
	 * console.log(date.daysInMonth()); // 输出 31
	 */
	daysInMonth (): number {
		
		// 如果是闰年，2月有 29 天
		if (this.dd.month == 2 && this.isLeapYear()) {
			return 29;
		}
		
		return MONTH_DAYS[this.dd.month - 1];
	}
	
	/**
	 * 转Date
	 * @description 从KuxDayjs中获取原生的Date对象
	 */
	toDate (): Date {
		return this.d;
	}
	
	/**
	 * 转数组
	 * @description 返回一个包含各个时间信息的 Array
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.toArray()); // 输出 [2023,12,13,10,16,18,0]
	 */
	toArray(): number[] {
		return Array(this.dd.year, this.dd.month, this.dd.date, this.dd.hour, this.dd.minute, this.dd.second, this.dd.millisecond);
	}
	
	/**
	 * 转JSON
	 * @description 序列化为 ISO 8601 格式的字符串
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.toJSON()); // 输出 2023-12-13T10:16:18.000Z
	 */
	toJSON(): string {
		const year = `${this.dd.year}`.padStart(2, '0');
		const month = `${this.dd.month}`.padStart(2, '0');
		const date = `${this.dd.date}`.padStart(2, '0');
		const hours = `${this.dd.hour}`.padStart(2, '0');
		const minutes = `${this.dd.minute}`.padStart(2, '0');
		const seconds = `${this.dd.second}`.padStart(2, '0');
		const milliseconds = `${this.dd.millisecond}`.padStart(3, '0');
		
		return `${year}-${month}-${date}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;
	}
	
	/**
	 * 转对象
	 * @description 返回包含时间信息的 Object
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.toObject()); // 输出 {"date":13,"hours":10,"milliseconds":0,"minutes":16,"months":12,"seconds":18,"years":2023}
	 */
	toObject(): DatetimeOptions {
		return {
			years: this.dd.year,
			months: this.dd.month,
			date: this.dd.date,
			hours: this.dd.hour,
			minutes: this.dd.minute,
			seconds: this.dd.second,
			milliseconds: this.dd.millisecond
		} as DatetimeOptions;
	}
	
	/**
	 * 转字符串
	 * @description 返回包含时间信息的"RFC 822" 或 "RFC 5322" 格式字符串
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.toRFCString()); // 输出 Wed, 13 Dec 2023 10:16:18 GMT
	 */
	toRFCString (): string {
		const weekday = WEEKDAYS[this.toDate().getDay()];
		const year = `${this.dd.year}`;
		const month = MONTHS[this.toDate().getMonth()];
		const day = `${this.dd.date}`.padStart(2, '0');
		const hours = `${this.dd.hour}`.padStart(2, '0');
		const minutes = `${this.dd.minute}`.padStart(2, '0');
		const seconds = `${this.dd.second}`.padStart(2, '0');
		
		return `${weekday}, ${day} ${month} ${year} ${hours}:${minutes}:${seconds} GMT`;
	}
	
	private _isGetDate (dayjs: KuxDayjs, unit: DiffUnit = 'ms'): Date {
		let date: Date;
		
		const year = dayjs.dd.year;
		const month = dayjs.dd.month;
		const day = dayjs.dd.date;
		const hour = dayjs.dd.hour;
		const minute = dayjs.dd.minute;
		const second = dayjs.dd.second;
		const millsecond = dayjs.dd.millisecond;
		
		if (unit === 'year' || unit === 'y') {
			date = new Date(year, 0, 0, 0, 0, 0, 0);
		} else if (unit === 'month' || unit === 'M') {
			date = new Date(year, month - 1);
		} else if (unit === 'day' || unit === 'd') {
			date = new Date(year, month - 1, day);
		} else if (unit === 'hour' || unit === 'h') {
			date = new Date(year, month - 1, day, hour);
		} else if (unit === 'minute' || unit === 'm') {
			date = new Date(year, month - 1, day, hour, minute);
		} else if (unit === 'second' || unit === 's') {
			date = new Date(year, month - 1, day, hour, minute, second);
		} else {
			date = new Date(year, month - 1, day, hour, minute, second, millsecond);
		}
		
		return date;
	}
	
	/**
	 * 是否之前
	 * @description 表示 KuxDayjs 对象是否在另一个提供的日期时间之前
	 * @param {string} datetime 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {DiffUnit} unit 比较单位，默认为ms
	 * + year - 年，缩写为 `y`
	 * + month - 月，缩写为 `M`
	 * + day - 日，缩写为 `d`
	 * + hour - 小时，缩写为 `h`
	 * + minute - 分钟，缩写为 `m`
	 * + second - 秒，缩写为 `s`
	 * + millisecond - 毫秒，缩写为 `ms`
	 * @returns {boolean}
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.isBefore('2024-12-12')); // 输出 true
	 * console.log(datetime.isBefore('2024-12-12', 'year')); // 输出 true
	 */
	isBefore (datetime: string, unit: DiffUnit = 'ms'): boolean {
		const dayjs = this.dayjs(datetime);
		const date1 = this._isGetDate(dayjs, unit);
		const date2 = this._isGetDate(this.clone(), unit);
		
		return date2.getTime() < date1.getTime();
	}
	
	/**
	 * 是否相同
	 * @description 表示 KuxDayjs 对象是否和另一个提供的日期时间相同
	 * @param {string} date 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {DatetimeUnit} unit 比较单位，默认为ms
	 * + year - 年，缩写为 `y`
	 * + month - 月，缩写为 `M`
	 * + day - 日，缩写为 `d`
	 * + hour - 小时，缩写为 `h`
	 * + minute - 分钟，缩写为 `m`
	 * + second - 秒，缩写为 `s`
	 * + millisecond - 毫秒，缩写为 `ms`
	 * @returns {boolean}
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.isSame('2023-12-12')); // 输出 false
	 * console.log(datetime.isSame('2023-12-12', 'year')); // 输出 true
	 */
	isSame (datetime: string, unit: DatetimeUnit = 'ms'): boolean {
		const dayjs = this.dayjs(datetime);
		const date1 = this._isGetDate(dayjs, unit);
		const date2 = this._isGetDate(this.clone());
		
		return date2.getTime() === date1.getTime();
	}
	
	/**
	 * 是否之后
	 * @description 表示 KuxDayjs 对象是否在另一个提供的日期时间之后
	 * @param {string} datetime 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {DatetimeUnit} unit 比较单位，默认为ms
	 * + year - 年，缩写为 `y`
	 * + month - 月，缩写为 `M`
	 * + day - 日，缩写为 `d`
	 * + hour - 小时，缩写为 `h`
	 * + minute - 分钟，缩写为 `m`
	 * + second - 秒，缩写为 `s`
	 * + millisecond - 毫秒，缩写为 `ms`
	 * @returns {boolean}
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.isAfter('2023-12-12')); // 输出 true
	 * console.log(datetime.isAfter('2023-12-12', 'year')); // 输出 true
	 */
	isAfter (datetime: string, unit: DatetimeUnit = 'ms'): boolean {
		const dayjs = this.dayjs(datetime);
		const date1 = this._isGetDate(dayjs, unit);
		const date2 = this._isGetDate(this.clone(), unit);
		
		return date2.getTime() > date1.getTime();
	}
	
	/**
	 * 是否相同或之前
	 * @description 表示 KuxDayjs 对象是和另一个提供的日期时间相同或在其之前
	 * @param {string} datetime 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {DatetimeUnit} unit 比较单位，默认为ms
	 * + year - 年，缩写为 `y`
	 * + month - 月，缩写为 `M`
	 * + day - 日，缩写为 `d`
	 * + hour - 小时，缩写为 `h`
	 * + minute - 分钟，缩写为 `m`
	 * + second - 秒，缩写为 `s`
	 * + millisecond - 毫秒，缩写为 `ms`
	 * @returns {boolean}
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.isSameOrBefore('2023-12-12')); // 输出 false
	 * console.log(datetime.isSameOrBefore('2023-12-12', 'year')); // 输出 true
	 */
	isSameOrBefore (datetime: string, unit: DatetimeUnit = 'ms'): boolean {
		const dayjs = this.dayjs(datetime);
		const date1 = this._isGetDate(dayjs, unit);
		const date2 = this._isGetDate(this.clone(), unit);
		
		const time1 = date1.getTime();
		const time2 = date2.getTime();
		
		return time2 <= time1;
	}
	
	/**
	 * 是否相同或之后
	 * @description 表示 KuxDayjs 对象是否和另一个提供的日期时间相同或在其之后
	 * @param {string} datetime 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {DatetimeUnit} unit 比较单位，默认为ms
	 * + year - 年，缩写为 `y`
	 * + month - 月，缩写为 `M`
	 * + day - 日，缩写为 `d`
	 * + hour - 小时，缩写为 `h`
	 * + minute - 分钟，缩写为 `m`
	 * + second - 秒，缩写为 `s`
	 * + millisecond - 毫秒，缩写为 `ms`
	 * @returns {boolean}
	 * @example
	 * const datetime = dayjs('2023-12-13 10:16:18');
	 * console.log(datetime.isSameOrAfter('2023-12-12')); // 输出 true
	 * console.log(datetime.isSameOrAfter('2023-12-12', 'year')); // 输出 true
	 */
	isSameOrAfter (datetime: string, unit: DatetimeUnit = 'ms'): boolean {
		const dayjs = this.dayjs(datetime);
		const date1 = this._isGetDate(dayjs, unit);
		const date2 = this._isGetDate(this.clone(), unit);
		
		const time1 = date1.getTime();
		const time2 = date2.getTime();
		
		return time2 >= time1;
	}
	
	/**
	 * 是否两者之间
	 * @description 表示 KuxDayjs 对象是否在其他两个的日期时间之间
	 * @param {string} datetime1 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {string} datetime2 日期时间字符串，仅支持 'YYYY-MM-DD HH:mm:ss.S'格式
	 * @param {DatetimeUnit} unit 比较单位，默认为 `ms`
	 * + year - 年，缩写为 `y`
	 * + month - 月，缩写为 `M`
	 * + day - 日，缩写为 `d`
	 * + hour - 小时，缩写为 `h`
	 * + minute - 分钟，缩写为 `m`
	 * + second - 秒，缩写为 `s`
	 * + millisecond - 毫秒，缩写为 `ms`
	 * @param {IsBetweenContains} contains 包含关系，见下方说明
	 * + `[` - 向前包含，等同于 `<=`
	 * + `]` - 向后包含，等同于 `>=`
	 * + `[]` - 前后都包含
	 * @returns {boolean}
	 * @example
	 * const date = dayjs('2023-12-13');
	 * console.log(date.isBetween('2023-12-13', '2023-12-14', 'day')); // 输出 false
	 * console.log(date.isBetween('2023-12-13', '2023-12-14', 'day', '[')); // 输出 true 
	 */
	isBetween (datetime1: string, datetime2: string, unit: DatetimeUnit = 'ms', contains: IsBetweenContains = ''): boolean {
		const dayjs1 = this.dayjs(datetime1);
		const date1 = this._isGetDate(dayjs1, unit);
		
		const dayjs2 = this.dayjs(datetime2);
		const date2 = this._isGetDate(dayjs2, unit);
		
		const date3 = this._isGetDate(this.clone(), unit);
		
		const time1 = date1.getTime();
		const time2 = date2.getTime();
		const time3 = date3.getTime();
		
		// 向前包含
		if (contains === '[') {
			return time3 >= time1 && time3 < time2;
		}
		
		// 向后包含
		if (contains === ']') {
			return time3 > time1 && time3 <= time2;
		}
		
		// 前后都包含
		if (contains === '[]') {
			return time3 >= time1 && time3 <= time2;
		}
		
		// 前后都不包含
		return time3 > time1 && time3 < time2;
	}
	
	/**
	 * 是否是Dayjs
	 * @description 这表示一个变量是否为 KuxDayjs 对象
	 * @param {any} dayjs 判断的对象
	 * @returns {boolean}
	 * @example
	 * const now = dayjs();
	 * console.log(now.isDayjs(dayjs())); // 输出 true
	 * console.log(now.isDayjs(new Date())); // 输出 false
	 */
	isDayjs (dayjs: any): boolean {
		return dayjs instanceof KuxDayjs;
	}
};

export function dayjs (date: string = ''): KuxDayjs {
	return new KuxDayjs(date);
};

// 导出类型
export * from '../utssdk/interface';