import uuid
import pytest
from httpx import AsyncClient
from sqlalchemy.ext.asyncio import AsyncSession
from modules.bots.models import Bot


@pytest.mark.asyncio
async def test_mcp_pro_full_lifecycle_and_tenant_isolation(
    async_client: AsyncClient, db_session: AsyncSession
):
    # 1. Setup Tenant A & User A
    user_a_email = f"mcp_admin_{uuid.uuid4().hex[:6]}@example.com"
    reg_resp_a = await async_client.post(
        "/api/v1/auth/register",
        json={"email": user_a_email, "password": "Password123!", "full_name": "MCP Platform Admin"},
    )
    assert reg_resp_a.status_code == 201
    token_a = reg_resp_a.json()["data"]["access_token"]

    tenant_resp_a = await async_client.post(
        "/api/v1/tenants",
        headers={"Authorization": f"Bearer {token_a}"},
        json={"name": "MCP Enterprise Tenant", "slug": f"mcp-corp-{uuid.uuid4().hex[:6]}"},
    )
    assert tenant_resp_a.status_code == 201
    tenant_a_id = tenant_resp_a.json()["data"]["id"]
    headers_a = {
        "Authorization": f"Bearer {token_a}",
        "X-Tenant-ID": tenant_a_id,
    }

    # 2. Test POST /api/v1/mcp/rpc - 'initialize'
    init_resp = await async_client.post(
        "/api/v1/mcp/rpc",
        headers=headers_a,
        json={
            "jsonrpc": "2.0",
            "id": 1,
            "method": "initialize",
            "params": {
                "protocolVersion": "2024-11-05",
                "capabilities": {},
                "clientInfo": {"name": "Claude-Cursor-Pro", "version": "2.0.0"},
            },
        },
    )
    assert init_resp.status_code == 200
    init_data = init_resp.json()
    assert init_data["result"]["protocolVersion"] == "2024-11-05"
    assert init_data["result"]["serverInfo"]["name"] == "SuperBot-MCP-Cloud"

    # 3. Test POST /api/v1/mcp/rpc - 'tools/list'
    tools_resp = await async_client.post(
        "/api/v1/mcp/rpc",
        headers=headers_a,
        json={
            "jsonrpc": "2.0",
            "id": 2,
            "method": "tools/list",
            "params": {},
        },
    )
    assert tools_resp.status_code == 200
    tools_data = tools_resp.json()
    tool_names = [t["name"] for t in tools_data["result"]["tools"]]
    assert "bot.list" in tool_names
    assert "marketplace.list" in tool_names
    assert "analytics.report" in tool_names

    # 4. Test POST /api/v1/mcp/rpc - 'tools/call' for marketplace.list
    call_resp = await async_client.post(
        "/api/v1/mcp/rpc",
        headers=headers_a,
        json={
            "jsonrpc": "2.0",
            "id": 3,
            "method": "tools/call",
            "params": {
                "name": "marketplace.list",
                "arguments": {"category": "business"},
            },
        },
    )
    assert call_resp.status_code == 200
    call_data = call_resp.json()
    assert call_data["result"]["isError"] is False
    content_text = call_data["result"]["content"][0]["text"]
    assert "bot_ecommerce_concierge" in content_text

    # 5. Test GET /api/v1/mcp/tools
    catalog_resp = await async_client.get("/api/v1/mcp/tools", headers=headers_a)
    assert catalog_resp.status_code == 200
    available_tools = catalog_resp.json()["data"]
    assert len(available_tools) >= 6

    # 6. Test Register External MCP Server Connection
    server_resp = await async_client.post(
        "/api/v1/mcp/servers",
        headers=headers_a,
        json={
            "name": "Corporate GitHub MCP",
            "slug": "corp-github",
            "transport_type": "http",
            "endpoint_url": "https://mcp.internal.corp/github",
            "auth_token": "ghp_secure_token_12345",
        },
    )
    assert server_resp.status_code == 201
    server_data = server_resp.json()["data"]
    server_id = server_data["id"]
    assert server_data["name"] == "Corporate GitHub MCP"
    assert server_data["slug"] == "corp-github"

    # List servers
    list_srv_resp = await async_client.get("/api/v1/mcp/servers", headers=headers_a)
    assert list_srv_resp.status_code == 200
    assert len(list_srv_resp.json()["data"]) >= 1

    # 7. Test Policy Management & Human Approval Workflow
    # Put policy for 'message.send' requiring human approval
    policy_resp = await async_client.put(
        "/api/v1/mcp/policies/message.send",
        headers=headers_a,
        json={
            "is_enabled": True,
            "requires_approval": True,
            "rate_limit_per_minute": 30,
            "allowed_roles": ["owner", "admin"],
        },
    )
    assert policy_resp.status_code == 200
    assert policy_resp.json()["data"]["requires_approval"] is True

    # Create Bot for Tenant A
    test_bot = Bot(
        tenant_id=uuid.UUID(tenant_a_id),
        name="MCP Guarded Bot",
        username=f"guarded_{uuid.uuid4().hex[:6]}",
        status="active",
        default_locale="en",
    )
    db_session.add(test_bot)
    await db_session.commit()

    # Call 'message.send' via MCP -> MUST trigger approval requirement
    call_msg_resp = await async_client.post(
        "/api/v1/mcp/rpc",
        headers=headers_a,
        json={
            "jsonrpc": "2.0",
            "id": 4,
            "method": "tools/call",
            "params": {
                "name": "message.send",
                "arguments": {
                    "bot_id": str(test_bot.id),
                    "chat_id": "123456789",
                    "text": "Hello from MCP Agent!",
                },
            },
        },
    )
    assert call_msg_resp.status_code == 200
    res_text = call_msg_resp.json()["result"]["content"][0]["text"]
    assert "requires human approval" in res_text

    # 8. Check Execution Logs
    logs_resp = await async_client.get("/api/v1/mcp/logs", headers=headers_a)
    assert logs_resp.status_code == 200
    logs = logs_resp.json()["data"]
    pending_log = next((l for l in logs if l["status"] == "approval_pending"), None)
    assert pending_log is not None
    execution_id = pending_log["id"]
    assert pending_log["tool_name"] == "message.send"
    assert pending_log["approval_status"] == "pending"

    # 9. Human Admin Approves the Execution
    approve_resp = await async_client.post(
        f"/api/v1/mcp/executions/{execution_id}/approve",
        headers=headers_a,
    )
    assert approve_resp.status_code == 200
    approved_data = approve_resp.json()["data"]
    assert approved_data["approval_status"] == "approved"
    assert approved_data["status"] == "success"
    assert approved_data["output_result"]["success"] is True

    # 10. Strict Tenant Isolation (Tenant B must NOT access Tenant A's servers or logs)
    user_b_email = f"mcp_user_b_{uuid.uuid4().hex[:6]}@example.com"
    reg_resp_b = await async_client.post(
        "/api/v1/auth/register",
        json={"email": user_b_email, "password": "PasswordB123!", "full_name": "Tenant B User"},
    )
    token_b = reg_resp_b.json()["data"]["access_token"]
    tenant_resp_b = await async_client.post(
        "/api/v1/tenants",
        headers={"Authorization": f"Bearer {token_b}"},
        json={"name": "Tenant B Corp", "slug": f"corp-b-{uuid.uuid4().hex[:6]}"},
    )
    headers_b = {
        "Authorization": f"Bearer {token_b}",
        "X-Tenant-ID": tenant_resp_b.json()["data"]["id"],
    }

    # Tenant B tries to delete Tenant A's server -> 404
    idor_del = await async_client.delete(f"/api/v1/mcp/servers/{server_id}", headers=headers_b)
    assert idor_del.status_code == 404

    # Clean up Tenant A's server
    del_ok = await async_client.delete(f"/api/v1/mcp/servers/{server_id}", headers=headers_a)
    assert del_ok.status_code == 200
