Update app.py

app.py

@@ -7,6 +7,7 @@ import docx
 import io
 import time
 import tempfile
+from dotenv import load_dotenv
 from pdfplumber import open as pdfplumber_open
 from PIL import Image
 import pytesseract
@@ -18,65 +19,84 @@ import difflib
 from html import escape
 import random
 import logging
-import re
 
-# Configuração do Logging
+# Configura o logging para depuração
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Leitura da API Key (usar Secrets no HF)
+load_dotenv()
+
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a como Secret nas configurações do Space.")
+    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a no arquivo .env ou como Secret.")
+
+# Use um modelo mais recente se disponível e adequado, como gemini-1.5-flash
+# GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={GEMINI_API_KEY}"
+# Se gemini-1.5-flash não estiver disponível ou causar problemas, volte para gemini-pro ou o que funcionava
+# GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key={GEMINI_API_KEY}"
+GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={GEMINI_API_KEY}"
 
-# API Endpoint
-GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={GEMINI_API_KEY}"
 
-# Configurações
 CONFIG = {
     "max_retry_attempts": 3,
     "retry_delay": 5,
-    "timeout": 120,
-    "temperatura": 0.3,
-    "max_tokens": 8192
+    "timeout": 120, # Aumentar timeout para prompts mais complexos
+    "temperatura": 0.3, # Um pouco mais de criatividade pode ser útil
+    "max_tokens": 8192 # Ajustar conforme necessidade e limites do modelo
 }
 
-# Rate Limiter
-rate_limiter = RateLimiter(max_calls=30, period=60)
+rate_limiter = RateLimiter(max_calls=30, period=60) # Reduzir um pouco a taxa para evitar 429
 
-# Constantes e Dicionários
+# --- TIPOS DE PEÇAS PROCESSUAIS ---
 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 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"
 ]
+
+# --- DICIONÁRIO DE DICAS (Pode ser expandido por tipo) ---
 DICAS_OAB_MELHORADO = {
+    # Dicas Gerais (aplicáveis a várias peças)
     "Clareza e Concisão": "Seja direto e evite jargões excessivos. Facilite a leitura do juiz.",
     "Fundamentação Legal": "Sempre cite os artigos de lei, súmulas e jurisprudência pertinentes ao seu argumento.",
     "Coerência Argumentativa": "Mantenha uma linha lógica de raciocínio do início ao fim da peça.",
     "Revisão Ortográfica e Gramatical": "Erros de português podem prejudicar a credibilidade da sua peça.",
     "Formatação": "Utilize parágrafos bem definidos, espaçamento adequado e destaque pontos importantes (negrito, itálico) com moderação.",
+
+    # Dicas Específicas (Exemplos para Petição Inicial)
     "Endereçamento (Inicial)": "Em relações de consumo, prefira o foro do domicílio do autor (Art. 101, I, CDC). Verifique a competência (material, territorial).",
     "Qualificação (Inicial)": "Inclua todos os dados do Art. 319, II, CPC. Use 'XXX' para dados não fornecidos.",
     "Fatos (Inicial)": "Narrativa cronológica, clara e objetiva, sem juízo de valor.",
     "Pedidos (Inicial)": "Certos, determinados e líquidos (sempre que possível). Cumule pedidos se necessário (Art. 327, CPC).",
     "Custas (Inicial)": "Sempre peça a juntada da guia ou a gratuidade de justiça (com declaração).",
     "Valor da Causa (Inicial)": "Deve corresponder ao benefício econômico pretendido (Art. 292, CPC).",
+
+    # Dicas Específicas (Exemplos para Contestação)
     "Preliminares (Contestação)": "Alegue todas as matérias do Art. 337 do CPC antes de discutir o mérito.",
     "Impugnação Específica (Contestação)": "Conteste cada fato alegado pelo autor, sob pena de presunção de veracidade (Art. 341, CPC).",
     "Mérito (Contestação)": "Apresente sua versão dos fatos e a fundamentação jurídica que ampara a improcedência dos pedidos do autor.",
     "Pedidos (Contestação)": "Requeira o acolhimento das preliminares e/ou a improcedência total dos pedidos do autor, além da condenação em custas e honorários.",
+
+    # Dicas Específicas (Exemplo para Recurso)
     "Pressupostos Recursais": "Verifique cabimento, tempestividade, preparo (custas recursais), regularidade formal e interesse/legitimidade.",
     "Dialeticidade (Recurso)": "Impugne especificamente os fundamentos da decisão recorrida (Art. 1010, II e III, CPC para Apelação).",
     "Delimitação da Matéria (Recurso)": "Indique claramente qual parte da decisão você está recorrendo.",
+
+     # Dicas Específicas (Tutela Provisória)
     "Fumus Boni Iuris": "Demonstre a plausibilidade do direito alegado com base em provas e argumentos sólidos.",
     "Periculum in Mora": "Evidencie o risco de dano irreparável ou de difícil reparação se a medida não for concedida imediatamente.",
     "Reversibilidade": "Se possível, argumente que a medida é reversível caso a decisão final seja diferente (Art. 300, §3º, CPC).",
 }
+
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-# --- Funções de Extração de Texto ---
+# --- Funções de Extração de Texto (sem alterações significativas) ---
 def preprocess_image_for_ocr(img):
     try:
         gray = img.convert('L')
@@ -85,7 +105,7 @@ def preprocess_image_for_ocr(img):
         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)}"
+        return f"❌ Erro no pré-processamento: {str(e)}" # Retorna o erro
 
 def extract_text_from_pdf(file_path_or_obj):
     text = ""
@@ -96,30 +116,24 @@ def extract_text_from_pdf(file_path_or_obj):
             page_text = page.extract_text()
             if page_text:
                 text += page_text + "\n"
-            else:
+            else: # Tenta OCR se texto extraído for pobre/vazio
                 logger.warning(f"Página {i+1} sem texto extraível, tentando OCR.")
                 try:
-                    img = page.to_image(resolution=300)
+                    img = page.to_image(resolution=300) # Aumenta resolução para OCR
                     preprocessed_img = preprocess_image_for_ocr(img.original)
-                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por')
+                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por') # Especifica português
                     if page_ocr_text.strip():
                         ocr_text += page_ocr_text + "\n"
                     else:
                         logger.warning(f"OCR falhou na página {i+1}.")
                         ocr_text += f"[OCR falhou na página {i+1}]\n"
                 except Exception as ocr_e:
-                    if "Tesseract is not installed or not in your PATH" in str(ocr_e):
-                         logger.error(f"Erro no OCR: Tesseract não encontrado ou não está no PATH. Verifique a instalação e o packages.txt no HF. {str(ocr_e)}")
-                         return "❌ Erro de OCR: Tesseract não encontrado. Verifique a configuração do ambiente."
-                    else:
-                        logger.error(f"Erro no OCR da página {i+1}: {str(ocr_e)}")
-                        ocr_text += f"[Erro no OCR da página {i+1}: {str(ocr_e)}]\n"
+                    logger.error(f"Erro no OCR da página {i+1}: {str(ocr_e)}")
+                    ocr_text += f"[Erro no OCR da página {i+1}: {str(ocr_e)}]\n"
         pdf_reader.close()
 
-        if "❌ Erro de OCR: Tesseract não encontrado." in ocr_text:
-            return ocr_text
-
-        if text.strip() and len(text) > len(ocr_text) * 0.5:
+        # Decide qual texto retornar
+        if text.strip() and len(text) > len(ocr_text) * 0.5: # Se texto extraído parece razoável
              logger.info("Usando texto extraído do PDF.")
              return text
         elif ocr_text.strip():
@@ -129,11 +143,9 @@ def extract_text_from_pdf(file_path_or_obj):
              logger.warning("Não foi possível extrair texto significativo do PDF.")
              return "⚠️ Não foi possível extrair texto do PDF (tentativa de OCR falhou ou texto inexistente)."
 
-    except ImportError as ie:
-         logger.error(f"Erro de importação ao processar PDF: {str(ie)}. Verifique se 'pdfplumber' está no requirements.txt.")
-         return f"❌ Erro interno: Falta dependência para PDF ({str(ie)})."
     except Exception as e:
-        logger.error(f"Erro geral ao processar o PDF: {str(e)}", exc_info=True)
+        logger.error(f"Erro geral ao processar o PDF: {str(e)}")
+        # Tenta reabrir e usar PyPDF2 como fallback básico se pdfplumber falhar
         try:
             logger.info("Tentando fallback com PyPDF2.")
             text_fallback = ""
@@ -143,6 +155,7 @@ def extract_text_from_pdf(file_path_or_obj):
                     for page in reader.pages:
                         text_fallback += page.extract_text() or ""
             else:
+                # Precisa resetar o ponteiro se for objeto de arquivo
                 file_path_or_obj.seek(0)
                 reader = PyPDF2.PdfReader(file_path_or_obj)
                 for page in reader.pages:
@@ -157,33 +170,41 @@ def extract_text_from_pdf(file_path_or_obj):
             logger.error(f"Erro no fallback com PyPDF2: {str(fallback_e)}")
             return f"❌ Erro crítico ao processar o PDF: {str(e)}"
 
+
 def extract_text_from_docx(file_path_or_obj):
     try:
-        doc = docx.Document(file_path_or_obj)
+        doc = docx.Document(file_path_or_obj) # Funciona com path ou file object
         text = ""
         for para in doc.paragraphs:
             text += para.text + "\n"
+        # Opcional: Extrair texto de tabelas
+        # for table in doc.tables:
+        #     for row in table.rows:
+        #         for cell in row.cells:
+        #             text += cell.text + "\t" # Separar células com tab
+        #         text += "\n"
         return text if text.strip() else "⚠️ Documento DOCX vazio ou sem texto."
-    except ImportError as ie:
-        logger.error(f"Erro de importação ao processar DOCX: {str(ie)}. Verifique se 'python-docx' está no requirements.txt.")
-        return f"❌ Erro interno: Falta dependência para DOCX ({str(ie)})."
     except Exception as e:
-        logger.error(f"Erro ao processar o DOCX: {str(e)}", exc_info=True)
+        logger.error(f"Erro ao processar o DOCX: {str(e)}")
         return f"❌ Erro ao processar o DOCX: {str(e)}"
 
 def extract_text_from_txt(file_path_or_obj):
     try:
+        # Se for um path, abre o arquivo
         if isinstance(file_path_or_obj, str):
             with open(file_path_or_obj, 'rb') as f:
                 content = f.read()
+        # Se for um objeto de arquivo (como do Gradio), lê diretamente
         elif hasattr(file_path_or_obj, 'read'):
             content = file_path_or_obj.read()
+            # Tenta resetar o ponteiro se possível, para reutilização
             if hasattr(file_path_or_obj, 'seek'):
                  try: file_path_or_obj.seek(0)
                  except: pass
         else:
              return "❌ Tipo de entrada TXT inválido."
 
+        # Tenta decodificar com encodings comuns
         encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
         for encoding in encodings:
             try:
@@ -195,51 +216,54 @@ def extract_text_from_txt(file_path_or_obj):
         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)
+        logger.error(f"Erro ao processar o TXT: {str(e)}")
         return f"❌ Erro ao processar o TXT: {str(e)}"
 
 def process_file(file_obj):
-    logger.info(">>> PROCESS FILE INICIADO")
     if file_obj is None:
-        logger.warning("--- Nenhum arquivo fornecido para processamento.")
+        logger.warning("Nenhum arquivo fornecido para processamento.")
         return "⚠️ Nenhum arquivo enviado."
     try:
-        file_path = file_obj.name
+        # Gradio > 3.0 usa tempfile._TemporaryFileWrapper que tem 'name'
+        # Gradio < 3.0 pode usar outros tipos, vamos checar a extensão pelo nome se disponível
+        file_path = getattr(file_obj, 'name', None)
+        if not file_path:
+             logger.error("Não foi possível obter o nome do arquivo do objeto.")
+             return "❌ Erro: Não foi possível identificar o tipo do arquivo."
+
         filename = os.path.basename(file_path).lower()
-        logger.info(f"--- Processando arquivo: {filename} (path: {file_path})")
+        logger.info(f"Processando arquivo: {filename}")
 
+        # Verifica tamanho (usando o arquivo temporário diretamente se possível)
         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} excede o limite de tamanho.")
+             logger.info(f"Tamanho do arquivo: {file_size} bytes")
+             if file_size > 15 * 1024 * 1024: # Aumentado para 15MB
+                 logger.warning(f"Arquivo {filename} excede o limite de tamanho.")
                  return "⚠️ O arquivo é muito grande. Máx. 15 MB."
         except OSError as size_e:
-             logger.warning(f"--- Não foi possível verificar o tamanho do arquivo: {size_e}")
+             logger.warning(f"Não foi possível verificar o tamanho do arquivo: {size_e}")
+             # Não impede o processamento, mas loga o aviso
 
-        result_text = ""
+        # Determina o tipo e extrai o texto
         if filename.endswith('.pdf'):
-            logger.info("--- Chamando extract_text_from_pdf")
-            result_text = extract_text_from_pdf(file_path)
+            # Passa o path do arquivo temporário
+            return extract_text_from_pdf(file_path)
         elif filename.endswith('.docx'):
-            logger.info("--- Chamando extract_text_from_docx")
-            result_text = extract_text_from_docx(file_path)
+             # Passa o path do arquivo temporário
+            return extract_text_from_docx(file_path)
         elif filename.endswith('.txt'):
-            logger.info("--- Chamando extract_text_from_txt")
-            result_text = extract_text_from_txt(file_path)
+             # Passa o path do arquivo temporário
+            return extract_text_from_txt(file_path)
         else:
-            logger.warning(f"--- Formato de arquivo não suportado: {filename}")
-            result_text = "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
-
-        logger.info(f"<<< PROCESS FILE FINALIZADO. Resultado: {result_text[:100]}...")
-        return result_text
+            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)
-        logger.info("<<< PROCESS FILE FINALIZADO COM ERRO GERAL")
         return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
+# --- ESTRUTURAÇÃO DE PROMPTS POR TIPO ---
 
-# --- Funções de Estruturação de Prompt ---
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     base = """
     **Estrutura da Avaliação:**
@@ -294,6 +318,8 @@ def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=Fals
 
     **Requisitos Específicos para {tipo_peticao}:**
     """
+
+    # Adiciona requisitos específicos por tipo
     if tipo_peticao == "Petição Inicial":
         prompt_especifico += """
        - Endereçamento e competência (Art. 319, I, CPC; leis especiais como CDC Art. 101, I).
@@ -471,6 +497,7 @@ def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=Fals
     return prompt_especifico
 
 def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
+    # Prompt base para gerar a versão corrigida
     prompt = f"""
     **Caso/Contexto Fornecido:**
     ```
@@ -486,6 +513,8 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
 
     **Instruções Específicas para a Peça Corrigida ({tipo_peticao}):**
     """
+
+    # Adiciona instruções específicas de CADA TIPO para a GERAÇÃO da peça corrigida
     if tipo_peticao == "Petição Inicial":
         prompt += """
     1.  **Endereçamento:** Correto e fundamentado (Art. 46 CPC ou Art. 101 CDC se aplicável e justificado).
@@ -534,20 +563,8 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
     10. **Continue com os Pedidos da Contestação** (improcedência da ação original, etc.).
     11. **Fechamento:** Padrão OAB.
          """
-    elif tipo_peticao == "Impugnação à Contestação":
-         prompt += """
-    1.  **Endereçamento:** Ao juízo correto.
-    2.  **Identificação:** Processo, Impugnante.
-    3.  **Tempestividade:** Mencione o prazo de 15 dias.
-    4.  **Estrutura:**
-        *   **Resposta às Preliminares:** Rebata cada preliminar arguida.
-        *   **Resposta aos Fatos Impeditivos/Modificativos/Extintivos:** Manifeste-se sobre fatos novos (Art. 350).
-        *   **Resposta aos Documentos:** Manifeste-se sobre documentos juntados (Art. 437).
-        *   **Ratificação da Inicial:** Reitere os termos e pedidos iniciais.
-    5.  **Pedidos:** Rejeição das preliminares, refutação da defesa, procedência da ação.
-    6.  **Provas:** Especifique provas para contrapor a defesa, se necessário.
-    7.  **Fechamento:** Padrão OAB.
-         """
+    # Adicionar instruções detalhadas para os outros tipos... (Impugnação, ED, Apelação, Agravo, Tutela)
+    # Exemplo para Embargos de Declaração:
     elif tipo_peticao == "Embargos de Declaração":
          prompt += """
     1.  **Endereçamento:** Ao juízo que proferiu a decisão embargada.
@@ -560,45 +577,10 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
     6.  **Pedido:** Peça o conhecimento e ACOLHIMENTO dos embargos para sanar o(s) vício(s) apontado(s), especificando o que se espera (ex: "para que seja suprida a omissão quanto a...", "para que seja corrigida a contradição entre..."). Se cabível e fundamentado, pedir efeitos infringentes.
     7.  **Fechamento:** Padrão OAB.
          """
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt += """
-    1.  **Peça de Interposição:** Ao juízo a quo (quem proferiu a sentença).
-    2.  **Identificação:** Processo, Apelante, Apelado.
-    3.  **Pressupostos:** Cabimento, tempestividade, preparo/JG.
-    4.  **Pedido (Interposição):** Recebimento e remessa ao Tribunal.
-    5.  **Razões Recursais:** Ao Tribunal (ad quem).
-    6.  **Resumo:** Fatos, lide, sentença.
-    7.  **Fundamentos (Art. 1010):** Error in procedendo/judicando. **Dialeticidade OBRIGATÓRIA**.
-    8.  **Pedidos (Razões):** Conhecimento, PROVIMENTO para anular/reformar, inversão sucumbência.
-    9.  **Fechamento:** Padrão OAB.
-        """
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt += """
-    1.  **Endereçamento:** Diretamente ao Tribunal.
-    2.  **Identificação:** Processo de origem, Agravante, Agravado, Advogados (com endereços).
-    3.  **Decisão Agravada:** Indicar e juntar cópia OBRIGATÓRIA.
-    4.  **Cabimento:** Demonstrar hipótese do Art. 1015 ou mitigação.
-    5.  **Pressupostos:** Tempestividade, preparo/JG.
-    6.  **Peças Obrigatórias (Art. 1017):** Decisão, intimação, procurações. Facultativas: outras úteis.
-    7.  **Razões:** Exposição do fato e direito para reforma/invalidação.
-    8.  **Efeito Suspensivo/Tutela Antecipada:** Pedir fundamentadamente se necessário (Art. 1019, I).
-    9.  **Pedidos Finais:** Conhecimento, efeito suspensivo/tutela (se houver), PROVIMENTO para reformar/invalidar.
-    10. **Fechamento:** Padrão OAB.
-        """
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += """
-    1.  **Tipo:** Urgência ou Evidência? Antecedente ou Incidental?
-    2.  **Endereçamento:** Juízo competente ou da causa.
-    3.  **Identificação:** Partes, processo (se incidental).
-    4.  **Requisitos:**
-        *   **Urgência (Art. 300):** Fumus Boni Iuris + Periculum in Mora (+ Reversibilidade, se possível).
-        *   **Evidência (Art. 311):** Uma das hipóteses legais (NÃO precisa periculum).
-    5.  **Pedido Específico:** Qual medida liminar é solicitada?
-    6.  **Se Antecedente:** Indicar pedido final ou aditar/completar no prazo.
-    7.  **Pedidos:** Concessão da tutela, citação/intimação.
-    8.  **Fechamento:** Padrão OAB.
-        """
-    else:
+    # (Continuar para os outros tipos: Apelação, Agravo, Tutela, Impugnação)
+    # ... (Omitido por brevidade, mas seguir a mesma lógica dos prompts de análise)
+
+    else: # Fallback genérico
         prompt += """
     1.  **Estrutura Lógica:** Organize a peça com começo, meio e fim.
     2.  **Argumentos:** Apresente os argumentos de forma clara.
@@ -609,7 +591,48 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
     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/...'. Não inclua NENHUM comentário, introdução ou explicação ANTES ou DEPOIS do texto da peça."
     return prompt
 
-# --- Função de Chamada da API ---
+
+def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
+    # Aplica correções finais comuns ou específicas do tipo
+
+    # Correção geral de fechamento
+    if "Nestes termos, pede deferimento" in peticao_corrigida:
+        peticao_corrigida = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
+
+    # Adiciona elementos faltantes ESSENCIAIS (com base no tipo)
+    if tipo_peticao == "Petição Inicial":
+        if "juntada da guia de custas" not in peticao_corrigida.lower() and "gratuidade de justiça" not in peticao_corrigida.lower():
+             # Tenta inserir antes do fechamento final
+             partes = peticao_corrigida.split("Nestes termos pede deferimento")
+             if len(partes) == 2:
+                 peticao_corrigida = partes[0] + "Requer, ainda, a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento" + partes[1]
+             else: # Adiciona no final antes do fechamento se a separação falhar
+                 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_corrigida.lower() and "audiência de mediação" not in peticao_corrigida.lower():
+             # Tenta inserir antes do fechamento final
+             partes = peticao_corrigida.split("Nestes termos pede deferimento")
+             if len(partes) == 2:
+                 peticao_corrigida = partes[0] + "Opta 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: # Adiciona no final antes do fechamento
+                 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.")
+
+
+    # Garantir o fechamento padrão OAB no final
+    linhas = [l.strip() for l in peticao_corrigida.strip().split('\n') if l.strip()]
+    fechamento_padrao = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
+    # Remove qualquer linha de fechamento existente que não seja a padrão
+    while linhas and any(term in linhas[-1] for term in ["ADVOGADO", "OAB", "Local", "data"]):
+        linhas.pop()
+    # Adiciona o fechamento padrão
+    linhas.extend(fechamento_padrao)
+    peticao_corrigida = "\n".join(linhas)
+
+
+    return peticao_corrigida
+
+
 def chamar_api(prompt):
     payload = {
         "contents": [{"parts": [{"text": prompt}]}],
@@ -617,10 +640,13 @@ def chamar_api(prompt):
             "temperature": CONFIG["temperatura"],
             "maxOutputTokens": CONFIG["max_tokens"],
             "topP": 0.95,
+             # Stop sequences podem ajudar a evitar texto indesejado após a peça
+             # "stopSequences": ["```", "---"]
         }
     }
     headers = {"Content-Type": "application/json"}
     logger.info(f"Chamando API Gemini com {len(prompt)} caracteres de prompt. Temperatura: {CONFIG['temperatura']}, Max Tokens: {CONFIG['max_tokens']}")
+    # logger.debug(f"Prompt enviado (primeiros 500 chars): {prompt[:500]}")
 
     for tentativa in range(CONFIG["max_retry_attempts"]):
         try:
@@ -629,6 +655,7 @@ def chamar_api(prompt):
                 response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
 
             logger.debug(f"Status Code recebido: {response.status_code}")
+            # logger.debug(f"Resposta da API (raw): {response.text[:500]}") # Log da resposta crua (cuidado com dados sensíveis)
 
             if response.status_code == 429:
                 retry_after = int(response.headers.get("Retry-After", CONFIG["retry_delay"] * (tentativa + 1)))
@@ -640,13 +667,8 @@ def chamar_api(prompt):
                     return "❌ Erro 429: Muitas requisições. Tente novamente mais tarde."
 
             if response.status_code != 200:
-                error_info = {}
-                error_msg = f"Erro desconhecido (Status {response.status_code})"
-                try:
-                    error_info = response.json()
-                    error_msg = error_info.get("error", {}).get("message", error_msg)
-                except json.JSONDecodeError:
-                    error_msg = f"{error_msg}. Resposta não é JSON: {response.text[:200]}"
+                error_info = response.json()
+                error_msg = error_info.get("error", {}).get("message", "Erro desconhecido na API")
                 logger.error(f"Erro da API (Status {response.status_code}): {error_msg}")
                 if tentativa < CONFIG["max_retry_attempts"] - 1:
                     logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
@@ -656,6 +678,7 @@ def chamar_api(prompt):
 
             response_data = response.json()
 
+            # Verifica bloqueio por segurança ou conteúdo
             if not response_data.get("candidates"):
                  prompt_feedback = response_data.get("promptFeedback", {})
                  block_reason = prompt_feedback.get("blockReason")
@@ -666,10 +689,14 @@ def chamar_api(prompt):
                  else:
                       return "❌ Resposta vazia ou inválida da API (sem 'candidates'). Verifique o log para detalhes."
 
+
             candidate = response_data["candidates"][0]
+
+            # Verifica se a GERAÇÃO foi bloqueada
             finish_reason = candidate.get("finishReason")
             if finish_reason not in [None, "STOP", "MAX_TOKENS"]:
                  logger.error(f"Geração interrompida pela API. Motivo: {finish_reason}")
+                 # Tenta obter a razão específica do bloqueio de segurança se houver
                  safety_ratings_candidate = candidate.get("safetyRatings", [])
                  harm_categories = [r['category'] for r in safety_ratings_candidate if r['probability'] not in ['NEGLIGIBLE', 'LOW']]
                  if harm_categories:
@@ -677,6 +704,7 @@ def chamar_api(prompt):
                  else:
                       return f"❌ A geração da resposta foi interrompida pela API. Motivo: {finish_reason}. Tente novamente ou simplifique a solicitação."
 
+
             if "content" not in candidate or "parts" not in candidate["content"] or not candidate["content"]["parts"]:
                  logger.error("Estrutura de resposta inesperada da API: Faltando content/parts.")
                  if tentativa < CONFIG["max_retry_attempts"] - 1:
@@ -687,6 +715,7 @@ def chamar_api(prompt):
 
             texto_gerado = candidate["content"]["parts"][0]["text"].strip()
             logger.info(f"API retornou com sucesso. Tamanho da resposta: {len(texto_gerado)} caracteres.")
+            # logger.debug(f"Texto gerado (primeiros 500 chars): {texto_gerado[:500]}")
             return texto_gerado
 
         except requests.Timeout:
@@ -705,10 +734,10 @@ def chamar_api(prompt):
             return f"❌ Erro na requisição: {e}"
         except json.JSONDecodeError as e:
              logger.error(f"Erro ao decodificar JSON da resposta da API: {e}")
-             logger.debug(f"Resposta que causou erro de JSON: {response.text[:500]}")
+             logger.debug(f"Resposta que causou erro de JSON: {response.text[:500]}") # Log da resposta problemática
              return f"❌ Erro ao processar a resposta da API (JSON inválido)."
         except Exception as e:
-            logger.exception(f"Erro inesperado na chamada da API na tentativa {tentativa + 1}: {str(e)}")
+            logger.exception(f"Erro inesperado na chamada da API na tentativa {tentativa + 1}: {str(e)}") # Loga o traceback completo
             if tentativa < CONFIG["max_retry_attempts"] - 1:
                  logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
                  time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
@@ -717,34 +746,36 @@ def chamar_api(prompt):
 
     return "❌ Falha ao chamar a API após todas as tentativas."
 
-# --- Função Principal de Correção ---
+
 def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
-    logger.info(f">>> CORRIGIR PETICAO INICIADO - Tipo: {tipo_peticao}, Treinamento: {modo_treinamento}")
+    logger.info(f"Iniciando correção para tipo: {tipo_peticao}")
     start_time = time.time()
 
     if not caso or not caso.strip():
-        logger.warning("--- Caso não fornecido.")
-        return "⚠️ Forneça o caso/contexto da peça.", "", "", "", "", ""
+        logger.warning("Caso não fornecido.")
+        return "⚠️ Forneça o caso/contexto da peça.", "", "", "", "" # Retorna tupla vazia para diff
 
     if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-         logger.warning(f"--- Tipo de petição inválido ou não fornecido: {tipo_peticao}")
-         return "⚠️ Selecione um tipo de petição válido.", "", "", "", "", ""
+         logger.warning(f"Tipo de petição inválido ou não fornecido: {tipo_peticao}")
+         return "⚠️ Selecione um tipo de petição válido.", "", "", "", ""
+
 
     peticao_conteudo = ""
     if peticao_arquivo is not None:
-        logger.info("--- Processando arquivo de petição...")
+        logger.info("Processando arquivo de petição...")
         peticao_conteudo = process_file(peticao_arquivo)
         if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
-            logger.error(f"--- Erro ao processar arquivo: {peticao_conteudo}")
-            return peticao_conteudo, "", "", "", "", ""
-        logger.info(f"--- Texto extraído do arquivo ({len(peticao_conteudo)} caracteres).")
+            logger.error(f"Erro ao processar arquivo: {peticao_conteudo}")
+            return peticao_conteudo, "", "", "", ""
+        logger.info(f"Texto extraído do arquivo ({len(peticao_conteudo)} caracteres).")
     elif peticao_texto and peticao_texto.strip():
          peticao_conteudo = peticao_texto
-         logger.info(f"--- Usando texto da petição fornecido ({len(peticao_conteudo)} caracteres).")
+         logger.info(f"Usando texto da petição fornecido ({len(peticao_conteudo)} caracteres).")
     else:
-        logger.warning("--- Nenhuma petição fornecida (nem texto, nem arquivo).")
-        return "⚠️ Forneça a petição (em texto ou arquivo).", "", "", "", "", ""
+        logger.warning("Nenhuma petição fornecida (nem texto, nem arquivo).")
+        return "⚠️ Forneça a petição (em texto ou arquivo).", "", "", "", ""
 
+    # --- TROLL DETECTION ---
     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",
@@ -763,41 +794,53 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
             "💡 Dica de ouro: Comece! Esboce a peça, mesmo que imperfeita. Depois a gente lapida juntos. Mande bala!",
             "😂 Pedir pra IA fazer a peça é tipo pedir pro GPS dirigir o carro. Ele te guia, mas quem tá no volante é você! Escreva aí!",
         ]
-        logger.info("--- Detectado pedido para escrever petição. Retornando resposta troll.")
-        return random.choice(respostas_troll), "", "", "", "", ""
+        logger.info("Detectado pedido para escrever petição. Retornando resposta troll.")
+        return random.choice(respostas_troll), "", "", "", ""
 
+    # --- VALIDAÇÃO BÁSICA (Opcional e específica) ---
+    # Pode ser desativada ou adaptada, pois é muito focada na Inicial
     aviso_validacao = ""
+    # if tipo_peticao == "Petição Inicial":
+    #     problemas = validar_peticao_basica(peticao_conteudo)
+    #     if problemas:
+    #         aviso_validacao = f"### ⚠️ Alertas Rápidos (Validação Inicial)\n" + "\n".join([f"- {p}" for p in problemas]) + "\n\n---\n\n"
 
+    # --- CACHE CHECK ---
     cache_key = f"{tipo_peticao}|{caso[:100]}|{peticao_conteudo[:100]}|{modo_treinamento}"
     if cache_key in CORRECAO_CACHE:
-        logger.info("--- Correção encontrada no cache.")
+        logger.info("Correção encontrada no cache.")
         cached_data = CORRECAO_CACHE[cache_key]
-        diff_html_cache, _, _ = calcular_diff_interno(cached_data["peticao_original"], cached_data["peticao_corrigida"])
-        logger.info("<<< CORRIGIR PETICAO FINALIZADO (CACHE HIT)")
-        # Retorna 6 elementos para corresponder aos outputs
-        return cached_data["analise_formatada"], cached_data["peticao_original"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"], diff_html_cache
+        # Retorna a tupla completa do cache
+        return cached_data["analise_formatada"], cached_data["peticao_original"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"]
 
-    logger.info("--- Gerando prompt de análise...")
+    # --- CHAMADA PARA ANÁLISE ---
+    logger.info("Gerando prompt de análise...")
     prompt_analise = estruturar_prompt_analise(caso, peticao_conteudo, tipo_peticao, modo_treinamento)
-    logger.info("--- Enviando para análise da API...")
+    logger.info("Enviando para análise da API...")
     analise = chamar_api(prompt_analise)
     if analise.startswith("❌") or analise.startswith("⏱️") or analise.startswith("⚠️"):
-        logger.error(f"--- Erro na análise da petição: {analise}")
-        return aviso_validacao + analise, peticao_conteudo, "", "", "", ""
-    logger.info("--- Análise recebida da API.")
-    analise_formatada = formatar_correcao(analise)
-
-    logger.info("--- Gerando prompt para peça corrigida...")
+        logger.error(f"Erro na análise da petição: {analise}")
+        # Retorna o erro e strings vazias para os outros campos
+        return aviso_validacao + analise, peticao_conteudo, "", "", ""
+    logger.info("Análise recebida da API.")
+    analise_formatada = formatar_correcao(analise) # Formata a análise para melhor visualização
+
+    # --- CHAMADA PARA GERAR PETIÇÃO CORRIGIDA ---
+    logger.info("Gerando prompt para peça corrigida...")
     prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo, tipo_peticao)
-    logger.info("--- Enviando para geração da peça corrigida API...")
+    logger.info("Enviando para geração da peça corrigida API...")
     peticao_corrigida_bruta = chamar_api(prompt_peticao)
 
-    peticao_corrigida_final = ""
+    peticao_corrigida_final = "" # Inicializa
     if peticao_corrigida_bruta.startswith("❌") or peticao_corrigida_bruta.startswith("⏱️") or peticao_corrigida_bruta.startswith("⚠️"):
-        logger.error(f"--- Erro ao gerar peça corrigida: {peticao_corrigida_bruta}")
+        logger.error(f"Erro ao gerar peça corrigida: {peticao_corrigida_bruta}")
+        # Retorna a análise formatada e o erro da peça corrigida
         peticao_corrigida_final = f"⚠️ Falha ao gerar a versão corrigida:\n{peticao_corrigida_bruta}"
     else:
-        logger.info("--- Peça corrigida recebida, aplicando pós-correção...")
+        logger.info("Peça corrigida recebida, aplicando pós-correção...")
+        # Tenta extrair APENAS a peça, caso a IA adicione texto extra
+        # Isso pode ser ajustado conforme o comportamento da IA
+        # Exemplo: procurar por "Excelentíssimo" ou similar e pegar dali pra frente
         start_markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
         start_index = -1
         peticao_lower_corr = peticao_corrigida_bruta.lower()
@@ -810,51 +853,65 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         if start_index != -1:
              peticao_extraida = peticao_corrigida_bruta[start_index:]
         else:
-             peticao_extraida = peticao_corrigida_bruta
+             peticao_extraida = peticao_corrigida_bruta # Usa como está se não achar marcador
 
         peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
-        logger.info("--- Pós-correção aplicada.")
+        logger.info("Pós-correção aplicada.")
+
 
-    logger.info("--- Calculando diferenças...")
+    # --- DIFERENÇA ---
+    logger.info("Calculando diferenças...")
+    # Usar peticao_conteudo (original) e peticao_corrigida_final
+    # A função comparar_peticao_melhorada agora será chamada internamente
+    # para gerar o diff e os resumos, retornando tudo junto.
     diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-    logger.info("--- Diferenças calculadas.")
+    logger.info("Diferenças calculadas.")
+
 
-    correcao_completa_formatada = aviso_validacao + analise_formatada
+    # --- HISTÓRICO E CACHE ---
+    correcao_completa_formatada = aviso_validacao + analise_formatada # Não inclui a peça corrigida aqui
     resultado_historico = {
         "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         "tipo_peticao": tipo_peticao,
         "caso": caso,
         "peticao_original": peticao_conteudo,
-        "analise_formatada": correcao_completa_formatada,
-        "peticao_corrigida": peticao_corrigida_final,
+        "analise_formatada": correcao_completa_formatada, # Salva análise formatada
+        "peticao_corrigida": peticao_corrigida_final, # Salva peça corrigida
         "resumo_diff": resumo_diff,
         "criticas_diff": criticas_diff
+        # Não salva o diff_html no histórico/cache por ser grande
     }
     HISTORICO.append(resultado_historico)
-    if len(HISTORICO) > 10:
+    if len(HISTORICO) > 10: # Limita o histórico
         HISTORICO.pop(0)
 
+    # Salva no cache os dados relevantes para exibição
     CORRECAO_CACHE[cache_key] = {
         "analise_formatada": correcao_completa_formatada,
         "peticao_original": peticao_conteudo,
         "peticao_corrigida": peticao_corrigida_final,
         "resumo_diff": resumo_diff,
         "criticas_diff": criticas_diff,
+        # "diff_html": diff_html # Opcional: salvar se o cache puder lidar
     }
 
     end_time = time.time()
-    logger.info(f"<<< CORRIGIR PETICAO FINALIZADO em {end_time - start_time:.2f} segundos.")
-    # Retorna 6 elementos para corresponder aos outputs
+    logger.info(f"Correção concluída em {end_time - start_time:.2f} segundos.")
+
+    # Retorna todos os resultados necessários para a interface
     return correcao_completa_formatada, peticao_conteudo, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html
 
-# --- Funções Auxiliares ---
+
 def formatar_correcao(texto):
+    # Esta função pode ser melhorada para usar Markdown de forma mais eficaz
+    # Ex: usar ** para títulos, * para ênfase, etc.
     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 dos Requisitos")
 
+    # Adiciona um pouco mais de formatação básica
     linhas = texto.split('\n')
     linhas_formatadas = []
     in_list = False
@@ -864,6 +921,7 @@ def formatar_correcao(texto):
              linhas_formatadas.append(f"\n**{linha_strip}**")
              in_list = False
         elif linha_strip.startswith("- ") or linha_strip.startswith("* "):
+             # Melhora listas dentro de pontos a melhorar
              prefix = "  * " if in_list else "* "
              linhas_formatadas.append(prefix + linha_strip[2:])
              in_list = True
@@ -872,10 +930,13 @@ def formatar_correcao(texto):
              in_list = True
         else:
             linhas_formatadas.append(linha)
-            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")):
+            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")): # Reseta se não for item de lista
                  in_list = False
 
+
+    # Tenta formatar a nota
     texto_final = "\n".join(linhas_formatadas)
+    import re
     nota_pattern = r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})"
     match = re.search(nota_pattern, texto_final, re.IGNORECASE)
     if match:
@@ -884,6 +945,7 @@ def formatar_correcao(texto):
 
     return texto_final
 
+
 def fornecer_dica_contextual(texto_peticao, tipo_peticao):
     if not texto_peticao or not texto_peticao.strip():
         return "Digite algo na petição para receber dicas..."
@@ -891,10 +953,12 @@ def fornecer_dica_contextual(texto_peticao, tipo_peticao):
     dicas_relevantes = []
     texto_lower = texto_peticao.lower()
 
+    # Adiciona dicas gerais primeiro
     for chave, dica in DICAS_OAB_MELHORADO.items():
          if chave in ["Clareza e Concisão", "Fundamentação Legal", "Coerência Argumentativa", "Revisão Ortográfica e Gramatical", "Formatação"]:
               dicas_relevantes.append(f"💡 **{chave}:** {dica}")
 
+    # Adiciona dicas específicas do tipo (se houver palavras-chave)
     keywords_por_tipo = {
         "Petição Inicial": ["endereçamento", "qualificação", "fatos", "fundamentos", "pedidos", "valor da causa", "provas", "audiência", "citação", "custas"],
         "Contestação": ["preliminar", "mérito", "impugnação", "fatos", "improcedência", "provas", "honorários"],
@@ -909,6 +973,7 @@ def fornecer_dica_contextual(texto_peticao, tipo_peticao):
     if tipo_peticao in keywords_por_tipo:
          for keyword in keywords_por_tipo[tipo_peticao]:
               if keyword in texto_lower:
+                   # Busca dicas que contenham a keyword ou o tipo no nome
                    for chave, dica in DICAS_OAB_MELHORADO.items():
                         chave_lower = chave.lower()
                         if f"({tipo_peticao.split()[0].lower()})" in chave_lower or keyword in chave_lower:
@@ -919,11 +984,15 @@ def fornecer_dica_contextual(texto_peticao, tipo_peticao):
     if not dicas_relevantes:
         return "💡 Continue escrevendo ou selecione o tipo de peça para dicas mais específicas."
 
-    return "\n\n".join(dicas_relevantes[:5])
+    # Limita o número de dicas exibidas
+    return "\n\n".join(dicas_relevantes[:5]) # Mostra no máximo 5 dicas
+
+# --- Funções de Comparação (Diff) ---
 
 def calcular_diff_interno(texto_original, texto_corrigido):
+    """Calcula a diferença e retorna HTML, resumo e críticas."""
     if not texto_original or not texto_corrigido or texto_corrigido.startswith("⚠️") or texto_corrigido.startswith("❌"):
-        return "","",""
+        return "","","" # Retorna vazio se não houver o que comparar
 
     orig_lines = texto_original.splitlines()
     corr_lines = texto_corrigido.splitlines()
@@ -953,6 +1022,8 @@ def calcular_diff_interno(texto_original, texto_corrigido):
             resultado_diff_html.append(f"<div class='linha-adicionada' title='Adicionado'><ins>{texto_escaped}</ins></div>")
             if any(kw in texto.lower() for kw in keywords_criticas_adicionadas):
                  criticas.append(f"<span style='color: green;'>🟢 ADICIONADO (Potencialmente Essencial):</span> {texto_escaped}")
+        #elif linha.startswith('? '): # Linha de informação do diff, pode ser ignorada ou estilizada
+            # resultado_diff_html.append(f"<div class='linha-info'>{texto_escaped}</div>")
 
     resumo_estatistico = f"""
 **Resumo das Mudanças:**
@@ -963,6 +1034,7 @@ def calcular_diff_interno(texto_original, texto_corrigido):
 
     criticas_texto = "### 🚨 Mudanças Críticas / Essenciais Identificadas:\n" + "\n".join(criticas) if criticas else "Nenhuma mudança crítica/essencial automaticamente detectada."
 
+    # Estilo CSS para o HTML do Diff
     css = """
 <style>
 .diff-container { font-family: monospace; white-space: pre-wrap; border: 1px solid #ccc; padding: 10px; background-color: #f9f9f9; }
@@ -979,6 +1051,9 @@ def calcular_diff_interno(texto_original, texto_corrigido):
 
     return visualizacao_detalhada_html, resumo_estatistico, criticas_texto
 
+
+# --- Funções de Progresso e Histórico ---
+
 def calcular_progresso():
     if not HISTORICO:
         return "📊 Nenhum progresso registrado ainda."
@@ -987,6 +1062,7 @@ def calcular_progresso():
     tipos_corrigidos = set()
     for entry in HISTORICO:
         tipos_corrigidos.add(entry["tipo_peticao"])
+        # Extrai a nota da análise formatada
         nota_str = "N/A"
         match = re.search(r"\*\*(\d{1,2}[,.]\d{1}|\d{1,2})/10\*\*", entry["analise_formatada"])
         if match:
@@ -995,7 +1071,7 @@ def calcular_progresso():
                 notas.append(nota)
                 nota_str = f"{nota:.1f}"
             except ValueError:
-                pass
+                pass # Ignora se não conseguir converter
 
     total_corridas = len(HISTORICO)
     media = sum(notas) / len(notas) if notas else 0
@@ -1017,32 +1093,43 @@ def calcular_progresso():
 """
     return progresso_texto
 
+
 def mostrar_historico():
     if not HISTORICO:
         return "📜 Histórico vazio."
 
     historico_md = "### 📜 Histórico de Correções (Últimas 10)\n\n---\n"
+    # Mostra do mais recente para o mais antigo
     for i, entry in enumerate(reversed(HISTORICO)):
         caso_resumo = (entry['caso'][:80] + '...') if len(entry['caso']) > 80 else entry['caso']
+        peticao_resumo = (entry['peticao_original'][:80] + '...') if len(entry['peticao_original']) > 80 else entry['peticao_original']
+
+        # Tenta pegar a nota
         nota_str = "N/A"
         match = re.search(r"\*\*(\d{1,2}[,.]\d{1}|\d{1,2})/10\*\*", entry["analise_formatada"])
         if match:
              nota_str = f"{match.group(1).replace(',', '.')}/10"
 
+
         historico_md += f"**{len(HISTORICO)-i}. Data:** {entry['data']}\n"
         historico_md += f"**Tipo:** {entry['tipo_peticao']}\n"
         historico_md += f"**Nota:** {nota_str}\n"
         historico_md += f"**Caso:** _{caso_resumo}_\n"
+        # historico_md += f"**Petição Original:** _{peticao_resumo}_\n" # Pode poluir muito
         historico_md += "---\n"
     return historico_md
 
+
+# --- Funções de Salvar/Carregar Progresso ---
+
 def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info(">>> SALVAR PROGRESSO INICIADO")
+    logger.info("Iniciando salvamento de progresso...")
     try:
         if not caso or not peticao or not tipo_peticao:
-            logger.warning("--- Inputs insuficientes para salvar progresso.")
+            logger.warning("Inputs insuficientes para salvar progresso.")
             return "", "⚠️ Caso, Petição e Tipo de Petição são necessários para salvar.", None
 
+        # Salva apenas os inputs atuais, não o histórico inteiro
         dados_progresso = {
             "tipo_peticao": tipo_peticao,
             "caso": caso,
@@ -1051,57 +1138,62 @@ def salvar_progresso(caso, peticao, tipo_peticao):
         }
 
         json_content = json.dumps(dados_progresso, ensure_ascii=False, indent=4)
+
+        # Cria nome de arquivo com data/hora para evitar conflitos
         timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
         filename = f"progresso_peticao_{timestamp_str}.json"
+
+        # Usa NamedTemporaryFile para segurança e limpeza automática se algo der errado
+        # Mas precisamos do path para o Gradio File output, então gerenciamos manualmente
         temp_dir = tempfile.gettempdir()
         temp_file_path = os.path.join(temp_dir, filename)
 
         with open(temp_file_path, 'w', encoding='utf-8') as f:
             f.write(json_content)
 
-        logger.info(f"--- Progresso salvo com sucesso no arquivo temporário: {temp_file_path}")
+        logger.info(f"Progresso salvo com sucesso no arquivo temporário: {temp_file_path}")
+
         success_message = (
             f"✅ Progresso salvo! Baixe o arquivo `{filename}`. "
             "Use o botão 'Carregar Progresso' e selecione este arquivo para restaurar."
         )
-        logger.info("<<< SALVAR PROGRESSO FINALIZADO COM SUCESSO")
-        # Retorna o path para o componente gr.File poder oferecer o download
+
+        # Retorna o conteúdo (para visualização opcional), a mensagem e o path do arquivo para download
         return json_content, success_message, temp_file_path
 
     except Exception as e:
         logger.error(f"Erro ao salvar progresso: {str(e)}", exc_info=True)
-        logger.info("<<< SALVAR PROGRESSO FINALIZADO COM ERRO")
-        # Retorna None para o path do arquivo em caso de erro
         return "", f"❌ Erro ao salvar o progresso: {str(e)}", None
 
+
 def carregar_progresso(arquivo_entrada):
-    logger.info(">>> CARREGAR PROGRESSO INICIADO")
+    logger.info("Iniciando carregamento de progresso...")
     if arquivo_entrada is None:
-        logger.warning("--- Nenhum arquivo selecionado para carregar.")
         return "", "", "", "⚠️ Nenhum arquivo selecionado para carregar."
 
     try:
+        # Gradio File object tem o atributo 'name' com o path do arquivo temporário
         file_path = arquivo_entrada.name
-        logger.info(f"--- Carregando progresso do arquivo: {file_path}")
+        logger.info(f"Carregando progresso do arquivo: {file_path}")
 
         with open(file_path, 'r', encoding='utf-8') as f:
             dados = json.load(f)
 
+        # Verifica se as chaves esperadas existem
         caso = dados.get("caso")
         peticao = dados.get("peticao")
         tipo_peticao = dados.get("tipo_peticao")
 
         if caso is None or peticao is None or tipo_peticao is None:
-             logger.warning(f"--- Arquivo JSON carregado não contém as chaves esperadas: {dados.keys()}")
+             logger.warning(f"Arquivo JSON carregado não contém as chaves esperadas: {dados.keys()}")
              return "", "", "", "❌ Erro: Arquivo de progresso inválido ou incompleto."
 
         if tipo_peticao not in TIPOS_DE_PETICAO:
-             logger.warning(f"--- Tipo de petição '{tipo_peticao}' do arquivo não é válido.")
-             # Retorna os dados carregados, mas deixa o dropdown vazio para seleção manual
-             return gr.update(value=None), caso, peticao, f"⚠️ Tipo de petição '{tipo_peticao}' do arquivo não é mais válido. Selecione manualmente."
+             logger.warning(f"Tipo de petição '{tipo_peticao}' do arquivo não é válido.")
+             return caso, peticao, "", f"⚠️ Tipo de petição '{tipo_peticao}' do arquivo não é mais válido. Selecione manualmente."
 
-        logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM SUCESSO")
-        # Retorna os valores corretos para atualizar os componentes
+
+        logger.info("Progresso carregado com sucesso.")
         return tipo_peticao, caso, peticao, "✅ Progresso carregado com sucesso!"
 
     except json.JSONDecodeError:
@@ -1109,69 +1201,119 @@ def carregar_progresso(arquivo_entrada):
         return "", "", "", "❌ Erro: Arquivo selecionado não é um JSON válido."
     except Exception as e:
         logger.error(f"Erro ao carregar o progresso: {str(e)}", exc_info=True)
-        logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM ERRO")
         return "", "", "", f"❌ Erro inesperado ao carregar o progresso: {str(e)}"
 
-# --- Geração de Caso Fictício ---
-def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    logger.info(f">>> GERAR CASO FICTICIO INICIADO para: {tipo_peticao}")
-    if not tipo_peticao:
-        logger.error("--- Tipo de petição não selecionado para gerar caso.")
-        return "Erro: Tipo de petição não selecionado para gerar caso."
-    prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-    logger.info("--- Prompt de geração de caso estruturado.")
-    caso_gerado = chamar_api(prompt)
-    logger.info(f"--- Resultado da chamada API para gerar caso: {caso_gerado[:100]}...")
 
-    if caso_gerado.startswith("❌") or caso_gerado.startswith("⏱️") or caso_gerado.startswith("⚠️"):
-        logger.error(f"--- Erro ao gerar caso fictício: {caso_gerado}")
-        return f"Falha ao gerar caso fictício.\n{caso_gerado}"
+# --- GERAÇÃO DE CASOS ---
 
-    frase_final_padrao = f"**Situação-Problema:** Na qualidade de advogado(a) de"
-    if frase_final_padrao.lower() not in caso_gerado.lower():
-        logger.warning("--- Frase 'Situação-Problema' não encontrada. Adicionando manualmente.")
-        nomes_possiveis = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
-        cliente_nome = nomes_possiveis[0] if nomes_possiveis else "[Cliente]"
-        caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente_nome}, elabore a peça processual cabível ({tipo_peticao})."
+def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
+    prompt = f"""
+    Crie um caso fictício **detalhado e realista** para um exercício prático de elaboração de uma peça do tipo **"{tipo_peticao}"**, simulando um cenário de Exame de Ordem (OAB).
 
-    logger.info("<<< GERAR CASO FICTICIO FINALIZADO COM SUCESSO")
-    return caso_gerado
+    **Instruções Gerais para o Caso:**
+    1.  **Complexidade Adequada:** Deve ter informações suficientes para redigir a peça solicitada, mas sem ser excessivamente longo ou complicado. (Ideal: 15-25 linhas).
+    2.  **Dados Essenciais:** Inclua nomes completos (fictícios) das partes envolvidas, locais (cidades/estados fictícios ou genéricos), datas relevantes, valores monetários (se aplicável), e uma descrição clara da relação jurídica e do conflito.
+    3.  **Coerência:** Os fatos devem ser lógicos e justificar a peça processual indicada.
+    4.  **Foco no Tipo de Peça:** O cenário deve ser construído para exigir especificamente a elaboração de um(a) **{tipo_peticao}**.
 
-# --- Validação Básica ---
-def validar_peticao_basica(peticao):
-    problemas = []
-    peticao_lower = peticao.lower()
-    if "excelentíssimo" not in peticao_lower and "eméritos" not in peticao_lower and "meritíssimo" not in peticao_lower :
-        problemas.append("Endereçamento inicial parece ausente ou incompleto.")
-    if "valor da causa" not in peticao_lower and "valor à causa" not in peticao_lower:
-        problemas.append("Atribuição de Valor da Causa não encontrada (essencial na Inicial).")
-    if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower :
-        problemas.append("Pedido de juntada de custas ou gratuidade de justiça não encontrado (essencial na Inicial).")
-    if "nestes termos" not in peticao_lower and "pede deferimento" not in peticao_lower:
-        problemas.append("Fechamento formal padrão ('Nestes termos pede deferimento') parece ausente.")
-    return problemas
+    **Instruções Específicas para Gerar Caso para "{tipo_peticao}":**
+    """
+
+    if tipo_peticao == "Petição Inicial":
+        prompt += """
+    *   Descreva uma situação onde direitos foram violados (contrato descumprido, dano sofrido, etc.) e o cliente (autor) busca a tutela jurisdicional pela primeira vez.
+    *   Inclua elementos que permitam calcular danos materiais e/ou justificar danos morais.
+    *   Forneça dados para qualificação das partes (autor e réu).
+    *   **Exemplo de Tema:** Acidente de consumo, inadimplemento contratual, cobrança indevida, ação de despejo, etc.
+    """
+    elif tipo_peticao == "Contestação":
+        prompt += """
+    *   **Apresente PRIMEIRO um resumo da Petição Inicial** que o réu (seu cliente) recebeu (quem processou, o que alegou, o que pediu).
+    *   **Depois, apresente a versão dos fatos do RÉU**, incluindo informações que permitam:
+        *   Alegar preliminares (ex: incompetência do juízo, ilegitimidade da parte, etc.).
+        *   Impugnar os fatos da inicial.
+        *   Apresentar defesa de mérito (ex: pagamento já realizado, culpa exclusiva da vítima, prescrição, etc.).
+    *   Forneça dados para qualificação do réu.
+    """
+    elif tipo_peticao == "Reconvenção":
+         prompt += """
+    *   Siga a estrutura da **Contestação**: Apresente o resumo da Petição Inicial do autor original.
+    *   Apresente a versão dos fatos do Réu (seu cliente) para a defesa.
+    *   **ADICIONE fatos e fundamentos que permitam ao RÉU fazer um pedido PRÓPRIO contra o AUTOR ORIGINAL**, que seja CONEXO com a ação principal ou com a defesa.
+    *   **Exemplo:** Numa ação de cobrança, o réu contesta e reconvém pedindo indenização por danos que o autor lhe causou no mesmo negócio.
+    """
+    elif tipo_peticao == "Impugnação à Contestação":
+        prompt += """
+    *   Apresente um resumo da Petição Inicial original do seu cliente (Autor).
+    *   **Apresente um resumo da Contestação** apresentada pelo réu, destacando:
+        *   As preliminares arguidas pelo réu (se houver).
+        *   Os fatos novos (impeditivos, modificativos, extintivos) alegados pelo réu.
+        *   Os documentos juntados pelo réu (se houver menção a algum relevante).
+    *   O objetivo é fornecer elementos para o Autor rebater a contestação.
+    """
+    elif tipo_peticao == "Embargos de Declaração":
+        prompt += """
+    *   Descreva brevemente o caso original (quem processou quem e por quê).
+    *   **Apresente o DISPOSITIVO ou um TRECHO FUNDAMENTAL de uma DECISÃO JUDICIAL (sentença, acórdão, etc.)** proferida no caso.
+    *   **INDIQUE CLARAMENTE qual o vício (omissão, contradição, obscuridade ou erro material) presente NESSA DECISÃO**, fornecendo contexto para que o aluno possa identificar e fundamentar os Embargos.
+    *   **Exemplo:** "A sentença julgou procedente o pedido X, mas foi omissa quanto ao pedido Y que também constava na inicial." OU "O acórdão afirmou X na fundamentação, mas concluiu Y no dispositivo, gerando contradição."
+    """
+    elif tipo_peticao == "Recurso de Apelação":
+        prompt += """
+    *   Descreva o caso original (Autor vs. Réu, causa de pedir, pedidos).
+    *   **Apresente um resumo da SENTENÇA proferida pelo juiz de primeira instância**, indicando se foi procedente, improcedente, parcialmente procedente, e os principais fundamentos do juiz.
+    *   **FORNEÇA ELEMENTOS que indiquem um ERRO na sentença (error in judicando ou in procedendo)**, que justifiquem a reforma ou anulação pelo Tribunal.
+    *   **Exemplo:** "A sentença julgou improcedente o pedido por falta de provas, ignorando o documento X juntado aos autos." OU "O juiz indeferiu a oitiva da testemunha chave Y, cerceando a defesa do réu, e julgou procedente."
+    *   Indique quem é o cliente (apelante).
+    """
+    elif tipo_peticao == "Agravo de Instrumento":
+        prompt += """
+    *   Descreva o caso original em andamento.
+    *   **Apresente uma DECISÃO INTERLOCUTÓRIA específica** proferida pelo juiz (NÃO a sentença final).
+    *   **A decisão DEVE se enquadrar numa das hipóteses do Art. 1015 do CPC** (ou justificar a taxatividade mitigada).
+    *   **FORNEÇA ELEMENTOS que indiquem um ERRO nessa decisão interlocutória** E, se possível, a **URGÊNCIA** em revertê-la (risco de dano).
+    *   **Exemplo:** "O juiz indeferiu o pedido de gratuidade de justiça, embora o autor tenha comprovado baixa renda." OU "O juiz deferiu a liminar de busca e apreensão do bem X sem a devida comprovação da mora."
+    *   Indique quem é o cliente (agravante).
+    """
+    elif tipo_peticao == "Petição de Tutela Provisória":
+        prompt += """
+    *   Descreva uma situação de conflito onde uma das partes precisa de uma medida **urgente** (risco iminente) ou onde seu direito é **evidente**.
+    *   **FORNEÇA ELEMENTOS claros que demonstrem:**
+        *   **Para Urgência:** A probabilidade do direito (fumus boni iuris) E o perigo de dano ou risco ao resultado útil do processo (periculum in mora).
+        *   **Para Evidência:** Uma das hipóteses do Art. 311 do CPC (ex: defesa protelatória, tese firmada em repetitivo, etc.).
+    *   Indique qual medida específica o cliente deseja (ex: bloqueio de bens, retirada de nome do SPC, etc.).
+    *   Especifique se a tutela é pedida ANTES do processo principal (antecedente) ou DENTRO de um processo já existente (incidental).
+    """
+    else:
+         prompt += "*   Crie um cenário jurídico cível com um conflito claro entre duas ou mais partes."
+
+    prompt += """
+    **Finalize o caso com:**
+    "**Situação-Problema:** Na qualidade de advogado(a) de [Nome do Cliente], elabore a peça processual cabível ({tipo_peticao})."
+
+    **Importante:** Evite criar casos que dependam de conhecimento jurídico EXTREMAMENTE específico ou de nicho. Foque em temas comuns do direito civil e processual civil. Seja criativo!
+    """
+    return prompt
 
 # --- Interface Gradio ---
+
 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 ⚖️")
         gr.Markdown("Analise e aprimore suas peças processuais! Selecione o tipo, forneça o caso e sua peça (texto ou arquivo).")
 
-        # Definir o Textbox oculto aqui para que as saídas dos botões possam referenciá-lo
-        peticao_original_hidden = gr.Textbox(visible=False, label="Original Hidden")
-
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("### Configurações")
+                gr.Markdown("###  настроики (Settings)") # Configurações em Russo para brincar ;)
                 tipo_peticao_input = gr.Dropdown(
-                    label="Selecione o Tipo de Peça Processual",
+                    label=" Selecione o Tipo de Peça Processual",
                     choices=TIPOS_DE_PETICAO,
-                    value="Petição Inicial"
+                    value="Petição Inicial" # Default
                 )
                 modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento (Feedback Detalhado)", value=False)
 
                 with gr.Accordion("⚙️ Configurações Avançadas", open=False):
-                    temperatura_slider = gr.Slider(minimum=0.0, maximum=1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade (Temperatura)")
+                    temperatura_slider = gr.Slider(minimum=0.0, maximum=1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade (Temperatura)", info="Valores maiores geram respostas mais criativas, porém menos previsíveis.")
                     timeout_slider = gr.Slider(minimum=30, maximum=180, value=CONFIG["timeout"], step=10, label="Timeout da API (segundos)")
                     max_tokens_slider = gr.Slider(minimum=2048, maximum=8192, value=CONFIG["max_tokens"], step=256, label="Tamanho Máx. Resposta (Tokens)")
                     def atualizar_config(temp, timeout, tokens):
@@ -1196,8 +1338,11 @@ def interface_gradio():
                      salvar_btn = gr.Button("💾 Salvar Caso/Peça Atual")
                      carregar_btn = gr.Button("📂 Carregar Caso/Peça de Arquivo")
                      arquivo_progresso_upload = gr.File(label="Selecione o arquivo .json para carregar", file_types=[".json"], scale=2)
-                     # Definido como interactive=False desde o início
+                     # Para o download
                      progresso_download_file = gr.File(label="Baixar Progresso Salvo", interactive=False)
+                     # Para visualização opcional do JSON salvo
+                     # progresso_json_output = gr.Textbox(label="Progresso Salvo (JSON)", lines=3, interactive=False, visible=False)
+
 
             with gr.Column(scale=3):
                 gr.Markdown("### 1. Forneça o Caso / Contexto")
@@ -1205,20 +1350,23 @@ def interface_gradio():
                      caso_input = gr.Textbox(label="📋 Caso ou Situação Processual", lines=10, placeholder="Insira o texto COMPLETO do caso ou da situação (ex: resumo da inicial para contestação, decisão para embargos/recurso).")
                      caso_btn = gr.Button("🎲 Gerar Caso Fictício", variant="secondary", scale=0)
 
+
                 gr.Markdown("### 2. Insira Sua Peça Processual")
                 with gr.Tabs():
                     with gr.TabItem("✏️ Digitar Texto"):
                         peticao_texto_input = gr.Textbox(label="Texto da Peça", lines=15, placeholder="Cole ou digite sua peça processual aqui...")
-                        dica_contextual_output = gr.Markdown(value="*Dicas aparecerão aqui enquanto você digita...*")
+                        dica_contextual_output = gr.Markdown(value="*Dicas aparecerão aqui enquanto você digita...*") # Usar Markdown
                         btn_corrigir = gr.Button("🚀 CORRIGIR E ANALISAR!", variant="primary")
 
                     with gr.TabItem("📎 Anexar Arquivo"):
-                        peticao_arquivo_input = gr.File(label="Arquivo da Peça (.pdf, .docx, .txt - Máx 15MB)", file_types=[".pdf", ".docx", ".txt"], file_count="single")
+                        peticao_arquivo_input = gr.File(label="Arquivo da Peça (.pdf, .docx, .txt - Máx 15MB)", file_types=[".pdf", ".docx", ".txt"])
                         arquivo_preview_output = gr.Textbox(label="🔍 Prévia do Conteúdo do Arquivo (Texto Extraído)", lines=5, interactive=False)
                         btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR E ANALISAR ARQUIVO!", variant="primary")
 
-        processing_message = gr.Markdown("", visible=False)
 
+        processing_message = gr.Markdown("", visible=False) # Para feedback de processamento
+
+        # --- ABA DE RESULTADOS ---
         with gr.Tabs():
              with gr.TabItem("📊 Análise e Correção"):
                   gr.Markdown("### 3. Resultados da Análise")
@@ -1235,123 +1383,99 @@ def interface_gradio():
                             criticas_output = gr.Markdown(label="Mudanças Críticas/Essenciais")
                        with gr.Column(scale=3):
                             visualizacao_detalhada_output = gr.HTML(label="📝 Alterações Detalhadas (Diff)")
+                            # Saídas ocultas para guardar os textos comparados
+                            # peticao_aluno_output_diff = gr.Textbox(visible=False)
+                            # peticao_corrigida_output_diff = gr.Textbox(visible=False)
 
-        clear_btn = gr.Button("🗑️ Limpar Tudo")
 
-        # --- FUNÇÕES WRAPPER (com try-except) ---
-        def corrigir_peticao_wrapper_texto(caso, tipo_peticao, peticao_texto, peticao_arquivo_state):
-            logger.info(">>> WRAPPER TEXTO INICIADO")
-            is_treinamento = modo_treinamento.value
-            logger.info(f"--- Modo Treinamento (Texto): {is_treinamento}")
-            try:
-                # A função corrigir_peticao retorna 6 valores
-                resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto, peticao_arquivo_state, is_treinamento)
-            except Exception as e:
-                logger.error(f"Erro dentro do wrapper texto chamando corrigir_peticao: {e}", exc_info=True)
-                # Retornar tupla com erro para todos os outputs esperados (6 outputs)
-                return f"❌ Erro interno no processamento: {e}", "", "", "", "", ""
-            logger.info("<<< WRAPPER TEXTO FINALIZADO")
-            return resultado
-
-        def corrigir_peticao_wrapper_arquivo(caso, tipo_peticao, peticao_texto_state, peticao_arquivo):
-            logger.info(">>> WRAPPER ARQUIVO INICIADO")
-            is_treinamento = modo_treinamento.value
-            logger.info(f"--- Modo Treinamento (Arquivo): {is_treinamento}")
-            try:
-                # A função corrigir_peticao retorna 6 valores
-                resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto_state, peticao_arquivo, is_treinamento)
-            except Exception as e:
-                logger.error(f"Erro dentro do wrapper arquivo chamando corrigir_peticao: {e}", exc_info=True)
-                 # Retornar tupla com erro para todos os outputs esperados (6 outputs)
-                return f"❌ Erro interno no processamento: {e}", "", "", "", "", ""
-            logger.info("<<< WRAPPER ARQUIVO FINALIZADO")
-            return resultado
-        # --- FIM DAS FUNÇÕES WRAPPER ---
+        # --- Botão Limpar ---
+        clear_btn = gr.Button("🗑️ Limpar Tudo")
 
 
         # --- LÓGICA DOS BOTÕES E EVENTOS ---
 
+        # Gerar Caso Fictício
         caso_btn.click(
              fn=gerar_caso_ficticio,
-             inputs=[tipo_peticao_input],
-             outputs=[caso_input],
-             show_progress="full"
+             inputs=[tipo_peticao_input], # Passa o tipo selecionado
+             outputs=[caso_input]
         )
 
+        # Atualizar dicas contextuais
         peticao_texto_input.change(
              fn=fornecer_dica_contextual,
              inputs=[peticao_texto_input, tipo_peticao_input],
              outputs=dica_contextual_output
         )
+         # Atualizar dicas se o TIPO mudar e já houver texto
         tipo_peticao_input.change(
              fn=fornecer_dica_contextual,
              inputs=[peticao_texto_input, tipo_peticao_input],
              outputs=dica_contextual_output
         )
 
+
+        # Processar arquivo para preview
         peticao_arquivo_input.change(
              fn=process_file,
              inputs=[peticao_arquivo_input],
-             outputs=[arquivo_preview_output],
-             show_progress="minimal"
+             outputs=[arquivo_preview_output]
         )
 
-        # Botão Corrigir (Texto) - Usando wrapper e output corrigido
+        # Botão Corrigir (Texto)
         btn_corrigir.click(
             fn=lambda: gr.update(value="⏳ Processando... Gerando análise e correção. Isso pode levar um minuto...", visible=True),
             inputs=None,
-            outputs=[processing_message],
-            show_progress=False
+            outputs=[processing_message]
         ).then(
-            fn=corrigir_peticao_wrapper_texto,
-            inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None)],
-            # 6 outputs correspondendo aos 6 valores retornados por corrigir_peticao
-            outputs=[resultado_analise_output, peticao_original_hidden, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            show_progress="full"
+            fn=corrigir_peticao,
+            # Inputs: caso, tipo_peticao, peticao_texto, peticao_arquivo=None, modo_treinamento
+            inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None), modo_treinamento],
+            # Outputs: analise_fmt, peticao_orig, peticao_corr, resumo_diff, criticas_diff, diff_html
+            outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output, # peticao_aluno_output_diff (oculto)
+                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output]
         ).then(
             fn=lambda: gr.update(value="", visible=False),
             inputs=None,
             outputs=[processing_message]
         )
 
-        # Botão Corrigir (Arquivo) - Usando wrapper e output corrigido
+        # Botão Corrigir (Arquivo)
         btn_corrigir_arquivo.click(
             fn=lambda: gr.update(value="⏳ Processando arquivo... Gerando análise e correção. Isso pode levar um minuto...", visible=True),
             inputs=None,
-            outputs=[processing_message],
-            show_progress=False
+            outputs=[processing_message]
         ).then(
-            fn=corrigir_peticao_wrapper_arquivo,
-            inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input],
-            # 6 outputs correspondendo aos 6 valores retornados por corrigir_peticao
-            outputs=[resultado_analise_output, peticao_original_hidden, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-             show_progress="full"
+            fn=corrigir_peticao,
+             # Inputs: caso, tipo_peticao, peticao_texto=None, peticao_arquivo, modo_treinamento
+            inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input, modo_treinamento],
+             # Outputs: analise_fmt, peticao_orig, peticao_corr, resumo_diff, criticas_diff, diff_html
+            outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output, # peticao_aluno_output_diff (oculto)
+                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output]
         ).then(
             fn=lambda: gr.update(value="", visible=False),
             inputs=None,
             outputs=[processing_message]
         )
 
-        # Botão Limpar - Usando gr.update()
+        # Botão Limpar
         clear_btn.click(
             fn=lambda: [
-                gr.update(value="Petição Inicial"),
-                gr.update(value=False),
-                gr.update(value=None),
-                gr.update(value=None),
-                gr.update(value=None),
-                gr.update(value=""),
-                gr.update(value="", visible=False),
-                gr.update(value=""),
-                gr.update(value=""),
-                gr.update(value=""),
-                gr.update(value=""),
-                gr.update(value=""),
-                gr.update(value="*Dicas aparecerão aqui enquanto você digita...*"),
-                gr.update(value=None),
-                gr.update(value=None) # Limpa o valor do arquivo de download
+                "Petição Inicial", # Reseta Dropdown
+                False, # Reseta Modo Treinamento
+                None, # Caso
+                None, # Petição Texto
+                None, # Petição Arquivo
+                None, # Arquivo Preview
+                "", # Mensagem Processamento
+                "", # Análise
+                "", # Petição Corrigida
+                "", # Resumo Diff
+                "", # Críticas Diff
+                "", # HTML Diff
+                "", # Dicas Contextuais
+                None, # Arquivo Progresso Upload
+                None, # Arquivo Progresso Download
             ],
             inputs=None,
             outputs=[
@@ -1359,51 +1483,113 @@ def interface_gradio():
                 arquivo_preview_output, processing_message, resultado_analise_output,
                 resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output,
                 visualizacao_detalhada_output, dica_contextual_output, arquivo_progresso_upload,
-                progresso_download_file # Mantém o componente na lista de outputs
+                progresso_download_file
             ]
         )
 
+        # Botões de Progresso e Histórico
         progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
         historico_btn.click(fn=mostrar_historico, outputs=historico_output)
 
-        # Salvar/Carregar Progresso - Lógica de visibilidade do botão de download removida
+        # Salvar Progresso
         salvar_btn.click(
              fn=lambda: gr.update(value="⏳ Salvando progresso atual...", visible=True),
-             inputs=None, outputs=processing_message, show_progress=False
+             inputs=None, outputs=processing_message
         ).then(
+             # Passa os campos relevantes para salvar
              fn=salvar_progresso,
              inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             # Saída para gr.File (terceiro output) atualiza o valor do componente progresso_download_file
-             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file],
-             show_progress="minimal"
-        # REMOVIDO o .then() que mexia com a visibilidade
+             # Retorna: json_content (não usado direto), success_message, temp_file_path
+             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file] # Usa config_status para msg, e file para download
         ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message
+            fn=lambda x: gr.update(visible=bool(x)), # Mostra o botão de download se path for retornado
+            inputs=[progresso_download_file],
+            outputs=[progresso_download_file]
+        ).then(
+            lambda: gr.update(value="", visible=False), None, processing_message # Limpa msg processamento
         )
 
+
+        # Carregar Progresso
         carregar_btn.click(
              fn=lambda: gr.update(value="⏳ Carregando progresso do arquivo...", visible=True),
-             inputs=None, outputs=processing_message, show_progress=False
+             inputs=None, outputs=processing_message
         ).then(
              fn=carregar_progresso,
              inputs=[arquivo_progresso_upload],
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status],
-             show_progress="minimal"
+             # Retorna: tipo_peticao, caso, peticao, status_message
+             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status] # Atualiza os campos e mostra status
          ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message
+            lambda: gr.update(value="", visible=False), None, processing_message # Limpa msg processamento
         )
 
+
     return demo
 
-# --- Bloco de Execução Principal ---
+# --- Funções de Validação (Manter simples ou remover/adaptar) ---
+def validar_peticao_basica(peticao):
+    # Esta validação é MUITO focada em Petição Inicial.
+    # Poderia ser desativada ou ter lógica condicional por tipo.
+    # Por enquanto, vamos mantê-la simples e avisar que é básica.
+    problemas = []
+    peticao_lower = peticao.lower()
+    if "excelentíssimo" not in peticao_lower and "eméritos" not in peticao_lower and "meritíssimo" not in peticao_lower :
+        problemas.append("Endereçamento inicial parece ausente ou incompleto.")
+    #if "art. 319" not in peticao and "cpc" not in peticao_lower:
+    #    problemas.append("Menção ao Art. 319 do CPC não encontrada (comum na Inicial).")
+    if "valor da causa" not in peticao_lower and "valor à causa" not in peticao_lower:
+        problemas.append("Atribuição de Valor da Causa não encontrada (essencial na Inicial).")
+    if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower :
+        problemas.append("Pedido de juntada de custas ou gratuidade de justiça não encontrado (essencial na Inicial).")
+    if "nestes termos" not in peticao_lower and "pede deferimento" not in peticao_lower:
+        problemas.append("Fechamento formal padrão ('Nestes termos pede deferimento') parece ausente.")
+    return problemas
+
+
+# --- Geração de Caso Fictício (Chamada Principal) ---
+def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
+    """Função principal para gerar caso, chamando a API com o prompt estruturado."""
+    if not tipo_peticao:
+        return "Erro: Tipo de petição não selecionado para gerar caso."
+    logger.info(f"Gerando caso fictício para: {tipo_peticao}")
+    prompt = estruturar_prompt_geracao_caso(tipo_peticao)
+    caso_gerado = chamar_api(prompt)
+
+    # Verifica se a resposta da API foi um erro
+    if caso_gerado.startswith("❌") or caso_gerado.startswith("⏱️") or caso_gerado.startswith("⚠️"):
+        logger.error(f"Erro ao gerar caso fictício: {caso_gerado}")
+        return f"Falha ao gerar caso fictício.\n{caso_gerado}" # Retorna o erro
+
+    # Pequeno pós-processamento para garantir que a frase final esteja lá
+    frase_final_padrao = f"**Situação-Problema:** Na qualidade de advogado(a) de"
+    if frase_final_padrao.lower() not in caso_gerado.lower():
+        # Tenta adicionar uma frase genérica se a específica falhar
+        logger.warning("Frase 'Situação-Problema' não encontrada na geração do caso. Adicionando manualmente.")
+        # Extrai um nome de cliente potencial do texto gerado
+        nomes_possiveis = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado) # Tenta achar nomes compostos
+        cliente_nome = nomes_possiveis[0] if nomes_possiveis else "[Cliente]"
+        caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente_nome}, elabore a peça processual cabível ({tipo_peticao})."
+
+    logger.info("Caso fictício gerado com sucesso.")
+    return caso_gerado
+
+# --- Execução ---
 if __name__ == "__main__":
-    logger.info("Iniciando a aplicação Gradio...")
-    try:
-        version = pytesseract.get_tesseract_version()
-        logger.info(f"Tesseract versão {version} detectado.")
-    except Exception as e:
-         logger.warning(f"Tesseract não encontrado ou erro ao verificar versão: {e}. OCR de PDFs pode falhar. Verifique packages.txt.")
+    # Configuração de Tesseract (Ajuste o caminho se necessário)
+    # try:
+    #     # Exemplo para Windows:
+    #     # pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
+    #     # Exemplo para Linux (geralmente já está no PATH se instalado via apt):
+    #     # Se não estiver no PATH, especifique o caminho:
+    #     # pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
+    #     # Apenas para verificar se o comando é encontrado:
+    #     version = pytesseract.get_tesseract_version()
+    #     logger.info(f"Tesseract versão {version} encontrado.")
+    # except Exception as e:
+    #      logger.warning(f"Tesseract não encontrado ou erro ao verificar versão: {e}. OCR de PDFs escaneados pode falhar.")
+    #      # Considerar desabilitar OCR ou avisar o usuário mais explicitamente
 
     app = interface_gradio()
-    app.launch()
-    logger.info("Aplicação Gradio encerrada.")
+    # Use share=True apenas se precisar de link público temporário
+    # app.launch(share=True)
+    app.launch()