import {Timestamp} from '../types/common';

/**
 * @license
 * Copyright 2020 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

const Duration = {
  HOUR: 1000 * 60 * 60,
  DAY: 1000 * 60 * 60 * 24,
};

export function parseDate(dateStr: Timestamp) {
  // Timestamps are given in UTC and have the format
  // "'yyyy-mm-dd hh:mm:ss.fffffffff'" where "'ffffffffff'" represents
  // nanoseconds.
  // Munge the date into an ISO 8061 format and parse that.
  return new Date(dateStr.replace(' ', 'T') + 'Z');
}

export function dateToTimestamp(date: Date): Timestamp {
  return date.toISOString().replace('T', ' ').replace('Z', '') as Timestamp;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function isValidDate(date: any): date is Date {
  return date instanceof Date && !isNaN(date.valueOf());
}

// similar to fromNow from moment.js
export function relative(date: Date, affix = false) {
  const now = new Date();
  if (now > date) {
    return fromNow(date, affix);
  } else {
    return toNow(date, affix);
  }
}

// similar to fromNow from moment.js
export function fromNow(date: Date, noAgo = false) {
  return durationString(date, new Date(), '', noAgo ? '' : 'ago');
}

// similar to toNow from moment.js
export function toNow(date: Date, noIn = false) {
  return durationString(new Date(), date, noIn ? '' : 'in', '');
}

// similar to fromNow from moment.js
export function durationString(
  from: Date,
  to: Date,
  prefix: string = '',
  suffix: string = ''
) {
  prefix = prefix ? `${prefix.trim()} ` : '';
  suffix = suffix ? ` ${suffix.trim()}` : '';
  const seconds = Math.floor((to.valueOf() - from.valueOf()) / 1000);
  if (seconds <= 59) {
    if (!prefix && !suffix) return `${seconds} seconds`;
    return 'just now';
  }
  if (seconds <= 119) return `${prefix}1 minute${suffix}`;
  const minutes = Math.floor(seconds / 60);
  if (minutes <= 59) return `${prefix}${minutes} minutes${suffix}`;
  if (minutes === 60) return `${prefix}1 hour${suffix}`;
  if (minutes <= 119) return `${prefix}1 hour ${minutes - 60} min${suffix}`;
  const hours = Math.floor(minutes / 60);
  if (hours <= 23) return `${prefix}${hours} hours${suffix}`;
  if (hours === 24) return `${prefix}1 day${suffix}`;
  if (hours <= 47) return `${prefix}1 day ${hours - 24} hr${suffix}`;
  const days = Math.floor(hours / 24);
  if (days <= 30) return `${prefix}${days} days${suffix}`;
  if (days <= 60) return `${prefix}1 month${suffix}`;
  const months = Math.floor(days / 30);
  if (months <= 11) return `${prefix}${months} months${suffix}`;
  if (months === 12) return `${prefix}1 year${suffix}`;
  if (months <= 24) return `${prefix}1 year ${months - 12} m${suffix}`;
  const years = Math.floor(days / 365);
  return `${prefix}${years} years${suffix}`;
}

/**
 * Return true if date is within 24 hours and on the same day.
 */
export function isWithinDay(now: Date, date: Date) {
  const diff = Math.abs(now.valueOf() - date.valueOf());
  return diff < Duration.DAY && date.getDay() === now.getDay();
}

export function wasYesterday(now: Date, date: Date) {
  const diff = now.valueOf() - date.valueOf();
  // return true if date is withing 24 hours and not on the same day
  if (diff < Duration.DAY && date.getDay() !== now.getDay()) return true;

  // move now to yesterday
  now.setDate(now.getDate() - 1);
  return isWithinDay(now, date);
}

/**
 * Returns true if date is from one to six months.
 */
export function isWithinHalfYear(now: Date, date: Date) {
  const diff = Math.abs(now.valueOf() - date.valueOf());
  return diff < 180 * Duration.DAY;
}

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts
interface DateTimeFormatParts {
  year?: string;
  month?: string;
  day?: string;
  hour?: string;
  minute?: string;
  second?: string;
  // AM or PM
  dayPeriod?: string;
  weekday?: string;
}

export function formatDate(date: Date, format: string) {
  const options: Intl.DateTimeFormatOptions = {};
  if (format.includes('MM')) {
    if (format.includes('MMM')) {
      options.month = 'short';
    } else {
      options.month = '2-digit';
    }
  }
  if (format.includes('YY')) {
    if (format.includes('YYYY')) {
      options.year = 'numeric';
    } else {
      options.year = '2-digit';
    }
  }

  if (format.includes('ddd')) {
    if (format.includes('dddd')) {
      options.weekday = 'long';
    } else {
      options.weekday = 'short';
    }
  }

  if (format.includes('DD')) {
    options.day = '2-digit';
  }

  if (format.includes('HH')) {
    options.hour = '2-digit';
    options.hour12 = false;
  }

  if (format.includes('h')) {
    options.hour = 'numeric';
    options.hour12 = true;
  }

  if (format.includes('mm')) {
    options.minute = '2-digit';
  }

  if (format.includes('ss')) {
    options.second = '2-digit';
  }

  let locale = 'en-US';
  // Workaround for Chrome 80, en-US is using h24 (midnight is 24:00),
  // en-GB is using h23 (midnight is 00:00)
  if (format.includes('HH')) {
    locale = 'en-GB';
  }

  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts
  const dtfParts = new Intl.DateTimeFormat(locale, options).formatToParts(date);
  const parts: DateTimeFormatParts = {};
  for (const entry of dtfParts) {
    switch (entry.type) {
      case 'year':
        parts.year = entry.value;
        break;
      case 'month':
        parts.month = entry.value;
        break;
      case 'day':
        parts.day = entry.value;
        break;
      case 'hour':
        parts.hour = entry.value;
        break;
      case 'minute':
        parts.minute = entry.value;
        break;
      case 'second':
        parts.second = entry.value;
        break;
      case 'dayPeriod':
        parts.dayPeriod = entry.value;
        break;
      case 'weekday':
        parts.weekday = entry.value;
        break;
    }
  }
  if (parts.year && format.includes('YY')) {
    if (format.includes('YYYY')) {
      format = format.replace('YYYY', parts.year);
    } else {
      format = format.replace('YY', parts.year);
    }
  }

  if (parts.day && format.includes('DD')) {
    format = format.replace('DD', parts.day);
  }

  if (parts.hour && format.includes('HH')) {
    format = format.replace('HH', parts.hour);
  }

  if (parts.hour && format.includes('h')) {
    format = format.replace('h', parts.hour);
  }

  if (parts.minute && format.includes('mm')) {
    format = format.replace('mm', parts.minute);
  }

  if (parts.second && format.includes('ss')) {
    format = format.replace('ss', parts.second);
  }

  if (parts.dayPeriod && format.includes('A')) {
    format = format.replace('A', parts.dayPeriod.toUpperCase());
  }

  // Month and weekday must be last, because they will yield characters that
  // could be interpreted as format strings, e.g. `h` in `Thursday` would
  // otherwise be replaced by "hours".

  if (parts.month && format.includes('MM')) {
    if (format.includes('MMM')) {
      format = format.replace('MMM', parts.month);
    } else {
      format = format.replace('MM', parts.month);
    }
  }

  if (parts.weekday && format.includes('ddd')) {
    if (format.includes('dddd')) {
      format = format.replace('dddd', parts.weekday);
    } else {
      format = format.replace('ddd', parts.weekday);
    }
  }

  return format;
}

export function utcOffsetString() {
  const now = new Date();
  const tzo = -now.getTimezoneOffset();
  const pad = (num: number) => {
    const norm = Math.floor(Math.abs(num));
    return (norm < 10 ? '0' : '') + norm.toString();
  };
  return ` UTC${tzo >= 0 ? '+' : '-'}${pad(tzo / 60)}:${pad(tzo % 60)}`;
}