Update app.py

app.py

@@ -1,8 +1,9 @@
+# -*- coding: utf-8 -*-
 import gradio as gr
-import requests
+import google.generativeai as genai
+from google.api_core import exceptions as google_exceptions
 import os
 import json
-import PyPDF2
 import docx
 import io
 import time
@@ -11,395 +12,535 @@ from dotenv import load_dotenv
 from pdfplumber import open as pdfplumber_open
 from PIL import Image
 import pytesseract
-import cv2
-import numpy as np
+try:
+    import cv2
+    import numpy as np
+    CV2_AVAILABLE = True
+except ImportError:
+    CV2_AVAILABLE = False
+    print("Aviso: OpenCV (cv2) não encontrado.")
 from datetime import datetime
 from ratelimiter import RateLimiter
 import difflib
 from html import escape
 import random
 import logging
-import uuid
+import traceback
+import re
 
-# Configura o logging para depuração
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - [%(funcName)s] - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Carrega variáveis de ambiente
 load_dotenv()
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.environ.get("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a no arquivo .env ou como Secret.")
+    raise ValueError("❌ Chave GEMINI_API_KEY não encontrada.")
 
-GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
+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}")
 
-# Configurações gerais
-CONFIG = {
-    "max_retry_attempts": 3,
-    "retry_delay": 5,
-    "timeout": 60,
-    "temperatura": 0.2,
-    "max_tokens": 12882
-}
+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)
 
-# Limitação de taxa para chamadas à API
-rate_limiter = RateLimiter(max_calls=60, 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"},
+]
 
-# Dicas gerais para petições
-DICAS_OAB_MELHORADO = {
-    "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": "Antecipe defesas da parte contrária e prepare respostas."
-}
+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"]
 
-# NOVO: 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.
-"""
+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)."
 }
 
-# Estado global
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-def preprocess_image_for_ocr(img):
+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')
     try:
-        gray = img.convert('L')
-        np_img = np.array(gray)
-        _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        img_cv = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2GRAY)
+        _, thresh = cv2.threshold(img_cv, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
         return Image.fromarray(thresh)
     except Exception as e:
-        logger.error(f"Erro no pré-processamento da imagem: {str(e)}")
-        return f"❌ Erro no pré-processamento: {str(e)}"
+        logger.error(f"Erro pré-processamento OpenCV: {e}")
+        return img_pil.convert('L')
 
 def extract_text_from_pdf(file_path_or_obj):
+    text = ""; ocr_text_parts = []
     try:
-        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)}"
+        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}"
 
 def extract_text_from_docx(file_path_or_obj):
     try:
-        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)}"
+        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}"
 
 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()
-                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()
-            encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
-            for encoding in encodings:
+            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:
-                    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)}"
+                    file_path_or_obj.seek(0)
+                except Exception as seek_e:
+                    logger.warning(f"Não foi possível resetar ponteiro TXT: {seek_e}")
+            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}"
 
 def process_file(file_obj):
-    if file_obj is None:
-        return "Nenhum arquivo enviado."
+    if file_obj is None: return "⚠️ Nenhum arquivo."
     try:
-        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:
-            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)}"
-
-# NOVO: Função para gerar casos simulados para cada tipo de petição
-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.")
-
-# MODIFICADO: Função para estruturar o prompt, agora com suporte a diferentes tipos de petições
+        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):
-    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
-
-# MODIFICADO: Função principal de análise, agora recebe o tipo de petição
-def analisar_peticao(file_obj, tipo_peticao, modo_treinamento):
+    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:
-        # 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)}"
-
-# MODIFICADO: Interface do Gradio com dropdown para tipo de petição
-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"
+        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}"
+        else:
+            markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
+            start_index = -1
+            p_lower = pet_corr_bruta.lower()
+            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
+
+def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
+    logger.info(f"Gerando caso para: {tipo_peticao}")
+    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]
         )
-        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
-    )
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("Iniciando a aplicação Gradio...")
+    app = interface_gradio()
+    app.launch()
+    logger.info("Aplicação Gradio encerrada.")