from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Depends, status
from sqlalchemy.ext.asyncio import AsyncSession
from apps.api.dependencies import get_current_tenant
from shared.schemas import ApiResponse
from infrastructure.database.session import get_db
from modules.plugins.schemas import (
    ActivatePluginRequest,
    ExecutePluginHookRequest,
    ExecutePluginHookResponse,
    PluginResponse,
    TenantPluginResponse,
    UpdatePluginConfigRequest,
)
from modules.plugins.service import PluginService
from modules.tenants.models import Tenant, TenantMember

router = APIRouter(prefix="/plugins", tags=["Plugins & Extensibility"])


@router.get("", response_model=ApiResponse[list[PluginResponse]], status_code=status.HTTP_200_OK)
async def list_available_plugins(
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists all plugins registered in the platform catalog."""
    service = PluginService(db)
    plugins = await service.list_available_plugins()
    return ApiResponse(
        message="Available plugins catalog retrieved",
        data=plugins,
    )


@router.get("/installed", response_model=ApiResponse[list[TenantPluginResponse]], status_code=status.HTTP_200_OK)
async def list_tenant_plugins(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists plugins installed and activated for the current tenant."""
    tenant, _ = tenant_context
    service = PluginService(db)
    installed = await service.list_tenant_plugins(tenant.id)
    return ApiResponse(
        message="Installed tenant plugins retrieved",
        data=installed,
    )


@router.post("/activate", response_model=ApiResponse[TenantPluginResponse], status_code=status.HTTP_201_CREATED)
async def activate_plugin(
    req: ActivatePluginRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Installs and activates a plugin with tenant-specific configuration."""
    tenant, _ = tenant_context
    service = PluginService(db)
    activated = await service.activate_plugin(tenant.id, req)
    return ApiResponse(
        message="Plugin activated successfully",
        data=activated,
    )


@router.patch("/{tenant_plugin_id}", response_model=ApiResponse[TenantPluginResponse], status_code=status.HTTP_200_OK)
async def update_tenant_plugin(
    tenant_plugin_id: UUID,
    req: UpdatePluginConfigRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Updates plugin configuration parameters or toggles enabled status."""
    tenant, _ = tenant_context
    service = PluginService(db)
    updated = await service.update_tenant_plugin(tenant.id, tenant_plugin_id, req)
    return ApiResponse(
        message="Plugin configuration updated",
        data=updated,
    )


@router.delete("/{tenant_plugin_id}", response_model=ApiResponse[None], status_code=status.HTTP_200_OK)
async def deactivate_plugin(
    tenant_plugin_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Deactivates and removes an installed plugin."""
    tenant, _ = tenant_context
    service = PluginService(db)
    await service.deactivate_plugin(tenant.id, tenant_plugin_id)
    return ApiResponse(
        message="Plugin deactivated successfully",
        data=None,
    )


@router.post("/{tenant_plugin_id}/execute", response_model=ApiResponse[ExecutePluginHookResponse], status_code=status.HTTP_200_OK)
async def execute_plugin_hook(
    tenant_plugin_id: UUID,
    req: ExecutePluginHookRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Executes a plugin hook in the sandboxed runtime with capability verification."""
    tenant, _ = tenant_context
    service = PluginService(db)
    result = await service.execute_hook(tenant.id, tenant_plugin_id, req)
    return ApiResponse(
        message="Plugin hook executed",
        data=result,
    )
