import datetime

from typing import Optional
from src.core.database import get_db
from sqlalchemy.ext.asyncio import AsyncSession
from src.services.atividades import AtividadeService
from src.core.auth import require_enterprise_or_front
from src.core.api_responses import (
    ErrorResponse,
    SuccessResponse,
    build_success_payload
)
from fastapi import (
    Form,
    File,
    Query,
    status,
    Request,
    Depends,
    APIRouter,
    UploadFile,
    HTTPException
)

router = APIRouter(
    prefix="/atividades",
    tags=["Atividades"]
)


@router.get(
    "/buscar",
    summary="Buscar atividades",
    description=(
        "Consulta atividades (logs) com filtros opcionais.\n\n"
        "Parâmetros (query, todos opcionais):\n"
        "- computador_id: filtra por um computador específico.\n"
        "- data_inicio: início do período "
        "(ISO: YYYY-MM-DDTHH:MM:SS).\n"
        "- data_fim: fim do período (ISO: YYYY-MM-DDTHH:MM:SS).\n\n"
        "Paginação recomendada (cursor):\n"
        "- cursor: data/hora ISO do último item da página anterior.\n"
        "- limit: quantidade de itens por página.\n"
        "- A resposta retorna `data.next_cursor` para a próxima requisição.\n\n"
        "Compatibilidade:\n"
        "- skip continua disponível, mas é menos performático em grandes volumes.\n\n"
        "Sem filtros, retorna as atividades disponíveis no escopo do "
        "token.\n\n"
        "Exemplo cURL (com período e computador):\n\n"
        "```bash\n"
        "curl -X GET 'https://api.seu-dominio.com/atividades/buscar?"
        "computador_id=1a2bbf80-9a6e-4527-9b7c-13d5b3b3d1f5&"
        "data_inicio=2025-01-01T00:00:00&"
        "data_fim=2025-01-31T23:59:59' \\\n"
        "  -H 'Authorization: Bearer <TOKEN>'\n"
        "```\n\n"
        "Usando X-Enterprise-Token:\n\n"
        "```bash\n"
        "curl -X GET 'https://api.seu-dominio.com/atividades/buscar?"
        "computador_id=1a2bbf80-9a6e-4527-9b7c-13d5b3b3d1f5&"
        "data_inicio=2025-01-01T00:00:00&"
        "data_fim=2025-01-31T23:59:59' \\\n"
        "  -H 'X-Enterprise-Token: <TOKEN_EMPRESA>'\n"
        "```"
    ),
    response_model=SuccessResponse,
    responses={
        200: {"description": "Atividades encontradas com sucesso"},
        400: {
            "description": "Parâmetros inválidos (ex.: formato de data)",
            "model": ErrorResponse},
        401: {
            "description": "Credenciais inválidas ou ausentes",
            "model": ErrorResponse},
        404: {
            "description": "Nenhuma atividade encontrada",
            "model": ErrorResponse},
        500: {
            "description": "Erro interno do servidor",
            "model": ErrorResponse},
    },
    openapi_extra={
        "responses": {
            "200": {
                "content": {
                    "application/json": {
                        "examples": {
                            "message": "Atividades recuperadas com sucesso.",
                            "data": {
                                "items": [
                                    {
                                        "id": (
                                            "3c4d5e6f-7a8b-9c0d-1e2f-"
                                            "3a4b5c6d7e8f"
                                        ),
                                        "computador_id": (
                                            "1a2bbf80-9a6e-4527-9b7c-"
                                            "13d5b3b3d1f5"
                                        ),
                                        "evento": "janela_ativa",
                                        "nome_usuario": "jdoe",
                                        "processo": "chrome.exe"
                                    }
                                ],
                                "next_cursor": "2025-01-31T23:59:59"
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            },
            "500": {
                "content": {
                    "application/json": {
                        "examples": {
                            "error": {
                                "code": "INTERNAL_SERVER_ERROR",
                                "message": "Erro interno do servidor"
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            }
        }
    }
)
async def buscar_atividades(
    computador_id: Optional[str] = Query(
        None,
        description="Filtrar por ID do computador",
        examples="1a2bbf80-9a6e-4527-9b7c-13d5b3b3d1f5"),
    data_inicio: Optional[str] = Query(
        None,
        description="Data/hora de início do período",
        examples="2025-01-01T00:00:00"),
    data_fim: Optional[str] = Query(
        None,
        description="Data/hora de término do período",
        examples="2025-01-31T23:59:59"),
    limit: int = Query(
        50,
        description="Número máximo de registros a retornar",
        ge=1,
        le=1000),
    cursor: Optional[str] = Query(
        None,
        description=(
            "Cursor de paginação (data/hora ISO) para busca eficiente"
        ),
        examples="2025-01-31T23:59:59"),
    skip: int = Query(
        0,
        description="Número de registros a pular (offset)",
        ge=0),
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
):
    data_inicio_dt = None
    data_fim_dt = None
    cursor_dt = None

    if data_inicio:
        try:
            data_inicio_dt = datetime.datetime.fromisoformat(
                data_inicio.replace(' ', 'T'))
        except (ValueError, AttributeError):
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=(
                    "Formato de data_inicio inválido. Use formato ISO "
                    "(YYYY-MM-DDTHH:MM:SS ou YYYY-MM-DD HH:MM:SS)"
                )
            )

    if data_fim:
        try:
            data_fim_dt = datetime.datetime.fromisoformat(
                data_fim.replace(' ', 'T'))
        except (ValueError, AttributeError):
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=(
                    "Formato de data_fim inválido. Use formato ISO "
                    "(YYYY-MM-DDTHH:MM:SS ou YYYY-MM-DD HH:MM:SS)"
                )
            )

    if cursor:
        try:
            cursor_dt = datetime.datetime.fromisoformat(cursor.replace(' ', 'T'))
        except (ValueError, AttributeError):
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=(
                    "Formato de cursor inválido. Use formato ISO "
                    "(YYYY-MM-DDTHH:MM:SS ou YYYY-MM-DD HH:MM:SS)"
                )
            )

    atividades = await AtividadeService.buscar_atividades(
        db=db,
        computador_id=computador_id,
        data_inicio=data_inicio_dt,
        data_fim=data_fim_dt,
        limit=limit,
        cursor=cursor_dt,
        skip=skip,
    )
    return build_success_payload(
        data=atividades,
        message="Atividades recuperadas com sucesso."
    )