"""Edge-case tests for pricing modules — boundary, sync, and provider lookups."""


class TestSyncModelWithMultipleSlashes:
    """Verify split('/')[-1] correctly extracts model from multi-slash names."""

    def test_sync_model_with_multiple_slashes(self):
        """'openai/org/gpt-4'.split('/')[-1] should resolve to 'gpt-4' pricing."""
        from local_deep_research.metrics.pricing.cost_calculator import (
            CostCalculator,
        )

        calc = CostCalculator()
        result = calc.calculate_cost_sync(
            model_name="openai/org/gpt-4",
            prompt_tokens=1000,
            completion_tokens=1000,
        )

        # Should find gpt-4 pricing via split("/")[-1]
        assert result["pricing_used"] is not None, (
            "Should resolve multi-slash model name"
        )
        assert result["prompt_cost"] > 0


class TestSyncZeroPromptTokens:
    """Verify 0 prompt + nonzero completion → prompt_cost=0.0."""

    def test_sync_zero_prompt_tokens(self):
        """Zero prompt tokens with nonzero completion should yield prompt_cost=0.0."""
        from local_deep_research.metrics.pricing.cost_calculator import (
            CostCalculator,
        )

        calc = CostCalculator()
        result = calc.calculate_cost_sync(
            model_name="gpt-4",
            prompt_tokens=0,
            completion_tokens=500,
        )

        assert result["prompt_cost"] == 0.0
        assert result["completion_cost"] > 0
        assert result["total_cost"] == result["completion_cost"]


class TestSyncVeryLargeTokenCount:
    """Verify 1M tokens doesn't overflow float arithmetic."""

    def test_sync_very_large_token_count(self):
        """1,000,000 tokens should produce valid (large) cost without overflow."""
        from local_deep_research.metrics.pricing.cost_calculator import (
            CostCalculator,
        )

        calc = CostCalculator()
        result = calc.calculate_cost_sync(
            model_name="gpt-4",
            prompt_tokens=1_000_000,
            completion_tokens=1_000_000,
        )

        assert result["pricing_used"] is not None
        # gpt-4: prompt=0.03/1K, completion=0.06/1K
        # Expected: 1M/1K * 0.03 = 30.0, 1M/1K * 0.06 = 60.0
        assert result["prompt_cost"] == 30.0
        assert result["completion_cost"] == 60.0
        assert result["total_cost"] == 90.0


class TestGetModelsByProviderCaseInsensitive:
    """Verify provider.lower() normalizes uppercase provider names."""

    def test_get_models_by_provider_case_insensitive(self):
        """'OPENAI' should return same models as 'openai' via provider.lower()."""
        from local_deep_research.metrics.pricing.pricing_fetcher import (
            PricingFetcher,
        )

        fetcher = PricingFetcher()
        lower_models = fetcher._get_models_by_provider("openai")
        upper_models = fetcher._get_models_by_provider("OPENAI")

        assert lower_models == upper_models
        assert len(lower_models) > 0
        for model_name in upper_models:
            assert model_name.startswith("gpt")
