/* Validates datetime string against atproto Lexicon 'datetime' format.
 * Syntax is described at: https://atproto.com/specs/lexicon#datetime
 */
export const ensureValidDatetime = (dtStr: string): void => {
  const date = new Date(dtStr);
  // must parse as ISO 8601; this also verifies semantics like month is not 13 or 00
  if (isNaN(date.getTime())) {
    throw new InvalidDatetimeError("datetime did not parse as ISO 8601");
  }
  if (date.toISOString().startsWith("-")) {
    throw new InvalidDatetimeError("datetime normalized to a negative time");
  }
  // regex and other checks for RFC-3339
  if (
    !/^[0-9]{4}-[01][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](.[0-9]{1,20})?(Z|([+-][0-2][0-9]:[0-5][0-9]))$/
      .test(
        dtStr,
      )
  ) {
    throw new InvalidDatetimeError("datetime didn't validate via regex");
  }
  if (dtStr.length > 64) {
    throw new InvalidDatetimeError("datetime is too long (64 chars max)");
  }
  if (dtStr.endsWith("-00:00")) {
    throw new InvalidDatetimeError(
      'datetime can not use "-00:00" for UTC timezone',
    );
  }
  if (dtStr.startsWith("000")) {
    throw new InvalidDatetimeError(
      "datetime so close to year zero not allowed",
    );
  }
};

/* Same logic as ensureValidDatetime(), but returns a boolean instead of throwing an exception.
 */
export const isValidDatetime = (dtStr: string): boolean => {
  try {
    ensureValidDatetime(dtStr);
  } catch (err) {
    if (err instanceof InvalidDatetimeError) {
      return false;
    }
    throw err;
  }

  return true;
};

/* Takes a flexible datetime string and normalizes representation.
 *
 * This function will work with any valid atproto datetime (eg, anything which isValidDatetime() is true for). It *additionally* is more flexible about accepting datetimes that don't comply to RFC 3339, or are missing timezone information, and normalizing them to a valid datetime.
 *
 * One use-case is a consistent, sortable string. Another is to work with older invalid createdAt datetimes.
 *
 * Successful output will be a valid atproto datetime with millisecond precision (3 sub-second digits) and UTC timezone with trailing 'Z' syntax. Throws `InvalidDatetimeError` if the input string could not be parsed as a datetime, even with permissive parsing.
 *
 * Expected output format: YYYY-MM-DDTHH:mm:ss.sssZ
 */
export const normalizeDatetime = (dtStr: string): string => {
  if (isValidDatetime(dtStr)) {
    const outStr = new Date(dtStr).toISOString();
    if (isValidDatetime(outStr)) {
      return outStr;
    }
  }

  // check if this permissive datetime is missing a timezone
  if (!/.*(([+-]\d\d:?\d\d)|[a-zA-Z])$/.test(dtStr)) {
    const date = new Date(dtStr + "Z");
    if (!isNaN(date.getTime())) {
      const tzStr = date.toISOString();
      if (isValidDatetime(tzStr)) {
        return tzStr;
      }
    }
  }

  // finally try parsing as simple datetime
  const date = new Date(dtStr);
  if (isNaN(date.getTime())) {
    throw new InvalidDatetimeError(
      "datetime did not parse as any timestamp format",
    );
  }
  const isoStr = date.toISOString();
  if (isValidDatetime(isoStr)) {
    return isoStr;
  } else {
    throw new InvalidDatetimeError(
      "datetime normalized to invalid timestamp string",
    );
  }
};

/* Variant of normalizeDatetime() which always returns a valid datetime strings.
 *
 * If a InvalidDatetimeError is encountered, returns the UNIX epoch time as a UTC datetime (1970-01-01T00:00:00.000Z).
 */
export const normalizeDatetimeAlways = (dtStr: string): string => {
  try {
    return normalizeDatetime(dtStr);
  } catch (err) {
    if (err instanceof InvalidDatetimeError) {
      return new Date(0).toISOString();
    }
    throw err;
  }
};

/* Indicates a datetime string did not pass full atproto Lexicon datetime string format checks.
 */
export class InvalidDatetimeError extends Error {}