import regex as re
from dateparser.utils import get_logger


class LanguageValidator:
    logger = None

    VALID_KEYS = [
        'name', 'skip', 'pertain', 'simplifications', 'no_word_spacing', 'ago', 'in',
        'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
        'january', 'february', 'march', 'april', 'may', 'june', 'july', 'august',
        'september', 'october', 'november', 'december', 'year', 'month', 'week', 'day',
        'hour', 'minute', 'second', 'sentence_splitter_group'
    ]

    @classmethod
    def get_logger(cls):
        if cls.logger is None:
            cls.logger = get_logger()
        return cls.logger

    @classmethod
    def validate_info(cls, language_id, info):
        result = True

        result &= cls._validate_type(language_id, info)
        if not result:
            return False

        result &= cls._validate_name(language_id, info)
        result &= cls._validate_word_spacing(language_id, info)
        result &= cls._validate_skip_list(language_id, info)
        result &= cls._validate_pertain_list(language_id, info)
        result &= cls._validate_weekdays(language_id, info)
        result &= cls._validate_months(language_id, info)
        result &= cls._validate_units(language_id, info)
        result &= cls._validate_other_words(language_id, info)
        result &= cls._validate_simplifications(language_id, info)
        result &= cls._validate_extra_keys(language_id, info)
        return result

    @classmethod
    def _validate_type(cls, language_id, info):
        result = True

        if not isinstance(info, dict):
            cls.get_logger().error(
                "Language '%(id)s' info expected to be dict, but have got %(type)s",
                {'id': language_id, 'type': type(info).__name__})
            result = False

        return result

    @classmethod
    def _validate_name(cls, language_id, info):
        result = True

        if 'name' not in info or not isinstance(info['name'], str) or not info['name']:
            cls.get_logger().error("Language '%(id)s' does not have a name", {'id': language_id})
            result = False

        return result

    @classmethod
    def _validate_word_spacing(cls, language_id, info):
        if 'no_word_spacing' not in info:
            return True  # Optional key

        result = True

        value = info['no_word_spacing']
        if value not in [True, False]:
            cls.get_logger().error(
                "Invalid 'no_word_spacing' value %(value)r for '%(id)s' language: "
                "expected boolean", {'value': value, 'id': language_id})
            result = False

        return result

    @classmethod
    def _validate_sentence_splitter_group(cls, language_id, info):
        if 'sentence_splitter_group' not in info:
            return True  # Optional key

        result = True

        group = info['sentence_splitter_group']
        if isinstance(group, int) or not group:
            if group < 1 or group > 6:
                cls.get_logger().error(
                    "Invalid 'sentence_splitter_group' number %(number)r for '%(id)s' language: "
                    "expected number from 1 to 6",
                    {'number': group, 'id': language_id}
                )
                result = False
        else:
            cls.get_logger().error(
                "Invalid 'sentence_splitter_group' for '%(id)s' language: "
                "expected int type but have got %(type)s",
                {'id': language_id, 'type': type(group).__name__})
            result = False

        return result

    @classmethod
    def _validate_skip_list(cls, language_id, info):
        if 'skip' not in info:
            return True  # Optional key

        result = True

        skip_tokens_list = info['skip']
        if isinstance(skip_tokens_list, list):
            for token in skip_tokens_list:
                if not isinstance(token, str) or not token:
                    cls.get_logger().error(
                        "Invalid 'skip' token %(token)r for '%(id)s' language: "
                        "expected not empty string",
                        {'token': token, 'id': language_id})
                    result = False
        else:
            cls.get_logger().error(
                "Invalid 'skip' list for '%(id)s' language: "
                "expected list type but have got %(type)s",
                {'id': language_id, 'type': type(skip_tokens_list).__name__})
            result = False

        return result

    @classmethod
    def _validate_pertain_list(cls, language_id, info):
        if 'pertain' not in info:
            return True  # Optional key

        result = True

        pertain_tokens_list = info['skip']
        if isinstance(pertain_tokens_list, list):
            for token in pertain_tokens_list:
                if not isinstance(token, str) or not token:
                    cls.get_logger().error(
                        "Invalid 'pertain' token %(token)r for '%(id)s' language: "
                        "expected not empty string",
                        {'token': token, 'id': language_id})
                    result = False
        else:
            cls.get_logger().error(
                "Invalid 'pertain' list for '%(id)s' language: "
                "expected list type but have got %(type)s",
                {'id': language_id, 'type': type(pertain_tokens_list).__name__})
            result = False

        return result

    @classmethod
    def _validate_weekdays(cls, language_id, info):
        result = True

        for weekday in 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday':
            if weekday not in info or not info[weekday]:
                cls.get_logger().error(
                    "No translations for '%(weekday)s' provided for '%(id)s' language",
                    {'weekday': weekday, 'id': language_id})
                result = False
                continue

            translations_list = info[weekday]
            if isinstance(translations_list, list):
                for token in translations_list:
                    if not isinstance(token, str) or not token:
                        cls.get_logger().error(
                            "Invalid '%(weekday)s' translation %(token)r for '%(id)s' language: "
                            "expected not empty string",
                            {'weekday': weekday, 'token': token, 'id': language_id})
                        result = False
            else:
                cls.get_logger().error(
                    "Invalid '%(weekday)s' translations list for '%(id)s' language: "
                    "expected list type but have got %(type)s",
                    {'weekday': weekday,
                     'id': language_id,
                     'type': type(translations_list).__name__})
                result = False

        return result

    @classmethod
    def _validate_months(cls, language_id, info):
        result = True

        for month in ('january', 'february', 'march', 'april', 'may', 'june', 'july',
                      'august', 'september', 'october', 'november', 'december'):
            if month not in info or not info[month]:
                cls.get_logger().error(
                    "No translations for '%(month)s' provided for '%(id)s' language",
                    {'month': month, 'id': language_id})
                result = False
                continue

            translations_list = info[month]
            if isinstance(translations_list, list):
                for token in translations_list:
                    if not isinstance(token, str) or not token:
                        cls.get_logger().error(
                            "Invalid '%(month)s' translation %(token)r for '%(id)s' language: "
                            "expected not empty string",
                            {'month': month, 'token': token, 'id': language_id})
                        result = False
            else:
                cls.get_logger().error(
                    "Invalid '%(month)s' translations list for '%(id)s' language: "
                    "expected list type but have got %(type)s",
                    {'month': month, 'id': language_id, 'type': type(translations_list).__name__})
                result = False

        return result

    @classmethod
    def _validate_units(cls, language_id, info):
        result = True

        for unit in 'year', 'month', 'week', 'day', 'hour', 'minute', 'second':
            if unit not in info or not info[unit]:
                cls.get_logger().error(
                    "No translations for '%(unit)s' provided for '%(id)s' language",
                    {'unit': unit, 'id': language_id})
                result = False
                continue

            translations_list = info[unit]
            if isinstance(translations_list, list):
                for token in translations_list:
                    if not isinstance(token, str) or not token:
                        cls.get_logger().error(
                            "Invalid '%(unit)s' translation %(token)r for '%(id)s' language: "
                            "expected not empty string",
                            {'unit': unit, 'token': token, 'id': language_id})
                        result = False
            else:
                cls.get_logger().error(
                    "Invalid '%(unit)s' translations list for '%(id)s' language: "
                    "expected list type but have got %(type)s",
                    {'unit': unit, 'id': language_id, 'type': type(translations_list).__name__})
                result = False

        return result

    @classmethod
    def _validate_other_words(cls, language_id, info):
        result = True

        for word in 'ago', :
            if word not in info or not info[word]:
                cls.get_logger().error(
                    "No translations for '%(word)s' provided for '%(id)s' language",
                    {'word': word, 'id': language_id})
                result = False
                continue

            translations_list = info[word]
            if isinstance(translations_list, list):
                for token in translations_list:
                    if not isinstance(token, str) or not token:
                        cls.get_logger().error(
                            "Invalid '%(word)s' translation %(token)r for '%(id)s' language: "
                            "expected not empty string",
                            {'word': word, 'token': token, 'id': language_id})
                        result = False
            else:
                cls.get_logger().error(
                    "Invalid '%(word)s' translations list for '%(id)s' language: "
                    "expected list type but have got %(type)s",
                    {'word': word, 'id': language_id, 'type': type(translations_list).__name__})
                result = False

        return result

    @classmethod
    def _validate_simplifications(cls, language_id, info):
        if 'simplifications' not in info:
            return True  # Optional key

        result = True

        simplifications_list = info['simplifications']
        if isinstance(simplifications_list, list):
            for simplification in simplifications_list:
                if not isinstance(simplification, dict) or len(simplification) != 1:
                    cls.get_logger().error(
                        "Invalid simplification %(simplification)r for '%(id)s' language: "
                        "eash simplification suppose to be one-to-one mapping",
                        {'simplification': simplification, 'id': language_id})
                    result = False
                    continue

                key, value = list(simplification.items())[0]
                if not isinstance(key, str) or not isinstance(value, (str, int)):
                    cls.get_logger().error(
                        "Invalid simplification %(simplification)r for '%(id)s' language: "
                        "each simplification suppose to be string-to-string-or-int mapping",
                        {'simplification': simplification, 'id': language_id})
                    result = False
                    continue

                compiled_key = re.compile(key)
                value = str(value)
                replacements = re.findall(r'\\(\d+)', value)
                replacements.extend(re.findall(r'\\g<(.+?)>', value))

                groups = []
                for group in replacements:
                    if group.isdigit():
                        groups.append(int(group))
                    elif group in compiled_key.groupindex:
                        groups.append(compiled_key.groupindex[group])
                    else:
                        cls.get_logger().error(
                            "Invalid simplification %(simplification)r for '%(id)s' language: "
                            "unknown group %(group)s",
                            {'simplification': simplification,
                             'id': language_id,
                             'group': group})
                        result = False

                used_groups = set(map(int, groups))
                expected_groups = set(range(0, compiled_key.groups + 1))
                extra_groups = used_groups - expected_groups
                not_used_groups = expected_groups - used_groups
                not_used_groups -= {0}  # Entire substring is not required to be used

                if extra_groups:
                    cls.get_logger().error(
                        "Invalid simplification %(simplification)r for '%(id)s' language: "
                        "unknown groups %(groups)s",
                        {'simplification': simplification,
                         'id': language_id,
                         'groups': ", ".join(map(str, sorted(extra_groups)))})
                    result = False

                if not_used_groups:
                    cls.get_logger().error(
                        "Invalid simplification %(simplification)r for '%(id)s' language: "
                        "groups %(groups)s were not used",
                        {'simplification': simplification,
                         'id': language_id,
                         'groups': ", ".join(map(str, sorted(not_used_groups)))})
                    result = False
        else:
            cls.get_logger().error(
                "Invalid 'simplifications' list for '%(id)s' language: "
                "expected list type but have got %(type)s",
                {'id': language_id, 'type': type(simplifications_list).__name__})
            result = False

        return result

    @classmethod
    def _validate_extra_keys(cls, language_id, info):
        result = True

        extra_keys = set(info.keys()) - set(cls.VALID_KEYS)
        if extra_keys:
            cls.get_logger().error(
                "Extra keys found for '%(id)s' language: %(keys)s",
                {'id': language_id, 'keys': ", ".join(map(repr, extra_keys))})
            result = False

        return result