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

from typing import Self, Any, Optional, Sequence
from Utils.Utils import Utils
from Interfaces.Application.NucelarMonitorInterface import NucelarMonitorInterface

class I18NManager:

    DEFAULT_SENTENCES:dict[str, dict[str, str]] = {
        "english" : {}
    }

    def set_defaults(self:Self) -> None:

        key:str

        self.__language = self.nucelar_monitor.settings.get("language", None, "english")

        for key in (
            "default_i18n_files", "i18n_files", 
            "default_i18n", "i18n"
        ):
            self.add(self.nucelar_monitor.settings.get(key, None, []), True)

    def __init__(self:Self, nucelar_monitor:NucelarMonitorInterface) -> None:
        self.nucelar_monitor:NucelarMonitorInterface = nucelar_monitor
        self.__sentences:dict[str, dict[str, str]] = self.DEFAULT_SENTENCES
        self.__language:str = "english"

    def __get(self:Self, 
        strings:str|Sequence[str], 
        language:Optional[str] = None
    ) -> str|Sequence[str]:
        
        keys:str = Utils.get_keys(strings)

        if len(keys):

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

            for language in [language, self.__language] + list(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 Utils.get_texts(strings)[0]

    def get(self:Self, 
        strings:str|Sequence[str], 
        inputs:Optional[dict[str, Any|None]|Sequence[Any|None]] = None, 
        language:Optional[str] = None
    ) -> str:
        
        string:str|Sequence[str] = self.__get(strings, language)

        return Utils.string_variables((
            "".join(string) if isinstance(string, Sequence) else 
        string), inputs)
    
    def add(self:Self, inputs:Any|None, overwrite:bool = False) -> None:
        
        block:dict[str, dict[str, str|Sequence[str]]]

        for block in self.nucelar_monitor.files.load_json(inputs):

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

            for language, sentences in block.items():
                if isinstance(sentences, dict):

                    key:str
                    sentence:str|Sequence[str]

                    if language not in self.__sentences:
                        self.__sentences[language] = {}

                    for key, sentence in sentences.items():
                        if overwrite or key not in self.__sentences[language]:
                            self.__sentences[language][key] = sentence