Custom Fluent [mod Groosha]

from typing import Optional

import structlog
from structlog.stdlib import BoundLogger
from pathlib import Path
from fluent.runtime import FluentLocalization, FluentResourceLoader

logger: BoundLogger = structlog.get_logger(__name__)


class CustomFluentLocalization(FluentLocalization):
    def get_keyboard_localization(self, msg: str) -> Optional[str]:
        for bundle in self._bundles():
            keyboard_localization: dict[Optional[str], Optional[str]] = {
                bundle.format_pattern(bundle.get_message(key).value)[0]: key
                for key in bundle._messages.keys()
                if "keyb" in key
            }
            return keyboard_localization.get(msg, None)
        return None


class FluentDispenser:
    def __init__(self, default_language: str = "ru"):
        locales_dir: Path = Path(__file__).parent.joinpath("locales")
        self.__loader = FluentResourceLoader(str(locales_dir) + "/{locale}")
        self.__default_language = default_language
        self.languages = dict()

        dirs_names = set()
        default_language_dir = None
        for item in locales_dir.iterdir():
            dirs_names.add(item.name)
            if item.name == self.__default_language:
                default_language_dir = item

        if not default_language_dir:
            raise ValueError("FluentDispenser: default language directory not found")

        ftl_files_list = [item.name for item in default_language_dir.iterdir() if item.suffix == ".ftl"]

        for name in dirs_names:
            if name == default_language:
                self.languages[name] = CustomFluentLocalization(
                    [self.__default_language], ftl_files_list, self.__loader
                )
            else:
                self.languages[name] = CustomFluentLocalization(
                    [name, self.__default_language], ftl_files_list, self.__loader
                )

    @property
    def default_locale(self) -> CustomFluentLocalization:
        return self.languages[self.__default_language]

    @property
    def available_languages(self) -> list[str]:
        return list(self.languages.keys())

    def get_localization(self, language_code: str) -> CustomFluentLocalization:
        localization: CustomFluentLocalization = self.languages.get(language_code, self.default_locale)
        if language_code not in localization.locales:
            logger.warn("Language not found", language_code=language_code)
        return localization