"""
Integration test for async subagent execution.

Tests the end-to-end flow:
1. Spawn subagent with async_=True
2. Verify immediate return with "running" status
3. Verify SubagentCompleteHook injects results when complete

Usage:
    uv run python scripts/test_async_subagent_integration.py [--verbose]
"""

import argparse
import asyncio
import sys

# Add parent directory to path
sys.path.insert(0, ".")

from massgen.subagent.models import SubagentResult  # noqa: E402
from massgen.subagent.result_formatter import (  # noqa: E402
    format_batch_results,
    format_single_result,
)


def test_callback_mechanism():
    """Test that callbacks are invoked when background subagents complete."""
    print("\n=== Test 1: Callback Mechanism ===")

    # Track callback invocations
    callback_results: list[tuple[str, SubagentResult]] = []

    def on_complete(subagent_id: str, result: SubagentResult):
        callback_results.append((subagent_id, result))
        print(f"  [Callback] Subagent {subagent_id} completed: status={result.status}")

    # Create a mock manager (we can't actually run subagents without config)
    # Instead, we'll test the callback registration and invocation

    # Create a SubagentResult for testing
    result = SubagentResult(
        subagent_id="test-sub-1",
        status="completed",
        success=True,
        answer="Test answer from async subagent",
        execution_time_seconds=5.5,
        workspace_path="/tmp/test-workspace",
        token_usage={"input_tokens": 100, "output_tokens": 50},
    )

    # Test callback invocation manually
    on_complete("test-sub-1", result)

    assert len(callback_results) == 1
    assert callback_results[0][0] == "test-sub-1"
    assert callback_results[0][1].success is True

    print("  [PASS] Callback mechanism works correctly")


def test_result_formatting():
    """Test that SubagentResult is formatted correctly for injection."""
    print("\n=== Test 2: Result Formatting ===")

    # Create test result
    result = SubagentResult(
        subagent_id="research-1",
        status="completed",
        success=True,
        answer="Here is my research on OAuth 2.0...",
        execution_time_seconds=45.2,
        workspace_path="/workspace/research-1",
        token_usage={"input_tokens": 1500, "output_tokens": 800},
    )

    # Test single result formatting
    formatted = format_single_result("research-1", result)
    print(f"  Single result formatted:\n{formatted[:200]}...")

    assert '<subagent_result id="research-1"' in formatted
    assert 'status="completed"' in formatted
    assert '<answer success="true">' in formatted
    assert "OAuth 2.0" in formatted

    print("  [PASS] Single result formatting correct")

    # Test batch formatting
    result2 = SubagentResult(
        subagent_id="analysis-1",
        status="completed",
        success=True,
        answer="Analysis complete",
        execution_time_seconds=30.1,
        workspace_path="/workspace/analysis-1",
    )

    batch_formatted = format_batch_results([("research-1", result), ("analysis-1", result2)])
    print(f"  Batch formatted:\n{batch_formatted[:300]}...")

    assert "ASYNC SUBAGENT RESULTS (2 completed)" in batch_formatted
    assert '<subagent_result id="research-1"' in batch_formatted
    assert '<subagent_result id="analysis-1"' in batch_formatted

    print("  [PASS] Batch formatting correct")


def test_hook_result_structure():
    """Test that SubagentCompleteHook returns correct HookResult."""
    print("\n=== Test 3: Hook Result Structure ===")

    from massgen.mcp_tools.hooks import SubagentCompleteHook

    # Test with no pending results
    hook = SubagentCompleteHook(injection_strategy="tool_result")
    hook.set_pending_results_getter(lambda: [])

    # Run the hook
    async def run_hook():
        return await hook.execute("test_tool", "{}", None)

    result = asyncio.run(run_hook())
    assert result.allowed is True
    assert result.inject is None
    print("  [PASS] No pending results returns allow without injection")

    # Test with pending results
    pending = [
        (
            "sub-1",
            SubagentResult(
                subagent_id="sub-1",
                status="completed",
                success=True,
                answer="Test answer",
                execution_time_seconds=10.0,
                workspace_path="/test",
            ),
        ),
    ]

    hook2 = SubagentCompleteHook(injection_strategy="tool_result")
    hook2.set_pending_results_getter(lambda: pending)

    result2 = asyncio.run(run_hook())

    # Note: The hook clears results after first call via the getter
    # So we need to re-set the getter
    hook2.set_pending_results_getter(lambda: pending)
    result2 = asyncio.run(hook2.execute("test_tool", "{}", None))

    assert result2.allowed is True
    assert result2.inject is not None
    assert "content" in result2.inject
    assert "strategy" in result2.inject
    assert result2.inject["strategy"] == "tool_result"
    print(f"  Injection content: {result2.inject['content'][:100]}...")
    print("  [PASS] Pending results returns injection")


def test_mcp_tool_async_parameter():
    """Test that spawn_subagents MCP tool has async_ parameter."""
    print("\n=== Test 4: MCP Tool Async Parameter ===")

    # Read the MCP server file and check for async_ parameter
    with open("massgen/mcp_tools/subagent/_subagent_mcp_server.py") as f:
        content = f.read()

    # Check that async_ parameter exists
    assert "async_: bool = False" in content
    print("  [PASS] async_ parameter exists with default False")

    # Check that async mode returns different format
    assert '"mode": "async"' in content
    print("  [PASS] Async mode returns 'mode': 'async' in response")

    # Check that blocking mode still works
    assert "manager.spawn_parallel" in content
    print("  [PASS] Blocking mode uses spawn_parallel")

    # Check that async mode uses spawn_subagent_background
    assert "manager.spawn_subagent_background" in content
    print("  [PASS] Async mode uses spawn_subagent_background")


def test_orchestrator_integration():
    """Test Orchestrator has pending results queue and hook registration."""
    print("\n=== Test 5: Orchestrator Integration ===")

    # Read orchestrator file
    with open("massgen/orchestrator.py") as f:
        content = f.read()

    # Check for pending results queue
    assert "_pending_subagent_results" in content
    print("  [PASS] Orchestrator has _pending_subagent_results")

    # Check for callback method
    assert "def _on_subagent_complete" in content
    print("  [PASS] Orchestrator has _on_subagent_complete callback")

    # Check for getter method
    assert "def _get_pending_subagent_results" in content
    print("  [PASS] Orchestrator has _get_pending_subagent_results getter")

    # Check for SubagentCompleteHook registration
    assert "SubagentCompleteHook" in content
    print("  [PASS] Orchestrator imports SubagentCompleteHook")

    # Check hook is registered in both paths
    assert content.count("SubagentCompleteHook(") >= 2
    print("  [PASS] SubagentCompleteHook registered in both hook paths")


def test_edge_case_handling():
    """Test edge case handling - flush pending results on cleanup."""
    print("\n=== Test 6: Edge Case Handling ===")

    # Read orchestrator file
    with open("massgen/orchestrator.py") as f:
        content = f.read()

    # Check for flush method
    assert "def _flush_pending_subagent_results" in content
    print("  [PASS] Orchestrator has _flush_pending_subagent_results method")

    # Check that flush is called in cleanup
    assert "_flush_pending_subagent_results()" in content
    print("  [PASS] Flush is called in cleanup")

    # Check for warning log about orphaned results
    assert "were not delivered" in content
    print("  [PASS] Warning logged for undelivered results")


def test_config_validation():
    """Test that async_subagents config is validated."""
    print("\n=== Test 7: Config Validation ===")

    from massgen.config_validator import ConfigValidator

    validator = ConfigValidator()

    # Valid config with proper agent structure
    valid_config = {
        "agent": {
            "id": "test-agent",
            "backend": {"model": "gpt-4o-mini", "type": "openai"},
        },
        "orchestrator": {
            "coordination": {
                "async_subagents": {"enabled": True, "injection_strategy": "tool_result"},
            },
        },
    }
    result = validator.validate_config(valid_config)
    assert not result.has_errors(), f"Valid config should pass: {result.errors}"
    print("  [PASS] Valid async_subagents config passes validation")

    # Invalid injection strategy
    invalid_config = {
        "agent": {
            "id": "test-agent",
            "backend": {"model": "gpt-4o-mini", "type": "openai"},
        },
        "orchestrator": {
            "coordination": {
                "async_subagents": {"enabled": True, "injection_strategy": "invalid"},
            },
        },
    }
    result = validator.validate_config(invalid_config)
    assert result.has_errors()
    print("  [PASS] Invalid injection_strategy fails validation")

    # Invalid enabled type
    invalid_config2 = {
        "agent": {
            "id": "test-agent",
            "backend": {"model": "gpt-4o-mini", "type": "openai"},
        },
        "orchestrator": {
            "coordination": {
                "async_subagents": {"enabled": "yes"},  # Should be bool
            },
        },
    }
    result = validator.validate_config(invalid_config2)
    assert result.has_errors()
    print("  [PASS] Invalid enabled type fails validation")


def main():
    """Run all integration tests."""
    parser = argparse.ArgumentParser(description="Async subagent integration tests")
    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
    parser.parse_args()

    print("=" * 60)
    print("Async Subagent Integration Tests")
    print("=" * 60)

    try:
        test_callback_mechanism()
        test_result_formatting()
        test_hook_result_structure()
        test_mcp_tool_async_parameter()
        test_orchestrator_integration()
        test_edge_case_handling()
        test_config_validation()

        print("\n" + "=" * 60)
        print("ALL TESTS PASSED!")
        print("=" * 60)
        return 0

    except AssertionError as e:
        print(f"\n[FAIL] Assertion error: {e}")
        return 1
    except Exception as e:
        print(f"\n[ERROR] Unexpected error: {e}")
        import traceback

        traceback.print_exc()
        return 1


if __name__ == "__main__":
    sys.exit(main())