from typing import Annotated, Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status, Request
from sqlalchemy.ext.asyncio import AsyncSession
from apps.api.dependencies import get_current_tenant, get_current_user
from shared.schemas import ApiResponse
from infrastructure.database.session import get_db
from modules.mcp.schemas import (
    JSONRPCRequest,
    RegisterMCPServerRequest,
    MCPServerResponse,
    UpdateToolPolicyRequest,
    ToolPolicyResponse,
    MCPExecutionLogResponse,
    ToolDefinitionResponse,
)
from modules.mcp.service import MCPService
from modules.tenants.models import Tenant, TenantMember
from modules.identity.models import User

router = APIRouter(prefix="/mcp", tags=["MCP Pro — Tool & Protocol Cloud"])


# ------------------------------------------------------------------------------
# STANDARD MCP JSON-RPC 2.0 PROTOCOL ENDPOINT (Claude / Cursor / AI Clients)
# ------------------------------------------------------------------------------

@router.post("/rpc", status_code=status.HTTP_200_OK)
async def handle_mcp_jsonrpc_request(
    payload: dict,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
    request: Request,
):
    """
    Official JSON-RPC 2.0 endpoint for Model Context Protocol (MCP).
    Handles 'initialize', 'tools/list', 'tools/call', and 'ping' methods.
    """
    tenant, member = tenant_context
    caller_identity = f"user_{member.user_id}" if member else "api_key"
    service = MCPService(db)
    response = await service.handle_jsonrpc(
        payload=payload,
        tenant_id=tenant.id,
        caller_identity=caller_identity,
    )
    return response


# ------------------------------------------------------------------------------
# TOOL DISCOVERY & CATALOG
# ------------------------------------------------------------------------------

@router.get("/tools", response_model=ApiResponse[list[ToolDefinitionResponse]], status_code=status.HTTP_200_OK)
async def list_available_tools(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists all available platform and external MCP tools with schemas and approval status."""
    tenant, _ = tenant_context
    service = MCPService(db)
    tools = await service.list_tools(tenant.id)
    return ApiResponse(
        message=f"Retrieved {len(tools)} available MCP tools",
        data=tools,
    )


# ------------------------------------------------------------------------------
# EXTERNAL MCP SERVER CONNECTIONS
# ------------------------------------------------------------------------------

@router.get("/servers", response_model=ApiResponse[list[MCPServerResponse]], status_code=status.HTTP_200_OK)
async def list_mcp_servers(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists external MCP server connections registered by this tenant."""
    tenant, _ = tenant_context
    service = MCPService(db)
    servers = await service.list_servers(tenant.id)
    items = [
        MCPServerResponse(
            id=s.id,
            tenant_id=s.tenant_id,
            name=s.name,
            slug=s.slug,
            transport_type=s.transport_type,
            endpoint_url=s.endpoint_url,
            is_active=s.is_active,
            status=s.status,
            discovered_tools_count=len(s.discovered_tools or []),
            discovered_tools=s.discovered_tools or [],
            last_synced_at=s.last_synced_at,
            created_at=s.created_at,
        )
        for s in servers
    ]
    return ApiResponse(
        message="MCP server connections retrieved",
        data=items,
    )


@router.post("/servers", response_model=ApiResponse[MCPServerResponse], status_code=status.HTTP_201_CREATED)
async def register_mcp_server(
    payload: RegisterMCPServerRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Registers an external MCP server connection and triggers tool discovery."""
    tenant, _ = tenant_context
    service = MCPService(db)
    s = await service.register_server(tenant.id, payload)
    await db.commit()

    resp = MCPServerResponse(
        id=s.id,
        tenant_id=s.tenant_id,
        name=s.name,
        slug=s.slug,
        transport_type=s.transport_type,
        endpoint_url=s.endpoint_url,
        is_active=s.is_active,
        status=s.status,
        discovered_tools_count=len(s.discovered_tools or []),
        discovered_tools=s.discovered_tools or [],
        last_synced_at=s.last_synced_at,
        created_at=s.created_at,
    )
    return ApiResponse(
        message=f"MCP Server '{s.name}' registered successfully",
        data=resp,
    )


@router.post("/servers/{server_id}/sync", response_model=ApiResponse[MCPServerResponse], status_code=status.HTTP_200_OK)
async def sync_mcp_server(
    server_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Triggers tool discovery on the remote MCP server."""
    tenant, _ = tenant_context
    service = MCPService(db)
    s = await service.sync_server_tools(server_id, tenant.id)
    await db.commit()

    resp = MCPServerResponse(
        id=s.id,
        tenant_id=s.tenant_id,
        name=s.name,
        slug=s.slug,
        transport_type=s.transport_type,
        endpoint_url=s.endpoint_url,
        is_active=s.is_active,
        status=s.status,
        discovered_tools_count=len(s.discovered_tools or []),
        discovered_tools=s.discovered_tools or [],
        last_synced_at=s.last_synced_at,
        created_at=s.created_at,
    )
    return ApiResponse(
        message=f"Tools synced from MCP Server '{s.name}'",
        data=resp,
    )


@router.delete("/servers/{server_id}", response_model=ApiResponse[dict[str, bool]], status_code=status.HTTP_200_OK)
async def delete_mcp_server(
    server_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Deletes an external MCP server connection."""
    tenant, _ = tenant_context
    service = MCPService(db)
    await service.delete_server(server_id, tenant.id)
    await db.commit()
    return ApiResponse(
        message="MCP server connection deleted",
        data={"deleted": True},
    )


# ------------------------------------------------------------------------------
# TOOL POLICIES & HUMAN APPROVAL RULES
# ------------------------------------------------------------------------------

@router.get("/policies", response_model=ApiResponse[list[ToolPolicyResponse]], status_code=status.HTTP_200_OK)
async def list_tool_policies(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists tool permission and approval policies for the tenant."""
    tenant, _ = tenant_context
    service = MCPService(db)
    policies = await service.list_policies(tenant.id)
    items = [
        ToolPolicyResponse(
            id=p.id,
            tenant_id=p.tenant_id,
            tool_name=p.tool_name,
            is_enabled=p.is_enabled,
            requires_approval=p.requires_approval,
            rate_limit_per_minute=p.rate_limit_per_minute,
            allowed_roles=p.allowed_roles or [],
            created_at=p.created_at,
            updated_at=p.updated_at,
        )
        for p in policies
    ]
    return ApiResponse(
        message="Tool policies retrieved",
        data=items,
    )


@router.put("/policies/{tool_name}", response_model=ApiResponse[ToolPolicyResponse], status_code=status.HTTP_200_OK)
async def update_tool_policy(
    tool_name: str,
    payload: UpdateToolPolicyRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Configures whether a tool is enabled or requires human approval."""
    tenant, _ = tenant_context
    service = MCPService(db)
    p = await service.update_policy(tenant.id, tool_name, payload)
    await db.commit()

    resp = ToolPolicyResponse(
        id=p.id,
        tenant_id=p.tenant_id,
        tool_name=p.tool_name,
        is_enabled=p.is_enabled,
        requires_approval=p.requires_approval,
        rate_limit_per_minute=p.rate_limit_per_minute,
        allowed_roles=p.allowed_roles or [],
        created_at=p.created_at,
        updated_at=p.updated_at,
    )
    return ApiResponse(
        message=f"Policy updated for tool '{tool_name}'",
        data=resp,
    )


# ------------------------------------------------------------------------------
# AUDIT LOGS & HUMAN APPROVAL WORKFLOW
# ------------------------------------------------------------------------------

@router.get("/logs", response_model=ApiResponse[list[MCPExecutionLogResponse]], status_code=status.HTTP_200_OK)
async def list_mcp_execution_logs(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
    tool_name: Optional[str] = Query(None, description="Filter logs by tool name"),
    limit: int = Query(50, ge=1, le=100),
    offset: int = Query(0, ge=0),
):
    """Audit log of all tool executions performed via MCP."""
    tenant, _ = tenant_context
    service = MCPService(db)
    logs = await service.list_execution_logs(tenant.id, tool_name=tool_name, limit=limit, offset=offset)
    items = [
        MCPExecutionLogResponse(
            id=lg.id,
            tenant_id=lg.tenant_id,
            server_id=lg.server_id,
            tool_name=lg.tool_name,
            caller_type=lg.caller_type,
            caller_identity=lg.caller_identity,
            input_arguments=lg.input_arguments or {},
            output_result=lg.output_result,
            status=lg.status,
            execution_time_ms=lg.execution_time_ms,
            approval_status=lg.approval_status,
            approver_user_id=lg.approver_user_id,
            error_message=lg.error_message,
            created_at=lg.created_at,
        )
        for lg in logs
    ]
    return ApiResponse(
        message="MCP execution logs retrieved",
        data=items,
    )


@router.post("/executions/{execution_id}/approve", response_model=ApiResponse[MCPExecutionLogResponse], status_code=status.HTTP_200_OK)
async def approve_pending_execution(
    execution_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Human-in-the-loop: Approves and triggers execution of a high-risk tool call."""
    tenant, _ = tenant_context
    service = MCPService(db)
    lg = await service.approve_execution(execution_id, tenant.id, current_user.id)
    await db.commit()

    resp = MCPExecutionLogResponse(
        id=lg.id,
        tenant_id=lg.tenant_id,
        server_id=lg.server_id,
        tool_name=lg.tool_name,
        caller_type=lg.caller_type,
        caller_identity=lg.caller_identity,
        input_arguments=lg.input_arguments or {},
        output_result=lg.output_result,
        status=lg.status,
        execution_time_ms=lg.execution_time_ms,
        approval_status=lg.approval_status,
        approver_user_id=lg.approver_user_id,
        error_message=lg.error_message,
        created_at=lg.created_at,
    )
    return ApiResponse(
        message=f"Tool execution for '{lg.tool_name}' approved and executed",
        data=resp,
    )


@router.post("/executions/{execution_id}/reject", response_model=ApiResponse[MCPExecutionLogResponse], status_code=status.HTTP_200_OK)
async def reject_pending_execution(
    execution_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    current_user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Human-in-the-loop: Rejects a dangerous pending tool execution."""
    tenant, _ = tenant_context
    service = MCPService(db)
    lg = await service.reject_execution(execution_id, tenant.id, current_user.id)
    await db.commit()

    resp = MCPExecutionLogResponse(
        id=lg.id,
        tenant_id=lg.tenant_id,
        server_id=lg.server_id,
        tool_name=lg.tool_name,
        caller_type=lg.caller_type,
        caller_identity=lg.caller_identity,
        input_arguments=lg.input_arguments or {},
        output_result=lg.output_result,
        status=lg.status,
        execution_time_ms=lg.execution_time_ms,
        approval_status=lg.approval_status,
        approver_user_id=lg.approver_user_id,
        error_message=lg.error_message,
        created_at=lg.created_at,
    )
    return ApiResponse(
        message=f"Tool execution for '{lg.tool_name}' rejected",
        data=resp,
    )
