app/services/utils/dateUtils.ts

import { format } from 'date-fns'

import { enUS, fr } from 'date-fns/locale'
import ArrayUtils from '~/services/utils/arrayUtils'

export const enum supportedLocales {
  FR = 'fr',
  EN = 'en',
}

const defaultLocale = 'fr'

export default class DateUtils {
  private constructor() {
    // Private constructor to prevent instantiation
    // This utility class is not meant to be instantiated
  }
  public static format(date: Date, fmt: string): string {
    return format(date, fmt)
  }

  /**
   * Formate la ou les dates au format donné et retourne la liste concaténée
   *
   * @param dates
   * @param fmt
   * @param sep
   */
  public static formatAndConcat(
    dates: Date | Array<Date>,
    fmt: string,
    sep: string = ' - ',
  ): string {
    dates = Array.isArray(dates) ? dates : [dates]
    return dates.map((d) => this.format(d, fmt)).join(sep)
  }

  /**
   * Trie les dates par ordre chronologique
   *
   * @param dates
   * @param reverse
   */
  public static sort(
    dates: Array<Date>,
    reverse: boolean = false,
  ): Array<Date> {
    return ArrayUtils.sort(dates, reverse) as Array<Date>
  }

  public static getFnsLocale(code: supportedLocales): Locale {
    // noinspection TypeScriptUnresolvedReference
    const mapping = {
      en: enUS,
      fr,
    }
    return mapping[code] ?? mapping[defaultLocale]
  }

  public static getShortFormatPattern(code: supportedLocales): string {
    const mapping = {
      en: 'MM/dd/yyyy',
      fr: 'dd/MM/yyyy',
    }
    return mapping[code] ?? mapping[defaultLocale]
  }

  public static getFormatPattern(code: supportedLocales): string {
    const mapping = {
      en: 'MM/dd/yyyy HH:mm',
      fr: 'dd/MM/yyyy HH:mm',
    }
    return mapping[code] ?? mapping[defaultLocale]
  }

  public static formatIsoShortDate(date: Date): string {
    return format(date, 'yyyy-MM-dd')
  }

  public static combineDateAndTime(date: Date = new Date(), time: string = '00:00'): Date {
    const [hours, minutes] = time.split(':').map(Number)

    const result = new Date(date)
    result.setHours(hours)
    result.setMinutes(minutes)
    result.setSeconds(0)
    result.setMilliseconds(0)

    return result
  }

  public static isBefore(dateA: string, dateB: string, strictly = true): boolean {
    const a = new Date(dateA)
    const b = new Date(dateB)

    if (isNaN(a.getTime()) || isNaN(b.getTime())) {
      throw new Error('Invalid date format')
    }

    return strictly ? a.getTime() < b.getTime() : a.getTime() <= b.getTime()
  }
}