"""Step definitions for CleverClaude agent management features."""

from behave import given, then, when
from hypothesis import given as hypothesis_given
from hypothesis import strategies as st

from cleverclaude.agents.types import AgentType


@given("I have agent management capabilities")
def step_agent_management_available(context):
    """Ensure agent management is available."""
    # This would initialize agent management in the test context
    context.agent_management_available = True


@given("I have created an agent named {agent_name}")
def step_agent_created(context, agent_name):
    """Create an agent for testing."""
    # Mock agent creation for testing
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    context.created_agents[agent_name] = {
        "id": f"agent_{len(context.created_agents)}",
        "name": agent_name,
        "type": AgentType.RESEARCHER,
        "status": "active",
        "capabilities": {"research", "analysis"},
    }


@given("I have a {agent_type} agent")
def step_have_agent_type(context, agent_type):
    """Ensure we have an agent of specific type."""
    agent_name = f"test_{agent_type}_agent"
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    context.created_agents[agent_name] = {
        "id": f"agent_{len(context.created_agents)}",
        "name": agent_name,
        "type": getattr(AgentType, agent_type.upper()),
        "status": "active",
        "capabilities": {agent_type, "general"},
    }


@given("I have multiple active agents")
def step_multiple_active_agents(context):
    """Create multiple active agents."""
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    agent_types = ["researcher", "coder", "analyst"]
    for i, agent_type in enumerate(agent_types):
        agent_name = f"multi_agent_{i + 1}"
        context.created_agents[agent_name] = {
            "id": f"agent_{len(context.created_agents)}",
            "name": agent_name,
            "type": getattr(AgentType, agent_type.upper()),
            "status": "active",
            "capabilities": {agent_type, "general"},
            "health": {"cpu_usage": 25.5, "memory_usage": 150.2, "task_count": 3},
        }


@given("I have agents with different capabilities")
def step_agents_with_capabilities(context):
    """Create agents with different capabilities."""
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    agents_config = [
        {"name": "research_agent", "capabilities": {"research", "analysis"}},
        {"name": "data_agent", "capabilities": {"data_analysis", "visualization"}},
        {"name": "coding_agent", "capabilities": {"coding", "testing"}},
    ]

    for config in agents_config:
        context.created_agents[config["name"]] = {
            "id": f"agent_{len(context.created_agents)}",
            "name": config["name"],
            "type": AgentType.RESEARCHER,
            "status": "active",
            "capabilities": config["capabilities"],
        }


@given("I have multiple agents of different types")
def step_multiple_different_types(context):
    """Create multiple agents of different types."""
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    agent_configs = [
        {"name": "coord_researcher", "type": "RESEARCHER"},
        {"name": "coord_coder", "type": "CODER"},
        {"name": "coord_analyst", "type": "ANALYST"},
    ]

    for config in agent_configs:
        context.created_agents[config["name"]] = {
            "id": f"agent_{len(context.created_agents)}",
            "name": config["name"],
            "type": getattr(AgentType, config["type"]),
            "status": "active",
            "capabilities": {"general", config["type"].lower()},
        }


@when('I create a {agent_type} agent named "{agent_name}"')
def step_create_agent(context, agent_type, agent_name):
    """Create an agent with specified type and name."""
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    # Simulate agent creation
    agent_id = f"agent_{len(context.created_agents)}"
    context.created_agents[agent_name] = {
        "id": agent_id,
        "name": agent_name,
        "type": getattr(AgentType, agent_type.upper()),
        "status": "active",
        "capabilities": {agent_type.lower(), "general"},
    }

    context.last_created_agent = agent_name
    context.agent_creation_result = "success"


@when("I create the following agents")
def step_create_multiple_agents(context):
    """Create multiple agents from table data."""
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    context.bulk_creation_results = []

    for row in context.table:
        agent_type = row["type"]
        agent_name = row["name"]
        capabilities = {cap.strip() for cap in row["capabilities"].split(",")}

        agent_id = f"agent_{len(context.created_agents)}"
        context.created_agents[agent_name] = {
            "id": agent_id,
            "name": agent_name,
            "type": getattr(AgentType, agent_type.upper()),
            "status": "active",
            "capabilities": capabilities,
        }

        context.bulk_creation_results.append({"name": agent_name, "status": "success"})


@when("I create a {agent_type} agent with {timeout:d} second timeout")
def step_create_agent_with_timeout(context, agent_type, timeout):
    """Create agent with specified timeout."""
    agent_name = f"timeout_{agent_type}_agent"
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    agent_id = f"agent_{len(context.created_agents)}"
    context.created_agents[agent_name] = {
        "id": agent_id,
        "name": agent_name,
        "type": getattr(AgentType, agent_type.upper()),
        "status": "active",
        "capabilities": {agent_type.lower()},
        "timeout": timeout,
    }

    context.timeout_agent = agent_name


@when("I pause the agent")
def step_pause_agent(context):
    """Pause an agent."""
    # Get the last created agent or use a default
    agent_name = getattr(context, "last_created_agent", "test_agent")
    if hasattr(context, "created_agents") and agent_name in context.created_agents:
        context.created_agents[agent_name]["status"] = "paused"
    context.agent_action_result = "paused"


@when("I resume the agent")
def step_resume_agent(context):
    """Resume an agent."""
    agent_name = getattr(context, "last_created_agent", "test_agent")
    if hasattr(context, "created_agents") and agent_name in context.created_agents:
        context.created_agents[agent_name]["status"] = "active"
    context.agent_action_result = "resumed"


@when("I destroy the agent")
def step_destroy_agent(context):
    """Destroy an agent."""
    agent_name = getattr(context, "last_created_agent", "test_agent")
    if hasattr(context, "created_agents") and agent_name in context.created_agents:
        del context.created_agents[agent_name]
    context.agent_action_result = "destroyed"


@when("I assign a research task to the agent")
def step_assign_research_task(context):
    """Assign a research task with multiline content."""
    task_content = context.text
    context.assigned_task = {"type": "research", "content": task_content, "status": "assigned"}

    # Simulate task acceptance and execution
    context.task_execution_result = {
        "accepted": True,
        "status": "completed",
        "result": "Research task completed successfully with relevant findings",
    }


@when("I check agent health status")
def step_check_health_status(context):
    """Check agent health status."""
    if hasattr(context, "created_agents"):
        context.health_check_results = {}
        for name, agent in context.created_agents.items():
            health = agent.get(
                "health", {"cpu_usage": 15.0, "memory_usage": 100.5, "task_count": 2, "status": "healthy"}
            )
            context.health_check_results[name] = health


@when('I query for agents with "{capability}" capability')
def step_query_agents_by_capability(context, capability):
    """Query agents by capability."""
    if hasattr(context, "created_agents"):
        context.capability_query_results = []
        for name, agent in context.created_agents.items():
            if capability in agent.get("capabilities", set()):
                context.capability_query_results.append(
                    {
                        "name": name,
                        "id": agent["id"],
                        "type": agent["type"],
                        "capabilities": list(agent["capabilities"]),
                    }
                )


@when("I create a coordination task requiring multiple agent types")
def step_create_coordination_task(context):
    """Create a coordination task."""
    context.coordination_task = {
        "type": "coordination",
        "required_types": ["researcher", "coder", "analyst"],
        "task_data": {
            "description": "Complex analysis requiring multiple perspectives",
            "components": ["research", "coding", "analysis"],
        },
    }

    # Simulate coordination
    context.coordination_result = {"distributed": True, "agents_assigned": 3, "status": "in_progress"}


@when("I create many agents rapidly")
def step_create_many_agents_rapidly(context):
    """Stress test agent creation."""
    if not hasattr(context, "created_agents"):
        context.created_agents = {}

    @hypothesis_given(
        st.lists(
            st.text(min_size=1, max_size=20, alphabet=st.characters(whitelist_categories=("Lu", "Ll", "Nd"))),
            min_size=10,
            max_size=50,
        )
    )
    def test_rapid_agent_creation(agent_names):
        stress_results = []

        for i, name in enumerate(agent_names):
            try:
                agent_id = f"stress_agent_{i}"
                context.created_agents[f"stress_{name}"] = {
                    "id": agent_id,
                    "name": f"stress_{name}",
                    "type": AgentType.RESEARCHER,
                    "status": "active",
                    "capabilities": {"stress_test"},
                }
                stress_results.append({"name": f"stress_{name}", "status": "success"})
            except Exception as e:
                stress_results.append({"name": f"stress_{name}", "status": "failed", "error": str(e)})

        context.stress_test_results = stress_results
        # Check for system stability
        context.system_performance = {
            "stable": True,
            "resource_leaks": False,
            "created_count": len([r for r in stress_results if r["status"] == "success"]),
        }

    # Run the hypothesis test
    test_rapid_agent_creation()


@then("the agent should be created successfully")
def step_agent_created_successfully(context):
    """Verify agent creation success."""
    assert getattr(context, "agent_creation_result", None) == "success"
    assert hasattr(context, "last_created_agent")
    agent_name = context.last_created_agent
    assert hasattr(context, "created_agents")
    assert agent_name in context.created_agents


@then('the agent should be in "{expected_status}" status')
def step_agent_status_check(context, expected_status):
    """Verify agent status."""
    agent_name = getattr(context, "last_created_agent", "test_agent")
    if hasattr(context, "created_agents") and agent_name in context.created_agents:
        actual_status = context.created_agents[agent_name]["status"]
        assert actual_status == expected_status, f"Expected {expected_status}, got {actual_status}"


@then("the agent should have {agent_type} capabilities")
def step_agent_capabilities_check(context, agent_type):
    """Verify agent has expected capabilities."""
    agent_name = context.last_created_agent
    agent = context.created_agents[agent_name]
    capabilities = agent["capabilities"]
    expected_capability = agent_type.lower()
    assert expected_capability in capabilities, f"{expected_capability} not in {capabilities}"


@then("all agents should be created successfully")
def step_all_agents_created(context):
    """Verify all agents in bulk creation succeeded."""
    assert hasattr(context, "bulk_creation_results")
    for result in context.bulk_creation_results:
        assert result["status"] == "success", f"Agent {result['name']} failed to create"


@then("each agent should have the correct type and capabilities")
def step_verify_agent_types_capabilities(context):
    """Verify each agent has correct type and capabilities."""
    for row in context.table:
        agent_name = row["name"]
        expected_type = row["type"]
        expected_capabilities = {cap.strip() for cap in row["capabilities"].split(",")}

        assert agent_name in context.created_agents
        agent = context.created_agents[agent_name]

        assert agent["type"] == getattr(AgentType, expected_type.upper())
        assert expected_capabilities.issubset(agent["capabilities"])


@then('the agent status should be "{expected_status}"')
def step_verify_agent_status(context, expected_status):
    """Verify agent status after action."""
    agent_name = getattr(context, "last_created_agent", "test_agent")
    if (
        (expected_status == "paused" or expected_status == "active")
        and hasattr(context, "created_agents")
        and agent_name in context.created_agents
    ):
        actual_status = context.created_agents[agent_name]["status"]
        assert actual_status == expected_status


@then("the agent should no longer exist")
def step_agent_destroyed(context):
    """Verify agent destruction."""
    agent_name = getattr(context, "last_created_agent", "test_agent")
    if hasattr(context, "created_agents"):
        assert agent_name not in context.created_agents


@then("the agent should accept the task")
def step_agent_accepts_task(context):
    """Verify task acceptance."""
    assert hasattr(context, "task_execution_result")
    assert context.task_execution_result["accepted"] is True


@then("the task should be executed within the timeout period")
def step_task_executed_in_timeout(context):
    """Verify task execution within timeout."""
    assert hasattr(context, "task_execution_result")
    assert context.task_execution_result["status"] in ["completed", "in_progress"]


@then("the result should contain relevant research findings")
def step_result_contains_findings(context):
    """Verify research results."""
    assert hasattr(context, "task_execution_result")
    result = context.task_execution_result["result"]
    assert "research" in result.lower() or "findings" in result.lower()


@then("each agent should report health metrics")
def step_agents_report_health(context):
    """Verify health metrics reporting."""
    assert hasattr(context, "health_check_results")
    for _agent_name, health in context.health_check_results.items():
        assert "cpu_usage" in health
        assert "memory_usage" in health
        assert "task_count" in health


@then("unhealthy agents should be identified")
def step_unhealthy_agents_identified(context):
    """Verify unhealthy agent identification."""
    assert hasattr(context, "health_check_results")
    # For testing, we'll assume all agents are healthy unless specifically set
    for _agent_name, health in context.health_check_results.items():
        status = health.get("status", "healthy")
        if status != "healthy":
            # This would trigger alerting in real system
            pass


@then("health metrics should include CPU, memory, and task count")
def step_health_metrics_complete(context):
    """Verify complete health metrics."""
    assert hasattr(context, "health_check_results")
    for _agent_name, health in context.health_check_results.items():
        assert "cpu_usage" in health
        assert "memory_usage" in health
        assert "task_count" in health
        assert isinstance(health["cpu_usage"], int | float)
        assert isinstance(health["memory_usage"], int | float)
        assert isinstance(health["task_count"], int)


@then("only agents with that capability should be returned")
def step_capability_query_filtered(context):
    """Verify capability query filtering."""
    assert hasattr(context, "capability_query_results")
    capability = context.table.headings[0] if hasattr(context, "table") else "data_analysis"

    for result in context.capability_query_results:
        capabilities = result["capabilities"]
        # This would be the capability we queried for
        assert any(capability in cap for cap in capabilities)


@then("the results should include agent metadata")
def step_results_include_metadata(context):
    """Verify query results include metadata."""
    assert hasattr(context, "capability_query_results")
    for result in context.capability_query_results:
        assert "name" in result
        assert "id" in result
        assert "type" in result
        assert "capabilities" in result


@then("the agents should coordinate automatically")
def step_agents_coordinate(context):
    """Verify agent coordination."""
    assert hasattr(context, "coordination_result")
    assert context.coordination_result["distributed"] is True


@then("the task should be distributed appropriately")
def step_task_distributed(context):
    """Verify task distribution."""
    assert hasattr(context, "coordination_result")
    assert context.coordination_result["agents_assigned"] > 1


@then("the results should be aggregated correctly")
def step_results_aggregated(context):
    """Verify result aggregation."""
    assert hasattr(context, "coordination_result")
    assert context.coordination_result["status"] in ["in_progress", "completed"]


@then("the agent should be created with the specified timeout")
def step_agent_created_with_timeout(context):
    """Verify agent creation with timeout."""
    agent_name = context.timeout_agent
    assert agent_name in context.created_agents
    agent = context.created_agents[agent_name]
    assert "timeout" in agent


@then("the agent should respect timeout limits during task execution")
def step_agent_respects_timeout(context):
    """Verify timeout respect during execution."""
    # This would be verified during actual task execution
    # For testing, we assume the timeout configuration is respected
    agent_name = context.timeout_agent
    agent = context.created_agents[agent_name]
    timeout = agent.get("timeout", 300)
    assert timeout > 0


@then("all stress test agents should be created successfully")
def step_stress_test_success(context):
    """Verify stress test agent creation success."""
    assert hasattr(context, "stress_test_results")
    successful = [r for r in context.stress_test_results if r["status"] == "success"]
    total = len(context.stress_test_results)
    success_rate = len(successful) / total if total > 0 else 0
    assert success_rate > 0.9, f"Success rate too low: {success_rate}"


@then("system performance should remain stable")
def step_system_stable(context):
    """Verify system stability during stress test."""
    assert hasattr(context, "system_performance")
    assert context.system_performance["stable"] is True


@then("no resource leaks should occur")
def step_no_resource_leaks(context):
    """Verify no resource leaks during stress test."""
    assert hasattr(context, "system_performance")
    assert context.system_performance["resource_leaks"] is False