Update app.py

app.py

@@ -20,19 +20,19 @@ import random
 import logging
 import re
 
-# Configuração do Logging (mantida)
+# Configuração do Logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Leitura da API Key (mantida - usar Secrets no HF)
+# Leitura da API Key (usar Secrets no HF)
 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.")
 
-# API Endpoint (mantido - gemini-1.5-flash)
+# API Endpoint
 GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={GEMINI_API_KEY}"
 
-# Configurações (mantidas)
+# Configurações
 CONFIG = {
     "max_retry_attempts": 3,
     "retry_delay": 5,
@@ -41,10 +41,10 @@ CONFIG = {
     "max_tokens": 8192
 }
 
-# Rate Limiter (mantido)
+# Rate Limiter
 rate_limiter = RateLimiter(max_calls=30, period=60)
 
-# Constantes e Dicionários (mantidos)
+# Constantes e Dicionários
 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",
@@ -76,7 +76,7 @@ DICAS_OAB_MELHORADO = {
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-# --- Funções de Extração de Texto (mantidas) ---
+# --- Funções de Extração de Texto ---
 def preprocess_image_for_ocr(img):
     try:
         gray = img.convert('L')
@@ -108,17 +108,14 @@ def extract_text_from_pdf(file_path_or_obj):
                         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:
-                    # Verificar se o erro é por Tesseract não encontrado
                     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)}")
-                         # Retorna um erro mais informativo neste caso específico
                          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"
         pdf_reader.close()
 
-        # Se Tesseract falhou e retornou o erro específico, paramos aqui
         if "❌ Erro de OCR: Tesseract não encontrado." in ocr_text:
             return ocr_text
 
@@ -133,12 +130,10 @@ def extract_text_from_pdf(file_path_or_obj):
              return "⚠️ Não foi possível extrair texto do PDF (tentativa de OCR falhou ou texto inexistente)."
 
     except ImportError as ie:
-         # Erro comum se pdfplumber não estiver instalado corretamente
          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)
-        # Fallback com PyPDF2
         try:
             logger.info("Tentando fallback com PyPDF2.")
             text_fallback = ""
@@ -162,7 +157,6 @@ 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)
@@ -205,18 +199,15 @@ def extract_text_from_txt(file_path_or_obj):
         return f"❌ Erro ao processar o TXT: {str(e)}"
 
 def process_file(file_obj):
-    logger.info(">>> PROCESS FILE INICIADO") # Log Adicionado
+    logger.info(">>> PROCESS FILE INICIADO")
     if file_obj is None:
         logger.warning("--- Nenhum arquivo fornecido para processamento.")
         return "⚠️ Nenhum arquivo enviado."
     try:
-        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."
-
+        # O file_obj do Gradio já é um objeto de arquivo temporário
+        file_path = file_obj.name # Obter o path temporário
         filename = os.path.basename(file_path).lower()
-        logger.info(f"--- Processando arquivo: {filename}")
+        logger.info(f"--- Processando arquivo: {filename} (path: {file_path})")
 
         try:
              file_size = os.path.getsize(file_path)
@@ -228,6 +219,7 @@ def process_file(file_obj):
              logger.warning(f"--- Não foi possível verificar o tamanho do arquivo: {size_e}")
 
         result_text = ""
+        # Passar o file_path para as funções de extração
         if filename.endswith('.pdf'):
             logger.info("--- Chamando extract_text_from_pdf")
             result_text = extract_text_from_pdf(file_path)
@@ -241,15 +233,15 @@ def process_file(file_obj):
             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]}...") # Log Adicionado
+        logger.info(f"<<< PROCESS FILE FINALIZADO. Resultado: {result_text[:100]}...")
         return result_text
 
     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") # Log Adicionado
+        logger.info("<<< PROCESS FILE FINALIZADO COM ERRO GERAL")
         return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
 
-# --- Funções de Estruturação de Prompt (mantidas) ---
+# --- Funções de Estruturação de Prompt ---
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     base = """
     **Estrutura da Avaliação:**
@@ -304,7 +296,6 @@ def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=Fals
 
     **Requisitos Específicos para {tipo_peticao}:**
     """
-    # ... (restante da lógica de adicionar requisitos específicos - mantida igual) ...
     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 +488,6 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
 
     **Instruções Específicas para a Peça Corrigida ({tipo_peticao}):**
     """
-    # ... (restante da lógica de adicionar instruções específicas - mantida igual) ...
     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).
@@ -649,115 +639,7 @@ def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
 
     return peticao_corrigida
 
-# --- Função de Chamada da API (mantida, com retry e tratamento de erros) ---
-def chamar_api(prompt):
-    payload = {
-        "contents": [{"parts": [{"text": prompt}]}],
-        "generationConfig": {
-            "temperature": CONFIG["temperatura"],
-            "maxOutputTokens": CONFIG["max_tokens"],
-            "topP": 0.95,
-        }
-    }
-    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']}")
-
-    for tentativa in range(CONFIG["max_retry_attempts"]):
-        try:
-            with rate_limiter:
-                logger.debug(f"Tentativa {tentativa + 1}/{CONFIG['max_retry_attempts']}...")
-                response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
-
-            logger.debug(f"Status Code recebido: {response.status_code}")
-
-            if response.status_code == 429:
-                retry_after = int(response.headers.get("Retry-After", CONFIG["retry_delay"] * (tentativa + 1)))
-                logger.warning(f"Erro 429 (Too Many Requests). Tentando novamente em {retry_after}s...")
-                if tentativa < CONFIG["max_retry_attempts"] - 1:
-                    time.sleep(retry_after)
-                    continue
-                else:
-                    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]}" # Mostra início da resposta não-JSON
-                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...")
-                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
-                    continue
-                return f"❌ Erro da API ({response.status_code}): {error_msg}"
-
-            response_data = response.json()
-
-            if not response_data.get("candidates"):
-                 prompt_feedback = response_data.get("promptFeedback", {})
-                 block_reason = prompt_feedback.get("blockReason")
-                 safety_ratings = prompt_feedback.get("safetyRatings")
-                 logger.error(f"Resposta da API sem 'candidates'. Block Reason: {block_reason}, Safety Ratings: {safety_ratings}")
-                 if block_reason:
-                     return f"❌ A solicitação foi bloqueada pela API. Motivo: {block_reason}. Tente reformular o caso ou a petição."
-                 else:
-                      return "❌ Resposta vazia ou inválida da API (sem 'candidates'). Verifique o log para detalhes."
-
-            candidate = response_data["candidates"][0]
-            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}")
-                 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:
-                      return f"❌ A resposta foi bloqueada por segurança pela API. Motivo: {finish_reason} (Categorias: {', '.join(harm_categories)}). Revise o conteúdo."
-                 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:
-                    logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
-                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
-                    continue
-                 return "❌ Resposta inválida da API (estrutura inesperada)."
-
-            texto_gerado = candidate["content"]["parts"][0]["text"].strip()
-            logger.info(f"API retornou com sucesso. Tamanho da resposta: {len(texto_gerado)} caracteres.")
-            return texto_gerado
-
-        except requests.Timeout:
-            logger.warning(f"Timeout na tentativa {tentativa + 1}.")
-            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))
-                continue
-            return "⏱️ Tempo esgotado após múltiplas tentativas. Verifique a conexão ou aumente o timeout."
-        except requests.RequestException as e:
-            logger.error(f"Erro de rede/requisição na tentativa {tentativa + 1}: {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))
-                 continue
-            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]}")
-             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)}")
-            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))
-                 continue
-            return f"❌ Erro inesperado: {str(e)}"
-
-    return "❌ Falha ao chamar a API após todas as tentativas."
-
-# --- Função Principal de Correção (com log adicionado) ---
+# --- 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}")
     start_time = time.time()
@@ -773,8 +655,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     peticao_conteudo = ""
     if peticao_arquivo is not None:
         logger.info("--- Processando arquivo de petição...")
-        # A função process_file agora lida com o objeto arquivo diretamente
-        peticao_conteudo = process_file(peticao_arquivo)
+        peticao_conteudo = process_file(peticao_arquivo) # process_file lida com o objeto Gradio
         if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
             logger.error(f"--- Erro ao processar arquivo: {peticao_conteudo}")
             return peticao_conteudo, "", "", "", "", ""
@@ -786,7 +667,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         logger.warning("--- Nenhuma petição fornecida (nem texto, nem arquivo).")
         return "⚠️ Forneça a petição (em texto ou arquivo).", "", "", "", "", ""
 
-    # Verificação Anti-Troll (mantida)
+    # Verificação Anti-Troll
     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",
@@ -810,7 +691,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
 
     aviso_validacao = ""
 
-    # Cache Check (mantido)
+    # 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.")
@@ -819,7 +700,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         logger.info("<<< CORRIGIR PETICAO FINALIZADO (CACHE HIT)")
         return cached_data["analise_formatada"], cached_data["peticao_original"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"], diff_html_cache
 
-    # Chamada para Análise (mantida)
+    # 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...")
@@ -830,7 +711,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     logger.info("--- Análise recebida da API.")
     analise_formatada = formatar_correcao(analise)
 
-    # Chamada para Gerar Petição Corrigida (mantida)
+    # 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...")
@@ -859,12 +740,12 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
         logger.info("--- Pós-correção aplicada.")
 
-    # Cálculo de Diferenças (mantido)
+    # Cálculo de Diferenças
     logger.info("--- Calculando diferenças...")
     diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
     logger.info("--- Diferenças calculadas.")
 
-    # Histórico e Cache (mantidos)
+    # Histórico e Cache
     correcao_completa_formatada = aviso_validacao + analise_formatada
     resultado_historico = {
         "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
@@ -892,7 +773,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     logger.info(f"<<< CORRIGIR PETICAO FINALIZADO em {end_time - start_time:.2f} segundos.")
     return correcao_completa_formatada, peticao_conteudo, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html
 
-# --- Funções de Formatação, Dicas, Diff, Progresso, Histórico, Salvar/Carregar (mantidas) ---
+# --- Funções Auxiliares (Formatação, Dicas, Diff, etc.) ---
 def formatar_correcao(texto):
     texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
     texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
@@ -1069,8 +950,6 @@ def mostrar_historico():
     historico_md = "### 📜 Histórico de Correções (Últimas 10)\n\n---\n"
     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'] # Removido para limpar
-
         nota_str = "N/A"
         match = re.search(r"\*\*(\d{1,2}[,.]\d{1}|\d{1,2})/10\*\*", entry["analise_formatada"])
         if match:
@@ -1112,11 +991,13 @@ def salvar_progresso(caso, peticao, tipo_peticao):
             "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
         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):
@@ -1142,9 +1023,11 @@ def carregar_progresso(arquivo_entrada):
 
         if tipo_peticao not in TIPOS_DE_PETICAO:
              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."
+             # 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.info("<<< CARREGAR PROGRESSO FINALIZADO COM SUCESSO")
+        # Retorna os valores corretos para atualizar os componentes
         return tipo_peticao, caso, peticao, "✅ Progresso carregado com sucesso!"
 
     except json.JSONDecodeError:
@@ -1155,7 +1038,94 @@ def carregar_progresso(arquivo_entrada):
         logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM ERRO")
         return "", "", "", f"❌ Erro inesperado ao carregar o progresso: {str(e)}"
 
-# --- Função de Geração de Caso (com log adicionado) ---
+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).
+
+    **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}**.
+
+    **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
+
 def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
     logger.info(f">>> GERAR CASO FICTICIO INICIADO para: {tipo_peticao}")
     if not tipo_peticao:
@@ -1164,7 +1134,7 @@ def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
     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]}...") # Log reduzido para não poluir
+    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}")
@@ -1180,7 +1150,7 @@ def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
     logger.info("<<< GERAR CASO FICTICIO FINALIZADO COM SUCESSO")
     return caso_gerado
 
-# --- Validação Básica (mantida) ---
+# --- Validação Básica ---
 def validar_peticao_basica(peticao):
     problemas = []
     peticao_lower = peticao.lower()
@@ -1194,7 +1164,7 @@ def validar_peticao_basica(peticao):
         problemas.append("Fechamento formal padrão ('Nestes termos pede deferimento') parece ausente.")
     return problemas
 
-# --- Interface Gradio (com correção do Checkbox e logs nas wrappers) ---
+# --- 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 ⚖️")
@@ -1208,7 +1178,6 @@ def interface_gradio():
                     choices=TIPOS_DE_PETICAO,
                     value="Petição Inicial"
                 )
-                # Definindo o componente checkbox
                 modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento (Feedback Detalhado)", value=False)
 
                 with gr.Accordion("⚙️ Configurações Avançadas", open=False):
@@ -1253,7 +1222,6 @@ def interface_gradio():
                         btn_corrigir = gr.Button("🚀 CORRIGIR E ANALISAR!", variant="primary")
 
                     with gr.TabItem("📎 Anexar Arquivo"):
-                        # Usar file_count="single" para garantir que é apenas um 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")
                         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")
@@ -1279,33 +1247,41 @@ def interface_gradio():
 
         clear_btn = gr.Button("🗑️ Limpar Tudo")
 
-        # --- FUNÇÕES WRAPPER (com logs adicionados) ---
+        # --- FUNÇÕES WRAPPER (com logs) ---
         def corrigir_peticao_wrapper_texto(caso, tipo_peticao, peticao_texto, peticao_arquivo_state):
             logger.info(">>> WRAPPER TEXTO INICIADO")
-            is_treinamento = modo_treinamento.value # Acessa o valor do componente checkbox
+            is_treinamento = modo_treinamento.value
             logger.info(f"--- Modo Treinamento (Texto): {is_treinamento}")
-            resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto, peticao_arquivo_state, is_treinamento)
+            try:
+                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
+                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 # Acessa o valor do componente checkbox
+            is_treinamento = modo_treinamento.value
             logger.info(f"--- Modo Treinamento (Arquivo): {is_treinamento}")
-            # peticao_arquivo aqui é o objeto de arquivo temporário do Gradio
-            resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto_state, peticao_arquivo, is_treinamento)
+            try:
+                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
+                return f"❌ Erro interno no processamento: {e}", "", "", "", "", ""
             logger.info("<<< WRAPPER ARQUIVO FINALIZADO")
             return resultado
         # --- FIM DAS FUNÇÕES WRAPPER ---
 
-
-        # --- LÓGICA DOS BOTÕES E EVENTOS (COM CORREÇÃO E LOGS) ---
+        # --- LÓGICA DOS BOTÕES E EVENTOS (COM CORREÇÃO DO CLEAR_BTN) ---
 
         caso_btn.click(
              fn=gerar_caso_ficticio,
              inputs=[tipo_peticao_input],
              outputs=[caso_input],
-             show_progress="full" # Mostra progresso no botão
+             show_progress="full"
         )
 
         peticao_texto_input.change(
@@ -1323,7 +1299,7 @@ def interface_gradio():
              fn=process_file,
              inputs=[peticao_arquivo_input],
              outputs=[arquivo_preview_output],
-             show_progress="minimal" # Mostra progresso no botão
+             show_progress="minimal"
         )
 
         # Botão Corrigir (Texto) - Usando wrapper
@@ -1331,13 +1307,14 @@ def interface_gradio():
             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 # Mensagem customizada já existe
+            show_progress=False
         ).then(
             fn=corrigir_peticao_wrapper_texto,
+            # Inputs SEM o componente modo_treinamento direto
             inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None)],
             outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            show_progress="full" # Mostra progresso durante a execução da função principal
+            show_progress="full"
         ).then(
             fn=lambda: gr.update(value="", visible=False),
             inputs=None,
@@ -1349,25 +1326,41 @@ def interface_gradio():
             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 # Mensagem customizada já existe
+            show_progress=False
         ).then(
             fn=corrigir_peticao_wrapper_arquivo,
+             # Inputs SEM o componente modo_treinamento direto
             inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input],
             outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-             show_progress="full" # Mostra progresso durante a execução da função principal
+             show_progress="full"
         ).then(
             fn=lambda: gr.update(value="", visible=False),
             inputs=None,
             outputs=[processing_message]
         )
 
+        # Botão Limpar - CORRIGIDO para usar gr.update()
         clear_btn.click(
             fn=lambda: [
-                "Petição Inicial", False, None, None, None, None, "", "", "", "", "", "", "", None, None,
+                gr.update(value="Petição Inicial"),
+                gr.update(value=False),            # <--- Usa gr.update()
+                gr.update(value=None),
+                gr.update(value=None),
+                gr.update(value=None),             # Limpa o gr.File
+                gr.update(value=""),               # Limpa o preview
+                gr.update(value="", visible=False),# Esconde msg processamento
+                gr.update(value=""),               # Limpa análise
+                gr.update(value=""),               # Limpa peça corrigida
+                gr.update(value=""),               # Limpa resumo diff
+                gr.update(value=""),               # Limpa críticas diff
+                gr.update(value=""),               # Limpa HTML diff
+                gr.update(value="*Dicas aparecerão aqui enquanto você digita...*"), # Reseta dicas
+                gr.update(value=None),             # Limpa upload progresso
+                gr.update(value=None, visible=False) # Limpa e esconde download progresso
             ],
-            inputs=None,
-            outputs=[
+            inputs=None, # Nenhum input para a função lambda de limpeza
+            outputs=[ # Lista de componentes a serem atualizados
                 tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
                 arquivo_preview_output, processing_message, resultado_analise_output,
                 resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output,
@@ -1379,16 +1372,19 @@ def interface_gradio():
         progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
         historico_btn.click(fn=mostrar_historico, outputs=historico_output)
 
+        # Salvar/Carregar Progresso (mantidos como antes, mas wrapper garante que não há bool direto)
         salvar_btn.click(
              fn=lambda: gr.update(value="⏳ Salvando progresso atual...", visible=True),
              inputs=None, outputs=processing_message, show_progress=False
         ).then(
              fn=salvar_progresso,
              inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
+             # Saída para gr.File deve ser o path
              outputs=[gr.Textbox(visible=False), config_status, progresso_download_file],
              show_progress="minimal"
         ).then(
-            fn=lambda x: gr.update(visible=bool(x)),
+            # Atualiza a visibilidade do componente de download
+            fn=lambda file_path: gr.update(visible=bool(file_path), value=file_path),
             inputs=[progresso_download_file],
             outputs=[progresso_download_file]
         ).then(
@@ -1401,6 +1397,7 @@ def interface_gradio():
         ).then(
              fn=carregar_progresso,
              inputs=[arquivo_progresso_upload],
+             # Outputs mapeados corretamente para os componentes
              outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status],
              show_progress="minimal"
          ).then(
@@ -1412,7 +1409,6 @@ def interface_gradio():
 # --- Bloco de Execução Principal ---
 if __name__ == "__main__":
     logger.info("Iniciando a aplicação Gradio...")
-    # Adiciona verificação Tesseract opcional (pode ser comentada se não for usar OCR)
     try:
         version = pytesseract.get_tesseract_version()
         logger.info(f"Tesseract versão {version} detectado.")
@@ -1420,8 +1416,6 @@ if __name__ == "__main__":
          logger.warning(f"Tesseract não encontrado ou erro ao verificar versão: {e}. OCR de PDFs pode falhar. Verifique packages.txt.")
 
     app = interface_gradio()
-    # queue() pode ajudar a gerenciar múltiplas requisições simultâneas
-    # app.queue()
-    # Defina server_name e server_port se precisar rodar em uma rede local específica
-    app.launch() # share=True não é recomendado para uso prolongado ou com secrets
+    # app.queue() # Descomente se precisar lidar com múltiplas requisições
+    app.launch() # share=True geralmente não necessário no HF e pode expor secrets se mal configurado
     logger.info("Aplicação Gradio encerrada.")