Update app.py

app.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 import gradio as gr
+import google.generativeai as genai
+from google.api_core import exceptions as google_exceptions
 import os
 import json
 import docx
@@ -16,7 +18,7 @@ try:
     CV2_AVAILABLE = True
 except ImportError:
     CV2_AVAILABLE = False
-    print("Aviso: OpenCV (cv2) não encontrado. Pré-processamento de imagem para OCR será limitado.")
+    print("Aviso: OpenCV (cv2) não encontrado.")
 from datetime import datetime
 from ratelimiter import RateLimiter
 import difflib
@@ -24,31 +26,43 @@ from html import escape
 import random
 import logging
 import traceback
-import google.generativeai as genai
-from google.api_core.exceptions import ResourceExhausted, GoogleAPIError
+import re
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - [%(funcName)s] - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Carrega a chave da API
 load_dotenv()
 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 no Hugging Face.")
+    raise ValueError("❌ Chave GEMINI_API_KEY não encontrada.")
 
-CONFIG = {"max_retry_attempts": 5, "retry_delay": 10, "timeout": 120, "temperatura": 0.3, "max_tokens": 8192}
-rate_limiter = RateLimiter(max_calls=20, period=60)
+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_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"},
+]
 
 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"]
 
 DICAS_OAB_MELHORADO = {
-    "Clareza e Concisão": "Seja direto e evite jargões excessivos.",
-    "Fundamentação Legal": "Sempre cite os artigos de lei, súmulas e jurisprudência pertinentes.",
-    "Revisão Ortográfica": "Erros de português prejudicam a credibilidade.",
-    "Endereçamento (Inicial)": "Verifique a competência (Art. 46 CPC / Art. 101 CDC).",
-    "Pedidos (Inicial)": "Certos, determinados e líquidos (se possível).",
-    "Preliminares (Contestação)": "Alegue todas as matérias do Art. 337 do CPC antes do mérito.",
-    "Impugnação Específica (Contestação)": "Conteste cada fato alegado (Art. 341, CPC)."
+    "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)."
 }
 
 HISTORICO = []
@@ -56,359 +70,226 @@ CORRECAO_CACHE = {}
 
 def preprocess_image_for_ocr(img_pil):
     if not CV2_AVAILABLE:
-        logger.warning("OpenCV não disponível, usando conversão simples para OCR.")
+        logger.warning("OpenCV indisponível, usando conversão simples.")
         return img_pil.convert('L')
     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)
         return Image.fromarray(thresh)
     except Exception as e:
-        logger.error(f"Erro no pré-processamento da imagem com OpenCV: {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 = []
+    text = ""; ocr_text_parts = []
     try:
         logger.info(f"Abrindo PDF: {getattr(file_path_or_obj, 'name', file_path_or_obj)}")
-        pdf_reader = pdfplumber_open(file_path_or_obj)
-        logger.info(f"PDF com {len(pdf_reader.pages)} páginas.")
-        for i, page in enumerate(pdf_reader.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ágina {i+1} sem texto significativo extraído, tentando OCR.")
-                try:
-                    img = page.to_image(resolution=200)
-                    preprocessed_img = preprocess_image_for_ocr(img.original)
-                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por', config='--psm 6')
-                    if page_ocr_text and page_ocr_text.strip():
-                        ocr_text_parts.append(page_ocr_text)
-                    else:
-                        logger.warning(f"OCR retornou vazio para a página {i+1}.")
-                        ocr_text_parts.append(f"[OCR Página {i+1}: Vazio ou falhou]")
-                except Exception as ocr_e:
-                    logger.error(f"Erro no OCR da página {i+1}: {str(ocr_e)}")
-                    ocr_text_parts.append(f"[Erro OCR Página {i+1}: {str(ocr_e)}]")
-        pdf_reader.close()
+        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)
-        if text.strip() and len(text) > len(ocr_text) * 0.7:
-            logger.info(f"Usando texto extraído do PDF ({len(text)} chars).")
-            return text
-        elif ocr_text.strip():
-            logger.info(f"Usando texto do OCR do PDF ({len(ocr_text)} chars).")
-            return ocr_text
-        elif text.strip():
-            logger.info("Usando texto extraído curto como fallback.")
-            return text
-        else:
-            logger.warning("Não foi possível extrair texto significativo do PDF.")
-            return "⚠️ Não foi possível extrair texto do PDF (extração e OCR falharam)."
-    except Exception as e:
-        logger.error(f"Erro geral ao processar o PDF: {str(e)}", exc_info=True)
-        return f"❌ Erro crítico ao processar o PDF: {str(e)}"
+        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:
         doc = docx.Document(file_path_or_obj)
-        text = "\n".join([para.text for para in doc.paragraphs if para.text])
-        return text if text.strip() else "⚠️ Documento DOCX vazio ou sem texto."
-    except Exception as e:
-        logger.error(f"Erro ao processar o DOCX: {str(e)}", exc_info=True)
-        return f"❌ Erro ao processar o DOCX: {str(e)}"
+        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''
+        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()
+            with open(file_path_or_obj, 'rb') as f: content = f.read()
         elif hasattr(file_path_or_obj, 'read'):
+            # CORRIGIDO: Bloco try/except indentado corretamente
             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 do arquivo: {seek_e}")
+                    logger.warning(f"Não foi possível resetar ponteiro do arquivo TXT: {seek_e}")
             content = file_path_or_obj.read()
-        else:
-            return "❌ Tipo de entrada TXT inválido."
-        encodings = ['utf-8', 'latin-1', 'cp1252']
-        for encoding in encodings:
+        else: return "❌ Input TXT inválido."
+        for enc in encodings:
             try:
-                decoded_text = content.decode(encoding)
-                logger.info(f"Arquivo TXT decodificado com {encoding}.")
-                return decoded_text if decoded_text.strip() else "⚠️ Arquivo TXT vazio."
-            except UnicodeDecodeError:
-                continue
-        logger.error("Não foi possível decodificar o arquivo TXT com encodings comuns.")
-        return "❌ Não foi possível decodificar o arquivo TXT. Verifique o encoding."
-    except Exception as e:
-        logger.error(f"Erro ao processar o TXT: {str(e)}", exc_info=True)
-        return f"❌ Erro ao processar o TXT: {str(e)}"
+                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):
-    logger.info(f"process_file chamado com: {file_obj}")
-    if file_obj is None:
-        logger.warning("Nenhum arquivo fornecido")
-        return "⚠️ Nenhum arquivo enviado."
+    if file_obj is None: return "⚠️ Nenhum arquivo."
     try:
-        file_path = getattr(file_obj, 'name', None)
-        if not file_path:
-            logger.error("Não foi possível obter o nome do arquivo (file_obj.name está ausente).")
-            return "❌ Erro: Não foi possível identificar o arquivo enviado."
-        filename = os.path.basename(file_path).lower()
-        logger.info(f"Processando arquivo: {filename}")
+        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:
-            file_size = os.path.getsize(file_path)
-            logger.info(f"Tamanho do arquivo: {file_size} bytes")
-            if file_size > 15 * 1024 * 1024:
-                logger.warning(f"Arquivo {filename} ({file_size} bytes) excede o limite de 15MB.")
-                return "⚠️ Arquivo muito grande (Máx 15MB)."
-        except OSError as size_e:
-            logger.warning(f"Não foi possível verificar o tamanho do arquivo: {size_e}")
-        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:
-            logger.warning(f"Formato de arquivo não suportado: {filename}")
-            return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
-    except Exception as e:
-        logger.error(f"Erro GERAL ao processar o arquivo '{getattr(file_obj, 'name', 'N/A')}': {str(e)}", exc_info=True)
-        return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
+             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 da Avaliação:**
-    1. **Análise Geral:** Visão geral concisa (2-3 linhas).
-    2. **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE.
-    3. **Pontos Positivos:** Liste 2-3 aspectos bem executados, com justificativa.
-    4. **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade. Para cada: Descrição, Fundamentação legal, Impacto na nota, Sugestão.
-    5. **Análise Específica dos Requisitos:** Avalie os itens chave da peça.
-    **Critérios Fundamentais:** Coerência, Fundamentação, Linguagem, Pedidos. **NÃO INVENTAR FATOS** (-3 a -5). **NÃO SE IDENTIFICAR** (Nota ZERO)."""
-    if modo_treinamento:
-        base += """
-    **Modo de Treinamento:** Para cada Ponto a Melhorar: a) Explicação aprofundada. b) Base legal. c) Exemplo Redação Corrigida. d) Dica prática. e) Estratégia alternativa. Destaque inconsistências. Sugira estratégias adicionais."""
+    **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_especifico = f"## Análise: {tipo_peticao}\n**Caso:**\n```\n{caso}\n```\n**Peça Aluno:**\n```\n{peticao}\n```\n{instrucoes_gerais}\n**Requisitos Específicos ({tipo_peticao}):**\n"
-    if tipo_peticao == "Petição Inicial":
-        prompt_especifico += "- Endereçamento/competência (Art. 319, I; CDC 101, I).\n- Qualificação (Art. 319, II).\n- Fatos.\n- Fundamentação (Art. 319, III).\n- Pedidos (Art. 319, IV).\n- Valor causa (Art. 291-292, 319, V).\n- Provas (Art. 319, VI).\n- Audiência (Art. 319, VII).\n- Citação.\n- Docs essenciais (procuração, custas/JG).\n- Fechamento.\n**Critérios Adicionais:** Usar 'XXX'. Falta custas/JG (-1.0). Vírgula em 'pede deferimento' (-0.2). Foro consumidor OK."
-    elif tipo_peticao == "Contestação":
-        prompt_especifico += "- Endereçamento. Qualificação réu. Processo nº. Tempestividade.\n- **Preliminares (Art. 337):** TODAS aplicáveis.\n- **Impugnação Específica Fatos (Art. 341):** PONTO A PONTO.\n- **Mérito:** Versão réu; defesa direta/indireta (fatos impeditivos/modificativos/extintivos).\n- Fundamentação defesa.\n- **Pedidos:** Acolher preliminares; IMPROCEDÊNCIA TOTAL; Condenação sucumbência (Art. 85).\n- Provas. Fechamento.\n**Critérios Adicionais:** Preliminar não arguida preclui? Falha grave impugnação (-2 a -4). Ausência pedido improcedência (-1.5)."
-    elif tipo_peticao == "Reconvenção":
-        prompt_especifico += "- NA MESMA PEÇA da Contestação (Art. 343). Endereçamento. Processo nº.\n- Qualificação réu-reconvinte e autor-reconvindo.\n- **Conexão** (Art. 343).\n- **Estrutura PI:** Fatos, Fundamentos, Pedidos específicos, Valor causa, Provas (da reconvenção).\n- Pedido intimação autor-reconvindo (Art. 343, §1º).\n**Critérios Adicionais:** Sem conexão (-2.0). Falta pedido/valor/provas reconv. (-1.0/item). Peça separada (-3.0)."
-    elif tipo_peticao == "Impugnação à Contestação":
-        prompt_especifico += "- Endereçamento. Processo nº. Qualificação autor. Tempestividade (15d - Art. 350/351).\n- **Resposta Preliminares.**\n- **Resposta Fatos Novos** (Art. 350).\n- **Resposta Documentos** (Art. 437).\n- **Ratificação Inicial.**\n- **Especificação Provas** (contra defesa indireta/preliminares).\n- Pedidos: Rejeitar preliminares; refutar defesa; proceder inicial.\n**Critérios Adicionais:** Não responder preliminar (-1.5). Não manifestar fato novo (-2.0). Não ratificar (-0.5)."
-    elif tipo_peticao == "Embargos de Declaração":
-        prompt_especifico += "- **Contra Decisão Específica.** Endereçamento ao juízo prolator. Processo nº. Partes. Tempestividade (5d - Art. 1023).\n- **Cabimento (Art. 1022):** Apontar PRECISAMENTE: Omissão, Contradição, Obscuridade ou Erro Material.\n- **NÃO REJULGAR CAUSA.**\n- **Pedido:** Conhecimento e ACOLHIMENTO para sanar vício.\n**Critérios Adicionais:** Rediscutir mérito (-4.0). Não apontar vício (-3.0). Endereçar tribunal (-1.0)."
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt_especifico += "- **Interposição:** Ao juízo a quo. Processo nº. Partes. Pressupostos (cabimento Art. 1009; tempestividade 15d; preparo/JG). Pedido recebimento/remessa.\n- **Razões:** Ao TRIBUNAL. Relato. **Fundamentos Reforma/Anulação (Art. 1010):** Error in procedendo/judicando. **Dialeticidade.**\n- **Pedidos:** Conhecimento; PROVIMENTO (anular/reformar); Inversão sucumbência.\n**Critérios Adicionais:** Falta peça (-10). Endereço razões (-1.0). Sem dialeticidade (-3 a -5). Sem pedido reforma/anulação (-1.5). Falta preparo/JG (-2.0)."
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt_especifico += "- Peça única ao TRIBUNAL. Processo origem. Partes e Advogados (endereços Art. 1016, IV). Cópia decisão agravada (Art. 1017, I).\n- **Cabimento (Art. 1015 / mitigada).** Tempestividade (15d). Preparo/JG.\n- **Peças Obrigatórias (Art. 1017, I):** Decisão, Intimação, Procurações. Facultativas (III).\n- **Razões (Art. 1016):** Motivos reforma/invalidação.\n- **Efeito Suspensivo / Tutela Antecipada Recursal (Art. 1019, I)** (se risco).\n- **Pedidos Finais:** Conhecimento; Efeito/Tutela (se aplicável); PROVIMENTO; Comunicação juiz.\n**Critérios Adicionais:** Falta peça obrigatória (-4.0). Sem cabimento (-3.0). Endereço juiz (-1.0). Sem advogados (-0.5)."
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt_especifico += "- Tipo (Urgência/Evidência). Caráter (Antecedente/Incidental). Endereçamento. Qualificação. Processo (se incidental).\n- **Tutela Urgência (Art. 300):** **Fumus Boni Iuris** E **Periculum in Mora**. **Reversibilidade** (Art. 300, §3º).\n- **Tutela Evidência (Art. 311):** Hipótese I a IV. **NÃO precisa periculum.**\n- **Pedido Específico:** Medida liminar CLARA.\n- **Se Antecedente (Art. 303/305):** Indicar pedido final ou aditar/apresentar inicial. Valor Causa.\n- **Pedidos:** Concessão tutela; citação/intima��ão; indicação ação/aditamento.\n**Critérios Adicionais:** Sem Fumus/Periculum (-3 a -5). Erro hipótese Evidência (-3.0). Pedido genérico (-2.0)."
-    else:
-        prompt_especifico += "- Adequação ao tipo? Clareza? Fundamentação Mínima? Pedido?"
-    prompt_especifico += "\n\n**Instruções Finais:** Analise estritamente com base no caso e critérios. Seja rigoroso mas construtivo. Gere **exclusivamente** no formato solicitado."
-    return prompt_especifico
+    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 da peça ({tipo_peticao}), seguindo rigorosamente práticas OAB.\n**Instruções Específicas ({tipo_peticao}):**\n"
-    if tipo_peticao == "Petição Inicial":
-        prompt += "1.Endereçamento correto/fundamentado. 2.Qualificação completa (Art.319,II,'XXX'). 3.Fatos cronológicos/fiéis. 4.Fundamentação (artigos, súmulas). 5.Pedidos certos/determinados (quantificar). 6.Valor causa (Art.292). 7.Provas ('protesta provar...'). 8.Audiência (Art.319,VII). 9.Citação (Art.246,I). 10.Custas/JG (NÃO OMITIR). 11.Fechamento ('Nestes termos pede deferimento.', Local, data., ADVOGADO(A), OAB/...). NUNCA identificar."
-    elif tipo_peticao == "Contestação":
-        prompt += "1.Endereçamento juízo ação. 2.Identificação (proc. nº, réu). 3.Tempestividade. 4.Estrutura: Síntese Inicial; Preliminares (Art.337, fund.); Mérito (Impug. Específica + Defesa fund.); Reconvenção (se houver, antes pedidos cont.). 5.Pedidos Cont.: Acolher prelim.; IMPROCEDÊNCIA TOTAL; Sucumbência. 6.Provas réu. 7.Fechamento OAB."
-    elif tipo_peticao == "Reconvenção":
-        prompt += "**IMPORTANTE:** Gere como parte da Contestação.\n1.Após defesa mérito cont., ANTES pedidos cont.: Tópico 'DA RECONVENÇÃO'. 2.Qualificação Reconvinte/Reconvindo. 3.Conexão. 4.Fatos e Direito Reconvencionais. 5.Pedidos Reconv.: Claros contra autor-reconvindo. 6.Valor Causa e Provas Reconv. 7.Intimação autor-reconvindo. 8.Continue com Pedidos Contestação. 9.Fechamento OAB."
-    elif tipo_peticao == "Impugnação à Contestação":
-        prompt += "1.Endereçamento, proc, autor, tempestividade. 2.Tópico: DA(S) PRELIMINAR(ES) - Rebater. 3.Tópico: DO MÉRITO E FATOS NOVOS - Manifestar. 4.Tópico: DA RATIFICAÇÃO INICIAL. 5.Tópico: DAS PROVAS - Especificar. 6.Pedidos: Rejeitar prelim., refutar defesa, proceder inicial. 7.Fechamento OAB."
-    elif tipo_peticao == "Embargos de Declaração":
-        prompt += "1.Endereçamento juízo prolator. Proc, Partes. Decisão embargada ID. Tempestividade (5d). 2.Tópico para cada vício (Art.1022): DA OMISSÃO / DA CONTRADIÇÃO / DA OBSCURIDADE / DO ERRO MATERIAL. 3.Dentro: Transcrever trecho + explicar vício OBJETIVAMENTE. NÃO REJULGAR. 4.Pedido: Conhecimento e ACOLHIMENTO p/ sanar vício(s). 5.Fechamento OAB."
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt += "1.Interposição: Juízo a quo. Proc, Partes. Pressupostos (cabim., temp., prep./JG). Pedido receb./remessa. 2.Razões: Tribunal. Relato. FUNDAMENTOS REFORMA/ANULAÇÃO (Error in proc./judic.). DIALETICIDADE. 3.Pedidos: Conhec.; PROVIMENTO (anular/reformar); Inversão sucumb. 4.Fechamento OAB."
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt += "1.Peça única Tribunal. Proc. origem, Partes, Advogados (endereços). Decisão agravada ID (juntar cópia). 2.CABIMENTO (Art.1015/mitig.). TEMPESTIVIDADE. PREPARO/JG. PEÇAS OBRIG./FACULT. 3.RAZÕES RECURSAIS: Motivos reforma/invalidação. 4.EFEITO SUSPENSIVO/TUTELA ANTECIPADA (se cabível). 5.PEDIDOS: Conhec.; Efeito/Tutela; PROVIMENTO; Comunicação juiz. 6.Fechamento OAB."
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += "1.Indicar TIPO(Urg/Evid) e CARÁTER(Antec/Incid). Endereç. Qualif. Proc(se incid). 2.REQUISITOS: Urgência=Fumus+Periculum(+Reversib.). Evidência=Hipótese Art.311. 3.PEDIDO LIMINAR: Medida CLARA. 4.Se Antec.: Indicar pedido final/aditar. Valor Causa. 5.PEDIDOS: Concessão tutela; citação/intim.; indic. ação/adit. 6.Fechamento OAB."
-    else:
-        prompt += "1.Estrutura Lógica. 2.Argumentos Claros. 3.Pedido Claro. 4.Formalidades OAB."
-    prompt += "\n\n**Instrução Final:** Gere **APENAS** o texto completo da peça corrigida abaixo, começando pelo endereçamento e terminando com 'OAB/...'. Sem comentários extras."
+    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":
-        peticao_lower = peticao_corrigida.lower()
-        if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_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 peticao_lower and "audiência de mediação" not in peticao_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.")
+        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_padrao = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
-    while linhas and any(term in linhas[-1] for term in ["ADVOGADO", "OAB", "Local", "data"]):
-        linhas.pop()
-    linhas.extend(fechamento_padrao)
+    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):
-    try:
-        # Configura o cliente com a chave da API
-        genai.configure(api_key=GEMINI_API_KEY)
-        
-        # Configurações do modelo
-        generation_config = {
-            "temperature": CONFIG["temperatura"],
-            "max_output_tokens": CONFIG["max_tokens"],
-            "top_p": 0.95,
-        }
-        
-        logger.info(f"Chamando API Gemini. Temp={CONFIG['temperatura']}, MaxTokens={CONFIG['max_tokens']}")
-        
-        for tentativa in range(CONFIG["max_retry_attempts"]):
-            try:
-                with rate_limiter:
-                    logger.debug(f"API Call - Tentativa {tentativa + 1}/{CONFIG['max_retry_attempts']}")
-                    # Chama o modelo
-                    response = genai.generate_content(
-                        model="gemini-1.5-flash-latest",
-                        contents=[{"parts": [{"text": prompt}]}],
-                        generation_config=generation_config
-                    )
-                
-                # Verifica se há conteúdo na resposta
-                if not response.candidates:
-                    logger.error("API Response sem 'candidates'.")
-                    prompt_feedback = getattr(response, "prompt_feedback", {})
-                    block_reason = prompt_feedback.get("block_reason", "Desconhecido")
-                    return f"❌ Bloqueado pela API: {block_reason}."
-                
-                candidate = response.candidates[0]
-                finish_reason = candidate.finish_reason
-                
-                if finish_reason not in ["STOP", "MAX_TOKENS", None]:
-                    logger.error(f"Geração API interrompida: {finish_reason}")
-                    safety_ratings = candidate.safety_ratings
-                    harm_categories = [r.category for r in safety_ratings if r.probability not in ['NEGLIGIBLE', 'LOW']]
-                    if harm_categories:
-                        return f"❌ Bloqueado por segurança: {finish_reason} ({','.join(harm_categories)})."
-                    return f"❌ Geração interrompida: {finish_reason}."
-                
-                texto_gerado = candidate.content.parts[0].text.strip()
-                logger.info(f"API retornou com sucesso ({len(texto_gerado)} chars). Finish: {finish_reason}")
-                return texto_gerado
-            
-            except ResourceExhausted as e:
-                logger.warning(f"Erro 429 (Quota Exceeded) - Tentativa {tentativa + 1}. Aguardando {CONFIG['retry_delay']}s...")
-                if tentativa < CONFIG["max_retry_attempts"] - 1:
-                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
-                    continue
-                return "❌ Erro 429: Muitas requisições."
-            
-            except GoogleAPIError as e:
-                logger.error(f"Erro API: {str(e)}")
-                if tentativa < CONFIG["max_retry_attempts"] - 1:
-                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
-                    continue
-                return f"❌ Erro API: {str(e)}"
-            
-            except Exception as e:
-                logger.exception(f"Erro inesperado API - Tentativa {tentativa + 1}: {str(e)}")
-                if tentativa < CONFIG["max_retry_attempts"] - 1:
-                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
-                    continue
-                return f"❌ Erro inesperado API: {str(e)}"
-    
-    except Exception as e:
-        logger.error(f"Erro crítico ao chamar API: {str(e)}", exc_info=True)
-        return f"❌ Erro crítico ao chamar API: {str(e)}"
+    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"Iniciando correção. Tipo={tipo_peticao}, Treinamento={modo_treinamento}")
-    start_time = time.time()
-    analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html = "", "", "", "", ""
-    peticao_conteudo = ""
+    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 o caso.", "", "", "", ""
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-            return "⚠️ Selecione tipo.", "", "", "", ""
-        if peticao_arquivo is not None:
-            peticao_conteudo = process_file(peticao_arquivo)
-            if peticao_conteudo.startswith(("❌", "⚠️")):
-                return peticao_conteudo, "", "", "", ""
-        elif peticao_texto and peticao_texto.strip():
-            peticao_conteudo = peticao_texto
-        else:
-            return "⚠️ Forneça a petição.", "", "", "", ""
-        logger.info(f"Petição recebida ({len(peticao_conteudo)} chars).")
-        troll_triggers = ["escreva a petição", "faça a petição", "redija a petição", "elabore a petição", "crie a petição", "gere a petição", "faça para mim", "faça por mim"]
-        if any(trigger in peticao_conteudo.lower() for trigger in troll_triggers):
-            logger.info("Detectado pedido para escrever petição.")
-            return random.choice(["Hummm... 😉", "🚫 Opa! Corrijo, não crio."]), "", "", "", ""
-        cache_key = f"{tipo_peticao}|{caso[:100]}|{peticao_conteudo[:100]}|{modo_treinamento}"
+        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("Correção encontrada no 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, peticao_conteudo, tipo_peticao, modo_treinamento)
+        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_formatada = formatar_correcao(analise_bruta)
-        prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo, tipo_peticao)
-        peticao_corrigida_bruta = chamar_api(prompt_peticao)
-        if peticao_corrigida_bruta.startswith(("❌", "⏱️", "⚠️")):
-            peticao_corrigida_final = f"⚠️ Falha ao gerar versão corrigida:\n{peticao_corrigida_bruta}"
+        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:
-            start_markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
-            start_index = -1
-            peticao_lower_corr = peticao_corrigida_bruta.lower()
-            for marker in start_markers:
-                idx = peticao_lower_corr.find(marker)
-                if idx != -1:
-                    start_index = idx
-                    break
-            peticao_extraida = peticao_corrigida_bruta[start_index:] if start_index != -1 else peticao_corrigida_bruta
-            peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
-        diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-        resultado_cache = {
-            "analise_formatada": analise_formatada,
-            "peticao_corrigida": peticao_corrigida_final,
-            "resumo_diff": resumo_diff,
-            "criticas_diff": criticas_diff,
-            "diff_html": diff_html
-        }
-        CORRECAO_CACHE[cache_key] = resultado_cache
-        HISTORICO.append({
-            "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "tipo_peticao": tipo_peticao,
-            "caso": caso,
-            "peticao_original": peticao_conteudo,
-            **resultado_cache
-        })
-        if len(HISTORICO) > 10:
-            HISTORICO.pop(0)
-        end_time = time.time()
-        logger.info(f"Correção concluída em {end_time - start_time:.2f} segundos.")
-        return analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html
-    except Exception as e:
-        logger.error(f"Erro GERAL inesperado em corrigir_peticao: {str(e)}", exc_info=True)
-        return f"❌ Erro inesperado correção: {str(e)}", "", "", "", ""
+            markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
+            start = -1; p_lower = pet_corr_bruta.lower()
+            for m in markers: idx = p_lower.find(m); if idx != -1: start = idx; break
+            pet_extr = pet_corr_bruta[start:] if start != -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")
@@ -416,385 +297,246 @@ def formatar_correcao(texto):
     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_formatadas = []
+    linhas = texto.split('\n'); linhas_fmt = []
     in_list = False
-    for linha in linhas:
-        ls = linha.strip()
-        if ls.startswith(("1.","2.","3.","4.","5.")):
-            linhas_formatadas.append(f"\n**{ls}**")
-            in_list = False
-        elif ls.startswith(("- ","* ")):
-            prefix = "  * " if in_list else "* "
-            linhas_formatadas.append(prefix + ls[2:])
-            in_list = True
-        elif ls.startswith(("a)","b)","c)","d)","e)")):
-            linhas_formatadas.append(f"    * {ls}")
-            in_list = True
-        else:
-            linhas_formatadas.append(linha)
-            in_list = False if not ls.startswith(("*","- ","a)","b)","c)","d)","e)"," ")) else in_list
-    texto_final = "\n".join(linhas_formatadas)
-    m = re.search(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", texto_final, re.I)
-    if m:
-        nota = m.group(2).replace(",",".")
-        texto_final = re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", f"\\1**{nota}/10**", texto_final, count=1, flags=re.I)
-    return texto_final
+    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_relevantes = []
-    texto_lower = texto_peticao.lower()
-    for chave in ["Clareza e Concisão", "Fundamentação Legal", "Revis��o Ortográfica"]:
-        if chave in DICAS_OAB_MELHORADO:
-            dicas_relevantes.append(f"💡 **{chave}:** {DICAS_OAB_MELHORADO[chave]}")
-    keywords_por_tipo = {
-        "Petição Inicial": ["endereçamento","qualificação","fatos","fundamentos","pedidos","valor","provas","audiência","citação","custas"],
-        "Contestação": ["preliminar","mérito","impugnação","improcedência","honorários","art. 337","art. 341"],
-        "Embargos de Declaração": ["omissão","contradição","obscuridade","erro material","art. 1022"],
-        "Recurso de Apelação": ["sentença","reforma","anulação","dialeticidade","preparo","tribunal","art. 1009"],
-        "Agravo de Instrumento": ["interlocutória","cabimento","urgência","efeito suspensivo","art. 1015"],
-        "Petição de Tutela Provisória": ["urgência","evidência","liminar","periculum","fumus boni","art. 300"],
-    }
-    if tipo_peticao in keywords_por_tipo:
-        for chave, dica in DICAS_OAB_MELHORADO.items():
-            cl = chave.lower()
-            if f"({tipo_peticao.split()[0].lower()})" in cl or any(kw in cl for kw in keywords_por_tipo[tipo_peticao] if kw in texto_lower):
-                dica_fmt = f"💡 **{chave}:** {dica}"
-                if dica_fmt not in dicas_relevantes:
-                    dicas_relevantes.append(dica_fmt)
-    if not dicas_relevantes:
-        return "*Continue escrevendo para dicas...*"
-    return "\n\n".join(dicas_relevantes[:4])
+    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_lines = texto_original.splitlines()
-    corr_lines = texto_corrigido.splitlines()
-    diff = difflib.ndiff(orig_lines, corr_lines)
-    res_html, crit, l_rem, l_add = [], [], 0, 0
-    kw_rem = ["invenção", "identificação", "erro crasso", "incorreto", "prazo"]
-    kw_add = ["custas", "art. 319", "art. 337", "art. 1022", "art. 1015", "art. 300", "fumus", "periculum", "essencial", "preliminar", "tempestividade", "cabimento"]
-    for linha in diff:
-        txt = linha[2:]
-        txt_esc = escape(txt)
-        if linha.startswith('  '):
-            res_html.append(f"<div class='linha-igual'>{txt_esc}</div>")
-        elif linha.startswith('- '):
-            l_rem += 1
-            res_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_rem):
-                crit.append(f"<span style='color:red'>🔴 REMOVIDO:</span> {txt_esc}")
-        elif linha.startswith('+ '):
-            l_add += 1
-            res_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_add):
-                crit.append(f"<span style='color:green'>🟢 ADICIONADO:</span> {txt_esc}")
-    resumo = f"**Resumo:** Rem={l_rem}, Add={l_add}, Saldo={l_add - l_rem}"
-    crit_txt = "### 🚨 Mudanças Críticas:\n" + "\n".join(crit) if crit else "*Nenhuma mudança crítica detectada.*"
+    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(res_html)}</div>"
+    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."
+    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 "↔️")
+            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."
+    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"
+        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()
-        }
+        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)
+        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
+    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."
+    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)
+        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}"
+        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 direitos. * Inclua danos. * Dados qualificação. * Tema: Consumo, Contrato, etc."
-    elif tipo_peticao == "Contestação":
-        prompt += "* Resumo PI recebida. * Versão Réu (p/ preliminares, impugnação, mérito). * Dados qualificação 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 (preliminares, fatos novos, docs). * Objetivo: Rebater contestação."
-    elif tipo_peticao == "Embargos de Declaração":
-        prompt += "* Breve caso. * TRECHO DECISÃO JUDICIAL. * INDIQUE VÍCIO (omissão/contradição/obscuridade/erro material) NESSA DECISÃO."
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt += "* Caso original. * Resumo SENTENÇA. * ELEMENTOS indicando ERRO (in judicando/procedendo). * Indique cliente (apelante)."
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt += "* Caso em andamento. * DECISÃO INTERLOCUTÓRIA. * Enquadrar Art.1015/mitigação. * ELEMENTOS indicando ERRO + URGÊNCIA. * Indique cliente (agravante)."
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += "* Situação URGENTE ou EVIDENTE. * ELEMENTOS: Urgência=Fumus+Periculum; Evidência=Hipótese Art.311. * Medida específica. * Antecedente ou Incidental."
-    else:
-        prompt += "* Crie cenário cível com conflito claro."
-    prompt += f'\n**Finalize:**\n"**Situação-Problema:** Advogado(a) de [Nome Cliente], elabore a peça processual cabível ({tipo_peticao})."\n**Importante:** Temas comuns. Seja criativo!'
+    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:
-        logger.info(f"Gerando caso para: {tipo_peticao}")
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-            return "⚠️ Selecione tipo válido."
+        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_final = "**Situação-Problema:** Na qualidade de advogado(a) de"
-        if frase_final.lower() not in caso_gerado.lower():
+        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.error(f"Erro ao gerar caso: {str(e)}", exc_info=True)
-        return f"❌ Erro ao gerar caso: {str(e)}"
+    except Exception as e: logger.exception("Erro gerar_caso:"); return f"❌ Erro gerar caso: {e}"
 
-def atualizar_config(temp, timeout, tokens):
+def atualizar_config(temp, max_tokens):
     CONFIG["temperatura"] = temp
-    CONFIG["timeout"] = timeout
-    CONFIG["max_tokens"] = tokens
-    logger.info(f"Configs atualizadas: Temp={temp}, Timeout={timeout}, Tokens={tokens}")
-    return "✅ Configs Atualizadas!"
+    CONFIG["max_tokens"] = max_tokens
+    logger.info(f"Configs: Temp={temp}, Max Tokens={max_tokens}")
+    return f"✅ Configs Atualizadas!"
 
 def interface_gradio():
-    logger.info(f"Versão do Gradio: {gr.__version__}")
-    with gr.Blocks(theme=gr.themes.Default()) as demo:
+    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("### ⚙️ Configurações")
-                tipo_peticao_input = gr.Dropdown(label="1. Selecione o Tipo", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
-                modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento", value=False)
-                with gr.Accordion("🛠️ Opções Avançadas", open=False):
+                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")
-                    timeout_slider = gr.Slider(30, 180, value=CONFIG["timeout"], step=10, label="Timeout (s)")
                     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 para ver.*")
-                    progresso_btn = gr.Button("🔄 Atualizar Progresso")
+                    progresso_output = gr.Markdown("*Atualize...*")
+                    progresso_btn = gr.Button("🔄 Progresso")
                 with gr.Accordion("📜 Histórico", open=False):
-                    historico_output = gr.Markdown("*Atualize para ver.*")
-                    historico_btn = gr.Button("🔄 Ver Histórico")
+                    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="Selecione .json", file_types=[".json"])
-                    progresso_download_file = gr.File(label="Baixar Progresso", interactive=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)
+                     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 da Peça", lines=12, placeholder="Cole ou digite...")
+                        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")
+             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(
-            fn=lambda: (logger.info("Botão Gerar clicado"), gr.update(value="⏳ Gerando...", visible=True))[1],
-            outputs=processing_message
-        ).then(
-            fn=gerar_caso_ficticio,
-            inputs=[tipo_peticao_input],
-            outputs=[caso_input]
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message
-        )
+        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]
-        )
+        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(
-            fn=lambda: (logger.info("Botão Corrigir Texto clicado"), gr.update(value="⏳ Processando texto...", visible=True))[1],
-            outputs=processing_message
-        ).then(
+        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=None
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message
-        )
+            concurrency_limit=1
+        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
 
-        btn_corrigir_arquivo.click(
-            fn=lambda: (logger.info("Botão Corrigir Arquivo clicado"), gr.update(value="⏳ Processando arquivo...", visible=True))[1],
-            outputs=processing_message
-        ).then(
+        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=None
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message
-        )
+            concurrency_limit=1
+        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
 
-        config_update_btn.click(
-            atualizar_config,
-            [temperatura_slider, timeout_slider, max_tokens_slider],
-            config_status
-        )
-        progresso_btn.click(
-            calcular_progresso,
-            outputs=progresso_output
-        )
-        historico_btn.click(
-            mostrar_historico,
-            outputs=historico_output
-        )
+        config_update_btn.click(atualizar_config, [temperatura_slider, max_tokens_slider], config_status) # Removido timeout_slider
+        progresso_btn.click(calcular_progresso, outputs=progresso_output)
+        historico_btn.click(mostrar_historico, outputs=historico_output)
 
-        salvar_btn.click(
-            fn=lambda: (logger.info("Botão Salvar clicado"), gr.update(value="⏳ Salvando...", visible=True))[1],
-            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(
-            fn=lambda x: gr.update(visible=bool(x)),
-            inputs=[progresso_download_file],
-            outputs=[progresso_download_file]
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=processing_message
-        )
+        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(
-            fn=lambda: (logger.info("Botão Carregar clicado"), gr.update(value="⏳ Carregando...", visible=True))[1],
-            outputs=processing_message
-        ).then(
-            fn=carregar_progresso,
-            inputs=[arquivo_progresso_upload],
-            outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
-        ).then(
-            fn=lambda: gr.update(value="", visible=False),
-            outputs=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
-            ]
+            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]
         )
-
     return demo
 
 if __name__ == "__main__":
     logger.info("Iniciando a aplicação Gradio...")
-    try:
-        app = interface_gradio()
-        app.launch(debug=True)
-    except Exception as e:
-        logger.error(f"Erro ao iniciar Gradio: {str(e)}", exc_info=True)
-        raise
+    app = interface_gradio()
+    app.launch()
     logger.info("Aplicação Gradio encerrada.")