import { StringUtils } from './StringUtils';

/**
 * 日期/时间工具
 */
// let myDate = new Date();
// myDate.getTime()              // 获取以毫秒为单位的时间值。
// myDate.getFullYear();         // 获取完整的年份(4位,1970-????)
// myDate.getMonth();            // 获取myDate月份(0-11,0代表1月)
// myDate.getDate();             // 获取myDate日期(1-31)
// myDate.getDay();              // 获取myDate星期X(0-6,0代表星期天)
// myDate.getTime();             // 获取myDate时间(从1970.1.1开始的毫秒数)
// myDate.getHours();            // 获取myDate小时数(0-23)
// myDate.getMinutes();          // 获取myDate分钟数(0-59)
// myDate.getSeconds();          // 获取myDate秒数(0-59)
// myDate.getMilliseconds();     // 获取myDate毫秒数(0-999)
// myDate.toLocaleDateString();  // 获取当前日期:使用当前或指定的区域设置将日期转换为字符串。
// myDate.toLocaleTimeString();  // 获取当前时间:使用当前或指定的区域设置将时间转换为字符串。
// myDate.toLocaleString();      // 获取日期与时间:使用当前或指定的区域设置将日期和时间转换为字符串

// 日期时间的年月日时分秒以及毫秒的各个字段
// export class DateOpt {
//   year: string = ''; // 年 小写y
//   month: string = ''; // 月 大写M
//   day: string = ''; // 日 小写d
//   hour: string = ''; // 时 大写H(24小时制)
//   // hh: string = ''; // 时 小写H(12小时制)
//   minute: string = ''; // 分 小写m
//   second: string = ''; // 秒 小写s
//   millisecond: string = ''; // 毫秒 大写S
// }

export class DateTimeUtils {
  static readonly MAX_TIME = Math.pow(10, 8) * 24 * 60 * 60 * 1000; // 8640000000000000 毫秒
  static readonly MIN_TIME = -DateTimeUtils.MAX_TIME; // -8640000000000000 毫秒

  // 日期+时间格式
  static readonly PATTERN_DATE_TIME_DEFAULT: string = 'yyyyMMddHHmmss'; // 年月日时分秒
  static readonly PATTERN_DATE_TIME_HYPHEN: string = 'yyyy-MM-dd HH:mm:ss'; // 日期中包含连字符/中划线(HYPHEN),时间是以冒号(Colon)分割
  static readonly PATTERN_DATE_TIME_HYPHEN_MS: string = 'yyyy-MM-dd HH:mm:ss.SSS'; // 日期中包含连字符/中划线(HYPHEN),时间是以冒号(Colon)分割
  static readonly PATTERN_DATE_TIME_SLASH: string = 'yyyy/MM/dd HH:mm:ss'; // 日期中包含正斜杠(forward slash '/')
  static readonly PATTERN_DATE_TIME_BACK_SLASH: string = 'yyyy\\MM\\dd HH:mm:ss'; // 日期中包含反斜杠(back slash '\')
  static readonly PATTERN_DATE_TIME_DOT: string = 'yyyy.MM.dd HH:mm:ss'; // 日期中包含英文小圆点(DOT '.')
  static readonly PATTERN_DATE_TIME_CN: string = 'yyyy年MM月dd日 HH:mm:ss'; // 日期中包含包含中文年月日
  static readonly PATTERN_DATE_TIME_MS: string = 'yyyyMMddHHmmssSSS'; // 时间中包含毫秒
  static readonly PATTERN_DATE_TIME_WITHOUT_SECOND: string = 'yyyyMMddHHmm'; // 时间中不包含秒
  static readonly PATTERN_DATE_TIME_SIMPLIFY: string = 'MM/dd HH:mm'; // 精简的日期+时间(不包含年份和秒), 月/日 时:分
  static readonly PATTERN_DATE_SLASH_WITHOUT_YEAR2: string = 'MM-dd'; // 日期中不包含年份

  // 仅日期格式(不包含时间)
  static readonly PATTERN_DATE_DEFAULT: string = 'yyyyMMdd'; // 年月日
  static readonly PATTERN_DATE_HYPHEN: string = 'yyyy-MM-dd'; // 日期中包含连字符/中划线(HYPHEN)
  static readonly PATTERN_DATE_SLASH: string = 'yyyy/MM/dd'; // 日期中包含正斜杠(forward slash '/')
  static readonly PATTERN_DATE_BACK_SLASH: string = 'yyyy\\MM\\dd'; // 日期中包含反斜杠(back slash '\')
  static readonly PATTERN_DATE_DOT: string = 'yyyy.MM.dd'; // 日期中包含英文小圆点(DOT '.')
  static readonly PATTERN_DATE_CN: string = 'yyyy年MM月dd日'; // 日期中包含包含中文年月日
  static readonly PATTERN_DATE_SLASH_WITHOUT_YEAR: string = 'MM/dd'; // 日期中不包含年份
  static readonly PATTERN_DATE_CN_WITHOUT_YEAR: string = 'MM月dd日'; // 日期中不包含年份，且month与day是中文

  // 仅时间格式(不包含日期)
  static readonly PATTERN_TIME_DEFAULT: string = 'HHmmss'; // 时分秒
  static readonly PATTERN_TIME_COLON: string = 'HH:mm:ss'; // 时间是以冒号(Colon)分割
  static readonly PATTERN_TIME_MS: string = 'HHmmssSSS'; // 时间中包含毫秒
  static readonly PATTERN_TIME_COLON_DOT_MS: string = 'HH:mm:ss.SSS'; // 时间是以冒号(Colon)与点号(DOT)分割，且包含毫秒
  static readonly PATTERN_TIME_WITHOUT_SECOND: string = 'HHmm'; // 时间中不包含秒
  static readonly PATTERN_TIME_COLON_WITHOUT_SECOND: string = 'HH:mm'; //  时间是以冒号(Colon)分割，且不包含秒
  static readonly PATTERN_TIME_COLON_WITHOUT_HOUR: string = 'mm:ss'; // 时间是以冒号(Colon)分割，且不包含小时(分钟长度至少2位，可能是3位)

  static readonly PATTERN_WEEK: string = 'E'; // 周几/星期几

  static readonly MONTHS_IN_YEAR: number = 12; // 1年12个月
  static readonly QUARTERS_IN_YEAR: number = 4; // 1年4个季度
  static readonly MONTHS_IN_QUARTER: number = 3; // 1季度3个月
  static readonly DAYS_MONTH: number[] = [31, 30, 29, 28]; // 每月多少天:大月(1/3/5/7/8/10/12月);小月(4/6/9/11月);2月(闰年29天/非闰月28天）
  static readonly DAYS_IN_WEEK: number = 7; // 1周7天
  static readonly HOURS_IN_DAY = 24; // 1天24小时
  // 分钟
  static readonly MINUTES_IN_HOUR = 60; // 1小时60分(时分秒之间的进制RADIX)
  static readonly MINUTES_IN_DAY = 1440 // 60 * 24 // 1天1440分钟
  // 秒
  static readonly SECONDS_IN_MINUTE = 60; // 1分60秒(时分秒之间的进制RADIX)
  static readonly SECONDS_IN_HOUR = 3600 // 60 * 60  // 1小时3600秒
  static readonly SECONDS_IN_DAY = 86400 // 60 * 60 * 24 // 1天86400秒
  // 毫秒
  static readonly MILLISECONDS_IN_SECOND: number = 1000; // 1秒是1000毫秒，秒与毫秒之间的转换进制RADIX
  static readonly MILLISECONDS_IN_MINUTE: number = 60000; // 1000 * 60 // 1分钟是60000毫秒
  static readonly MILLISECONDS_IN_HOUR: number = 3600000; // 1000 * 60 * 60 // 1小时是3600000毫秒
  static readonly MILLISECONDS_IN_DAY: number = 86400000; // 1000 * 60 * 60 * 24 // 1天是86400000毫秒

  static readonly CHINESE_YEAR: string = '年';
  static readonly CHINESE_MONTH: string = '月';
  static readonly CHINESE_DAY: string = '日';
  static readonly CHINESE_LAST_WEEK: string = '上周';
  static readonly CHINESE_YESTERDAY: string = '昨天';
  static readonly CHINESE_TODAY: string = '今天';
  static readonly CHINESE_TOMORROW: string = '明天';
  static readonly CHINESE_NEXT_WEEK: string = '下周';
  // 周x/星期X
  static readonly CHINESE_WEEK1: string[] = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
  static readonly CHINESE_WEEK2: string[] = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
  static readonly ENGLISH_WEEK1 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
  static readonly ENGLISH_WEEK2 = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
  static readonly ENGLISH_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  /**
   * 获取当前日期：年月日
   * 返回格式，默认如：yyyyMMdd,20230926
   */
  static getCurDate(format = DateTimeUtils.PATTERN_DATE_DEFAULT): string {
    const DATETIME = new Date()
    return DateTimeUtils.formatDate(DATETIME.getTime(), format)
  }

  /**
   * 获取当前时间：时分秒
   * 返回格式，默认如：HHmmss,230559
   */
  static getCurTime(format = DateTimeUtils.PATTERN_TIME_DEFAULT): string {
    const DATETIME = new Date()
    return DateTimeUtils.formatDate(DATETIME.getTime(), format)
  }

  /**
   * 获取当前时间戳，毫秒
   * */
  public static getTimeStamp(): number {
    return new Date().getTime();
  }

  /**
   * 当数字转字符串不足maxLength位时，用前导0补足maxLength位
   * @param value-数据值
   * @returns
   * 年份是4位
   * 月/日/时/分/秒，都是2位
   * 毫秒是3位
   */
  static fill(num: number, maxLength: number = 2): string {
    let value: string = '' + num
    return value.padStart(maxLength, '0')
  }

  /**
   * 获取两个时间点的时间差
   * @param milliseconds1
   * @param milliseconds2
   * @returns Duration
   */
  static getDuration(milliseconds1: number, milliseconds2: number): number {
    let date1 = new Date(milliseconds1)
    let date2 = new Date(milliseconds2)
    let timeDiff = Math.abs(date2.getTime() - date1.getTime());
    return timeDiff;
  }

  /**
   * 格式化Duration时间
   * @param duration 毫秒
   * @returns 返回格式化后的Duration时间
   */
  static getFormattedDuration(duration: number): string {
    // 也可以直接先除以1000转换为秒后再计算 // duration = duration/1000
    // Math.floor 用于向下取整
    let hour = Math.floor(duration / (DateTimeUtils.MILLISECONDS_IN_HOUR))
    // 用总毫秒数duration减去hour所对应的毫秒数差，再除以每分钟所占用的毫秒数
    let minute = Math.floor((duration - hour * (DateTimeUtils.MILLISECONDS_IN_HOUR)) / (DateTimeUtils.MILLISECONDS_IN_MINUTE));
    let second = Math.floor(duration / DateTimeUtils.MILLISECONDS_IN_SECOND) % DateTimeUtils.SECONDS_IN_MINUTE; // 先除以1000,转换为秒;再对整分钟取余
    if (hour > 0) {
      return `${DateTimeUtils.fill(hour)}:${DateTimeUtils.fill(minute)}:${DateTimeUtils.fill(second)}`
    }
    return `${DateTimeUtils.fill(minute)}:${DateTimeUtils.fill(second)}`
  }

  /**
   * 格式化显示倒计时
   * @param milliseconds 时间戳 毫秒
   * @returns 返回格式化后的Duration时间
   */
  static getDurationToNow(milliseconds: number): string {
    let nowDateTime = new Date();
    let duration = milliseconds - nowDateTime.getTime();
    if (duration < 0) {
      duration = 0;
    }
    return DateTimeUtils.getFormattedDuration(duration)
  }

  /**
   * 根据日期/时间字符串反序列化对应的时间戳
   * @param dateTimeString string 日期+时间字符串
   * 列举字符串格式,如:
   * 20231129,yyyyMMdd
   * 20231126230559 yyyyMMddHHmmss
   * 20231126230559729 yyyyMMddHHmmssSSS
   * 2023-11-26 23:05:59.729, yyyy-MM-dd HH:mm:ss.SSS(先移除所有中划线和冒号及空格等非数字字符)
   * 日期/时间字符串中包含连字符/中划线(Hyphen/Strike)/移除冒号(Colon)/移除空白字符(包括空格、制表符、换行符等)/移除正斜杠(forward slash '/')/移除反斜杠(back slash '\')
   * @param format:string 日期+时间的格式，默认格式：yyyy-MM-dd
   * @param referenceDate:Date 参考日期+时间
   * @returns 转换后的时间戳:milliseconds 毫秒
   * let dateTimeStr:string   = "(预告) 2024年12月24日 02:50 开播"
   * let formatPattern:string = "(预告) yyyy年MM月dd日 HH:mm 开播"
   * let parsedDate = DateTimeUtils.parseDate(dateTimeStr, formatPattern)
   */
  static parseDate(dateTimeString: string, format: string = DateTimeUtils.PATTERN_DATE_HYPHEN, referenceDate?: Date): number {
    if (!dateTimeString) {
      return 0
    }
    if (!referenceDate) {
      referenceDate = new Date(); // 参考当前时间
    }

    const optPatternList: string[] = ['y+', 'M+', 'd+', 'H+', 'm+', 's+', 'S+'];
    let targetYear: number = 0 // 年
    let targetMonth: number = 0 // 月, monthIndex
    let targetDay: number = 0 // 日
    let targetHour: number = 0 // 时
    let targetMinute: number = 0 // 分
    let targetSecond: number = 0 // 秒
    let targetMillisecond: number = 0 // 毫秒
    for (let i = 0; i < optPatternList.length; i++) {
      const optPattern = optPatternList[i];
      const regExp = new RegExp(optPattern, 'g');
      // console.log(optPattern);
      let matches = regExp.exec(format);
      if (!matches) {
        continue
      }
      // console.dir(matches)
      // console.dir(matches?.[0])
      // console.dir(matches?.index)
      let pick: number = StringUtils.parseNumber(dateTimeString.substring(matches.index, matches.index + matches?.[0].length))
      // console.dir(pick)
      switch (optPattern) {
        case 'y+':
          if (pick >= -271821 && pick <= 275760) { // 根据最大日期/时间与根据最小日期/时间计算出的年份范围
            targetYear = pick
          } else {
            targetYear = referenceDate.getFullYear() // 当解析不到年份时，则设置为今年
          }
          break;
        case 'M+': // monthIndex between 0 and 11
          if (pick >= 1 && pick <= 12) {
            targetMonth = pick - 1
          } else {
            targetMonth = referenceDate.getMonth() // 当解析不到月份时，则设置为本月
          }
          break;
        case 'd+': // between 1 and 31.
          if (pick >= 1 && pick <= 31) {
            targetDay = pick
          } else {
            targetDay = referenceDate.getDate()
          }
          break;
        case 'H+': // from 0 to 23
          if (pick >= 0 && pick <= 23) {
            targetHour = pick
          } else {
            targetDay = referenceDate.getDate()
          }
          break;
        case 'm+': // from 0 to 59
          if (pick >= 0 && pick <= 59) {
            targetMinute = pick
          } else {
            targetDay = referenceDate.getMinutes()
          }
          break;
        case 's+': // from 0 to 59
          if (pick >= 0 && pick <= 59) {
            targetSecond = pick
          } else {
            targetSecond = referenceDate.getSeconds()
          }
          break;
        case 'S+': // from 0 to 999
          if (pick >= 0 && pick <= 999) {
            targetMillisecond = pick
          } else {
            targetMillisecond = referenceDate.getMilliseconds()
          }
          break;
        default:
          break;
      }
    }
    let targetDate: Date = new Date(targetYear, targetMonth, targetDay, targetHour, targetMinute, targetSecond, targetMillisecond)
    return targetDate.getTime()
  }

  /**
   * 把整数时间戳格式化为指定格式的日期+时间字符串
   * @param timestamp:毫秒
   * @param format 指定要格式化的pattern，默认格式：yyyy-MM-dd
   * @returns 格式化后的字符串
   * 举例：
   * let date_fmt = DateTimeUtils.formatDate(dateTime, "预告 (E) MM月dd日 HH:mm 开播")
   */
  static formatDate(timestamp: number, format: string = DateTimeUtils.PATTERN_DATE_HYPHEN): string {
    try {
      const date = new Date(timestamp);
      let targetYear: string = date.getFullYear().toString();
      let targetMonth: string = DateTimeUtils.fill(date.getMonth() + 1);
      let targetDay: string = DateTimeUtils.fill(date.getDate());
      let targetHours: string = DateTimeUtils.fill(date.getHours());
      let targetMinutes: string = DateTimeUtils.fill(date.getMinutes());
      let targetSeconds: string = DateTimeUtils.fill(date.getSeconds());
      let targetMilliseconds: string = DateTimeUtils.fill(date.getMilliseconds(), 3);
      let targetDayOfWeek: number = date.getDay();

      const dateOptionPatternList: string[] = ['y+', 'M+', 'd+', 'H+', 'm+', 's+', 'S+', 'E'];
      for (let i = 0; i < dateOptionPatternList.length; i++) {
        const dateOptionPattern = dateOptionPatternList[i];
        const dateOptionRegExp = new RegExp(dateOptionPattern);
        let match = dateOptionRegExp.exec(format); // 使用 RegExp 的exec 方法在目标字符串中查找匹配项
        if (!match) {
          continue
        }
        switch (dateOptionPattern) {
          case 'y+':
            format = format.replace(dateOptionRegExp, targetYear);
            break;
          case 'M+':
            format = format.replace(dateOptionRegExp, targetMonth);
            break;
          case 'd+':
            format = format.replace(dateOptionRegExp, targetDay);
            break;
          case 'H+':
            format = format.replace(dateOptionRegExp, targetHours);
            break;
          case 'm+':
            format = format.replace(dateOptionRegExp, targetMinutes);
            break;
          case 's+':
            format = format.replace(dateOptionRegExp, targetSeconds);
            break;
          case 'S+':
            format = format.replace(dateOptionRegExp, targetMilliseconds);
            break;
          case 'E': // from 0 to 6; the day of the week
            format = format.replace(dateOptionRegExp, DateTimeUtils.CHINESE_WEEK1[targetDayOfWeek]);
            break;
          default:
            break;
        }
      }
      return format;
    } catch (error) {
      console.error(`ERROR formatDate error: ${error}.`);
      return "";
    }
  }

  /**
   * 构造一周中的哪一天/构造星期X/周X
   * @param timestamp
   * @returns
   */
  static buildDayOfWeek(timestamp: number, weeks: string[] = DateTimeUtils.CHINESE_WEEK1): string {
    try {
      const date = new Date(timestamp);
      let day = date.getDay()
      let week = weeks[day];
      return week ?? ''
    } catch (error) {
      console.error(`ERROR formatDate error: ${error}.`);
      return ''
    }
  }

  static startOfDay(argument: number): Date {
    const _date = new Date(argument);
    _date.setHours(0, 0, 0, 0);
    return _date;
  }

  static isSameDay(dateLeft: number, dateRight: number): boolean {
    const dateLeftStartOfDay = DateTimeUtils.startOfDay(dateLeft);
    const dateRightStartOfDay = DateTimeUtils.startOfDay(dateRight);
    return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();
  }

  static addDays(argument: number, amount: number): Date {
    const _date = new Date(argument);
    if (amount == 0) {
      return _date;
    }
    _date.setDate(_date.getDate() + amount);
    return _date;
  }

  static subDays(date: number, amount: number): Date {
    return DateTimeUtils.addDays(date, -amount);
  }

  static isToday(date: number,): boolean {
    return DateTimeUtils.isSameDay(date, Date.now());
  }

  static isYesterday(date: number): boolean {
    return DateTimeUtils.isSameDay(date, DateTimeUtils.subDays(Date.now(), 1).getTime());
  }

  static isTomorrow(date: number): boolean {
    return DateTimeUtils.isSameDay(date, DateTimeUtils.addDays(Date.now(), 1).getTime());
  }

  // 检查指定的日期是过去的吗？
  static isPast(_date: Date): boolean {
    return _date.getTime() < Date.now();
  }

  // 检查指定的日期在未来/将来吗？
  static isFuture(_date: Date): boolean {
    return _date.getTime() > Date.now();
  }

  // 检查_date是在dateToCompare之后吗？，如
  // const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
  // => true
  static isAfter(_date: Date, dateToCompare: Date): boolean {
    return _date.getTime() > dateToCompare.getTime();
  }

  // 检查_date是在dateToCompare之前吗？，如
  // const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
  // => false
  static isBefore(_date: Date, dateToCompare: Date): boolean {
    return _date.getTime() < dateToCompare.getTime();
  }

  /**
   * 获取文章发布时间
   * */
  public static getCommentTime(publishTime: number): string {
    let currentTime: number = new Date().getTime();
    let timeGap = currentTime - publishTime;
    let timeStr = ""
    if (timeGap >= 60 * 60 * 1000 * 48) {
      let publishYear = new Date(publishTime).getFullYear();
      let currentYear = new Date(currentTime).getFullYear();
      if (publishYear == currentYear) {
        timeStr = this.formatDate(publishTime, DateTimeUtils.PATTERN_DATE_SLASH_WITHOUT_YEAR2)
      } else {
        timeStr = this.formatDate(publishTime)
      }
    } else if (timeGap > 60 * 60 * 1000 * 24) {
      timeStr = Math.floor(timeGap / (60 * 60 * 1000 * 24)) + "天前";
    } else if (timeGap > 60 * 60 * 1000) { // 1小时-24小时
      timeStr = Math.floor(timeGap / (60 * 60 * 1000)) + "小时前";
    } else if (timeGap > 60 * 1000) { // 1分钟-59分钟
      timeStr = Math.floor(timeGap / (60 * 1000)) + "分钟前";
    } else { // 1秒钟-59秒钟
      timeStr = "刚刚";
    }
    return timeStr;
  }

}

// const dateTimeUtils = new DateTimeUtils()