import { get, isObject } from 'lodash';
import * as parser from 'string-interpolation-parser'

import { CountryCode } from '../countries'

export type Languages = {
  [countryCode in CountryCode]:  Record<string, any>
}

type Join<K, P> = K extends string | number ?
    P extends string | number ?
    `${K}${"" extends P ? "" : "."}${P}`
    : never : never;

type Leaves<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?
    { [K in keyof T]-?: Join<K, Leaves<T[K]>> }[keyof T] : "";

export type TranslateKey<T extends Languages> = Leaves<T[CountryCode]>

export type TranslationKeys<T extends Languages, U extends TranslateKey<T> = TranslateKey<T>> = {
  [key in keyof T[CountryCode]]: U
}
export type TranslateParam = Record<string, any>

export class TranslateHelper<
  T extends Languages = any,
  U extends TranslateKey<T> = TranslateKey<T>,
  V extends TranslationKeys<T, U> = TranslationKeys<T, U>
> {
  translateKey: V

  get keys(): V {
    return this.translateKey
  }

  constructor(private readonly languages: T) {
    this.translateKey = Object.values(this.languages).reduce(
      (keys, language) => ({
        ...keys,
        ...Object.keys(language).reduce((translations, key) => ({ ...translations, [key]: key as U }), {}),
      }),
      {},
    ) as V
  }

  get<T = string | Record<string, any>>(
    countryCode: CountryCode,
    key: U,
    { alt, params }: { alt?: CountryCode; params?: TranslateParam } = {},
  ): T {
    const lang = this.languages[countryCode] || this.languages[alt]
    const text = get(lang, key, null)

    if(!params) return text 

    if (isObject(text))
      return parser(text, params)

    return parser({text}, params)['text']
  }
}