#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from typing import Any, Optional, Self, Sequence
from Interfaces.Application.AnPInterface import AnPInterface
from Utils.Checks import Check
from Utils.Common import Common

class I18NManager:

    def __init__(self:Self, anp:AnPInterface) -> None:

        self.anp:AnPInterface = anp
        self.__sentences:dict[str, dict[str, str|list[str]]] = {
            "english" : {}
        }
        self.__default_language:str = list(self.__sentences.keys())[0]
        self.__language:str = self.__default_language

        self.update()

    def update(self:Self) -> None:

        key:str

        for key in ("default_i18n_files", "i18n_files", "default_i18n", "i18n"):
            self.add(self.anp.settings.get(key), True)

        self.__default_language = self.anp.settings.get("language", None, self.__default_language)
        self.__language = self.anp.settings.get("language", None, self.__language)

    def reset(self:Self) -> None:

        self.__sentences = {
            "english" : {}
        }
        self.__default_language = list(self.__sentences.keys())[0]
        self.__language = self.__default_language

        self.update()

    def __get_sentence(self:Self, texts:str|Sequence[str], custom_language:Optional[str] = None) -> str|list[str]|None:

        keys:list[str] = Common.get_keys(texts)

        if len(keys) != 0:

            language:str
            done:list[str] = []

            for language in (custom_language, self.__language, self.__default_language) + tuple(self.__sentences.keys()):
                if language not in done and language in self.__sentences:

                    key:str

                    done.append(language)

                    for key in keys:
                        if key in self.__sentences[language]:
                            return self.__sentences[language][key]
        return (
            (texts[0] if len(texts) > 0 else None) if Check.is_array(texts) else 
            texts if Check.is_string(texts) else 
        None)

    def get(self:Self, 
        keys:str|Sequence[str], 
        inputs:Optional[dict[str, Any|None]|Sequence[Any|None]] = None, 
        custom_language:Optional[Any] = None
    ) -> Any|None:
        
        text:str|list[str]|None = self.__get_sentence(keys, custom_language)

        return Common.string_variables((
            text if Check.is_string(text) else
            "".join(text) if Check.is_array(text) else
        ""), inputs)
    
    def add(self:Self, inputs:Any|None, overwrite:bool = False) -> None:
        
        subinputs:dict[str, Any|None]

        for subinputs in Common.load_json(inputs, True):

            language:str
            sentences:dict[str, str|list[str]]

            for language, sentences in subinputs.items():

                key:str
                sentence:str|list[str]

                if language not in self.__sentences:
                    self.__sentences[language] = {}
                for key, sentence in sentences.items():
                    if Common.is_mark_key(key) and sentence is None:
                        continue
                    if overwrite or key not in self.__sentences[language]:
                        self.__sentences[language][key] = sentence