import uuid
from typing import Annotated, Any, Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query, 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.ai.schemas import (
    AIAgentResponse,
    AIUsageSummaryResponse,
    ChatRequest,
    ChatResponse,
    CreateAIAgentRequest,
    CreateTenantAIKeyRequest,
    TenantAIKeyResponse,
    UpdateAIAgentRequest,
)
from modules.ai.service import AIService
from modules.tenants.models import Tenant, TenantMember

router = APIRouter(prefix="/ai", tags=["AI Agents & LLM Integration"])


@router.get("/models", response_model=ApiResponse[list[dict[str, Any]]], status_code=status.HTTP_200_OK)
async def list_models(
    provider: str = Query(default="openai", description="openai or openrouter"),
    db: Annotated[AsyncSession, Depends(get_db)] = None,
):
    """Lists available LLM models and context windows for a provider."""
    service = AIService(db)
    models = service.list_supported_models(provider)
    return ApiResponse(
        message=f"Supported models for '{provider}'",
        data=models,
    )


@router.get("/keys", response_model=ApiResponse[list[TenantAIKeyResponse]], status_code=status.HTTP_200_OK)
async def list_tenant_keys(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists encrypted custom tenant LLM API keys."""
    tenant, _ = tenant_context
    service = AIService(db)
    keys = await service.list_tenant_api_keys(tenant.id)
    return ApiResponse(
        message="Tenant API keys retrieved",
        data=keys,
    )


@router.post("/keys", response_model=ApiResponse[TenantAIKeyResponse], status_code=status.HTTP_201_CREATED)
async def add_tenant_key(
    req: CreateTenantAIKeyRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Saves a tenant API key encrypted with AES-256-GCM."""
    tenant, _ = tenant_context
    service = AIService(db)
    key = await service.add_tenant_api_key(tenant.id, req)
    return ApiResponse(
        message="Tenant API key securely saved",
        data=key,
    )


@router.delete("/keys/{key_id}", response_model=ApiResponse[None], status_code=status.HTTP_200_OK)
async def delete_tenant_key(
    key_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Deletes a custom tenant API key."""
    tenant, _ = tenant_context
    service = AIService(db)
    await service.delete_tenant_api_key(tenant.id, key_id)
    return ApiResponse(
        message="API key deleted successfully",
        data=None,
    )


@router.get("/agents", response_model=ApiResponse[list[AIAgentResponse]], status_code=status.HTTP_200_OK)
async def list_agents(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Lists configured AI agents for the tenant."""
    tenant, _ = tenant_context
    service = AIService(db)
    agents = await service.list_agents(tenant.id)
    return ApiResponse(
        message="AI agents retrieved",
        data=agents,
    )


@router.post("/agents", response_model=ApiResponse[AIAgentResponse], status_code=status.HTTP_201_CREATED)
async def create_agent(
    req: CreateAIAgentRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Creates a new AI assistant agent with custom system prompt."""
    tenant, _ = tenant_context
    service = AIService(db)
    agent = await service.create_agent(tenant.id, req)
    return ApiResponse(
        message="AI agent created successfully",
        data=agent,
    )


@router.get("/agents/{agent_id}", response_model=ApiResponse[AIAgentResponse], status_code=status.HTTP_200_OK)
async def get_agent(
    agent_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Fetches details of an AI agent."""
    tenant, _ = tenant_context
    service = AIService(db)
    agent = await service.get_agent(tenant.id, agent_id)
    return ApiResponse(
        message="AI agent retrieved",
        data=agent,
    )


@router.patch("/agents/{agent_id}", response_model=ApiResponse[AIAgentResponse], status_code=status.HTTP_200_OK)
async def update_agent(
    agent_id: UUID,
    req: UpdateAIAgentRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Updates AI agent prompt or parameters."""
    tenant, _ = tenant_context
    service = AIService(db)
    agent = await service.update_agent(tenant.id, agent_id, req)
    return ApiResponse(
        message="AI agent updated successfully",
        data=agent,
    )


@router.delete("/agents/{agent_id}", response_model=ApiResponse[None], status_code=status.HTTP_200_OK)
async def delete_agent(
    agent_id: UUID,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Deletes an AI agent."""
    tenant, _ = tenant_context
    service = AIService(db)
    await service.delete_agent(tenant.id, agent_id)
    return ApiResponse(
        message="AI agent deleted successfully",
        data=None,
    )


@router.post("/agents/{agent_id}/chat", response_model=ApiResponse[ChatResponse], status_code=status.HTTP_200_OK)
async def chat_with_agent(
    agent_id: UUID,
    req: ChatRequest,
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Executes a multi-turn chat message with an AI agent."""
    tenant, _ = tenant_context
    service = AIService(db)
    result = await service.chat(tenant.id, agent_id, req)
    return ApiResponse(
        message="AI completion generated",
        data=result,
    )


@router.get("/usage", response_model=ApiResponse[AIUsageSummaryResponse], status_code=status.HTTP_200_OK)
async def get_usage_summary(
    tenant_context: Annotated[tuple[Tenant, TenantMember | None], Depends(get_current_tenant)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    """Returns token consumption, estimated costs, and request counts."""
    tenant, _ = tenant_context
    service = AIService(db)
    summary = await service.get_usage_summary(tenant.id)
    return ApiResponse(
        message="AI usage summary retrieved",
        data=summary,
    )
