import os
from unittest.mock import patch

import pytest

from minisweagent.models import GlobalModelStats, get_model, get_model_class, get_model_name
from minisweagent.models.test_models import DeterministicModel, make_output


class TestGetModelName:
    # Common config used across tests - model_name should be direct, not nested under "model"
    CONFIG_WITH_MODEL_NAME = {"model_name": "config-model"}

    def test_input_model_name_takes_precedence(self):
        """Test that explicit input_model_name overrides all other sources."""
        with patch.dict(os.environ, {"MSWEA_MODEL_NAME": "env-model"}):
            assert get_model_name("input-model", self.CONFIG_WITH_MODEL_NAME) == "input-model"

    def test_config_takes_precedence_over_env(self):
        """Test that config takes precedence over environment variable."""
        with patch.dict(os.environ, {"MSWEA_MODEL_NAME": "env-model"}):
            assert get_model_name(None, self.CONFIG_WITH_MODEL_NAME) == "config-model"

    def test_env_var_fallback(self):
        """Test that environment variable is used when no config provided."""
        with patch.dict(os.environ, {"MSWEA_MODEL_NAME": "env-model"}):
            assert get_model_name(None, {}) == "env-model"

    def test_config_fallback(self):
        """Test that config model name is used when input and env are missing."""
        with patch.dict(os.environ, {}, clear=True):
            assert get_model_name(None, self.CONFIG_WITH_MODEL_NAME) == "config-model"

    def test_raises_error_when_no_model_configured(self):
        """Test that ValueError is raised when no model is configured anywhere."""
        with patch.dict(os.environ, {}, clear=True):
            with pytest.raises(
                ValueError, match="No default model set. Please run `mini-extra config setup` to set one."
            ):
                get_model_name(None, {})

            with pytest.raises(
                ValueError, match="No default model set. Please run `mini-extra config setup` to set one."
            ):
                get_model_name(None, None)


class TestGetModelClass:
    def test_anthropic_model_selection(self):
        """Test that anthropic-related model names return LitellmModel by default."""
        from minisweagent.models.litellm_model import LitellmModel

        for name in ["anthropic", "sonnet", "opus", "claude-sonnet", "claude-opus"]:
            assert get_model_class(name) == LitellmModel

    def test_litellm_model_fallback(self):
        """Test that non-anthropic model names return LitellmModel."""
        from minisweagent.models.litellm_model import LitellmModel

        for name in ["gpt-4", "gpt-3.5-turbo", "llama2", "random-model"]:
            assert get_model_class(name) == LitellmModel

    def test_partial_matches(self):
        """Test that partial string matches work correctly."""
        from minisweagent.models.litellm_model import LitellmModel

        assert get_model_class("my-anthropic-model") == LitellmModel
        assert get_model_class("sonnet-latest") == LitellmModel
        assert get_model_class("opus-v2") == LitellmModel
        assert get_model_class("gpt-anthropic-style") == LitellmModel
        assert get_model_class("totally-different") == LitellmModel

    def test_litellm_response_model_selection(self):
        """Test that litellm_response model class can be selected."""
        from minisweagent.models.litellm_response_model import LitellmResponseModel

        assert get_model_class("any-model", "litellm_response") == LitellmResponseModel


class TestGetModel:
    def test_config_deep_copy(self):
        """Test that get_model preserves original config via deep copy."""
        original_config = {"model_kwargs": {"api_key": "original"}, "outputs": [make_output("test", [])]}

        with patch("minisweagent.models.get_model_class") as mock_get_class:
            mock_get_class.return_value = lambda **kwargs: DeterministicModel(
                outputs=[make_output("test", [])], model_name="test"
            )
            get_model("test-model", original_config)
            assert original_config["model_kwargs"]["api_key"] == "original"
            assert "model_name" not in original_config

    def test_integration_with_compatible_model(self):
        """Test get_model works end-to-end with a model that handles extra kwargs."""
        with patch("minisweagent.models.get_model_class") as mock_get_class:
            hello_output = make_output("hello", [])

            def compatible_model(**kwargs):
                # Filter to only what DeterministicModel accepts, provide defaults
                config_args = {k: v for k, v in kwargs.items() if k in ["outputs", "model_name"]}
                if "outputs" not in config_args:
                    config_args["outputs"] = [make_output("default", [])]
                return DeterministicModel(**config_args)

            mock_get_class.return_value = compatible_model
            model = get_model("test-model", {"outputs": [hello_output]})
            assert isinstance(model, DeterministicModel)
            assert model.config.outputs == [hello_output]
            assert model.config.model_name == "test-model"

    def test_config_api_key_used_when_no_env_var(self):
        """Test that config api_key is used when env var is not set."""
        with patch.dict(os.environ, {}, clear=True):
            config = {"model_kwargs": {"api_key": "config-key"}, "model_class": "litellm"}
            model = get_model("test-model", config)

            # LitellmModel stores the api_key in model_kwargs
            assert model.config.model_kwargs["api_key"] == "config-key"

    def test_no_api_key_when_none_provided(self):
        """Test that no api_key is set when neither env var nor config provide one."""
        with patch.dict(os.environ, {}, clear=True):
            config = {"model_class": "litellm"}
            model = get_model("test-model", config)

            # LitellmModel should not have api_key when none provided
            model_kwargs = getattr(model.config, "model_kwargs", {})
            assert "api_key" not in model_kwargs

    def test_get_deterministic_model(self):
        """Test that get_model can instantiate DeterministicModel via model_class parameter."""
        outputs = [make_output("hello", []), make_output("world", [])]
        config = {"outputs": outputs, "cost_per_call": 2.0}
        model = get_model("test-model", config | {"model_class": "deterministic"})

        assert isinstance(model, DeterministicModel)
        assert model.config.outputs == outputs
        assert model.config.cost_per_call == 2.0
        assert model.config.model_name == "test-model"


class TestGlobalModelStats:
    def test_prints_cost_limit_when_set(self, capsys):
        """Test that cost limit is printed when MSWEA_GLOBAL_COST_LIMIT is set."""
        with patch.dict(os.environ, {"MSWEA_GLOBAL_COST_LIMIT": "5.5"}, clear=True):
            GlobalModelStats()
            captured = capsys.readouterr()
            assert "Global cost/call limit: $5.5000 / 0" in captured.out

    def test_prints_call_limit_when_set(self, capsys):
        """Test that call limit is printed when MSWEA_GLOBAL_CALL_LIMIT is set."""
        with patch.dict(os.environ, {"MSWEA_GLOBAL_CALL_LIMIT": "10"}, clear=True):
            GlobalModelStats()
            captured = capsys.readouterr()
            assert "Global cost/call limit: $0.0000 / 10" in captured.out

    def test_prints_both_limits_when_both_set(self, capsys):
        """Test that both limits are printed when both environment variables are set."""
        with patch.dict(os.environ, {"MSWEA_GLOBAL_COST_LIMIT": "2.5", "MSWEA_GLOBAL_CALL_LIMIT": "5"}, clear=True):
            GlobalModelStats()
            captured = capsys.readouterr()
            assert "Global cost/call limit: $2.5000 / 5" in captured.out

    def test_no_print_when_silent_startup_set(self, capsys):
        """Test that limits are not printed when MSWEA_SILENT_STARTUP is set."""
        with patch.dict(
            os.environ,
            {"MSWEA_GLOBAL_COST_LIMIT": "5.0", "MSWEA_GLOBAL_CALL_LIMIT": "10", "MSWEA_SILENT_STARTUP": "1"},
            clear=True,
        ):
            GlobalModelStats()
            captured = capsys.readouterr()
            assert "Global cost/call limit" not in captured.out

    def test_no_print_when_no_limits_set(self, capsys):
        """Test that nothing is printed when no limits are set."""
        with patch.dict(os.environ, {}, clear=True):
            GlobalModelStats()
            captured = capsys.readouterr()
            assert "Global cost/call limit" not in captured.out

    def test_no_print_when_limits_are_zero(self, capsys):
        """Test that nothing is printed when limits are explicitly set to zero."""
        with patch.dict(os.environ, {"MSWEA_GLOBAL_COST_LIMIT": "0", "MSWEA_GLOBAL_CALL_LIMIT": "0"}, clear=True):
            GlobalModelStats()
            captured = capsys.readouterr()
            assert "Global cost/call limit" not in captured.out