"""Tests for the parameter pipeline (Task 4)."""

from __future__ import annotations

import pytest

from app.ai_provider.config.models import ModelConfig, ParameterMapping, ProviderConfig
from app.ai_provider.pipeline import PipelineContext, PipelineFactory


class TestParameterPipeline:
    """Test the config-driven 4-stage parameter pipeline."""

    @pytest.fixture
    def pipeline(self):
        provider_cfg = ProviderConfig(
            name="deepseek",
            format="openai",
            base_url_env="DEEPSEEK_BASE_URL",
            api_key_env="DEEPSEEK_API_KEY",
            parameter_mappings={
                "temperature": ParameterMapping(provider_param="temperature", min=0, max=2),
                "max_tokens": ParameterMapping(provider_param="max_tokens", min=1),
                "top_p": ParameterMapping(provider_param="top_p", min=0, max=1),
            },
        )
        return PipelineFactory.create(provider_cfg)

    def test_normalize_temperature(self, pipeline):
        ctx = PipelineContext(params={"temperature": 0.7})
        result = pipeline.run(ctx)
        assert result.params["temperature"] == 0.7

    def test_clamp_temperature(self, pipeline):
        ctx = PipelineContext(params={"temperature": 5.0})
        result = pipeline.run(ctx)
        assert result.params["temperature"] == 2.0  # clamped to max

    def test_filter_unknown_param(self, pipeline):
        ctx = PipelineContext(params={"temperature": 0.5, "unknown_param": "value"})
        result = pipeline.run(ctx)
        assert "unknown_param" not in result.params
        assert "temperature" in result.params

    def test_inject_provider_defaults(self):
        provider_cfg = ProviderConfig(
            name="anthropic",
            format="anthropic",
            base_url_env="ANTHROPIC_BASE_URL",
            api_key_env="ANTHROPIC_API_KEY",
            parameter_mappings={
                "max_tokens": ParameterMapping(provider_param="max_tokens", default=4096),
            },
        )
        pipeline = PipelineFactory.create(provider_cfg)
        ctx = PipelineContext(params={})
        result = pipeline.run(ctx)
        assert result.params["max_tokens"] == 4096

    def test_transform_param(self):
        provider_cfg = ProviderConfig(
            name="openai",
            format="openai",
            base_url_env="OPENAI_BASE_URL",
            api_key_env="OPENAI_API_KEY",
            parameter_mappings={
                "max_tokens": ParameterMapping(provider_param="max_tokens", transform="int"),
            },
        )
        pipeline = PipelineFactory.create(provider_cfg)
        ctx = PipelineContext(params={"max_tokens": 4096.0})
        result = pipeline.run(ctx)
        assert isinstance(result.params["max_tokens"], int)

    def test_capability_filter_vision(self):
        model = ModelConfig(
            name="test",
            provider="openai",
            model="gpt-4o",
            format="openai",
            supports_vision=False,
        )
        provider_cfg = ProviderConfig(
            name="openai", format="openai", base_url_env="X", api_key_env="Y"
        )
        pipeline = PipelineFactory.create(provider_cfg)
        ctx = PipelineContext(
            params={"image_url": "http://example.com/img.png"}, model_config=model
        )
        result = pipeline.run(ctx)
        assert "image_url" in result.filtered_params