from . import logger

from abc import ABC, abstractmethod
import gettext

class language(ABC):
    def __init__(self):
        self.logger = logger.loader.get()

    def get(self, find):
        if (self.exists(find)):
            return self.translate(find)
        
        self.logger.warning("Can not translate: \"" + find + "\"")
        return find

    @abstractmethod
    def exists(self, find):
        pass

    @abstractmethod
    def translate(self, find):
        pass


class gettext_parser(language):
    def __init__(self, domain = None, path = None):
        super().__init__()

        if domain is None:
            domain = "cx-newsletter-importer"

        if path is None:
            path = "./langugage/"

        self.domain = domain
        self.path = path
      
        self.prepare_gettext()

    def prepare_gettext(self):
        self.logger.info("Loading language to gettext")
        self.logger.info("Language text domain: " + self.domain)
        self.logger.info("Language path: " + self.path)

        gettext.bindtextdomain(self.domain, self.path)
        gettext.textdomain(self.domain)
    
    def exists(self, fing):
        return False

    def translate(self, find):
        return find


class loader:
    _language = None

    def get():
        if loader._language is None:
            Exception("Language must be set in loader first.")

        return loader._language

    def set(new_language):
        if type(new_language) is not language:
            Exception("Language is not language class.")

        loader._language = new_language

    def __init__(self):
        Exception("Loader is static class.")