"""Tests for crystallise.config.model_capabilities — central capability policy."""
import pytest

from crystallise.config.model_capabilities import (
    MODEL_CAPABILITIES,
    get_capability,
    validate_request,
    should_strip_temperature,
)


class TestModelCapabilities:
    def test_known_models_present(self):
        assert "gpt-5-nano" in MODEL_CAPABILITIES
        assert "gpt-5-mini" in MODEL_CAPABILITIES
        assert "gpt-4.1" in MODEL_CAPABILITIES
        assert "gpt-5.4-nano" in MODEL_CAPABILITIES
        assert "gpt-5.4-mini" in MODEL_CAPABILITIES

    def test_gpt4_1_supports_temperature(self):
        cap = MODEL_CAPABILITIES["gpt-4.1"]
        assert cap.supports_temperature is True
        assert cap.context_window == 400_000

    def test_gpt5_nano_no_temperature(self):
        cap = MODEL_CAPABILITIES["gpt-5-nano"]
        assert cap.supports_temperature is False

    def test_all_models_support_function_calling(self):
        for name, cap in MODEL_CAPABILITIES.items():
            assert cap.supports_function_calling is True, f"{name} should support function calling"


class TestGetCapability:
    def test_known_model(self):
        cap = get_capability("gpt-5-mini")
        assert cap is not None
        assert cap.max_output_tokens == 16_384

    def test_unknown_model_returns_none(self):
        assert get_capability("gpt-99") is None


class TestValidateRequest:
    def test_valid_request_passes(self):
        # Should not raise
        validate_request("gpt-5-mini", max_output_tokens=4096)

    def test_unknown_model_passes(self):
        # Permissive — unknown models are allowed
        validate_request("new-model-xyz", max_output_tokens=999999)

    def test_max_output_tokens_exceeded(self):
        with pytest.raises(ValueError, match="max_output_tokens is 16384"):
            validate_request("gpt-5-mini", max_output_tokens=50000)

    def test_max_output_tokens_at_limit(self):
        # Exact limit should pass
        validate_request("gpt-5-mini", max_output_tokens=16384)

    def test_function_calling_supported(self):
        validate_request("gpt-5-mini", needs_function_calling=True)

    def test_structured_output_supported(self):
        validate_request("gpt-5-mini", needs_structured_output=True)

    def test_temperature_not_supported_gpt5(self):
        with pytest.raises(ValueError, match="does not support temperature"):
            validate_request("gpt-5-mini", needs_temperature=True)

    def test_temperature_supported_gpt4_1(self):
        validate_request("gpt-4.1", needs_temperature=True)


class TestShouldStripTemperature:
    def test_gpt5_family(self):
        assert should_strip_temperature("gpt-5-nano") is True
        assert should_strip_temperature("gpt-5-mini") is True
        assert should_strip_temperature("gpt-5.4-nano") is True
        assert should_strip_temperature("gpt-5.4-mini") is True

    def test_gpt4_1(self):
        assert should_strip_temperature("gpt-4.1") is False

    def test_unknown_model(self):
        assert should_strip_temperature("unknown-model") is False