"""Tests for Evolution Dashboard API routes"""

from __future__ import annotations

import json
from datetime import datetime, timezone
from unittest.mock import AsyncMock, MagicMock, patch

import pytest
from fastapi.testclient import TestClient

from agentkit.llm.gateway import LLMGateway
from agentkit.server.app import create_app
from agentkit.server.routes.evolution_dashboard import (
    DashboardExperience,
    DashboardOptimization,
    _experiences,
    _optimizations,
)
from agentkit.skills.registry import SkillRegistry
from agentkit.tools.registry import ToolRegistry


# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------


@pytest.fixture
def mock_llm_gateway():
    return LLMGateway()


@pytest.fixture
def skill_registry():
    return SkillRegistry()


@pytest.fixture
def tool_registry():
    return ToolRegistry()


@pytest.fixture
def app(mock_llm_gateway, skill_registry, tool_registry):
    return create_app(
        llm_gateway=mock_llm_gateway,
        skill_registry=skill_registry,
        tool_registry=tool_registry,
    )


@pytest.fixture
def client(app):
    return TestClient(app)


@pytest.fixture(autouse=True)
def clear_in_memory_stores():
    """Clear in-memory stores before each test"""
    _experiences.clear()
    _optimizations.clear()
    yield
    _experiences.clear()
    _optimizations.clear()


def _add_experience(
    task_type: str = "code_review",
    goal: str = "Review PR #123",
    outcome: str = "success",
    duration: float = 30.0,
):
    """Helper to add an experience to the in-memory store"""
    exp = DashboardExperience(
        id=f"exp-{len(_experiences)}",
        task_type=task_type,
        goal=goal,
        outcome=outcome,
        duration_seconds=duration,
        created_at=datetime.now(timezone.utc),
    )
    _experiences.append(exp)
    return exp


def _add_optimization(
    task_type: str = "code_review",
    previous_path: list[str] | None = None,
    current_path: list[str] | None = None,
    improvement: float = 0.15,
):
    """Helper to add an optimization to the in-memory store"""
    opt = DashboardOptimization(
        id=f"opt-{len(_optimizations)}",
        task_type=task_type,
        previous_path=previous_path or ["step1", "step2", "step3"],
        current_path=current_path or ["step1", "step3"],
        improvement=improvement,
        updated_at=datetime.now(timezone.utc),
    )
    _optimizations.append(opt)
    return opt


# ---------------------------------------------------------------------------
# GET /evolution-dashboard/experiences
# ---------------------------------------------------------------------------


class TestListExperiences:
    def test_list_experiences_empty(self, client):
        response = client.get("/api/v1/evolution-dashboard/experiences")
        assert response.status_code == 200
        data = response.json()
        assert "experiences" in data
        assert "total" in data
        assert data["total"] == 0
        assert data["experiences"] == []

    def test_list_experiences_with_data(self, client):
        _add_experience(goal="Review PR #1", outcome="success")
        _add_experience(goal="Review PR #2", outcome="failure")

        response = client.get("/api/v1/evolution-dashboard/experiences")
        assert response.status_code == 200
        data = response.json()
        assert data["total"] == 2
        assert len(data["experiences"]) == 2

    def test_list_experiences_filter_by_task_type(self, client):
        _add_experience(task_type="code_review", goal="Review PR")
        _add_experience(task_type="data_analysis", goal="Analyze data")

        response = client.get(
            "/api/v1/evolution-dashboard/experiences?task_type=code_review"
        )
        assert response.status_code == 200
        data = response.json()
        assert data["total"] == 1
        assert data["experiences"][0]["task_type"] == "code_review"

    def test_list_experiences_filter_by_outcome(self, client):
        _add_experience(outcome="success", goal="Success task")
        _add_experience(outcome="failure", goal="Failed task")

        response = client.get(
            "/api/v1/evolution-dashboard/experiences?outcome=success"
        )
        assert response.status_code == 200
        data = response.json()
        assert data["total"] == 1
        assert data["experiences"][0]["outcome"] == "success"

    def test_list_experiences_limit(self, client):
        for i in range(10):
            _add_experience(goal=f"Task {i}")

        response = client.get(
            "/api/v1/evolution-dashboard/experiences?limit=3"
        )
        assert response.status_code == 200
        data = response.json()
        assert len(data["experiences"]) == 3

    def test_experience_structure(self, client):
        _add_experience()

        response = client.get("/api/v1/evolution-dashboard/experiences")
        data = response.json()
        exp = data["experiences"][0]
        assert "id" in exp
        assert "task_type" in exp
        assert "goal" in exp
        assert "outcome" in exp
        assert "duration" in exp
        assert "created_at" in exp


# ---------------------------------------------------------------------------
# GET /evolution-dashboard/metrics
# ---------------------------------------------------------------------------


class TestGetMetrics:
    def test_metrics_empty(self, client):
        response = client.get("/api/v1/evolution-dashboard/metrics")
        assert response.status_code == 200
        data = response.json()
        assert "metrics" in data
        assert "trends" in data
        metrics = data["metrics"]
        assert metrics["total_tasks"] == 0
        assert metrics["success_rate"] == 0.0

    def test_metrics_with_data(self, client):
        _add_experience(outcome="success", duration=10.0)
        _add_experience(outcome="success", duration=20.0)
        _add_experience(outcome="failure", duration=30.0)

        response = client.get("/api/v1/evolution-dashboard/metrics")
        assert response.status_code == 200
        data = response.json()
        metrics = data["metrics"]
        assert metrics["total_tasks"] == 3
        assert metrics["success_rate"] == pytest.approx(2 / 3, abs=0.01)
        assert metrics["avg_duration"] == pytest.approx(20.0, abs=0.1)

    def test_metrics_period_7d(self, client):
        response = client.get("/api/v1/evolution-dashboard/metrics?period=7d")
        assert response.status_code == 200
        data = response.json()
        assert len(data["trends"]) == 7

    def test_metrics_period_30d(self, client):
        response = client.get("/api/v1/evolution-dashboard/metrics?period=30d")
        assert response.status_code == 200
        data = response.json()
        assert len(data["trends"]) == 30

    def test_metrics_trends_structure(self, client):
        response = client.get("/api/v1/evolution-dashboard/metrics?period=7d")
        data = response.json()
        for trend in data["trends"]:
            assert "date" in trend
            assert "success_rate" in trend
            assert "avg_duration" in trend
            assert "retry_rate" in trend

    def test_metrics_period_all(self, client):
        response = client.get("/api/v1/evolution-dashboard/metrics?period=all")
        assert response.status_code == 200
        data = response.json()
        assert len(data["trends"]) == 30


# ---------------------------------------------------------------------------
# GET /evolution-dashboard/pitfalls
# ---------------------------------------------------------------------------


class TestCheckPitfalls:
    def test_pitfalls_no_detector(self, client):
        """When pitfall_detector is not configured, return empty warnings"""
        response = client.get(
            "/api/v1/evolution-dashboard/pitfalls?task_type=code_review&steps=step1,step2"
        )
        assert response.status_code == 200
        data = response.json()
        assert "warnings" in data
        assert data["warnings"] == []

    def test_pitfalls_no_steps(self, client):
        """When no steps provided, return empty warnings"""
        response = client.get(
            "/api/v1/evolution-dashboard/pitfalls?task_type=code_review"
        )
        assert response.status_code == 200
        data = response.json()
        assert data["warnings"] == []

    def test_pitfalls_with_steps(self, client):
        """When steps are provided but no detector, return empty warnings"""
        response = client.get(
            "/api/v1/evolution-dashboard/pitfalls?task_type=code_review&steps=analyze,review,approve"
        )
        assert response.status_code == 200
        data = response.json()
        assert "warnings" in data

    def test_pitfalls_missing_task_type(self, client):
        """When task_type is missing, should return 422"""
        response = client.get("/api/v1/evolution-dashboard/pitfalls")
        assert response.status_code == 422


# ---------------------------------------------------------------------------
# GET /evolution-dashboard/path-optimizations
# ---------------------------------------------------------------------------


class TestListPathOptimizations:
    def test_optimizations_empty(self, client):
        response = client.get("/api/v1/evolution-dashboard/path-optimizations")
        assert response.status_code == 200
        data = response.json()
        assert "optimizations" in data
        assert data["optimizations"] == []

    def test_optimizations_with_data(self, client):
        _add_optimization(
            task_type="code_review",
            previous_path=["analyze", "review", "approve"],
            current_path=["analyze", "approve"],
            improvement=0.2,
        )

        response = client.get("/api/v1/evolution-dashboard/path-optimizations")
        assert response.status_code == 200
        data = response.json()
        assert len(data["optimizations"]) == 1
        opt = data["optimizations"][0]
        assert opt["task_type"] == "code_review"
        assert opt["improvement"] == 0.2
        assert opt["previous_path"] == ["analyze", "review", "approve"]
        assert opt["current_path"] == ["analyze", "approve"]

    def test_optimizations_filter_by_task_type(self, client):
        _add_optimization(task_type="code_review")
        _add_optimization(task_type="data_analysis")

        response = client.get(
            "/api/v1/evolution-dashboard/path-optimizations?task_type=code_review"
        )
        assert response.status_code == 200
        data = response.json()
        assert len(data["optimizations"]) == 1
        assert data["optimizations"][0]["task_type"] == "code_review"

    def test_optimizations_limit(self, client):
        for i in range(10):
            _add_optimization(task_type=f"task_{i}")

        response = client.get(
            "/api/v1/evolution-dashboard/path-optimizations?limit=3"
        )
        assert response.status_code == 200
        data = response.json()
        assert len(data["optimizations"]) <= 3

    def test_optimization_structure(self, client):
        _add_optimization()

        response = client.get("/api/v1/evolution-dashboard/path-optimizations")
        data = response.json()
        opt = data["optimizations"][0]
        assert "id" in opt
        assert "task_type" in opt
        assert "previous_path" in opt
        assert "current_path" in opt
        assert "improvement" in opt
        assert "updated_at" in opt


# ---------------------------------------------------------------------------
# WebSocket /evolution-dashboard/ws
# ---------------------------------------------------------------------------


class TestEvolutionDashboardWebSocket:
    def test_ws_connect(self, client):
        with client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws:
            data = ws.receive_json()
            assert data["type"] == "connected"

    def test_ws_ping_pong(self, client):
        with client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws:
            # Receive connected message
            connected = ws.receive_json()
            assert connected["type"] == "connected"

            # Send ping
            ws.send_json({"type": "ping"})
            pong = ws.receive_json()
            assert pong["type"] == "pong"

    def test_ws_subscribe(self, client):
        with client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws:
            connected = ws.receive_json()
            assert connected["type"] == "connected"

            ws.send_json({"type": "subscribe", "channels": ["experiences"]})
            sub = ws.receive_json()
            assert sub["type"] == "subscribed"


# ---------------------------------------------------------------------------
# With experience_store configured
# ---------------------------------------------------------------------------


class TestWithExperienceStore:
    def test_experiences_with_store(self, app, client):
        """Test that experiences endpoint works when experience_store is configured"""
        mock_store = AsyncMock()
        mock_store.search = AsyncMock(return_value=[])

        app.state.experience_store = mock_store

        response = client.get("/api/v1/evolution-dashboard/experiences")
        assert response.status_code == 200
        data = response.json()
        assert "experiences" in data

        # Clean up
        app.state.experience_store = None

    def test_metrics_with_store(self, app, client):
        """Test that metrics endpoint works when experience_store is configured"""
        from agentkit.evolution.experience_schema import EvolutionMetrics

        mock_store = AsyncMock()
        mock_metrics = EvolutionMetrics(
            task_type="code_review",
            time_window="7d",
            completion_rate=0.85,
            avg_duration=25.0,
            retry_rate=0.1,
            sample_count=100,
            window_start=datetime.now(timezone.utc),
            window_end=datetime.now(timezone.utc),
        )
        mock_store.get_metrics = AsyncMock(return_value=[mock_metrics])

        app.state.experience_store = mock_store

        response = client.get("/api/v1/evolution-dashboard/metrics?period=7d")
        assert response.status_code == 200
        data = response.json()
        assert data["metrics"]["total_tasks"] == 100
        assert data["metrics"]["success_rate"] == 0.85

        # Clean up
        app.state.experience_store = None

    def test_pitfalls_with_detector(self, app, client):
        """Test that pitfalls endpoint works when pitfall_detector is configured"""
        from agentkit.evolution.pitfall_detector import PitfallWarning, WarningLevel

        mock_detector = AsyncMock()
        mock_detector.check_pitfalls = AsyncMock(
            return_value=[
                PitfallWarning(
                    step_name="deploy",
                    warning_level=WarningLevel.HIGH,
                    failure_rate=0.6,
                    historical_failures=["timeout", "config error"],
                    suggestion="该步骤历史失败率高达 60%，建议重点关注",
                )
            ]
        )

        app.state.pitfall_detector = mock_detector

        response = client.get(
            "/api/v1/evolution-dashboard/pitfalls?task_type=deployment&steps=build,deploy,verify"
        )
        assert response.status_code == 200
        data = response.json()
        assert len(data["warnings"]) == 1
        assert data["warnings"][0]["step"] == "deploy"
        assert data["warnings"][0]["risk_level"] == "high"
        assert data["warnings"][0]["historical_failure_rate"] == 0.6

        # Clean up
        app.state.pitfall_detector = None

    def test_optimizations_with_optimizer(self, app, client):
        """Test that path-optimizations endpoint works when path_optimizer is configured"""
        from agentkit.evolution.path_optimizer import ExecutionPath

        mock_optimizer = MagicMock()
        recommended_path = ExecutionPath(
            path_id="path-001",
            task_type="code_review",
            steps=["analyze", "approve"],
            total_duration=15.0,
            success_rate=0.9,
            sample_count=10,
            is_recommended=True,
            created_at=datetime.now(timezone.utc),
        )
        mock_optimizer.get_recommended_path = MagicMock(return_value=recommended_path)
        mock_optimizer._recommended_paths = {"code_review": recommended_path}

        app.state.path_optimizer = mock_optimizer

        response = client.get("/api/v1/evolution-dashboard/path-optimizations")
        assert response.status_code == 200
        data = response.json()
        assert len(data["optimizations"]) >= 1

        # Clean up
        app.state.path_optimizer = None


# ---------------------------------------------------------------------------
# Without experience_store configured (graceful degradation)
# ---------------------------------------------------------------------------


class TestWithoutExperienceStore:
    def test_experiences_graceful(self, client):
        """When experience_store is None, should still return valid response"""
        response = client.get("/api/v1/evolution-dashboard/experiences")
        assert response.status_code == 200
        assert "experiences" in response.json()

    def test_metrics_graceful(self, client):
        """When experience_store is None, should still return valid response"""
        response = client.get("/api/v1/evolution-dashboard/metrics")
        assert response.status_code == 200
        assert "metrics" in response.json()
        assert "trends" in response.json()

    def test_pitfalls_graceful(self, client):
        """When pitfall_detector is None, should return empty warnings"""
        response = client.get(
            "/api/v1/evolution-dashboard/pitfalls?task_type=test&steps=step1"
        )
        assert response.status_code == 200
        assert response.json()["warnings"] == []

    def test_optimizations_graceful(self, client):
        """When path_optimizer is None, should still return valid response"""
        response = client.get("/api/v1/evolution-dashboard/path-optimizations")
        assert response.status_code == 200
        assert "optimizations" in response.json()


# ---------------------------------------------------------------------------
# POST /evolution-dashboard/experiences
# ---------------------------------------------------------------------------


class TestRecordExperience:
    def test_record_experience(self, client):
        """Test recording a new experience via POST"""
        response = client.post(
            "/api/v1/evolution-dashboard/experiences",
            json={
                "task_type": "code_review",
                "goal": "Review PR #42",
                "outcome": "success",
                "duration": 25.0,
            },
        )
        assert response.status_code == 200
        data = response.json()
        assert data["task_type"] == "code_review"
        assert data["goal"] == "Review PR #42"
        assert data["outcome"] == "success"
        assert "id" in data
        assert "created_at" in data

        # Verify it was added to the store
        response = client.get("/api/v1/evolution-dashboard/experiences")
        assert response.json()["total"] == 1

    def test_record_experience_with_optional_fields(self, client):
        """Test recording experience with all optional fields"""
        response = client.post(
            "/api/v1/evolution-dashboard/experiences",
            json={
                "task_type": "deployment",
                "goal": "Deploy to production",
                "outcome": "failure",
                "duration": 120.0,
                "steps_summary": "Build, test, deploy",
                "failure_reasons": ["timeout", "config error"],
                "optimization_tips": ["Increase timeout", "Validate config"],
            },
        )
        assert response.status_code == 200
        data = response.json()
        assert data["outcome"] == "failure"


# ---------------------------------------------------------------------------
# POST /evolution-dashboard/path-optimizations
# ---------------------------------------------------------------------------


class TestRecordPathOptimization:
    def test_record_optimization(self, client):
        """Test recording a path optimization via POST"""
        response = client.post(
            "/api/v1/evolution-dashboard/path-optimizations",
            json={
                "task_type": "code_review",
                "previous_path": ["analyze", "review", "approve"],
                "current_path": ["analyze", "approve"],
                "improvement": 0.25,
            },
        )
        assert response.status_code == 200
        data = response.json()
        assert data["task_type"] == "code_review"
        assert data["improvement"] == 0.25
        assert "id" in data
        assert "updated_at" in data

        # Verify it was added to the store
        response = client.get("/api/v1/evolution-dashboard/path-optimizations")
        assert len(response.json()["optimizations"]) == 1


# ---------------------------------------------------------------------------
# WebSocket push events
# ---------------------------------------------------------------------------


class TestWebSocketPushEvents:
    def test_ws_receives_experience_added_on_post(self, client):
        """Test that WebSocket clients receive experience_added event after POST"""
        with client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws:
            # Receive connected message
            connected = ws.receive_json()
            assert connected["type"] == "connected"

            # Subscribe to channels
            ws.send_json({"type": "subscribe", "channels": ["experiences"]})
            ws.receive_json()  # subscribed ack

            # Record a new experience via POST
            client.post(
                "/api/v1/evolution-dashboard/experiences",
                json={
                    "task_type": "code_review",
                    "goal": "Review PR",
                    "outcome": "success",
                    "duration": 10.0,
                },
            )

            # WebSocket should receive experience_added event
            event = ws.receive_json()
            assert event["type"] == "experience_added"
            assert event["data"]["task_type"] == "code_review"
            assert event["data"]["outcome"] == "success"

            # Should also receive metrics_updated event
            metrics_event = ws.receive_json()
            assert metrics_event["type"] == "metrics_updated"
            assert "period" in metrics_event["data"]

    def test_ws_receives_optimization_updated_on_post(self, client):
        """Test that WebSocket clients receive optimization_updated event after POST"""
        with client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws:
            connected = ws.receive_json()
            assert connected["type"] == "connected"

            # Record a new optimization via POST
            client.post(
                "/api/v1/evolution-dashboard/path-optimizations",
                json={
                    "task_type": "code_review",
                    "previous_path": ["step1", "step2"],
                    "current_path": ["step1"],
                    "improvement": 0.1,
                },
            )

            # WebSocket should receive optimization_updated event
            event = ws.receive_json()
            assert event["type"] == "optimization_updated"
            assert event["data"]["task_type"] == "code_review"
            assert event["data"]["improvement"] == 0.1

    def test_ws_receives_pitfall_detected(self, app, client):
        """Test that WebSocket clients receive pitfall_detected event when pitfalls found"""
        from agentkit.evolution.pitfall_detector import PitfallWarning, WarningLevel

        mock_detector = AsyncMock()
        mock_detector.check_pitfalls = AsyncMock(
            return_value=[
                PitfallWarning(
                    step_name="deploy",
                    warning_level=WarningLevel.HIGH,
                    failure_rate=0.6,
                    historical_failures=["timeout"],
                    suggestion="Check timeout settings",
                )
            ]
        )
        app.state.pitfall_detector = mock_detector

        with client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws:
            connected = ws.receive_json()
            assert connected["type"] == "connected"

            # Check pitfalls via GET
            client.get(
                "/api/v1/evolution-dashboard/pitfalls?task_type=deployment&steps=build,deploy"
            )

            # WebSocket should receive pitfall_detected event
            event = ws.receive_json()
            assert event["type"] == "pitfall_detected"
            assert event["data"]["task_type"] == "deployment"
            assert len(event["data"]["warnings"]) == 1

        # Clean up
        app.state.pitfall_detector = None

    def test_broadcast_event_sends_to_all_connections(self, client):
        """Test that _broadcast_event sends messages to all connected clients"""
        with (
            client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws1,
            client.websocket_connect("/api/v1/evolution-dashboard/ws") as ws2,
        ):
            # Receive connected messages
            ws1.receive_json()
            ws2.receive_json()

            # Trigger a broadcast via POST (which calls _broadcast_event internally)
            client.post(
                "/api/v1/evolution-dashboard/experiences",
                json={
                    "task_type": "test_broadcast",
                    "goal": "Broadcast test",
                    "outcome": "success",
                    "duration": 1.0,
                },
            )

            # Both clients should receive experience_added event
            event1 = ws1.receive_json()
            assert event1["type"] == "experience_added"
            assert event1["data"]["task_type"] == "test_broadcast"

            event2 = ws2.receive_json()
            assert event2["type"] == "experience_added"
            assert event2["data"]["task_type"] == "test_broadcast"

            # Both clients should also receive metrics_updated event
            metrics1 = ws1.receive_json()
            assert metrics1["type"] == "metrics_updated"

            metrics2 = ws2.receive_json()
            assert metrics2["type"] == "metrics_updated"