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

from unittest.mock import patch


class TestIsExpiredBoundaryExactlyAtTTL:
    """Verify strict '>' comparison: at exactly TTL seconds, entry is NOT expired."""

    def test_is_expired_boundary_exactly_at_ttl(self):
        """At exactly TTL seconds elapsed, _is_expired must return False (strict >)."""
        from local_deep_research.metrics.pricing.pricing_cache import (
            PricingCache,
        )

        cache = PricingCache(cache_ttl=100)
        now = 1000.0

        with patch(
            "local_deep_research.metrics.pricing.pricing_cache.time"
        ) as mock_time:
            mock_time.time.return_value = now
            # Timestamp is exactly TTL seconds in the past: now - timestamp == TTL
            timestamp = now - 100  # exactly 100 seconds ago
            result = cache._is_expired(timestamp)

        # (1000 - 900) > 100  →  100 > 100  →  False
        assert result is False, (
            "At exactly TTL, entry should NOT be expired (strict >)"
        )


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")
