# DRF Rack
# Библиотека классов расширений для Django REST Framework
#
# Автор: Николай В. Анохин <n.anokhin@xeaf.net>
# Все права защищены. Лицензия: MIT

"""
Описание класса LocaleManagerTest
"""

from django.conf import settings
from django.test import TestCase
from django.utils import translation
from rest_framework.request import Request
from rest_framework.test import APIRequestFactory

from net.xeaf.rack.enums import UILanguage
from net.xeaf.rack.managers import LocaleManager


class LocaleManagerTests(TestCase):
    """
    Тесты для класса LocaleManager
    """

    def setUp(self):
        """
        Подготовка данных для тестов
        """
        self.factory = APIRequestFactory()
        self.default_language = UILanguage.from_string(settings.LANGUAGE_CODE)

    def test_get_default_language_returns_settings_value(self):
        """
        Проверяем, что метод возвращает язык из настроек
        """
        result = LocaleManager.get_default_language()

        expected = UILanguage.from_string(settings.LANGUAGE_CODE)
        self.assertEqual(result, expected)

    def test_get_accepted_language_returns_english_for_en(self):
        """
        Проверяем, что для 'en' возвращается UILanguage.ENGLISH
        """
        result = LocaleManager.get_accepted_language('en')
        self.assertEqual(result, UILanguage.ENGLISH)

    def test_get_accepted_language_returns_russian_for_ru(self):
        """
        Проверяем, что для 'ru' возвращается UILanguage.RUSSIAN
        """
        result = LocaleManager.get_accepted_language('ru')
        self.assertEqual(result, UILanguage.RUSSIAN)

    def test_get_accepted_language_handles_uppercase(self):
        """
        Проверяем, что метод корректно обрабатывает заглавные буквы
        """
        result = LocaleManager.get_accepted_language('EN')
        self.assertEqual(result, UILanguage.ENGLISH)

    def test_get_accepted_language_returns_default_for_unknown(self):
        """
        Проверяем, что для неизвестного кода возвращается язык по умолчанию
        """
        result = LocaleManager.get_accepted_language('fr')
        self.assertEqual(result, self.default_language)

    def test_get_accepted_language_returns_default_for_empty_string(self):
        """
        Проверяем, что для пустой строки возвращается язык по умолчанию
        """
        result = LocaleManager.get_accepted_language('')
        self.assertEqual(result, self.default_language)

    def test_get_request_language_returns_default_for_none_request(self):
        """
        Проверяем, что для None запроса возвращается язык по умолчанию
        """
        result = LocaleManager.get_request_language(None)
        self.assertEqual(result, self.default_language)

    def test_get_request_language_from_query_param_on_get_request(self):
        """
        Проверяем, что для GET запроса язык берется из query параметра
        """
        request = self.factory.get('/?x-ui-language=ru')
        request.method = 'GET'
        request = Request(request)

        result = LocaleManager.get_request_language(request)
        self.assertEqual(result, UILanguage.RUSSIAN)

    def test_get_request_language_ignores_query_param_on_non_get(self):
        """
        Проверяем, что для не-GET запроса query параметр игнорируется
        """
        request = self.factory.post('/?x-ui-language=ru')
        request.method = 'POST'
        request.META['HTTP_ACCEPT_LANGUAGE'] = 'en-US,en;q=0.9'
        request = Request(request)

        result = LocaleManager.get_request_language(request)
        self.assertEqual(result, UILanguage.ENGLISH)

    def test_get_request_language_from_accept_header(self):
        """
        Проверяем, что язык берется из заголовка Accept-Language
        """
        request = self.factory.get('/')
        request.method = 'GET'
        request.META['HTTP_ACCEPT_LANGUAGE'] = 'ru-RU,ru;q=0.9,en;q=0.8'
        request = Request(request)

        result = LocaleManager.get_request_language(request)
        self.assertEqual(result, UILanguage.RUSSIAN)

    def test_get_request_language_returns_default_if_header_missing(self):
        """
        Проверяем, что при отсутствии заголовка возвращается язык по умолчанию
        """
        request = self.factory.get('/')
        request.method = 'GET'
        request = Request(request)

        result = LocaleManager.get_request_language(request)
        self.assertEqual(result, self.default_language)

    def test_get_request_language_prefers_query_param_over_header(self):
        """
        Проверяем, что query параметр имеет приоритет над заголовком
        """
        request = self.factory.get('/?x-ui-language=en')
        request.method = 'GET'
        request.META['HTTP_ACCEPT_LANGUAGE'] = 'ru-RU,ru;q=0.9'
        request = Request(request)

        result = LocaleManager.get_request_language(request)
        self.assertEqual(result, UILanguage.ENGLISH)

    def test_set_request_language_activates_translation(self):
        """
        Проверяем, что метод активирует перевод для указанного языка
        """
        request = self.factory.get('/')
        request = Request(request)

        LocaleManager.set_request_language(request, UILanguage.RUSSIAN)

        from django.utils import translation
        self.assertEqual(translation.get_language(), 'ru')

    def test_set_request_language_sets_language_code_in_request(self):
        """
        Проверяем, что метод устанавливает LANGUAGE_CODE в запросе
        """
        request = self.factory.get('/')
        request = Request(request)

        LocaleManager.set_request_language(request, UILanguage.ENGLISH)

        self.assertEqual(request.LANGUAGE_CODE, 'EN')

    def test_set_request_language_handles_none_request(self):
        """
        Проверяем, что метод корректно обрабатывает None в запросе
        """

        LocaleManager.set_request_language(None, UILanguage.RUSSIAN)
        self.assertEqual(translation.get_language(), 'ru')

    def test_process_accepted_language_returns_first_matching_language(self):
        """
        Проверяем, что метод возвращает первый подходящий язык из заголовка
        """
        request = self.factory.get('/')
        request.META['HTTP_ACCEPT_LANGUAGE'] = 'fr-FR,fr;q=0.9,ru-RU,ru;q=0.8,en;q=0.7'
        request = Request(request)

        result = LocaleManager.process_accepted_language(request)
        self.assertEqual(result, 'ru')

    def test_process_accepted_language_returns_default_if_no_match(self):
        """
        Проверяем, что если ни один язык не найден, возвращается язык по умолчанию
        """
        request = self.factory.get('/')
        request.META['HTTP_ACCEPT_LANGUAGE'] = 'fr-FR,fr;q=0.9,de;q=0.8'
        request = Request(request)

        result = LocaleManager.process_accepted_language(request)
        self.assertEqual(result, str(self.default_language).lower())

    def test_process_accepted_language_raises_keyerror_if_header_missing(self):
        """
        Проверяем, что при отсутствии заголовка выбрасывается KeyError
        """
        request = self.factory.get('/')
        request = Request(request)

        with self.assertRaises(KeyError):
            LocaleManager.process_accepted_language(request)

    def test_adjust_request_language_sets_language_from_request(self):
        """
        Проверяем, что метод настраивает язык на основе запроса
        """
        request = self.factory.get('/?x-ui-language=ru')
        request.method = 'GET'
        request = Request(request)

        LocaleManager.adjust_request_language(request)

        from django.utils import translation
        self.assertEqual(translation.get_language(), 'ru')
        self.assertEqual(request.LANGUAGE_CODE, 'RU')

    def test_adjust_request_language_uses_default_if_no_language_found(self):
        """
        Проверяем, что если язык не найден, используется язык по умолчанию
        """
        request = self.factory.get('/')
        request.method = 'GET'
        request = Request(request)

        LocaleManager.adjust_request_language(request)

        from django.utils import translation
        expected = str(self.default_language).lower()
        self.assertEqual(translation.get_language(), expected)

    def test_adjust_request_language_handles_empty_request(self):
        """
        Проверяем, что метод корректно обрабатывает пустой запрос
        """
        request = self.factory.get('/')
        request.method = 'GET'
        request = Request(request)

        # Метод не должен выбрасывать исключений
        try:
            LocaleManager.adjust_request_language(request)
        except Exception as e:
            self.fail(f"adjust_request_language raised {e}")