import { getUserLocale } from 'utils/user-locale'
import { getDateTimeFromISO, getTz, type DefaultOpts } from './datetime'

const isBetweenCache = new Map<string, boolean>()
export const isBetween = (
  subjectDateString: string,
  periodStartDateString: string,
  periodEndDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    periodStartDateString,
    periodEndDateString,
    locale,
    timezone,
  })
  if (isBetweenCache.has(key)) {
    return isBetweenCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('minute') // prettier-ignore
    const periodStartDate = getDateTimeFromISO(periodStartDateString, opts).startOf('minute') // prettier-ignore
    const periodEndDate = getDateTimeFromISO(periodEndDateString, opts).startOf('minute') // prettier-ignore

    const result = subjectDate >= periodStartDate && subjectDate < periodEndDate
    isBetweenCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isBetweenDateOnlyCache = new Map<string, boolean>()
export const isBetweenDateOnly = (
  subjectDateString: string,
  periodStartDateString: string,
  periodEndDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    periodStartDateString,
    periodEndDateString,
    locale,
    timezone,
  })
  if (isBetweenDateOnlyCache.has(key)) {
    return isBetweenDateOnlyCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('day') // prettier-ignore
    const periodStartDate = getDateTimeFromISO(periodStartDateString, opts).startOf('day') // prettier-ignore
    const periodEndDate = getDateTimeFromISO(periodEndDateString, opts).startOf('day') // prettier-ignore

    const result = subjectDate >= periodStartDate && subjectDate < periodEndDate
    isBetweenDateOnlyCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isBeforeCache = new Map<string, boolean>()
export const isBefore = (
  subjectDateString: string,
  otherDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    otherDateString,
    locale,
    timezone,
  })
  if (isBeforeCache.has(key)) {
    return isBeforeCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('minute') // prettier-ignore
    const otherDate = getDateTimeFromISO(otherDateString, opts).startOf('minute') // prettier-ignore

    const result = subjectDate < otherDate
    isBeforeCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isBeforeDateOnlyCache = new Map<string, boolean>()
export const isBeforeDateOnly = (
  subjectDateString: string,
  otherDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    otherDateString,
    locale,
    timezone,
  })
  if (isBeforeDateOnlyCache.has(key)) {
    return isBeforeDateOnlyCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('day') // prettier-ignore
    const otherDate = getDateTimeFromISO(otherDateString, opts).startOf('day') // prettier-ignore

    const result = subjectDate < otherDate
    isBeforeDateOnlyCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isAfterCache = new Map<string, boolean>()
export const isAfter = (
  subjectDateString: string,
  otherDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    otherDateString,
    locale,
    timezone,
  })
  if (isAfterCache.has(key)) {
    return isAfterCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('minute') // prettier-ignore
    const otherDate = getDateTimeFromISO(otherDateString, opts).startOf('minute') // prettier-ignore

    const result = subjectDate > otherDate
    isAfterCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isAfterDateOnlyCache = new Map<string, boolean>()
export const isAfterDateOnly = (
  subjectDateString: string,
  otherDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    otherDateString,
    locale,
    timezone,
  })
  if (isAfterDateOnlyCache.has(key)) {
    return isAfterDateOnlyCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('day') // prettier-ignore
    const otherDate = getDateTimeFromISO(otherDateString, opts).startOf('day') // prettier-ignore

    const result = subjectDate > otherDate
    isAfterDateOnlyCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isSameCache = new Map<string, boolean>()
export const isSame = (
  subjectDateString: string,
  otherDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    otherDateString,
    locale,
    timezone,
  })
  if (isSameCache.has(key)) {
    return isSameCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('minute') // prettier-ignore
    const otherDate = getDateTimeFromISO(otherDateString, opts).startOf('minute') // prettier-ignore

    const result = subjectDate.equals(otherDate)
    isSameCache.set(key, result)

    return result
  } catch {
    return false
  }
}

const isSameDateOnlyCache = new Map<string, boolean>()
export const isSameDateOnly = (
  subjectDateString: string,
  otherDateString: string,
  { locale = getUserLocale(), timezone = getTz() }: DefaultOpts = {}
): boolean => {
  const key = JSON.stringify({
    subjectDateString,
    otherDateString,
    locale,
    timezone,
  })
  if (isSameDateOnlyCache.has(key)) {
    return isSameDateOnlyCache.get(key) as boolean
  }

  try {
    const opts = { locale, timezone }
    const subjectDate = getDateTimeFromISO(subjectDateString, opts).startOf('day') // prettier-ignore
    const otherDate = getDateTimeFromISO(otherDateString, opts).startOf('day') // prettier-ignore

    const result = subjectDate.equals(otherDate)
    isSameDateOnlyCache.set(key, result)

    return result
  } catch {
    return false
  }
}