"""
Unit tests for the AgentOps validation module.
"""

import pytest
from unittest.mock import patch, Mock
import requests

from agentops.validation import (
    get_jwt_token,
    get_trace_details,
    check_llm_spans,
    validate_trace_spans,
    ValidationError,
    print_validation_summary,
)
from agentops.exceptions import ApiServerException


class TestGetJwtToken:
    """Test JWT token exchange functionality."""

    @patch("agentops.validation.requests.post")
    def test_get_jwt_token_success(self, mock_post):
        """Test successful JWT token retrieval."""
        mock_response = Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"bearer": "test-token"}
        mock_post.return_value = mock_response

        token = get_jwt_token("test-api-key")
        assert token == "test-token"

        mock_post.assert_called_once_with(
            "https://api.agentops.ai/public/v1/auth/access_token", json={"api_key": "test-api-key"}, timeout=10
        )

    @patch("agentops.validation.requests.post")
    def test_get_jwt_token_failure(self, mock_post):
        """Test JWT token retrieval failure."""
        mock_response = Mock()
        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("401 Unauthorized")
        mock_post.return_value = mock_response

        with pytest.raises(ApiServerException, match="Failed to get JWT token"):
            get_jwt_token("invalid-api-key")

    @patch("os.getenv")
    @patch("agentops.get_client")
    @patch("agentops.validation.requests.post")
    def test_get_jwt_token_from_env(self, mock_post, mock_get_client, mock_getenv):
        """Test JWT token retrieval using environment variable."""
        mock_get_client.return_value = None
        mock_getenv.return_value = "env-api-key"

        mock_response = Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"bearer": "env-token"}
        mock_post.return_value = mock_response

        token = get_jwt_token()
        assert token == "env-token"

        mock_getenv.assert_called_once_with("AGENTOPS_API_KEY")


class TestGetTraceDetails:
    """Test trace details retrieval."""

    @patch("agentops.validation.requests.get")
    def test_get_trace_details_success(self, mock_get):
        """Test successful trace details retrieval."""
        mock_response = Mock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"trace_id": "test-trace", "spans": [{"span_name": "test-span"}]}
        mock_get.return_value = mock_response

        details = get_trace_details("test-trace", "test-token")
        assert details["trace_id"] == "test-trace"
        assert len(details["spans"]) == 1

        mock_get.assert_called_once_with(
            "https://api.agentops.ai/public/v1/traces/test-trace",
            headers={"Authorization": "Bearer test-token"},
            timeout=10,
        )

    @patch("agentops.validation.requests.get")
    def test_get_trace_details_failure(self, mock_get):
        """Test trace details retrieval failure."""
        mock_response = Mock()
        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("404 Not Found")
        mock_get.return_value = mock_response

        with pytest.raises(ApiServerException, match="Failed to get trace details"):
            get_trace_details("invalid-trace", "test-token")


class TestCheckLlmSpans:
    """Test LLM span checking."""

    def test_check_llm_spans_found(self):
        """Test when LLM spans are found."""
        spans = [
            {"span_name": "OpenAI Chat Completion", "span_attributes": {"agentops.span.kind": "llm"}},
            {"span_name": "Some other span"},
            {"span_name": "anthropic.messages.create", "span_attributes": {"agentops": {"span": {"kind": "llm"}}}},
        ]

        has_llm, llm_names = check_llm_spans(spans)
        assert has_llm is True
        assert len(llm_names) == 2
        assert "OpenAI Chat Completion" in llm_names
        assert "anthropic.messages.create" in llm_names

    def test_check_llm_spans_not_found(self):
        """Test when no LLM spans are found."""
        spans = [{"span_name": "database.query"}, {"span_name": "http.request"}]

        has_llm, llm_names = check_llm_spans(spans)
        assert has_llm is False
        assert len(llm_names) == 0

    def test_check_llm_spans_empty(self):
        """Test with empty spans list."""
        has_llm, llm_names = check_llm_spans([])
        assert has_llm is False
        assert len(llm_names) == 0

    def test_check_llm_spans_with_request_type(self):
        """Test when LLM spans are identified by LLM_REQUEST_TYPE attribute."""
        from agentops.semconv import SpanAttributes, LLMRequestTypeValues

        spans = [
            {
                "span_name": "openai.chat.completion",
                "span_attributes": {SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
            },
            {
                "span_name": "anthropic.messages.create",
                "span_attributes": {SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
            },
            {
                "span_name": "llm.completion",
                "span_attributes": {SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value},
            },
            {
                "span_name": "embedding.create",
                "span_attributes": {SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.EMBEDDING.value},
            },
            {"span_name": "database.query"},
        ]

        has_llm, llm_names = check_llm_spans(spans)
        assert has_llm is True
        assert len(llm_names) == 3  # Only chat and completion types count as LLM
        assert "openai.chat.completion" in llm_names
        assert "anthropic.messages.create" in llm_names
        assert "llm.completion" in llm_names
        assert "embedding.create" not in llm_names  # Embeddings are not LLM spans

    def test_check_llm_spans_real_world(self):
        """Test with real-world span structures from OpenAI and Anthropic."""
        from agentops.semconv import SpanAttributes, LLMRequestTypeValues

        # This simulates what we actually get from the OpenAI and Anthropic instrumentations
        spans = [
            {
                "span_name": "openai.chat.completion",
                "span_attributes": {
                    SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value,
                    SpanAttributes.LLM_SYSTEM: "OpenAI",
                    SpanAttributes.LLM_REQUEST_MODEL: "gpt-4",
                },
            },
            {
                "span_name": "anthropic.messages.create",
                "span_attributes": {
                    SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value,
                    SpanAttributes.LLM_SYSTEM: "Anthropic",
                    SpanAttributes.LLM_REQUEST_MODEL: "claude-3-opus-20240229",
                },
            },
        ]

        has_llm, llm_names = check_llm_spans(spans)
        assert has_llm is True
        assert len(llm_names) == 2
        assert "openai.chat.completion" in llm_names
        assert "anthropic.messages.create" in llm_names


class TestValidateTraceSpans:
    """Test the main validation function."""

    @patch("agentops.validation.get_jwt_token")
    @patch("agentops.validation.get_trace_details")
    @patch("agentops.validation.get_trace_metrics")
    def test_validate_trace_spans_success(self, mock_metrics, mock_details, mock_token):
        """Test successful validation."""
        mock_token.return_value = "test-token"
        mock_details.return_value = {
            "spans": [
                {"span_name": "OpenAI Chat Completion", "span_attributes": {"agentops.span.kind": "llm"}},
                {"span_name": "Other span"},
            ]
        }
        mock_metrics.return_value = {"total_tokens": 100, "total_cost": "0.0025"}

        result = validate_trace_spans(trace_id="test-trace")

        assert result["trace_id"] == "test-trace"
        assert result["span_count"] == 2
        assert result["has_llm_spans"] is True
        # LLM activity can be confirmed via metrics or span inspection
        assert result["metrics"]["total_tokens"] == 100

    @patch("agentops.validation.get_jwt_token")
    @patch("agentops.validation.get_trace_details")
    @patch("agentops.validation.get_trace_metrics")
    def test_validate_trace_spans_success_via_metrics(self, mock_metrics, mock_details, mock_token):
        """Test successful validation when LLM activity is confirmed via metrics."""
        mock_token.return_value = "test-token"
        mock_details.return_value = {
            "spans": [
                {
                    "span_name": "openai.chat.completion",
                    "span_attributes": {},  # No specific LLM attributes
                },
                {"span_name": "Other span"},
            ]
        }
        # But we have token usage, proving LLM activity
        mock_metrics.return_value = {"total_tokens": 1066, "total_cost": "0.0006077"}

        result = validate_trace_spans(trace_id="test-trace")

        assert result["trace_id"] == "test-trace"
        assert result["span_count"] == 2
        assert result["has_llm_spans"] is True  # Confirmed via metrics
        assert result["metrics"]["total_tokens"] == 1066

    @patch("agentops.validation.get_jwt_token")
    @patch("agentops.validation.get_trace_details")
    @patch("agentops.validation.get_trace_metrics")
    def test_validate_trace_spans_no_llm(self, mock_metrics, mock_details, mock_token):
        """Test validation failure when no LLM spans found and no token usage."""
        mock_token.return_value = "test-token"
        mock_details.return_value = {"spans": [{"span_name": "database.query"}]}
        # No token usage either
        mock_metrics.return_value = {"total_tokens": 0, "total_cost": "0.0000"}

        with pytest.raises(ValidationError, match="No LLM activity detected"):
            validate_trace_spans(trace_id="test-trace", check_llm=True)

    @patch("agentops.validation.get_jwt_token")
    @patch("agentops.validation.get_trace_details")
    @patch("agentops.validation.get_trace_metrics")
    def test_validate_trace_spans_retry(self, mock_metrics, mock_details, mock_token):
        """Test validation with retries."""
        mock_token.return_value = "test-token"

        # First two calls return empty, third returns spans
        mock_details.side_effect = [
            {"spans": []},
            {"spans": []},
            {"spans": [{"span_name": "OpenAI Chat Completion", "span_attributes": {"agentops.span.kind": "llm"}}]},
        ]

        # Mock metrics for the successful attempt
        mock_metrics.return_value = {"total_tokens": 100, "total_cost": "0.0025"}

        result = validate_trace_spans(trace_id="test-trace", max_retries=3, retry_delay=0.01)

        assert result["span_count"] == 1
        assert mock_details.call_count == 3

    @patch("opentelemetry.trace.get_current_span")
    def test_validate_trace_spans_no_trace_id(self, mock_get_current_span):
        """Test validation without trace ID."""
        # Mock get_current_span to return None
        mock_get_current_span.return_value = None

        with pytest.raises(ValueError, match="No trace ID found"):
            validate_trace_spans()

    @patch("opentelemetry.trace.get_current_span")
    @patch("agentops.validation.get_jwt_token")
    @patch("agentops.validation.get_trace_details")
    @patch("agentops.validation.get_trace_metrics")
    def test_validate_trace_spans_from_current_span(self, mock_metrics, mock_details, mock_token, mock_get_span):
        """Test extracting trace ID from current span."""
        # Mock the current span
        mock_span_context = Mock()
        mock_span_context.trace_id = 12345678901234567890

        mock_span = Mock()
        mock_span.get_span_context.return_value = mock_span_context

        mock_get_span.return_value = mock_span

        mock_token.return_value = "test-token"
        mock_details.return_value = {
            "spans": [{"span_name": "OpenAI Chat Completion", "span_attributes": {"agentops.span.kind": "llm"}}]
        }
        mock_metrics.return_value = {"total_tokens": 100, "total_cost": "0.0025"}

        result = validate_trace_spans()
        assert result["trace_id"] == "0000000000000000ab54a98ceb1f0ad2"  # hex format of trace ID


class TestPrintValidationSummary:
    """Test validation summary printing."""

    def test_print_validation_summary(self, capsys):
        """Test printing validation summary."""
        result = {
            "span_count": 3,
            "has_llm_spans": True,
            "llm_span_names": ["OpenAI Chat", "Claude Message"],
            "metrics": {"total_tokens": 150, "prompt_tokens": 100, "completion_tokens": 50, "total_cost": "0.0030"},
        }

        print_validation_summary(result)

        captured = capsys.readouterr()
        assert "Found 3 span(s)" in captured.out
        assert "OpenAI Chat" in captured.out
        assert "Total tokens: 150" in captured.out
        assert "Total cost: $0.0030" in captured.out
        assert "✅ Validation successful!" in captured.out

    def test_print_validation_summary_metrics_only(self, capsys):
        """Test printing validation summary when LLM activity confirmed via metrics only."""
        result = {
            "span_count": 2,
            "has_llm_spans": True,
            "llm_span_names": [],  # No specific LLM span names found
            "metrics": {
                "total_tokens": 1066,
                "prompt_tokens": 800,
                "completion_tokens": 266,
                "total_cost": "0.0006077",
            },
        }

        print_validation_summary(result)

        captured = capsys.readouterr()
        assert "Found 2 span(s)" in captured.out
        assert "LLM activity confirmed via token usage metrics" in captured.out
        assert "Total tokens: 1066" in captured.out
        assert "Total cost: $0.0006077" in captured.out
        assert "✅ Validation successful!" in captured.out

    def test_print_validation_summary_llm_prefix(self, capsys):
        """Test with spans using llm.* prefix (as returned by API)."""
        result = {
            "span_count": 1,
            "has_llm_spans": True,
            "llm_span_names": ["openai.chat.completion"],
            "metrics": {"total_tokens": 150, "prompt_tokens": 100, "completion_tokens": 50, "total_cost": "0.0030"},
        }

        print_validation_summary(result)

        captured = capsys.readouterr()
        assert "Found 1 span(s)" in captured.out
        assert "openai.chat.completion" in captured.out
        assert "✅ Validation successful!" in captured.out


class TestCheckLlmSpansWithLlmPrefix:
    """Test LLM span checking with llm.* prefix attributes."""

    def test_check_llm_spans_with_llm_prefix(self):
        """Test when spans use llm.request.type instead of gen_ai.request.type."""
        spans = [
            {
                "span_name": "openai.chat.completion",
                "span_attributes": {
                    "llm.request.type": "chat",
                    "llm.system": "OpenAI",
                    "llm.request.model": "gpt-4",
                    "llm.usage.total_tokens": 150,
                },
            },
            {
                "span_name": "anthropic.messages.create",
                "span_attributes": {
                    "llm.request.type": "chat",
                    "llm.system": "Anthropic",
                    "llm.request.model": "claude-3-opus",
                    "llm.usage.total_tokens": 300,
                },
            },
            {"span_name": "embedding.create", "span_attributes": {"llm.request.type": "embedding"}},
            {"span_name": "database.query"},
        ]

        has_llm, llm_names = check_llm_spans(spans)
        assert has_llm is True
        assert len(llm_names) == 2  # Only chat types
        assert "openai.chat.completion" in llm_names
        assert "anthropic.messages.create" in llm_names
