import os
import unittest
from unittest.mock import patch

from assistant_bot import config


class AppSettingsTests(unittest.TestCase):
    @staticmethod
    def load_settings(**overrides):
        environment = {
            config.TOKEN_ENV_NAME: "token",
            config.PASSWORD_ENV_NAME: "secret",
            **overrides,
        }
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            environment,
            clear=True,
        ):
            return config.load_app_settings()

    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)

    def test_gpu_int8_defaults(self) -> None:
        settings = self.load_settings()

        self.assertEqual(settings.whisper_model, "large-v3")
        self.assertEqual(settings.whisper_device, "cuda")
        self.assertEqual(settings.whisper_compute_type, "int8")

    def test_local_mode_is_default(self) -> None:
        self.assertEqual(self.load_settings().mode, "local")

    def test_yandex_mode_is_supported(self) -> None:
        settings = self.load_settings(
            **{
                config.MODE_ENV_NAME: "YANDEX",
                config.YANDEX_CLOUD_FOLDER_ENV_NAME: "folder-id",
            }
        )

        self.assertEqual(settings.mode, "yandex")

    def test_unknown_mode_is_rejected(self) -> None:
        with self.assertRaises(RuntimeError):
            self.load_settings(**{config.MODE_ENV_NAME: "cloud"})

    def test_yandex_model_is_full_gpt_uri(self) -> None:
        settings = self.load_settings(
            **{
                config.MODE_ENV_NAME: "yandex",
                config.YANDEX_CLOUD_FOLDER_ENV_NAME: "folder-id",
                config.YANDEX_CLOUD_MODEL_ENV_NAME: "yandexgpt/latest",
            }
        )

        self.assertEqual(
            settings.default_models()["yandex"],
            "gpt://folder-id/yandexgpt/latest",
        )

    def test_password_is_required(self) -> None:
        with patch("assistant_bot.config.load_env_file"), patch.dict(
            os.environ,
            {config.TOKEN_ENV_NAME: "token"},
            clear=True,
        ):
            with self.assertRaises(RuntimeError):
                config.load_app_settings()

    def test_password_is_read_from_environment(self) -> None:
        settings = self.load_settings(
            **{config.PASSWORD_ENV_NAME: "  test-password  "}
        )

        self.assertEqual(settings.assistant_password, "test-password")


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