"""Tests for EvolutionAgent."""

import pytest

from app.agents.evolution_agent import ALL_AGENTS, EvolutionAgent


@pytest.fixture
def evolution_agent():
    return EvolutionAgent()


@pytest.mark.asyncio
async def test_evolution_agent_initialization(evolution_agent):
    """Test EvolutionAgent initializes correctly."""
    assert evolution_agent.name == "evolution_agent"
    assert evolution_agent.version == "1.0.0"


@pytest.mark.asyncio
async def test_evolution_agent_health_check(evolution_agent):
    """Test EvolutionAgent health check."""
    result = await evolution_agent.health_check()
    assert isinstance(result, bool)


@pytest.mark.asyncio
async def test_evolution_agent_get_status(evolution_agent):
    """Test EvolutionAgent get status."""
    result = await evolution_agent.run()
    assert result.success
    assert "total_agents" in result.data


@pytest.mark.asyncio
async def test_evolution_agent_analyze(evolution_agent):
    """Test EvolutionAgent analyze."""
    context = {"action": "analyze"}
    result = await evolution_agent.run(context)
    assert result.success
    assert "analyses" in result.data


@pytest.mark.asyncio
async def test_evolution_agent_suggest(evolution_agent):
    """Test EvolutionAgent suggest improvements."""
    context = {"action": "suggest"}
    result = await evolution_agent.run(context)
    assert result.success
    assert "suggestions" in result.data


@pytest.mark.asyncio
async def test_evolution_agent_evolve_without_id(evolution_agent):
    """Test EvolutionAgent evolve without agent_id."""
    context = {"action": "evolve"}
    result = await evolution_agent.run(context)
    assert result.success is False


@pytest.mark.asyncio
async def test_evolution_agent_evolve(evolution_agent):
    """Test EvolutionAgent evolve with capabilities bump."""
    context = {
        "action": "evolve",
        "agent_id": "doc_agent",
        "capabilities": ["new_capability"],
    }
    result = await evolution_agent.run(context)
    assert result.success
    assert result.data.get("agent_id") == "doc_agent"
    assert "new_version" in result.data


@pytest.mark.asyncio
async def test_evolution_agent_version_check(evolution_agent):
    """Test EvolutionAgent version_check action."""
    context = {"action": "version_check"}
    result = await evolution_agent.run(context)
    assert result.success
    assert "versions" in result.data


@pytest.mark.asyncio
async def test_evolution_agent_version_bump(evolution_agent):
    """Test EvolutionAgent version_bump action."""
    context = {
        "action": "version_bump",
        "agent_id": "doc_agent",
        "version_type": "minor",
        "entries": ["Added: new capability"],
    }
    result = await evolution_agent.run(context)
    assert result.success
    assert result.data.get("agent_id") == "doc_agent"
    assert result.data.get("new_version") == "1.1.0"


@pytest.mark.asyncio
async def test_evolution_agent_version_bump_invalid_type(evolution_agent):
    """Test EvolutionAgent version_bump with invalid type."""
    context = {
        "action": "version_bump",
        "agent_id": "doc_agent",
        "version_type": "patch",
        "entries": [],
    }
    result = await evolution_agent.run(context)
    assert result.success is False


@pytest.mark.asyncio
async def test_evolution_agent_version_bump_major(evolution_agent):
    """Test EvolutionAgent version_bump major."""
    context = {
        "action": "version_bump",
        "agent_id": "doc_agent",
        "version_type": "major",
        "entries": ["Breaking: changed API"],
    }
    result = await evolution_agent.run(context)
    assert result.success
    assert result.data.get("new_version") == "2.0.0"


@pytest.mark.asyncio
async def test_evolution_agent_version_check_specific(evolution_agent):
    """Test EvolutionAgent version_check for specific agent."""
    context = {
        "action": "version_check",
        "agent_id": "doc_agent",
    }
    result = await evolution_agent.run(context)
    assert result.success
    assert "doc_agent" in result.data["versions"]


@pytest.mark.asyncio
async def test_all_agents_list_completeness(evolution_agent):
    """Test ALL_AGENTS contains all 11 agents."""
    assert len(ALL_AGENTS) == 11
    agent_ids = {a["id"] for a in ALL_AGENTS}
    expected = {
        "doc_agent", "backlog_agent", "spec_agent", "audit_agent",
        "observer_agent", "security_agent", "qa_tester_agent",
        "fix_agent", "ui_test_agent", "rollout_agent", "evolution_agent",
    }
    assert agent_ids == expected


@pytest.mark.asyncio
async def test_evolution_agent_status_transitions(evolution_agent):
    """Test EvolutionAgent status transitions."""
    assert evolution_agent.status.value == "idle"

    await evolution_agent.set_running("evolution")
    assert evolution_agent.status.value == "running"

    await evolution_agent.set_idle()
    assert evolution_agent.status.value == "idle"


@pytest.mark.asyncio
async def test_evolution_agent_metrics(evolution_agent):
    """Test EvolutionAgent metrics."""
    metrics = await evolution_agent.get_metrics()
    assert "agent_id" in metrics
    assert "status" in metrics
    assert metrics["capabilities_tracked"] == 11


@pytest.mark.asyncio
async def test_get_agent_capabilities(evolution_agent):
    """Test capability retrieval."""
    caps = evolution_agent._get_agent_capabilities("doc_agent")
    assert len(caps) > 0
    assert "documentation" in caps

    caps = evolution_agent._get_agent_capabilities("unknown")
    assert len(caps) == 0