main.py

import os
import asyncio
import logging
from fastapi import FastAPI, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse  # Importação corrigida
from motor.motor_asyncio import AsyncIOMotorClient
from openai import AsyncOpenAI, OpenAIError
from dotenv import load_dotenv
from pydantic import BaseModel
from datetime import datetime
from typing import Dict

# Configuração de logs
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Carregar variáveis de ambiente
load_dotenv()

# Criar instância do FastAPI antes de definir rotas
app = FastAPI()

# Servindo arquivos estáticos
app.mount("/static", StaticFiles(directory="static"), name="static")

# Rota para servir o index.html
@app.get("/")
async def serve_index():
    return FileResponse("./static/index.html")

# Configurar API do OpenAI
client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Conectar ao MongoDB
MONGO_URI = os.getenv("MONGO_URI")
DB_NAME = os.getenv("DB_NAME")

mongo_client = AsyncIOMotorClient(MONGO_URI)
db = mongo_client[DB_NAME]

# Definir coleções
collection_messages = db["messages"]
collection_faq = db["perguntas_respostas"]

# Armazena tarefas ativas
active_tasks: Dict[str, asyncio.Task] = {}

# Modelos de dados
class ChatRequest(BaseModel):
    user_id: str
    message: str

class ChatResponse(BaseModel):
    user_id: str
    message: str
    response: str
    timestamp: datetime

# Timeout máximo da IA
TIMEOUT = 10

async def gerar_resposta_chatgpt(user_id: str, mensagem: str):
    """Executa a IA em segundo plano e permite cancelamento imediato."""
    try:
        response = await client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": mensagem}]
        )
        return response.choices[0].message.content
    except OpenAIError as e:
        logger.error(f"Erro na OpenAI: {e}")
        raise HTTPException(status_code=502, detail="Erro ao processar a resposta da IA.")
    except asyncio.CancelledError:
        logger.info(f"Requisição {user_id} cancelada.")
        raise HTTPException(status_code=499, detail="Requisição cancelada pelo usuário.")
    except Exception as e:
        logger.exception(f"Erro inesperado: {e}")
        raise HTTPException(status_code=500, detail="Erro interno.")

# Função para buscar a resposta no MongoDB
async def buscar_resposta_faq(pergunta: str):
    """Consulta a FAQ no MongoDB para encontrar uma resposta registrada."""
    pergunta_lower = pergunta.strip().lower()
    result = await collection_faq.find_one({"pergunta": {"$regex": pergunta_lower, "$options": "i"}})
    if result:
        return result.get("resposta", "Resposta não encontrada.")
    return None

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """Processa a requisição do chatbot e permite cancelamento."""
    if request.user_id in active_tasks:
        raise HTTPException(status_code=400, detail="Já existe uma requisição em andamento para este usuário.")

    # Verificar se a pergunta já está no banco de dados
    resposta_faq = await buscar_resposta_faq(request.message)

    if resposta_faq:
        bot_response = resposta_faq
    else:
        # Criar e armazenar a tarefa assíncrona para a resposta da IA
        task = asyncio.create_task(gerar_resposta_chatgpt(request.user_id, request.message))
        active_tasks[request.user_id] = task

        try:
            bot_response = await asyncio.wait_for(task, timeout=TIMEOUT)
        finally:
            active_tasks.pop(request.user_id, None)  # Remover a tarefa concluída/cancelada

    # Salvar a interação no MongoDB
    chat_record = {
        "user_id": request.user_id,
        "message": request.message,
        "response": bot_response,
        "timestamp": datetime.utcnow()
    }
    await collection_messages.insert_one(chat_record)

    return ChatResponse(**chat_record)