import type { Dictionary } from './dictionaries/dictionary.type'

export function createTranslationEngine(dictionary: Dictionary) {
  function t(key: string, params?: Record<string, string | number>): string {
    const keys = key.split('.')
    let value: any = dictionary

    for (const k of keys) {
      if (value === undefined || value === null) {
        console.warn(`Translation missing for key: ${key}`)
        return key
      }
      value = value[k]
    }

    if (typeof value !== 'string') {
      console.warn(`Translation value is not a string for key: ${key}`)
      return key
    }

    if (params) {
      return value.replace(/\{(\w+)\}/g, (_, paramKey: string) => {
        return String(params[paramKey] ?? `{${paramKey}}`)
      })
    }

    return value
  }

  function plural(
    count: number,
    forms: Record<Intl.LDMLPluralRule, string>,
    locale: string
  ): string {
    const rule = new Intl.PluralRules(locale).select(count)
    const template = forms[rule] || forms.other
    return template.replace('{count}', String(count))
  }

  function formatNumber(value: number, locale: string, options?: Intl.NumberFormatOptions): string {
    return new Intl.NumberFormat(locale, options).format(value)
  }

  function formatDate(value: Date | number, locale: string, options?: Intl.DateTimeFormatOptions): string {
    return new Intl.DateTimeFormat(locale, options).format(value)
  }

  function formatRelativeTime(
    value: number,
    unit: Intl.RelativeTimeFormatUnit,
    locale: string,
    options?: Intl.RelativeTimeFormatOptions
  ): string {
    return new Intl.RelativeTimeFormat(locale, options).format(value, unit)
  }

  return { t, plural, formatNumber, formatDate, formatRelativeTime }
}

export type TranslationEngine = ReturnType<typeof createTranslationEngine>