import os
import unittest
from unittest.mock import patch

from assistant_bot import config


class AppSettingsTests(unittest.TestCase):
    def test_loads_complete_startup_configuration_once(self) -> None:
        environment = {
            config.TOKEN_ENV_NAME: "token",
            config.PASSWORD_ENV_NAME: "secret",
            config.MODE_ENV_NAME: "local",
            config.DB_ENV_NAME: "data/test.sqlite3",
            config.TIMEZONE_ENV_NAME: "UTC",
            config.WHISPER_LANGUAGE_ENV_NAME: "auto",
        }
        with patch(
            "assistant_bot.config.load_env_file"
        ) as load_env_file, patch.dict(
            os.environ,
            environment,
            clear=True,
        ):
            settings = config.load_app_settings()

        load_env_file.assert_called_once_with()
        self.assertEqual(settings.bot_token, "token")
        self.assertEqual(settings.assistant_password, "secret")
        self.assertEqual(settings.mode, "local")
        self.assertEqual(settings.db_path, config.PROJECT_ROOT / "data/test.sqlite3")
        self.assertEqual(settings.timezone.key, "UTC")
        self.assertIsNone(settings.whisper_language)
        self.assertIsNone(settings.yandex_cloud_folder)


class WhisperConfigTests(unittest.TestCase):
    def test_gpu_int8_defaults(self) -> None:
        variable_names = (
            config.WHISPER_MODEL_ENV_NAME,
            config.WHISPER_DEVICE_ENV_NAME,
            config.WHISPER_COMPUTE_TYPE_ENV_NAME,
        )
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {},
            clear=False,
        ):
            for variable_name in variable_names:
                os.environ.pop(variable_name, None)

            self.assertEqual(config.get_whisper_model(), "large-v3")
            self.assertEqual(config.get_whisper_device(), "cuda")
            self.assertEqual(config.get_whisper_compute_type(), "int8")


class AssistantModeConfigTests(unittest.TestCase):
    def test_local_mode_is_default(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {},
            clear=False,
        ):
            os.environ.pop(config.MODE_ENV_NAME, None)
            self.assertEqual(config.get_assistant_mode(), "local")

    def test_yandex_mode_is_supported(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {config.MODE_ENV_NAME: "YANDEX"},
            clear=False,
        ):
            self.assertEqual(config.get_assistant_mode(), "yandex")

    def test_unknown_mode_is_rejected(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {config.MODE_ENV_NAME: "cloud"},
            clear=False,
        ):
            with self.assertRaises(RuntimeError):
                config.get_assistant_mode()

    def test_yandex_model_is_full_gpt_uri(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {
                config.YANDEX_CLOUD_FOLDER_ENV_NAME: "folder-id",
                config.YANDEX_CLOUD_MODEL_ENV_NAME: "yandexgpt/latest",
            },
            clear=False,
        ):
            self.assertEqual(
                config.get_default_yandex_model(),
                "gpt://folder-id/yandexgpt/latest",
            )


class PasswordConfigTests(unittest.TestCase):
    def test_password_is_required(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {},
            clear=False,
        ):
            os.environ.pop(config.PASSWORD_ENV_NAME, None)
            with self.assertRaises(RuntimeError):
                config.get_assistant_password()

    def test_password_is_read_from_environment(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {config.PASSWORD_ENV_NAME: "  test-password  "},
            clear=False,
        ):
            self.assertEqual(config.get_assistant_password(), "test-password")


if __name__ == "__main__":
    unittest.main()