import { SupportDateTime } from '../SupportDateTime';
import { SerializerAndDeserializer } from './SerializerFactory';

const reISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/;
const reMsAjax = /^\/Date\(([+-]?\d*)\)[\/|\\]$/;
const reMsAjaxWithTimezone =
  /^\/Date\((-?[0-9]+)([+-])([0-9][0-9])([0-9][0-9])\)\//;

/**
 * Date serializer for WCF Request
 *
 * @export
 * @class DateTimeSerializer
 * @implements {SerializerAndDeserializer<Date>}
 */
export class DateSerializer implements SerializerAndDeserializer<Date> {
  /**
   * Serialize a Date to string with format compatible with WCF
   *
   * @template Date
   * @param {Date} object
   * @returns {String}
   * @memberof DateSerializer
   */
  Serialize(object: Date): any {
    if (object.getTime() === SupportDateTime.MinValue.getTime()) {
      return `/Date(${SupportDateTime.MinValueTicksUtc})/`;
    }
    const offset = object.getTimezoneOffset() * 60 * 1000;
    const time = object.getTime() - offset;
    return `/Date(${time})/`;
  }

  /**
   * Deserialize a Date from string
   *
   * @param {unknown} obj
   * @returns {Date}
   * @memberof DateSerializer
   */
  Deserialize(obj: unknown): Date {
    if (typeof obj == 'string') {
      const dateWcfISO = reISO.exec(obj);
      if (dateWcfISO) {
        return new Date(
          Date.UTC(
            +dateWcfISO[1],
            +dateWcfISO[2] - 1,
            +dateWcfISO[3],
            +dateWcfISO[4],
            +dateWcfISO[5],
            +dateWcfISO[6]
          )
        );
      }
      const matchWithMsRegexTz = reMsAjaxWithTimezone.exec(obj);
      if (matchWithMsRegexTz) {
        return this.processRegexWithTimeZone(matchWithMsRegexTz);
      }
      const matchWithMsRegex = reMsAjax.exec(obj);
      if (matchWithMsRegex) {
        return this.processRegexWithoutTimeZone(matchWithMsRegex);
      }
    }
    return null;
  }

  /**
   * Process a match without time zone into a `Date`.
   *
   * @private
   * @param {RegExpExecArray} matchWithMsRegex
   * @return {*}
   * @memberof DateSerializer
   */
  private processRegexWithoutTimeZone(matchWithMsRegex: RegExpExecArray) {
    const ticks = Number.parseInt(matchWithMsRegex[1] ?? '0');
    if (ticks === SupportDateTime.MinValueTicksUtc) {
      return SupportDateTime.MinValue;
    }
    return new Date(ticks);
  }

  /**
   * Process a match with timezone into a `Date`.
   *
   * @private
   * @param {RegExpExecArray} matchWithMsRegexTz
   * @return {*}
   * @memberof DateSerializer
   */
  private processRegexWithTimeZone(matchWithMsRegexTz: RegExpExecArray) {
    const ticks = Number.parseInt(matchWithMsRegexTz[1], 10);
    const offsetDirection = matchWithMsRegexTz[2] === '-' ? -1 : 1;
    const offsetHours = Number.parseInt(matchWithMsRegexTz[3]);
    const offsetMinutes = Number.parseInt(matchWithMsRegexTz[4]);
    const offset =
      offsetDirection * ((offsetHours * 60 + offsetMinutes) * 60 * 1000);
    const ticksUtc = ticks + offset;
    if (ticksUtc === SupportDateTime.MinValueTicksUtc) {
      return SupportDateTime.MinValue;
    }
    const currentTimezoneOffset = new Date().getTimezoneOffset() * 60 * 1000;
    const dstOffset = this.getDSTOffset(ticks);
    return new Date(ticksUtc + currentTimezoneOffset + dstOffset);
  }

  /**
   * Determine timezone offset difference between
   * parameter date and current date.
   *
   * @private
   * @param {number} ticks
   * @return {number}
   * @memberof DateSerializer
   */
  private getDSTOffset(ticks: number): number {
    const dateOffset = new Date(ticks).getTimezoneOffset();
    const currentOffset = new Date().getTimezoneOffset();
    return (dateOffset - currentOffset) * 60 * 1000;
  }
}