import { type Resource } from 'i18next'

export type Resources = Record<string, Resource>

export interface MissingTranslation {
  englishValue: string
  language: string
  key: string
}

export const SUPPORTED_LANGUAGES = {
  en: {
    language: 'English',
    country_code: 'us',
    translated_language: 'English',
  },
  es: {
    language: 'Spanish',
    country_code: 'es',
    translated_language: 'Español',
  },
  fr: {
    language: 'French',
    country_code: 'fr',
    translated_language: 'Français',
  },
  pl: {
    language: 'Polish',
    country_code: 'pl',
    translated_language: 'Polski',
  },
  zh: {
    language: 'Chinese',
    country_code: 'cn',
    translated_language: '中文',
  },
} as const

export type SupportedLanguageKeys = keyof typeof SUPPORTED_LANGUAGES

const getMissingTranslations = (
  language: string,
  namespace: string,
  resources: Resources,
) => {
  return Object.entries(resources.en[namespace]).reduce(
    (result: MissingTranslation[], [key, value]) => {
      if (!resources?.[language]?.[namespace]?.[key]) {
        result.push({ englishValue: value?.toString(), language, key })
      }
      return result
    },
    [],
  )
}

export const getGroupedMissingTranslations = ({
  resources,
  languagesToCheck,
}: {
  resources: Resources
  languagesToCheck: SupportedLanguageKeys[]
}) => {
  return languagesToCheck.reduce(
    (accumulator, language) => {
      accumulator[language] = {}

      for (const namespace of Object.keys(resources.en)) {
        const missingTranslations = getMissingTranslations(
          language,
          namespace,
          resources,
        )
        if (missingTranslations.length > 0) {
          accumulator[language][namespace] = missingTranslations
        }
      }

      return accumulator
    },
    {} as Record<string, Record<string, MissingTranslation[]>>,
  )
}

export const getMissingTranslationCount = (
  groupedMissingTranslations: Record<
    string,
    Record<string, MissingTranslation[]>
  >,
) => {
  return Object.values(groupedMissingTranslations)?.reduce(
    (agg, modules) =>
      agg +
      Object.values(modules).reduce(
        (innerAgg, translations) => innerAgg + translations.length,
        0,
      ),
    0,
  )
}

type ResourceObject = {
  namespace: string
  key: string
  [lang: string]: string
}

export const getFlatResources = (resources: Resources) => {
  const flatResources: Array<ResourceObject> = []
  const languages = Object.keys(resources)
  const namespaces = Object.keys(resources.en)

  namespaces.forEach((namespace) => {
    // Create a set of all keys across all languages for this namespace
    const keys = new Set<string>()
    languages.forEach((lang) => {
      Object.keys(resources[lang][namespace] || {}).forEach((key) => {
        keys.add(key)
      })
    })

    keys.forEach((key) => {
      const resourceObject: { [lang: string]: string } = { namespace, key }
      languages.forEach((lang) => {
        resourceObject[lang] =
          resources[lang]?.[namespace]?.[key]?.toString() ?? ''
      })
      flatResources.push(resourceObject as ResourceObject)
    })
  })

  return flatResources
}