
import datetime

from typing import Optional, List
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"
        "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": [
                                {
                                    "id": (
                                        "3c4d5e6f-7a8b-9c0d-1e2f-"
                                        "3a4b5c6d7e8f"
                                    ),
                                    "computador_id": (
                                        "1a2bbf80-9a6e-4527-9b7c-"
                                        "13d5b3b3d1f5"
                                    ),
                                    "evento": "janela_ativa",
                                    "nome_usuario": "jdoe",
                                    "processo": "chrome.exe"
                                }
                            ],
                            "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),
    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

    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)"
                )
            )

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


@router.post(
    "/criar",
    summary="Criar atividades",
    description=(
        "Ingestão de atividades via upload de arquivo(s) .zip "
        "contendo logs .txt.\n\n"
        "- Content-Type: multipart/form-data\n"
        "- Campos: computador_id (obrigatório), arquivo (um .zip) OU "
        "arquivos (múltiplos .zip).\n"
        "- Autenticação: token de Empresa ou Front.\n\n"
        "Exemplo cURL (upload único):\n\n"
        "```bash\n"
        "curl -X POST 'https://api.seu-dominio.com/atividades/criar' "
        "\\\n"
        "  -H 'Authorization: Bearer <TOKEN>' \\\n"
        "  -F 'computador_id=1a2bbf80-9a6e-4527-9b7c-13d5b3b3d1f5' "
        "\\\n"
        "  -F 'arquivo=@logs.zip'\n"
        "```\n\n"
        "Upload múltiplo:\n\n"
        "```bash\n"
        "curl -X POST 'https://api.seu-dominio.com/atividades/criar' "
        "\\\n"
        "  -H 'Authorization: Bearer <TOKEN>' \\\n"
        "  -F 'computador_id=1a2bbf80-9a6e-4527-9b7c-13d5b3b3d1f5' "
        "\\\n"
        "  -F 'arquivos=@parte1.zip' \\\n"
        "  -F 'arquivos=@parte2.zip'\n"
        "```\n\n"
        "Usando X-Enterprise-Token:\n\n"
        "```bash\n"
        "curl -X POST 'https://api.seu-dominio.com/atividades/criar' "
        "\\\n"
        "  -H 'X-Enterprise-Token: <TOKEN_EMPRESA>' \\\n"
        "  -F 'computador_id=1a2bbf80-9a6e-4527-9b7c-13d5b3b3d1f5' "
        "\\\n"
        "  -F 'arquivo=@logs.zip'\n"
        "```"
    ),
    status_code=status.HTTP_201_CREATED,
    response_model=SuccessResponse,
    responses={
        201: {"description": "Atividades criadas com sucesso"},
        400: {
            "description": "Erro na requisição",
            "model": ErrorResponse},
        401: {
            "description": "Credenciais inválidas ou ausentes",
            "model": ErrorResponse},
        413: {
            "description": "Lote excede o limite permitido",
            "model": ErrorResponse},
        500: {"description": "Erro interno", "model": ErrorResponse},
    },
    openapi_extra={
        "requestBody": {
            "content": {
                "multipart/form-data": {
                    "schema": {
                        "type": "object",
                        "properties": {
                            "computador_id": {
                                "type": "string",
                                "format": "uuid"
                            },
                            "arquivo": {
                                "type": "string",
                                "format": "binary"
                            },
                            "arquivos": {
                                "type": "array",
                                "items": {
                                    "type": "string",
                                    "format": "binary"
                                }
                            }
                        },
                        "required": ["computador_id"]
                    },
                    "exampless": {
                        "upload_unico": {
                            "summary": "Upload de um .zip",
                            "value": {
                                "computador_id": (
                                    "1a2bbf80-9a6e-4527-9b7c-"
                                    "13d5b3b3d1f5"
                                )
                            }
                        },
                        "upload_multiplo": {
                            "summary": "Upload de múltiplos .zip",
                            "value": {
                                "computador_id": (
                                    "1a2bbf80-9a6e-4527-9b7c-"
                                    "13d5b3b3d1f5"
                                )
                            }
                        }
                    }
                }
            }
        },
        "responses": {
            "201": {
                "content": {
                    "application/json": {
                        "examples": {
                            "message": "Atividades criadas com sucesso",
                            "data": {"inserted": 128},
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            },
            "400": {
                "content": {
                    "application/json": {
                        "examples": {
                            "error": {
                                "code": "VALIDATION_ERROR",
                                "message": "Erro na requisição"
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            },
            "401": {
                "content": {
                    "application/json": {
                        "examples": {
                            "error": {
                                "code": "AUTH_ERROR",
                                "message": (
                                    "Credenciais inválidas ou ausentes"
                                )
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            },
            "413": {
                "content": {
                    "application/json": {
                        "examples": {
                            "error": {
                                "code": "PAYLOAD_TOO_LARGE",
                                "message": (
                                    "Lote excede o limite permitido"
                                )
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            },
            "500": {
                "content": {
                    "application/json": {
                        "examples": {
                            "error": {
                                "code": "INTERNAL_SERVER_ERROR",
                                "message": "Erro interno"
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            }
        }
    }
)
async def criar_atividades(
    request: Request,
    computador_id: str = Form(
        ..., description="ID do computador (form-data)"),
    arquivo: Optional[UploadFile] = File(
        None, description="Arquivo .zip contendo logs"),
    arquivos: Optional[List[UploadFile]] = File(
        None, description="Múltiplos arquivos .zip"),
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
):
    """
    Cria atividades no sistema via upload de arquivos .zip (um ou
    vários) contendo logs em arquivos .txt.
    Aceita apenas 'multipart/form-data'.
    """
    resultado = await AtividadeService.criar_atividades(
        request=request, db=db
    )
    return resultado
