Update app.py

app.py

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
 import gradio as gr
-import google.generativeai as genai
-from google.api_core import exceptions as google_exceptions
+import requests
 import os
 import json
+import PyPDF2
 import docx
 import io
 import time
@@ -12,534 +11,388 @@ from dotenv import load_dotenv
 from pdfplumber import open as pdfplumber_open
 from PIL import Image
 import pytesseract
-try:
-    import cv2
-    import numpy as np
-    CV2_AVAILABLE = True
-except ImportError:
-    CV2_AVAILABLE = False
-    print("Aviso: OpenCV (cv2) não encontrado.")
+import cv2
+import numpy as np
 from datetime import datetime
 from ratelimiter import RateLimiter
 import difflib
 from html import escape
 import random
 import logging
-import traceback
-import re
+import uuid
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - [%(funcName)s] - %(message)s')
+# Configura o logging para depuração
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 load_dotenv()
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.environ.get("GEMINI_API_KEY")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    raise ValueError("❌ Chave GEMINI_API_KEY não encontrada.")
+    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a no arquivo .env ou como Secret.")
 
-try:
-    genai.configure(api_key=GEMINI_API_KEY)
-    logger.info("Biblioteca google-generativeai configurada.")
-except Exception as e:
-    raise ValueError(f"❌ Erro config google-generativeai: {e}")
+GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
 
-GEMINI_MODEL_NAME = "gemini-1.5-flash-latest"
-CONFIG = {"max_retry_attempts": 3, "retry_delay": 5, "timeout_api": 120, "temperatura": 0.3, "max_tokens": 8192}
-rate_limiter = RateLimiter(max_calls=15, period=60)
-
-SAFETY_SETTINGS = [
-    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-]
+CONFIG = {
+    "max_retry_attempts": 3,
+    "retry_delay": 5,
+    "timeout": 60,
+    "temperatura": 0.2,
+    "max_tokens": 12882
+}
 
-TIPOS_DE_PETICAO = ["Petição Inicial", "Contestação", "Reconvenção", "Impugnação à Contestação", "Embargos de Declaração", "Recurso de Apelação", "Agravo de Instrumento", "Petição de Tutela Provisória"]
+rate_limiter = RateLimiter(max_calls=60, period=60)
 
+# Dicas gerais para petições
 DICAS_OAB_MELHORADO = {
-    "Clareza e Concisão": "Direto, evite jargões.",
-    "Fundamentação Legal": "Cite leis, súmulas, jurisprudência.",
-    "Revisão Ortográfica": "Evite erros de português.",
-    "Endereçamento (Inicial)": "Verifique competência.",
-    "Pedidos (Inicial)": "Certos, determinados, líquidos.",
-    "Preliminares (Contestação)": "Art. 337 CPC antes do mérito.",
-    "Impugnação Específica (Contestação)": "Conteste cada fato (Art. 341)."
+    "Endereçamento": "Em relações de consumo, prefira o foro do domicílio do autor (Art. 101, I, CDC). Exemplo: 'Excelentíssimo Senhor Juiz de Direito da Vara Cível da Comarca de [Cidade do Autor]'.",
+    "Qualificação": "Mencione nome, estado civil (se informado), endereço (use 'Rua XXX' se não fornecido). Dica: Verifique se todos os dados estão corretos.",
+    "Fatos": "Descreva os fatos cronologicamente, sem inventar informações. Exemplo: 'Em [data], o autor celebrou contrato com o réu para [descrição]'.",
+    "Pedidos": "Seja específico nos pedidos (ex.: 'condenação ao pagamento de R$ X'). Inclua danos morais e materiais, se aplicável.",
+    "Custas": "Inclua 'Requer a juntada da guia de custas devidamente recolhida'. Nunca omita para evitar extinção do processo.",
+    "Fundamentação": "Baseie-se em artigos do CPC ou CDC e súmulas do STJ (ex.: Súmula 387 para danos morais).",
+    "Fechamento": "Finalize com 'Nestes termos pede deferimento', sem vírgula. Evite erros de pontuação.",
+    "Estratégia Jurídica": "Utilize precedentes e súmulas para fortalecer a argumentação.",
+    "Provas": "Especifique as provas a produzir. Inclua testemunhas, documentos e perícias, se necessário.",
+    "Contra-argumentação": "Antecipar defesas da parte contrária e preparar respostas."
+}
+
+# Prompts específicos para cada tipo de petição
+PROMPTS_PETICOES = {
+    "Petição Inicial": """
+Você é um corretor de petições iniciais para prática cível no Brasil, com base no CPC. Analise a petição fornecida e corrija-a considerando:
+- **Endereçamento**: Verifique se está correto (ex.: "Excelentíssimo Senhor Juiz de Direito da [Vara] da Comarca de [Cidade]"). Sugira foro do domicílio do autor em relações de consumo (Art. 101, I, CDC).
+- **Qualificação**: Confirme se inclui nome, estado civil, CPF/CNPJ, endereço e representação legal (se aplicável).
+- **Fatos**: Avalie se os fatos estão claros, cronológicos e suficientes para embasar o pedido.
+- **Fundamentação Jurídica**: Verifique se cita artigos do CPC, CC ou CDC e jurisprudência relevante (ex.: Súmula 387/STJ para danos morais).
+- **Pedidos**: Confirme se são específicos (ex.: "condenação ao pagamento de R$ X") e incluem tutela provisória, se cabível.
+- **Provas**: Avalie se especifica documentos, testemunhas ou perícias.
+- **Valor da Causa**: Verifique se está presente e correto (Art. 292, CPC).
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos para maior clareza e conformidade. Retorne o resultado em markdown com seções claras (ex.: ### Endereçamento, ### Qualificação).
+""",
+    "Contestação": """
+Você é um corretor de contestações para prática cível no Brasil, com base no CPC. Analise a contestação fornecida e corrija-a considerando:
+- **Endereçamento**: Igual ao da petição inicial, mas com menção à ação principal (ex.: "Processo nº [número]").
+- **Qualificação**: Confirme se o réu está corretamente qualificado.
+- **Preliminares**: Verifique se aponta ilegitimidade, incompetência ou outras defesas processuais (Art. 337, CPC).
+- **Mérito**: Avalie se refuta os fatos da inicial e apresenta defesa sólida, com base legal (ex.: Arts. CC, CDC).
+- **Reconvenção**: Se presente, confirme se está vinculada à ação principal e bem fundamentada (Art. 343, CPC).
+- **Provas**: Avalie se especifica provas a produzir (ex.: documentos, testemunhas).
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos para maior clareza e conformidade. Retorne o resultado em markdown com seções claras.
+""",
+    "Reconvenção": """
+Você é um corretor de reconvenções para prática cível no Brasil, com base no CPC. Analise a reconvenção fornecida e corrija-a considerando:
+- **Endereçamento**: Igual à contestação, com menção ao processo principal.
+- **Qualificação**: Confirme se as partes estão corretamente qualificadas.
+- **Vinculação**: Verifique se o pedido está relacionado à ação principal (Art. 343, CPC).
+- **Fatos**: Avalie se os fatos são claros e suficientes para embasar o pedido reconvencional.
+- **Fundamentação Jurídica**: Confirme se cita dispositivos legais e jurisprudência.
+- **Pedidos**: Verifique se são específicos e compatíveis com a reconvenção.
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos. Retorne o resultado em markdown com seções claras.
+""",
+    "Impugnação à Contestação": """
+Você é um corretor de impugnações à contestação para prática cível no Brasil, com base no CPC. Analise a impugnação fornecida e corrija-a considerando:
+- **Endereçamento**: Igual ao da ação principal.
+- **Qualificação**: Confirme se as partes estão corretamente mencionadas.
+- **Refutação**: Avalie se contesta ponto a ponto as alegações da contestação, com argumentos claros.
+- **Fundamentação Jurídica**: Verifique se reforça os argumentos da inicial com base legal e jurisprudência.
+- **Provas**: Confirme se reitera ou adiciona provas relevantes.
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos. Retorne o resultado em markdown com seções claras.
+""",
+    "Embargos de Declaração": """
+Você é um corretor de embargos de declaração para prática cível no Brasil, com base no CPC. Analise os embargos fornecidos e corrija-os considerando:
+- **Endereçamento**: Dirigido ao juiz ou tribunal da decisão embargada.
+- **Qualificação**: Confirme se as partes estão corretamente qualificadas.
+- **Objetivo**: Verifique se aponta obscuridade, contradição, omissão ou erro material (Art. 1.022, CPC).
+- **Fundamentação**: Avalie se explica claramente o vício apontado, sem rediscutir o mérito.
+- **Pedidos**: Confirme se solicita esclarecimento ou correção da decisão.
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos. Retorne o resultado em markdown com seções claras.
+""",
+    "Recurso de Apelação": """
+Você é um corretor de recursos de apelação para prática cível no Brasil, com base no CPC. Analise o recurso fornecido e corrija-o considerando:
+- **Endereçamento**: Dirigido ao tribunal competente (ex.: "Tribunal de Justiça do Estado de [Estado]").
+- **Qualificação**: Confirme se as partes estão corretamente qualificadas.
+- **Tempestividade**: Verifique se menciona o prazo de 15 dias (Art. 1.003, CPC).
+- **Razões**: Avalie se aponta erros de fato ou de direito na sentença, com fundamentação legal e jurisprudencial.
+- **Pedidos**: Confirme se solicita reforma ou anulação da sentença.
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos. Retorne o resultado em markdown com seções claras.
+""",
+    "Agravo de Instrumento": """
+Você é um corretor de agravos de instrumento para prática cível no Brasil, com base no CPC. Analise o agravo fornecido e corrija-o considerando:
+- **Endereçamento**: Dirigido ao tribunal competente (ex.: "Tribunal de Justiça do Estado de [Estado]").
+- **Qualificação**: Confirme se as partes estão corretamente qualificadas.
+- **Tempestividade**: Verifique se menciona o prazo de 15 dias (Art. 1.003, CPC).
+- **Decisão Impugnada**: Avalie se identifica claramente a decisão interlocutória (Art. 1.015, CPC).
+- **Risco de Dano**: Confirme se demonstra o risco de dano irreparável ou de difícil reparação.
+- **Fundamentação**: Verifique se aponta erro na decisão com base legal e jurisprudencial.
+- **Pedidos**: Confirme se solicita efeito suspensivo ou reforma da decisão.
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos. Retorne o resultado em markdown com seções claras.
+""",
+    "Petição de Tutela Provisória": """
+Você é um corretor de petições de tutela provisória para prática cível no Brasil, com base no CPC. Analise a petição fornecida e corrija-a considerando:
+- **Endereçamento**: Igual ao da ação principal ou ao juiz competente.
+- **Qualificação**: Confirme se as partes estão corretamente qualificadas.
+- **Tipo de Tutela**: Verifique se especifica tutela de urgência (cautelar/antecipada) ou de evidência (Art. 294, CPC).
+- **Requisitos**: Avalie se demonstra probabilidade do direito e perigo de dano ou risco ao resultado útil do processo (Art. 300, CPC).
+- **Fundamentação Jurídica**: Confirme se cita dispositivos do CPC e jurisprudência.
+- **Pedidos**: Verifique se solicita medida específica (ex.: liminar para suspender ato).
+- **Fechamento**: Deve conter "Nestes termos, pede deferimento" e assinatura.
+Forneça uma análise detalhada com sugestões de melhoria e, se necessário, reescreva trechos. Retorne o resultado em markdown com seções claras.
+"""
 }
 
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-def preprocess_image_for_ocr(img_pil):
-    if not CV2_AVAILABLE:
-        logger.warning("OpenCV indisponível, usando conversão simples.")
-        return img_pil.convert('L')
+def preprocess_image_for_ocr(img):
     try:
-        img_cv = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2GRAY)
-        _, thresh = cv2.threshold(img_cv, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        gray = img.convert('L')
+        np_img = np.array(gray)
+        _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
         return Image.fromarray(thresh)
     except Exception as e:
-        logger.error(f"Erro pré-processamento OpenCV: {e}")
-        return img_pil.convert('L')
+        logger.error(f"Erro no pré-processamento da imagem: {str(e)}")
+        return f"❌ Erro no pré-processamento: {str(e)}"
 
 def extract_text_from_pdf(file_path_or_obj):
-    text = ""; ocr_text_parts = []
     try:
-        logger.info(f"Abrindo PDF: {getattr(file_path_or_obj, 'name', file_path_or_obj)}")
-        with pdfplumber_open(file_path_or_obj) as pdf:
-            logger.info(f"PDF com {len(pdf.pages)} páginas.")
-            for i, page in enumerate(pdf.pages):
-                page_text = page.extract_text(x_tolerance=2, y_tolerance=2)
-                if page_text and len(page_text.strip()) > 20: text += page_text + "\n"
-                else:
-                    logger.warning(f"Pág {i+1} sem texto, tentando OCR.")
-                    try:
-                        img = page.to_image(resolution=200)
-                        preprocessed_img = preprocess_image_for_ocr(img.original)
-                        page_ocr = pytesseract.image_to_string(preprocessed_img, lang='por', config='--psm 6')
-                        if page_ocr and page_ocr.strip(): ocr_text_parts.append(page_ocr)
-                        else: logger.warning(f"OCR vazio pág {i+1}."); ocr_text_parts.append(f"[OCR P{i+1}: Vazio]")
-                    except Exception as e: logger.error(f"Erro OCR pág {i+1}: {e}"); ocr_text_parts.append(f"[Erro OCR P{i+1}: {e}]")
-        ocr_text = "\n".join(ocr_text_parts)
-        len_text, len_ocr = len(text.strip()), len(ocr_text.strip())
-        if len_text > len_ocr * 0.7: logger.info(f"Usando texto PDF ({len_text} chars)."); return text
-        elif len_ocr > 0: logger.info(f"Usando OCR PDF ({len_ocr} chars)."); return ocr_text
-        elif len_text > 0: logger.info("Usando texto curto PDF."); return text
-        else: logger.warning("PDF sem texto."); return "⚠️ PDF sem texto (extração/OCR falharam)."
-    except Exception as e: logger.error(f"Erro PDF: {e}", exc_info=True); return f"❌ Erro PDF: {e}"
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                text = ""
+                with pdfplumber_open(f) as pdf:
+                    for page in pdf.pages:
+                        text += (page.extract_text() or "") + "\n"
+                if not text.strip():
+                    images = pdfplumber_open(f).pages
+                    for i, image in enumerate(images):
+                        try:
+                            img = image.to_image()
+                            preprocessed_img = preprocess_image_for_ocr(img)
+                            text += pytesseract.image_to_string(preprocessed_img) + "\n"
+                        except Exception as e:
+                            text += f"[Erro na página {i+1}: {str(e)}]\n"
+        else:
+            text = ""
+            with pdfplumber_open(file_path_or_obj) as pdf:
+                for page in pdf.pages:
+                    text += (page.extract_text() or "") + "\n"
+                if not text.strip():
+                    images = pdfplumber_open(file_path_or_obj).pages
+                    for i, image in enumerate(images):
+                        try:
+                            img = image.to_image()
+                            preprocessed_img = preprocess_image_for_ocr(img)
+                            text += pytesseract.image_to_string(preprocessed_img) + "\n"
+                        except Exception as e:
+                            text += f"[Erro na página {i+1}: {str(e)}]\n"
+        return text if text.strip() else "⚠️ Não foi possível extrair texto do PDF."
+    except Exception as e:
+        logger.error(f"Erro ao processar o PDF: {str(e)}")
+        return f"❌ Erro ao processar o PDF: {str(e)}"
 
 def extract_text_from_docx(file_path_or_obj):
     try:
-        doc = docx.Document(file_path_or_obj)
-        text = "\n".join([p.text for p in doc.paragraphs if p.text])
-        return text if text.strip() else "⚠️ DOCX vazio."
-    except Exception as e: logger.error(f"Erro DOCX: {e}", exc_info=True); return f"❌ Erro DOCX: {e}"
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                doc = docx.Document(f)
+                text = ""
+                for para in doc.paragraphs:
+                    text += para.text + "\n"
+                for table in doc.tables:
+                    for row in table.rows:
+                        for cell in row.cells:
+                            text += cell.text + " "
+                    text += "\n"
+        else:
+            doc = docx.Document(file_path_or_obj)
+            text = ""
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+            for table in doc.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text += cell.text + " "
+                text += "\n"
+        return text if text.strip() else "⚠️ Não foi possível extrair texto do DOCX."
+    except Exception as e:
+        logger.error(f"Erro ao processar o DOCX: {str(e)}")
+        return f"❌ Erro ao processar o DOCX: {str(e)}"
 
 def extract_text_from_txt(file_path_or_obj):
     try:
-        content = b''; encodings = ['utf-8', 'latin-1', 'cp1252']
         if isinstance(file_path_or_obj, str):
-            with open(file_path_or_obj, 'rb') as f: content = f.read()
-        elif hasattr(file_path_or_obj, 'read'):
-            if hasattr(file_path_or_obj, 'seek') and callable(file_path_or_obj.seek):
-                try: file_path_or_obj.seek(0)
-                except Exception as seek_e: logger.warning(f"Não foi possível resetar ponteiro TXT: {seek_e}")
+            with open(file_path_or_obj, 'rb') as f:
+                content = f.read()
+                encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+                for encoding in encodings:
+                    try:
+                        return content.decode(encoding)
+                    except UnicodeDecodeError:
+                        continue
+                return "❌ Não foi possível decodificar o arquivo TXT."
+        else:
             content = file_path_or_obj.read()
-        else: return "❌ Input TXT inválido."
-        for enc in encodings:
-            try:
-                decoded = content.decode(enc)
-                logger.info(f"TXT decodificado: {enc}.")
-                return decoded if decoded.strip() else "⚠️ TXT vazio."
-            except UnicodeDecodeError: continue
-        return "❌ Não foi possível decodificar TXT."
-    except Exception as e: logger.error(f"Erro TXT: {e}", exc_info=True); return f"❌ Erro TXT: {e}"
+            encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+            for encoding in encodings:
+                try:
+                    return content.decode(encoding)
+                except UnicodeDecodeError:
+                    continue
+            return "❌ Não foi possível decodificar o arquivo TXT."
+    except Exception as e:
+        logger.error(f"Erro ao processar o TXT: {str(e)}")
+        return f"❌ Erro ao processar o TXT: {str(e)}"
 
 def process_file(file_obj):
-    if file_obj is None: return "⚠️ Nenhum arquivo."
+    if file_obj is None:
+        return "Nenhum arquivo enviado."
     try:
-        fpath = getattr(file_obj, 'name', None);
-        if not fpath: return "❌ Erro: Não identificou arquivo."
-        fname = os.path.basename(fpath).lower(); logger.info(f"Processando: {fname}")
-        try:
-             fsize = os.path.getsize(fpath); logger.info(f"Tamanho: {fsize} bytes")
-             if fsize > 15*1024*1024: return "⚠️ Arquivo grande (Máx 15MB)."
-        except OSError as e: logger.warning(f"Erro tamanho arquivo: {e}")
-        if fname.endswith('.pdf'): return extract_text_from_pdf(fpath)
-        elif fname.endswith('.docx'): return extract_text_from_docx(fpath)
-        elif fname.endswith('.txt'): return extract_text_from_txt(fpath)
-        else: return "⚠️ Formato não suportado (PDF, DOCX, TXT)."
-    except Exception as e: logger.error(f"Erro process_file: {e}", exc_info=True); return f"❌ Erro processar arquivo: {e}"
-
-def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
-    base = """
-    **Estrutura:** 1.Análise Geral. 2.Nota Final(0-10). 3.Pontos Positivos. 4.Pontos a Melhorar(Desc, Fund., Impacto, Sug.). 5.Análise Requisitos.
-    **Critérios:** Coerência, Fundamentação, Linguagem, Pedidos. NÃO INVENTAR FATOS(-3a-5). NÃO SE IDENTIFICAR(Nota ZERO)."""
-    if modo_treinamento: base += "\n**Treinamento:** Detalhar Pontos a Melhorar(a-e). Destacar inconsistências. Sugerir estratégias."
-    return base
-
-def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
-    instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
-    prompt = f"## Análise: {tipo_peticao}\n**Caso:**\n```\n{caso}\n```\n**Peça Aluno:**\n```\n{peticao}\n```\n{instrucoes_gerais}\n**Requisitos({tipo_peticao}):**\n"
-    if tipo_peticao == "Petição Inicial": prompt += "-End. Comp(319,I;CDC101,I).\n-Qualif(319,II).\n-Fatos.\n-Fundam(319,III).\n-Pedidos(319,IV).\n-Vlr Causa(291-2,319,V).\n-Provas(319,VI).\n-Aud(319,VII).\n-Citação.\n-Docs essenc.\n-Fecho.\n**Adic:**'XXX'.Falta custas/JG(-1).Vírgula pede defer.(-0.2)."
-    elif tipo_peticao == "Contestação": prompt += "-End. Qualif réu. Proc nº. Temp.\n-Prelim(337):TODAS.\n-Impug.Esp Fatos(341):PONTOxPONTO.\n-Mérito:Versão réu;defesa dir/indir.\n-Fundam defesa.\n-Pedidos:Acolher prelim;IMPROC TOTAL;Sucumb(85).\n-Provas.\n**Adic:**Prelim preclui?Falha impug(-2a-4).Sem ped improc(-1.5)."
-    elif tipo_peticao == "Reconvenção": prompt += "-NA MESMA PEÇA(343).End. Proc nº.Qualif.\n-Conexão(343).\n-Estrut PI:Fatos,Fund,Ped,Vlr,Provas(reconv).\n-Ped intim(343§1).\n**Adic:**S/conex(-2).Falta ped/vlr/prov(-1/item).Peça separada(-3)."
-    elif tipo_peticao == "Impugnação à Contestação": prompt += "-End.Proc nº.Autor.Temp(15d-350/1).\n-Resp Prelim.\n-Resp Fatos Novos(350).\n-Resp Docs(437).\n-Ratific Inicial.\n-Espec Provas.\n-Peds:Rej prelim;refutar def;proced inicial.\n**Adic:**Ñ resp prelim(-1.5).Ñ manif fato novo(-2).Ñ ratificar(-0.5)."
-    elif tipo_peticao == "Embargos de Declaração": prompt += "-Contra Decisão Espec.End juiz prolator.Proc nº.Partes.Temp(5d-1023).\n-Cabim(1022):Apontar PRECISAMENTE:Omissão/Contrad/Obscur/ErroMat.\n-NÃO REJULGAR.\n-Ped:Conhec e ACOLHER p/ sanar vício.\n**Adic:**Rediscutir mérito(-4).Ñ apontar vício(-3)."
-    elif tipo_peticao == "Recurso de Apelação": prompt += "-Interpos:Juízo a quo.Proc nº.Partes.Pressup(cabim 1009;temp 15d;prep/JG).Ped receb/remessa.\n-Razões:TRIBUNAL.Relato.Fundam Reforma/Anul(1010):Error in proc/judic.DIALETICIDADE.\n-Peds:Conhec;PROVIM(anul/ref);Inv sucumb.\n**Adic:**Falta peça(-10).End razões(-1).S/dialetic(-3a-5)."
-    elif tipo_peticao == "Agravo de Instrumento": prompt += "-Peça única TRIBUNAL.Proc origem.Partes+Advs(end 1016).Cópia Decisão(1017,I).\n-Cabim(1015/mitig).Temp(15d).Prep/JG.\n-Peças Obrig(1017,I):Dec,Intim,Proc.Facult(III).\n-Razões(1016):Motivos ref/inval.\n-Efeito Susp/Tut Antecip Rec(1019,I)(se risco).\n-Peds Finais:Conhec;Efeito/Tut;PROVIM;Comunic juiz.\n**Adic:**Falta peça obrig(-4).S/cabim(-3)."
-    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "-Tipo(Urg/Evid).Caráter(Antec/Incid).End.Qualif.Proc(se incid).\n-Urg(300):Fumus Boni Iuris E Periculum in Mora.Reversib(300§3).\n-Evid(311):Hipótese I-IV.NÃO precisa periculum.\n-Ped Específico:Medida liminar CLARA.\n-Se Antec(303/5):Indicar ped final ou aditar.Vlr Causa.\n-Peds:Concessão tutela;cit/intim;indic ação/adit.\n**Adic:**S/Fumus/Peric(-3a-5).Erro Evid(-3).Ped genérico(-2)."
-    else: prompt += "-Adequação? Clareza? Fundam? Pedido?"
-    prompt += "\n\n**Instruções Finais:** Analise estritamente. Rigoroso e construtivo. Gere **exclusivamente** no formato solicitado."
-    return prompt
-
-def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
-    prompt = f"**Caso:**\n```\n{caso}\n```\n**Peça Original ({tipo_peticao}):**\n```\n{peticao_original}\n```\n**Tarefa:** Gere versão corrigida ({tipo_peticao}), seguindo práticas OAB.\n**Instruções ({tipo_peticao}):**\n"
-    if tipo_peticao == "Petição Inicial": prompt += "1.End. 2.Qualif(319,II,'XXX'). 3.Fatos. 4.Fundam. 5.Pedidos(quantif). 6.Vlr Causa(292). 7.Provas. 8.Aud(319,VII). 9.Citação(246,I). 10.Custas/JG(NÃO OMITIR). 11.Fecho('Nestes termos...')."
-    elif tipo_peticao == "Contestação": prompt += "1.End. 2.ID(proc nº,réu). 3.Temp. 4.Estrut:Síntese;Prelim(337);Mérito(Impug+Defesa);Reconv(se antes peds cont). 5.Peds Cont:Acolher prelim;IMPROC TOTAL;Sucumb. 6.Provas réu. 7.Fecho."
-    elif tipo_peticao == "Reconvenção": prompt += "*Parte da Contest.* 1.Após mérito cont, antes peds: 'DA RECONVENÇÃO'. 2.Qualif Recvte/Recvdo. 3.Conexão. 4.Fatos/Dir Recv. 5.Peds Recv. 6.Vlr Causa/Provas Recv. 7.Intim Recvdo. 8.Peds Cont. 9.Fecho."
-    elif tipo_peticao == "Impugnação à Contestação": prompt += "1.End,proc,autor,temp. 2.Tópico PRELIM - Rebater. 3.Tópico MÉRITO/FATOS NOVOS - Manifestar. 4.Tópico RATIFICAÇÃO. 5.Tópico PROVAS. 6.Peds:Rej prelim, refutar def, proced inicial. 7.Fecho."
-    elif tipo_peticao == "Embargos de Declaração": prompt += "1.End juiz prolator.Proc,Partes.Decisão ID.Temp(5d). 2.Tópico p/ vício(1022):OMISSÃO/CONTRAD/OBSCUR/ERRO MAT. 3.Dentro:Trecho + Explicar vício. Ñ REJULGAR. 4.Ped:Conhec e ACOLHER p/ sanar. 5.Fecho."
-    elif tipo_peticao == "Recurso de Apelação": prompt += "1.Interpos:Juízo a quo.Proc,Partes.Pressup(cab,temp,prep/JG).Ped receb/remessa. 2.Razões:Tribunal.Relato.FUND REFORMA/ANUL(Error in proc/judic).DIALETICIDADE. 3.Peds:Conhec;PROVIM(anul/ref);Inv sucumb. 4.Fecho."
-    elif tipo_peticao == "Agravo de Instrumento": prompt += "1.Peça única Trib.Proc origem,Partes,Advs(ends).Decisão ID(cópia). 2.CABIM(1015/mitig).TEMP.PREP/JG.PEÇAS OBRIG/FACULT. 3.RAZÕES:Motivos ref/inval. 4.EFEITO SUSP/TUT ANTEC(se cabível). 5.PEDS:Conhec;Efeito/Tut;PROVIM;Comunic juiz. 6.Fecho."
-    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "1.TIPO(Urg/Evid) e CARÁTER(Antec/Incid).End.Qualif.Proc(se incid). 2.REQUISITOS:Urg=Fumus+Peric(+Reversib).Evid=Hipót 311. 3.PED LIMINAR:Medida CLARA. 4.Se Antec:Indic ped final/aditar.Vlr Causa. 5.PEDS:Concessão tutela;cit/intim;indic ação/adit. 6.Fecho."
-    else: prompt += "1.Estrutura. 2.Args Claros. 3.Ped Claro. 4.Formais OAB."
-    prompt += "\n\n**Instrução Final:** Gere **APENAS** texto da peça corrigida (endereçamento até 'OAB/...'). Sem comentários."
-    return prompt
-
-def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
-    if "Nestes termos, pede deferimento" in peticao_corrigida:
-        peticao_corrigida = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
-    if tipo_peticao == "Petição Inicial":
-        p_lower = peticao_corrigida.lower()
-        if "juntada da guia de custas" not in p_lower and "gratuidade de justiça" not in p_lower:
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes)==2: peticao_corrigida = partes[0].strip()+"\nRequer, ainda, a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento"+partes[1]
-             else: peticao_corrigida = peticao_corrigida.replace("Local, data.","Requer, ainda, a juntada da guia de custas devidamente recolhida.\n\nLocal, data.")
-        if "audiência de conciliação" not in p_lower and "audiência de mediação" not in p_lower:
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes)==2: peticao_corrigida = partes[0].strip()+"\nOpta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\nNestes termos pede deferimento"+partes[1]
-             else: peticao_corrigida = peticao_corrigida.replace("Local, data.","Opta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\n\nLocal, data.")
-    linhas = [l.strip() for l in peticao_corrigida.strip().split('\n') if l.strip()]
-    fechamento = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
-    while linhas and any(t in linhas[-1] for t in ["ADVOGADO","OAB","Local","data"]): linhas.pop()
-    linhas.extend(fechamento)
-    return "\n".join(linhas)
-
-def chamar_api(prompt):
-    logger.info(f"Chamando API Gemini (Modelo: {GEMINI_MODEL_NAME})...")
-    model = genai.GenerativeModel(GEMINI_MODEL_NAME, safety_settings=SAFETY_SETTINGS)
-    gen_config = genai.types.GenerationConfig(temperature=CONFIG["temperatura"], max_output_tokens=CONFIG["max_tokens"], top_p=0.95)
-    for tentativa in range(CONFIG["max_retry_attempts"]):
-        try:
-            with rate_limiter:
-                logger.debug(f"API Tentativa {tentativa + 1}")
-                response = model.generate_content(contents=prompt, generation_config=gen_config)
-            if response.prompt_feedback.block_reason:
-                logger.error(f"Prompt bloqueado: {response.prompt_feedback.block_reason}")
-                return f"❌ Prompt bloqueado: {response.prompt_feedback.block_reason}. Reformule."
-            if not response.text:
-                 if response.candidates and response.candidates[0].finish_reason != genai.types.FinishReason.STOP:
-                      finish_reason = response.candidates[0].finish_reason.name
-                      logger.error(f"Geração interrompida (s/ texto): {finish_reason}")
-                      safety = response.candidates[0].safety_ratings
-                      harms = [r.category.name for r in safety if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
-                      if harms: return f"❌ Bloqueado segurança: {finish_reason} ({','.join(harms)})."
-                      else: return f"❌ Geração interrompida: {finish_reason}."
-                 else: logger.warning("API retornou s/ texto ou bloqueio."); return "⚠️ API retornou resposta vazia."
-            logger.info(f"API OK ({len(response.text)} chars).")
-            return response.text
-        except google_exceptions.ResourceExhausted as e:
-            logger.warning(f"Erro 429 - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: wait = CONFIG['retry_delay']*(2**tentativa); logger.info(f"Aguardando {wait}s..."); time.sleep(wait); continue
-            return "❌ Erro 429: Muitas requisições."
-        except google_exceptions.PermissionDenied as e: logger.error(f"Erro Permissão API: {e}"); return f"❌ Erro Permissão: Verifique API Key/acesso modelo '{GEMINI_MODEL_NAME}'."
-        except google_exceptions.InvalidArgument as e: logger.error(f"Erro Argumento API: {e}"); return f"❌ Erro parâmetros API: {e}"
-        except genai.types.BlockedPromptException as e: logger.error(f"Prompt bloqueado (exc): {e}"); return f"❌ Prompt bloqueado. Reformule."
-        except genai.types.StopCandidateException as e: logger.error(f"Geração interrompida (exc): {e}"); return f"❌ Geração interrompida (segurança/outro)."
-        except google_exceptions.GoogleAPIError as e:
-            logger.error(f"Erro API Google - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay']*(tentativa + 1)); continue
-            return f"❌ Erro API Google: {e}"
-        except Exception as e:
-            logger.exception(f"Erro inesperado API - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay']*(tentativa + 1)); continue
-            return f"❌ Erro inesperado API: {e}"
-    logger.error("Falha API após todas as tentativas.")
-    return "❌ Falha API após múltiplas tentativas."
-
-def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
-    logger.info(f"Correção: Tipo={tipo_peticao}, Treinamento={modo_treinamento}")
-    start = time.time()
-    analise_fmt, pet_corr, res_diff, crit_diff, html_diff = "", "", "", "", ""
-    pet_cont = ""
-    try:
-        if not caso or not caso.strip(): return "⚠️ Forneça caso.", "", "", "", ""
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo.", "", "", "", ""
-        if peticao_arquivo: pet_cont = process_file(peticao_arquivo)
-        elif peticao_texto: pet_cont = peticao_texto
-        else: return "⚠️ Forneça petição.", "", "", "", ""
-        if pet_cont.startswith(("❌", "⚠️")): return pet_cont, "", "", "", ""
-        logger.info(f"Petição recebida ({len(pet_cont)} chars).")
-        troll = ["escreva a petição", "faça a petição", "gere a petição"]
-        if any(t in pet_cont.lower() for t in troll): return random.choice(["Hummm 😉","🚫 Corrijo, não crio."]), "", "", "", ""
-        cache_key = f"{tipo_peticao}|{caso[:100]}|{pet_cont[:100]}|{modo_treinamento}"
-        if cache_key in CORRECAO_CACHE:
-            logger.info("Cache hit.")
-            cached = CORRECAO_CACHE[cache_key]
-            return cached["analise_formatada"], cached["peticao_corrigida"], cached["resumo_diff"], cached["criticas_diff"], cached["diff_html"]
-        prompt_analise = estruturar_prompt_analise(caso, pet_cont, tipo_peticao, modo_treinamento)
-        analise_bruta = chamar_api(prompt_analise)
-        if analise_bruta.startswith(("❌", "⏱️", "⚠️")): return analise_bruta, "", "", "", ""
-        analise_fmt = formatar_correcao(analise_bruta)
-        prompt_peticao = estruturar_prompt_peticao_corrigida(caso, pet_cont, tipo_peticao)
-        pet_corr_bruta = chamar_api(prompt_peticao)
-        if pet_corr_bruta.startswith(("❌", "⏱️", "⚠️")): pet_corr = f"⚠️ Falha gerar corrigida:\n{pet_corr_bruta}"
+        if hasattr(file_obj, 'name'):
+            file_path = file_obj.name
+            filename = os.path.basename(file_path).lower()
+            file_size = os.path.getsize(file_path)
+            if file_size > 10 * 1024 * 1024:
+                return "⚠️ O arquivo é muito grande. Máx. 10 MB."
+            if filename.endswith('.pdf'):
+                return extract_text_from_pdf(file_path)
+            elif filename.endswith('.docx'):
+                return extract_text_from_docx(file_path)
+            elif filename.endswith('.txt'):
+                return extract_text_from_txt(file_path)
+            else:
+                return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
         else:
-            markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
-            start_index = -1
-            p_lower = pet_corr_bruta.lower()
-            # CORRIGIDO: Bloco for com indentação correta
-            for m in markers:
-                idx = p_lower.find(m)
-                if idx != -1:
-                    start_index = idx
-                    break
-            pet_extr = pet_corr_bruta[start_index:] if start_index != -1 else pet_corr_bruta
-            pet_corr = pos_corrigir_peticao(pet_extr, tipo_peticao)
-        html_diff, res_diff, crit_diff = calcular_diff_interno(pet_cont, pet_corr)
-        res_cache = {"analise_formatada":analise_fmt,"peticao_corrigida":pet_corr,"resumo_diff":res_diff,"criticas_diff":crit_diff,"diff_html":html_diff}
-        CORRECAO_CACHE[cache_key] = res_cache
-        HISTORICO.append({"data":datetime.now().strftime("%Y%m%d_%H%M%S"),"tipo_peticao":tipo_peticao,"caso":caso,"peticao_original":pet_cont,**res_cache})
-        if len(HISTORICO) > 10: HISTORICO.pop(0)
-        logger.info(f"Correção concluída em {time.time() - start:.2f}s.")
-        return analise_fmt, pet_corr, res_diff, crit_diff, html_diff
-    except Exception as e: logger.exception("Erro GERAL corrigir_peticao:"); return f"❌ Erro correção: {e}", "", "", "", ""
-
-def formatar_correcao(texto):
-    texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
-    texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
-    texto = texto.replace("### Pontos Positivos", "## ✅ Pontos Positivos")
-    texto = texto.replace("### Pontos a Melhorar", "## ⚠️ Pontos a Melhorar")
-    texto = texto.replace("### Análise Específica dos Requisitos", "## 🔎 Análise Específica")
-    linhas = texto.split('\n'); linhas_fmt = []
-    in_list = False
-    for l in linhas:
-        ls = l.strip()
-        if ls.startswith(("1.","2.","3.","4.","5.")): linhas_fmt.append(f"\n**{ls}**"); in_list = False
-        elif ls.startswith(("- ","* ")): prefix = "  * " if in_list else "* "; linhas_fmt.append(prefix + ls[2:]); in_list = True
-        elif ls.startswith(("a)","b)","c)","d)","e)")): linhas_fmt.append(f"    * {ls}"); in_list = True
-        else: linhas_fmt.append(l); in_list = False if not ls.startswith(("*","- ","a)","b)","c)","d)","e)"," ")) else in_list
-    txt_final = "\n".join(linhas_fmt)
-    m = re.search(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", txt_final, re.I)
-    if m: nota = m.group(2).replace(",","."); txt_final = re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", f"\\1**{nota}/10**", txt_final, count=1, flags=re.I)
-    return txt_final
-
-def fornecer_dica_contextual(texto_peticao, tipo_peticao):
-    if not texto_peticao or not texto_peticao.strip(): return "*Digite para dicas...*"
-    dicas = []; txt_l = texto_peticao.lower()
-    for k in ["Clareza e Concisão", "Fundamentação Legal", "Revisão Ortográfica"]:
-        if k in DICAS_OAB_MELHORADO: dicas.append(f"💡 **{k}:** {DICAS_OAB_MELHORADO[k]}")
-    kw = { "Petição Inicial": ["endereçamento","qualificação","fatos","pedidos","valor","provas","audiência","custas"],
-           "Contestação": ["preliminar","mérito","impugnação","art. 337"], "Embargos de Declaração": ["omissão","contradição","art. 1022"],
-           "Recurso de Apelação": ["sentença","reforma","dialeticidade","art. 1009"], "Agravo de Instrumento": ["interlocutória","cabimento","art. 1015"],
-           "Petição de Tutela Provisória": ["urgência","evidência","periculum","fumus","art. 300"]}
-    if tipo_peticao in kw:
-         for k, v in DICAS_OAB_MELHORADO.items():
-              cl = k.lower()
-              if f"({tipo_peticao.split()[0].lower()})" in cl or any(w in cl for w in kw[tipo_peticao] if w in txt_l):
-                    fmt = f"💡 **{k}:** {v}"
-                    if fmt not in dicas: dicas.append(fmt)
-    if not dicas: return "*Continue para dicas...*"
-    return "\n\n".join(dicas[:4])
-
-def calcular_diff_interno(texto_original, texto_corrigido):
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")): return "","",""
-    orig = texto_original.splitlines(); corr = texto_corrigido.splitlines()
-    diff = difflib.ndiff(orig, corr)
-    html, crit, rem, add = [], [], 0, 0
-    kw_r = ["invenção","identificação","erro","incorreto","prazo"]
-    kw_a = ["custas","art. 319","art. 337","art. 1022","art. 1015","art. 300","fumus","periculum","essencial","preliminar","tempestividade","cabimento"]
-    for l in diff:
-        txt = l[2:]; txt_esc = escape(txt)
-        if l.startswith('  '): html.append(f"<div class='linha-igual'>{txt_esc}</div>")
-        elif l.startswith('- '):
-            rem += 1; html.append(f"<div class='linha-removida'><del>{txt_esc}</del></div>")
-            if txt.strip() and any(kw in txt.lower() for kw in kw_r): crit.append(f"<span style='color:red'>🔴 REM:</span> {txt_esc}")
-        elif l.startswith('+ '):
-            add += 1; html.append(f"<div class='linha-adicionada'><ins>{txt_esc}</ins></div>")
-            if txt.strip() and any(kw in txt.lower() for kw in kw_a): crit.append(f"<span style='color:green'>🟢 ADD:</span> {txt_esc}")
-    resumo = f"**Resumo:** Rem={rem}, Add={add}, Saldo={add-rem}"
-    crit_txt = "### 🚨 Críticas:\n"+"\n".join(crit) if crit else "*Nenhuma crítica.*"
-    css = "<style>.diff-container{font-family:monospace;white-space:pre-wrap;border:1px solid #ccc;padding:10px;background-color:#f9f9f9;max-height:600px;overflow-y:auto}.linha-igual{color:#555}.linha-removida{background-color:#ffebee;color:#c62828}.linha-adicionada{background-color:#e8f5e9;color:#2e7d32}.linha-removida del,.linha-adicionada ins{text-decoration:none;padding:0 2px;border-radius:2px}.linha-removida del{background-color:#ffcdd2}.linha-adicionada ins{background-color:#c8e6c9}</style>"
-    html_diff = f"{css}<div class='diff-container'>{''.join(html)}</div>"
-    return html_diff, resumo, crit_txt
-
-def calcular_progresso():
-    if not HISTORICO: return "📊 Nenhum progresso."
-    notas, tipos = [], set()
-    for entry in HISTORICO:
-        tipos.add(entry["tipo_peticao"])
-        m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
-        if m:
-            try: notas.append(float(m.group(1).replace(",", ".")))
-            except ValueError: pass
-    tot = len(HISTORICO); media = sum(notas)/len(notas) if notas else 0; tend = ""
-    if len(notas) > 1: tend = "⬆️" if notas[-1] > notas[-2] else ("⬇️" if notas[-1] < notas[-2] else "↔️")
-    return f"**📊 Resumo:** Corrs:{tot}, Tipos:{len(tipos)}, Média:{media:.1f}/10 ({len(notas)} val), Tend:{tend if tend else 'N/A'}"
-
-def mostrar_historico():
-    if not HISTORICO: return "📜 Histórico vazio."
-    md = "### 📜 Histórico (Últimas 10)\n---\n"
-    for i, entry in enumerate(reversed(HISTORICO)):
-        caso = (entry['caso'][:70] + '...') if len(entry['caso']) > 70 else entry['caso']
-        nota = "N/A"; m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
-        if m: nota = f"{m.group(1).replace(',', '.')}/10"
-        md += f"**{len(HISTORICO)-i}.** {entry['data']} | **{entry['tipo_peticao']}** | **Nota:{nota}**\n   **Caso:** _{caso}_\n---\n"
-    return md
-
-def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info("Salvando progresso...")
-    try:
-        if not caso or not peticao or not tipo_peticao: return "", "⚠️ Inputs necessários.", None
-        dados = {"tipo_peticao":tipo_peticao,"caso":caso,"peticao":peticao,"timestamp":datetime.now().isoformat()}
-        json_cont = json.dumps(dados, ensure_ascii=False, indent=4)
-        fname = f"progresso_peticao_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        fpath = os.path.join(tempfile.gettempdir(), fname)
-        with open(fpath, 'w', encoding='utf-8') as f: f.write(json_cont)
-        logger.info(f"Progresso salvo: {fpath}")
-        msg = f"✅ Salvo! Baixe `{fname}`."
-        return json_cont, msg, fpath
-    except Exception as e: logger.error(f"Erro salvar: {e}", exc_info=True); return "", f"❌ Erro salvar: {e}", None
-
-def carregar_progresso(arquivo_entrada):
-    logger.info("Carregando progresso...")
-    if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo."
-    try:
-        fpath = arquivo_entrada.name; logger.info(f"Carregando: {fpath}")
-        with open(fpath, 'r', encoding='utf-8') as f: dados = json.load(f)
-        caso, peticao, tipo = dados.get("caso"), dados.get("peticao"), dados.get("tipo_peticao")
-        if not all([caso, peticao, tipo]): return "", "", "", "❌ Arquivo inválido."
-        if tipo not in TIPOS_DE_PETICAO: return caso, peticao, "", f"⚠️ Tipo '{tipo}' inválido."
-        logger.info("Progresso carregado."); return tipo, caso, peticao, "✅ Progresso carregado!"
-    except Exception as e: logger.error(f"Erro carregar: {e}", exc_info=True); return "", "", "", f"❌ Erro carregar: {e}"
-
-def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
-    prompt = f"Crie caso fictício **detalhado e realista** p/ peça **'{tipo_peticao}'** (simulado OAB).\n**Geral:**\n1.Complexidade adequada (15-25l).\n2.Dados Essenciais (nomes,locais,datas,valores,relação,conflito).\n3.Coerência.\n4.Foco no Tipo Peça.\n**Específico '{tipo_peticao}':**\n"
-    if tipo_peticao == "Petição Inicial": prompt += "* Descreva violação. * Inclua danos. * Dados qualificação. * Tema: Consumo, Contrato, etc."
-    elif tipo_peticao == "Contestação": prompt += "* Resumo PI recebida. * Versão Réu (p/ prelim, impug, mérito). * Dados qualif réu."
-    elif tipo_peticao == "Reconvenção": prompt += "* Estrutura Contestação + Fatos/Fundamentos p/ pedido PRÓPRIO CONEXO do Réu contra Autor."
-    elif tipo_peticao == "Impugnação à Contestação": prompt += "* Resumo PI Autor. * Resumo Contestação Réu (prelim, fatos novos, docs). * Objetivo: Rebater."
-    elif tipo_peticao == "Embargos de Declaração": prompt += "* Breve caso. * TRECHO DECISÃO. * INDIQUE VÍCIO (omissão/contradição/obscuridade/erro material)."
-    elif tipo_peticao == "Recurso de Apelação": prompt += "* Caso original. * Resumo SENTENÇA. * ELEMENTOS ERRO (in judicando/procedendo). * Indique apelante."
-    elif tipo_peticao == "Agravo de Instrumento": prompt += "* Caso andamento. * DECISÃO INTERLOCUTÓRIA. * Enquadrar Art.1015/mitig. * ELEMENTOS ERRO + URGÊNCIA. * Indique agravante."
-    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "* Situação URGENTE ou EVIDENTE. * ELEMENTOS: Urg=Fumus+Peric; Evid=Hipót Art.311. * Medida específica. * Antec/Incid."
-    else: prompt += "* Crie cenário cível com conflito."
-    prompt += f'\n**Finalize:**\n"**Situação-Problema:** Advogado(a) de [Nome Cliente], elabore a peça cabível ({tipo_peticao})."\n**Importante:** Temas comuns.'
-    return prompt
+            return "❌ Erro: Objeto de arquivo inválido."
+    except Exception as e:
+        logger.error(f"Erro ao processar o arquivo: {str(e)}")
+        return f"❌ Erro ao processar o arquivo: {str(e)}"
+
+def gerar_caso_simulado(tipo_peticao):
+    casos = {
+        "Petição Inicial": """
+        João, residente em São Paulo, celebrou contrato de compra de um veículo com a concessionária AutoLux em 01/01/2025. O veículo apresentou defeitos graves em 15/01/2025, e a concessionária recusou o reparo. João deseja rescindir o contrato, receber o valor pago (R$ 50.000) e indenização por danos morais (R$ 10.000).
+        """,
+        "Contestação": """
+        Na ação movida por João contra a AutoLux, a concessionária alega que o defeito no veículo decorre de mau uso por João e que não há prova de falha na fabricação. A AutoLux contesta o pedido de rescisão e danos morais, requerendo a improcedência da ação.
+        """,
+        "Reconvenção": """
+        Na mesma ação, a AutoLux, ao contestar, alega que João deve R$ 5.000 por serviços de manutenção não pagos, requerendo a condenação de João ao pagamento dessa quantia.
+        """,
+        "Impugnação à Contestação": """
+        João, ao responder à contestação da AutoLux, nega o mau uso do veículo e apresenta laudo técnico comprovando defeito de fabricação. Reitera os pedidos da inicial e contesta a reconvenção, negando a dívida de R$ 5.000.
+        """,
+        "Embargos de Declaração": """
+        Em sentença que julgou a ação de João contra a AutoLux, o juiz omitiu-se sobre o pedido de danos morais, apesar de deferir a rescisão contratual. João deseja esclarecer a omissão.
+        """,
+        "Recurso de Apelação": """
+        A sentença na ação de João contra a AutoLux deferiu a rescisão, mas negou os danos morais, sob o argumento de ausência de prova. João apela, alegando que os danos morais decorrem do descaso da concessionária.
+        """,
+        "Agravo de Instrumento": """
+        Na ação de João contra a AutoLux, o juiz indeferiu liminar para suspender a cobrança de parcelas do veículo. João agrava, alegando risco de inclusão de seu nome em cadastros de inadimplentes.
+        """,
+        "Petição de Tutela Provisória": """
+        João, na ação contra a AutoLux, requer tutela de urgência para suspender a cobrança de parcelas do veículo, sob risco de negativação, enquanto se discute a rescisão contratual.
+        """
+    }
+    return casos.get(tipo_peticao, "⚠️ Tipo de petição não suportado.")
 
-def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    logger.info(f"Gerando caso para: {tipo_peticao}")
+def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
+    prompt = PROMPTS_PETICOES.get(tipo_peticao, PROMPTS_PETICOES["Petição Inicial"])
+    base_prompt = f"""
+{prompt}
+**Caso fornecido**: {caso}
+**Petição fornecida**: {peticao}
+**Instruções adicionais**:
+- Se o caso ou a petição estiverem incompletos, sugira informações plausíveis com base no CPC e nas práticas forenses.
+- Em modo de treinamento, forneça exemplos práticos e compare com a petição fornecida.
+- Retorne a análise em markdown, com seções claras e sugestões específicas.
+"""
+    return base_prompt
+
+def analisar_peticao(file_obj, tipo_peticao, modo_treinamento):
     try:
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo válido."
-        prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-        caso_gerado = chamar_api(prompt)
-        if caso_gerado.startswith(("❌","⏱️","⚠️")): return f"⚠️ Falha gerar caso:\n{caso_gerado}"
-        frase = "**Situação-Problema:** Na qualidade de advogado(a) de"
-        if frase.lower() not in caso_gerado.lower():
-            logger.warning("Frase final não encontrada. Adicionando.")
-            nomes = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
-            cliente = nomes[0] if nomes else "[Cliente]"
-            caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente}, elabore a peça processual cabível ({tipo_peticao})."
-        logger.info("Caso gerado.")
-        return caso_gerado
-    except Exception as e: logger.exception("Erro gerar_caso:"); return f"❌ Erro gerar caso: {e}"
-
-def atualizar_config(temp, max_tokens):
-    CONFIG["temperatura"] = temp
-    CONFIG["max_tokens"] = max_tokens
-    logger.info(f"Configs: Temp={temp}, Max Tokens={max_tokens}")
-    return f"✅ Configs Atualizadas!"
-
-def interface_gradio():
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange")) as demo:
-        gr.Markdown("# ⚖️ Corretor Jurídico OAB Master ⚖️\nAnalise e aprimore suas peças processuais!")
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### ⚙️ Configs")
-                tipo_peticao_input = gr.Dropdown(label="1. Tipo Peça", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
-                modo_treinamento = gr.Checkbox(label="🎓 Treinamento", value=False)
-                with gr.Accordion("🛠️ Opções IA", open=False):
-                    temperatura_slider = gr.Slider(0.0, 1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
-                    max_tokens_slider = gr.Slider(2048, 8192, value=CONFIG["max_tokens"], step=256, label="Max Tokens")
-                    config_update_btn = gr.Button("💾 Salvar Configs")
-                    config_status = gr.Textbox(label="Status", interactive=False, lines=1)
-                with gr.Accordion("📊 Dashboard", open=False):
-                    progresso_output = gr.Markdown("*Atualize...*")
-                    progresso_btn = gr.Button("🔄 Progresso")
-                with gr.Accordion("📜 Histórico", open=False):
-                    historico_output = gr.Markdown("*Atualize...*")
-                    historico_btn = gr.Button("🔄 Histórico")
-                with gr.Accordion("💾📂 Salvar/Carregar", open=False):
-                     salvar_btn = gr.Button("💾 Salvar")
-                     carregar_btn = gr.Button("📂 Carregar")
-                     arquivo_progresso_upload = gr.File(label=".json", file_types=[".json"])
-                     progresso_download_file = gr.File(label="Baixar", interactive=False)
-            with gr.Column(scale=3):
-                gr.Markdown("### 1. Caso / Contexto")
-                with gr.Row():
-                     caso_input = gr.Textbox(label="📋 Caso", lines=8, placeholder="Insira o texto do caso...")
-                     caso_btn = gr.Button("🎲 Gerar", variant="secondary", scale=0)
-                gr.Markdown("### 2. Sua Peça")
-                with gr.Tabs():
-                    with gr.TabItem("✏️ Texto"):
-                        peticao_texto_input = gr.Textbox(label="Texto", lines=12, placeholder="Cole ou digite...")
-                        dica_contextual_output = gr.Markdown("*Dicas...*")
-                        btn_corrigir = gr.Button("🚀 CORRIGIR!", variant="primary")
-                    with gr.TabItem("📎 Arquivo"):
-                        peticao_arquivo_input = gr.File(label="Arquivo (.pdf,.docx,.txt)", file_types=[".pdf",".docx",".txt"])
-                        arquivo_preview_output = gr.Textbox(label="🔍 Prévia", lines=4, interactive=False)
-                        btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR ARQUIVO!", variant="primary")
-
-        processing_message = gr.Markdown("", visible=False)
-        gr.Markdown("--- \n ### 3. Resultados")
-        with gr.Tabs():
-             with gr.TabItem("📊 Análise e Correção"):
-                  resultado_analise_output = gr.Markdown(label="Análise e Nota")
-                  resultado_peticao_corrigida_output = gr.Textbox(label="✨ Versão Sugerida", lines=18, show_copy_button=True)
-             with gr.TabItem("⚖️ Comparativo"):
-                  gr.Markdown("### ↔️ Comparativo (Diff)")
-                  with gr.Row():
-                       with gr.Column(scale=1): resumo_alteracoes_output = gr.Markdown(label="Resumo"); criticas_output = gr.Markdown(label="Críticas")
-                       with gr.Column(scale=3): visualizacao_detalhada_output = gr.HTML(label="Detalhes")
-        clear_btn = gr.Button("🗑️ Limpar Tudo")
-
-        caso_btn.click(lambda: gr.update(value="⏳ Gerando...", visible=True), outputs=processing_message).then(
-             fn=gerar_caso_ficticio, inputs=[tipo_peticao_input], outputs=[caso_input]
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
-
-        peticao_texto_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
-        tipo_peticao_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
-        peticao_arquivo_input.change(process_file, [peticao_arquivo_input], [arquivo_preview_output])
-
-        btn_corrigir.click(lambda: gr.update(value="⏳ Processando texto...", visible=True), outputs=processing_message).then(
-            fn=corrigir_peticao,
-            inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None), modo_treinamento],
-            outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            concurrency_limit=1
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
-
-        btn_corrigir_arquivo.click(lambda: gr.update(value="⏳ Processando arquivo...", visible=True), outputs=processing_message).then(
-            fn=corrigir_peticao,
-            inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input, modo_treinamento],
-            outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            concurrency_limit=1
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
-
-        config_update_btn.click(atualizar_config, [temperatura_slider, max_tokens_slider], config_status)
-        progresso_btn.click(calcular_progresso, outputs=progresso_output)
-        historico_btn.click(mostrar_historico, outputs=historico_output)
-
-        salvar_btn.click(lambda: gr.update(value="⏳ Salvando...", visible=True), outputs=processing_message).then(
-             fn=salvar_progresso, inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
-        ).then(lambda x: gr.update(visible=bool(x)), [progresso_download_file], [progresso_download_file]
-        ).then(lambda: gr.update(value="", visible=False), None, processing_message)
-
-        carregar_btn.click(lambda: gr.update(value="⏳ Carregando...", visible=True), outputs=processing_message).then(
-             fn=carregar_progresso, inputs=[arquivo_progresso_upload],
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
-         ).then(lambda: gr.update(value="", visible=False), None, processing_message)
-
-        clear_btn.click(
-            fn=lambda: ["Petição Inicial", False, None, None, None, None, "*Dicas...*", "", "", "", "", "", None, None, ""],
-            outputs=[tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
-                     arquivo_preview_output, dica_contextual_output, resultado_analise_output, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output,
-                     arquivo_progresso_upload, progresso_download_file, config_status]
+        # Processa o arquivo da petição
+        peticao_texto = process_file(file_obj)
+        if peticao_texto.startswith("❌") or peticao_texto.startswith("⚠️"):
+            return peticao_texto
+
+        # Gera um caso simulado para o tipo de petição
+        caso_simulado = gerar_caso_simulado(tipo_peticao)
+
+        # Estrutura o prompt com base no tipo de petição
+        prompt = estruturar_prompt_analise(caso_simulado, peticao_texto, tipo_peticao, modo_treinamento)
+
+        # Chama a API do Gemini para análise
+        headers = {"Content-Type": "application/json"}
+        data = {
+            "contents": [{"parts": [{"text": prompt}]}],
+            "generationConfig": {
+                "temperature": CONFIG["temperatura"],
+                "maxOutputTokens": CONFIG["max_tokens"]
+            }
+        }
+
+        with rate_limiter:
+            for attempt in range(CONFIG["max_retry_attempts"]):
+                try:
+                    response = requests.post(GEMINI_API_URL, headers=headers, json=data, timeout=CONFIG["timeout"])
+                    response.raise_for_status()
+                    result = response.json()
+                    if "candidates" in result and result["candidates"]:
+                        correcao = result["candidates"][0]["content"]["parts"][0]["text"]
+                        CORRECAO_CACHE[peticao_texto[:50]] = correcao
+                        HISTORICO.append({
+                            "id": str(uuid.uuid4()),
+                            "timestamp": datetime.now().isoformat(),
+                            "tipo_peticao": tipo_peticao,
+                            "peticao": peticao_texto[:500],
+                            "correcao": correcao
+                        })
+                        return correcao
+                    else:
+                        logger.error("Nenhuma resposta válida retornada pela API.")
+                        return "❌ Nenhuma resposta válida retornada pela API."
+                except requests.exceptions.RequestException as e:
+                    logger.error(f"Tentativa {attempt + 1} falhou: {str(e)}")
+                    if attempt < CONFIG["max_retry_attempts"] - 1:
+                        time.sleep(CONFIG["retry_delay"])
+                    else:
+                        return f"❌ Erro após {CONFIG['max_retry_attempts']} tentativas: {str(e)}"
+    except Exception as e:
+        logger.error(f"Erro ao analisar a petição: {str(e)}")
+        return f"❌ Erro ao analisar a petição: {str(e)}"
+
+# Interface do Gradio
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Corretor de Petições Jurídicas")
+    gr.Markdown("Faça o upload de uma petição em PDF, DOCX ou TXT e selecione o tipo de petição para análise detalhada.")
+
+    with gr.Row():
+        tipo_peticao = gr.Dropdown(
+            choices=list(PROMPTS_PETICOES.keys()),
+            label="Tipo de Petição",
+            value="Petição Inicial"
         )
-    return demo
+        file_input = gr.File(label="Upload da Petição (PDF, DOCX, TXT)", file_types=[".pdf", ".docx", ".txt"])
+    
+    modo_treinamento = gr.Checkbox(label="Modo de Treinamento (inclui exemplos práticos)", value=False)
+    
+    with gr.Row():
+        submit_button = gr.Button("Analisar Petição", variant="primary")
+    
+    output = gr.Markdown(label="Resultado da Análise")
+    
+    submit_button.click(
+        fn=analisar_peticao,
+        inputs=[file_input, tipo_peticao, modo_treinamento],
+        outputs=output
+    )
 
 if __name__ == "__main__":
-    logger.info("Iniciando a aplicação Gradio...")
-    app = interface_gradio()
-    app.launch()
-    logger.info("Aplicação Gradio encerrada.")
+    demo.launch()