Update app.py

app.py

@@ -19,8 +19,8 @@ import difflib
 from html import escape
 import random
 import logging
+import re
 
-# Configura o logging para depuração
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
@@ -30,24 +30,18 @@ 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 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}"
 
-
 CONFIG = {
     "max_retry_attempts": 3,
     "retry_delay": 5,
-    "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
+    "timeout": 120,
+    "temperatura": 0.3,
+    "max_tokens": 8192
 }
 
-rate_limiter = RateLimiter(max_calls=30, period=60) # Reduzir um pouco a taxa para evitar 429
+rate_limiter = RateLimiter(max_calls=30, period=60)
 
-# --- TIPOS DE PEÇAS PROCESSUAIS ---
 TIPOS_DE_PETICAO = [
     "Petição Inicial",
     "Contestação",
@@ -59,35 +53,25 @@ TIPOS_DE_PETICAO = [
     "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).",
@@ -96,7 +80,6 @@ DICAS_OAB_MELHORADO = {
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-# --- Funções de Extração de Texto (sem alterações significativas) ---
 def preprocess_image_for_ocr(img):
     try:
         gray = img.convert('L')
@@ -105,7 +88,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)}" # Retorna o erro
+        return f"❌ Erro no pré-processamento: {str(e)}"
 
 def extract_text_from_pdf(file_path_or_obj):
     text = ""
@@ -116,12 +99,12 @@ def extract_text_from_pdf(file_path_or_obj):
             page_text = page.extract_text()
             if page_text:
                 text += page_text + "\n"
-            else: # Tenta OCR se texto extraído for pobre/vazio
+            else:
                 logger.warning(f"Página {i+1} sem texto extraível, tentando OCR.")
                 try:
-                    img = page.to_image(resolution=300) # Aumenta resolução para OCR
+                    img = page.to_image(resolution=300)
                     preprocessed_img = preprocess_image_for_ocr(img.original)
-                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por') # Especifica português
+                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por')
                     if page_ocr_text.strip():
                         ocr_text += page_ocr_text + "\n"
                     else:
@@ -132,8 +115,7 @@ def extract_text_from_pdf(file_path_or_obj):
                     ocr_text += f"[Erro no OCR da página {i+1}: {str(ocr_e)}]\n"
         pdf_reader.close()
 
-        # Decide qual texto retornar
-        if text.strip() and len(text) > len(ocr_text) * 0.5: # Se texto extraído parece razoável
+        if text.strip() and len(text) > len(ocr_text) * 0.5:
              logger.info("Usando texto extraído do PDF.")
              return text
         elif ocr_text.strip():
@@ -145,7 +127,6 @@ def extract_text_from_pdf(file_path_or_obj):
 
     except Exception as e:
         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 = ""
@@ -155,7 +136,6 @@ 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:
@@ -170,19 +150,12 @@ 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) # Funciona com path ou file object
+        doc = docx.Document(file_path_or_obj)
         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 Exception as e:
         logger.error(f"Erro ao processar o DOCX: {str(e)}")
@@ -190,21 +163,17 @@ def extract_text_from_docx(file_path_or_obj):
 
 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:
@@ -224,8 +193,6 @@ def process_file(file_obj):
         logger.warning("Nenhum arquivo fornecido para processamento.")
         return "⚠️ Nenhum arquivo enviado."
     try:
-        # 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.")
@@ -234,26 +201,20 @@ def process_file(file_obj):
         filename = os.path.basename(file_path).lower()
         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: # Aumentado para 15MB
+             if file_size > 15 * 1024 * 1024:
                  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}")
-             # Não impede o processamento, mas loga o aviso
 
-        # Determina o tipo e extrai o texto
         if filename.endswith('.pdf'):
-            # Passa o path do arquivo temporário
             return extract_text_from_pdf(file_path)
         elif filename.endswith('.docx'):
-             # Passa o path do arquivo temporário
             return extract_text_from_docx(file_path)
         elif filename.endswith('.txt'):
-             # 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}")
@@ -262,7 +223,6 @@ def process_file(file_obj):
     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)}"
-# --- ESTRUTURAÇÃO DE PROMPTS POR TIPO ---
 
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     base = """
@@ -319,7 +279,6 @@ 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).
@@ -497,7 +456,6 @@ 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:**
     ```
@@ -514,7 +472,6 @@ 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).
@@ -563,8 +520,6 @@ 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.
          """
-    # 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.
@@ -577,10 +532,7 @@ 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.
          """
-    # (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
+    else:
         prompt += """
     1.  **Estrutura Lógica:** Organize a peça com começo, meio e fim.
     2.  **Argumentos:** Apresente os argumentos de forma clara.
@@ -591,48 +543,34 @@ 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
 
-
 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
+             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_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
+             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.")
 
-
-    # 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}]}],
@@ -640,13 +578,10 @@ 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:
@@ -655,7 +590,6 @@ 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)))
@@ -678,7 +612,6 @@ 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")
@@ -689,14 +622,11 @@ 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:
@@ -704,7 +634,6 @@ 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:
@@ -715,7 +644,6 @@ 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:
@@ -734,10 +662,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]}") # Log da resposta problemática
+             logger.debug(f"Resposta que causou erro de JSON: {response.text[:500]}")
              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)}") # Loga o traceback completo
+            logger.exception(f"Erro inesperado na chamada da API na tentativa {tentativa + 1}: {str(e)}")
             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))
@@ -746,19 +674,17 @@ def chamar_api(prompt):
 
     return "❌ Falha ao chamar a API após todas as tentativas."
 
-
 def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
     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.", "", "", "", "" # Retorna tupla vazia para diff
+        return "⚠️ Forneça o caso/contexto da peça.", "", "", "", "", ""
 
     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.", "", "", "", ""
-
+         return "⚠️ Selecione um tipo de petição válido.", "", "", "", "", ""
 
     peticao_conteudo = ""
     if peticao_arquivo is not None:
@@ -766,16 +692,15 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         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, "", "", "", ""
+            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).")
     else:
         logger.warning("Nenhuma petição fornecida (nem texto, nem arquivo).")
-        return "⚠️ Forneça a petição (em texto ou 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",
@@ -795,52 +720,37 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
             "😂 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), "", "", "", ""
+        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.")
         cached_data = CORRECAO_CACHE[cache_key]
-        # 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"]
+        return cached_data["analise_formatada"], cached_data["peticao_original"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"], cached_data["diff_html"]
 
-    # --- 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...")
     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}")
-        # Retorna o erro e strings vazias para os outros campos
-        return aviso_validacao + analise, peticao_conteudo, "", "", ""
+        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
+    analise_formatada = formatar_correcao(analise)
 
-    # --- 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...")
     peticao_corrigida_bruta = chamar_api(prompt_peticao)
 
-    peticao_corrigida_final = "" # Inicializa
+    peticao_corrigida_final = ""
     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}")
-        # 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...")
-        # 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()
@@ -853,65 +763,51 @@ 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 # Usa como está se não achar marcador
+             peticao_extraida = peticao_corrigida_bruta
 
         peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
         logger.info("Pós-correção aplicada.")
 
-
-    # --- 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)
+    visualizacao_detalhada_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
     logger.info("Diferenças calculadas.")
 
-
-    # --- HISTÓRICO E CACHE ---
-    correcao_completa_formatada = aviso_validacao + analise_formatada # Não inclui a peça corrigida aqui
+    correcao_completa_formatada = aviso_validacao + analise_formatada
     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, # Salva análise formatada
-        "peticao_corrigida": peticao_corrigida_final, # Salva peça corrigida
+        "analise_formatada": correcao_completa_formatada,
+        "peticao_corrigida": peticao_corrigida_final,
         "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: # Limita o histórico
+    if len(HISTORICO) > 10:
         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
+        "diff_html": visualizacao_detalhada_html
     }
 
     end_time = time.time()
     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
-
+    return correcao_completa_formatada, peticao_conteudo, peticao_corrigida_final, resumo_diff, criticas_diff, visualizacao_detalhada_html
 
 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
@@ -921,7 +817,6 @@ 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
@@ -930,13 +825,11 @@ def formatar_correcao(texto):
              in_list = True
         else:
             linhas_formatadas.append(linha)
-            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")): # Reseta se não for item de lista
+            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")):
                  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:
@@ -945,7 +838,6 @@ 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..."
@@ -953,12 +845,10 @@ 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"],
@@ -973,7 +863,6 @@ 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:
@@ -984,15 +873,11 @@ 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."
 
-    # 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) ---
+    return "\n\n".join(dicas_relevantes[:5])
 
 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 "","","" # Retorna vazio se não houver o que comparar
+        return "","",""
 
     orig_lines = texto_original.splitlines()
     corr_lines = texto_corrigido.splitlines()
@@ -1022,8 +907,6 @@ 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:**
@@ -1034,7 +917,6 @@ 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; }
@@ -1051,9 +933,6 @@ 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."
@@ -1062,7 +941,6 @@ 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:
@@ -1071,7 +949,7 @@ def calcular_progresso():
                 notas.append(nota)
                 nota_str = f"{nota:.1f}"
             except ValueError:
-                pass # Ignora se não conseguir converter
+                pass
 
     total_corridas = len(HISTORICO)
     media = sum(notas) / len(notas) if notas else 0
@@ -1093,35 +971,27 @@ 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("Iniciando salvamento de progresso...")
     try:
@@ -1129,7 +999,6 @@ def salvar_progresso(caso, peticao, tipo_peticao):
             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,
@@ -1139,12 +1008,9 @@ 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)
 
@@ -1158,28 +1024,24 @@ def salvar_progresso(caso, peticao, tipo_peticao):
             "Use o botão 'Carregar Progresso' e selecione este arquivo para restaurar."
         )
 
-        # 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)
         return "", f"❌ Erro ao salvar o progresso: {str(e)}", None
 
-
 def carregar_progresso(arquivo_entrada):
     logger.info("Iniciando carregamento de progresso...")
     if arquivo_entrada is None:
         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}")
 
         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")
@@ -1192,7 +1054,6 @@ def carregar_progresso(arquivo_entrada):
              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("Progresso carregado com sucesso.")
         return tipo_peticao, caso, peticao, "✅ Progresso carregado com sucesso!"
 
@@ -1203,9 +1064,6 @@ def carregar_progresso(arquivo_entrada):
         logger.error(f"Erro ao carregar o progresso: {str(e)}", exc_info=True)
         return "", "", "", f"❌ Erro inesperado ao carregar o progresso: {str(e)}"
 
-
-# --- GERAÇÃO DE CASOS ---
-
 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).
@@ -1295,8 +1153,6 @@ def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
     """
     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 ⚖️")
@@ -1304,11 +1160,11 @@ def interface_gradio():
 
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("###  Configurações (Settings)") 
+                gr.Markdown("###  Configurações (Settings)")
                 tipo_peticao_input = gr.Dropdown(
                     label=" Selecione o Tipo de Peça Processual",
                     choices=TIPOS_DE_PETICAO,
-                    value="Petição Inicial" # Default
+                    value="Petição Inicial"
                 )
                 modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento (Feedback Detalhado)", value=False)
 
@@ -1338,11 +1194,7 @@ 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)
-                     # 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")
@@ -1350,12 +1202,11 @@ 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...*") # Usar Markdown
+                        dica_contextual_output = gr.Markdown(value="*Dicas aparecerão aqui enquanto você digita...*")
                         btn_corrigir = gr.Button("🚀 CORRIGIR E ANALISAR!", variant="primary")
 
                     with gr.TabItem("📎 Anexar Arquivo"):
@@ -1363,10 +1214,8 @@ def interface_gradio():
                         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")
@@ -1383,56 +1232,40 @@ 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)
-
 
-        # --- 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], # Passa o tipo selecionado
+             inputs=[tipo_peticao_input],
              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]
         )
 
-        # 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]
         ).then(
             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)
+            outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output]
         ).then(
             fn=lambda: gr.update(value="", visible=False),
@@ -1440,17 +1273,14 @@ def interface_gradio():
             outputs=[processing_message]
         )
 
-        # 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]
         ).then(
             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)
+            outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output]
         ).then(
             fn=lambda: gr.update(value="", visible=False),
@@ -1458,24 +1288,23 @@ def interface_gradio():
             outputs=[processing_message]
         )
 
-        # Botão Limpar
         clear_btn.click(
             fn=lambda: [
-                "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
+                "Petição Inicial",
+                False,
+                None,
+                None,
+                None,
+                None,
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                None,
+                None,
             ],
             inputs=None,
             outputs=[
@@ -1487,56 +1316,42 @@ def interface_gradio():
             ]
         )
 
-        # 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 Progresso
         salvar_btn.click(
              fn=lambda: gr.update(value="⏳ Salvando progresso atual...", visible=True),
              inputs=None, outputs=processing_message
         ).then(
-             # Passa os campos relevantes para salvar
              fn=salvar_progresso,
              inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             # 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
+             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
         ).then(
-            fn=lambda x: gr.update(visible=bool(x)), # Mostra o botão de download se path for retornado
+            fn=lambda x: gr.update(visible=bool(x)),
             inputs=[progresso_download_file],
             outputs=[progresso_download_file]
         ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message # Limpa msg processamento
+            lambda: gr.update(value="", visible=False), None, processing_message
         )
 
-
-        # Carregar Progresso
         carregar_btn.click(
              fn=lambda: gr.update(value="⏳ Carregando progresso do arquivo...", visible=True),
              inputs=None, outputs=processing_message
         ).then(
              fn=carregar_progresso,
              inputs=[arquivo_progresso_upload],
-             # Retorna: tipo_peticao, caso, peticao, status_message
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status] # Atualiza os campos e mostra status
+             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
          ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message # Limpa msg processamento
+            lambda: gr.update(value="", visible=False), None, processing_message
         )
 
-
     return demo
 
-# --- 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 :
@@ -1545,51 +1360,27 @@ def validar_peticao_basica(peticao):
         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
+        return f"Falha ao gerar caso fictício.\n{caso_gerado}"
 
-    # 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
+        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})."
 
     logger.info("Caso fictício gerado com sucesso.")
     return caso_gerado
 
-# --- Execução ---
 if __name__ == "__main__":
-    # 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()
-    # Use share=True apenas se precisar de link público temporário
-    # app.launch(share=True)
     app.launch()