Update app.py

app.py

@@ -20,17 +20,19 @@ import random
 import logging
 import re
 
+# Configuração do Logging (mantida)
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# A chave API deve ser configurada como Secret no Hugging Face
+# Leitura da API Key (mantida - 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.")
 
-# Usando o endpoint gemini-1.5-flash que demonstrou funcionar no Colab
+# API Endpoint (mantido - gemini-1.5-flash)
 GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={GEMINI_API_KEY}"
 
+# Configurações (mantidas)
 CONFIG = {
     "max_retry_attempts": 3,
     "retry_delay": 5,
@@ -39,19 +41,15 @@ CONFIG = {
     "max_tokens": 8192
 }
 
+# Rate Limiter (mantido)
 rate_limiter = RateLimiter(max_calls=30, period=60)
 
+# Constantes e Dicionários (mantidos)
 TIPOS_DE_PETICAO = [
-    "Petição Inicial",
-    "Contestação",
-    "Reconvenção",
-    "Impugnação à Contestação",
-    "Embargos de Declaração",
-    "Recurso de Apelação",
-    "Agravo de Instrumento",
+    "Petição Inicial", "Contestação", "Reconvenção", "Impugnação à Contestação",
+    "Embargos de Declaração", "Recurso de Apelação", "Agravo de Instrumento",
     "Petição de Tutela Provisória"
 ]
-
 DICAS_OAB_MELHORADO = {
     "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.",
@@ -75,10 +73,10 @@ DICAS_OAB_MELHORADO = {
     "Periculum in Mora": "Evidencie o risco de dano irreparável ou de difícil reparação se a medida não for concedida imediatamente.",
     "Reversibilidade": "Se possível, argumente que a medida é reversível caso a decisão final seja diferente (Art. 300, §3º, CPC).",
 }
-
 HISTORICO = []
 CORRECAO_CACHE = {}
 
+# --- Funções de Extração de Texto (mantidas) ---
 def preprocess_image_for_ocr(img):
     try:
         gray = img.convert('L')
@@ -110,10 +108,20 @@ 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:
-                    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"
+                    # 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
+
         if text.strip() and len(text) > len(ocr_text) * 0.5:
              logger.info("Usando texto extraído do PDF.")
              return text
@@ -124,8 +132,13 @@ def extract_text_from_pdf(file_path_or_obj):
              logger.warning("Não foi possível extrair texto significativo do PDF.")
              return "⚠️ Não foi possível extrair texto do PDF (tentativa de OCR falhou ou texto inexistente)."
 
+    except ImportError as ie:
+         # 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)}")
+        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 = ""
@@ -149,6 +162,7 @@ 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)
@@ -156,8 +170,11 @@ def extract_text_from_docx(file_path_or_obj):
         for para in doc.paragraphs:
             text += para.text + "\n"
         return text if text.strip() else "⚠️ Documento DOCX vazio ou sem texto."
+    except ImportError as ie:
+        logger.error(f"Erro de importação ao processar DOCX: {str(ie)}. Verifique se 'python-docx' está no requirements.txt.")
+        return f"❌ Erro interno: Falta dependência para DOCX ({str(ie)})."
     except Exception as e:
-        logger.error(f"Erro ao processar o DOCX: {str(e)}")
+        logger.error(f"Erro ao processar o DOCX: {str(e)}", exc_info=True)
         return f"❌ Erro ao processar o DOCX: {str(e)}"
 
 def extract_text_from_txt(file_path_or_obj):
@@ -184,45 +201,55 @@ def extract_text_from_txt(file_path_or_obj):
         logger.error("Não foi possível decodificar o arquivo TXT com encodings comuns.")
         return "❌ Não foi possível decodificar o arquivo TXT. Verifique o encoding."
     except Exception as e:
-        logger.error(f"Erro ao processar o TXT: {str(e)}")
+        logger.error(f"Erro ao processar o TXT: {str(e)}", exc_info=True)
         return f"❌ Erro ao processar o TXT: {str(e)}"
 
 def process_file(file_obj):
+    logger.info(">>> PROCESS FILE INICIADO") # Log Adicionado
     if file_obj is None:
-        logger.warning("Nenhum arquivo fornecido para processamento.")
+        logger.warning("--- Nenhum arquivo fornecido para processamento.")
         return "⚠️ Nenhum arquivo enviado."
     try:
         file_path = getattr(file_obj, 'name', None)
         if not file_path:
-             logger.error("Não foi possível obter o nome do arquivo do objeto.")
+             logger.error("--- Não foi possível obter o nome do arquivo do objeto.")
              return "❌ Erro: Não foi possível identificar o tipo do arquivo."
 
         filename = os.path.basename(file_path).lower()
-        logger.info(f"Processando arquivo: {filename}")
+        logger.info(f"--- Processando arquivo: {filename}")
 
         try:
              file_size = os.path.getsize(file_path)
-             logger.info(f"Tamanho do arquivo: {file_size} bytes")
+             logger.info(f"--- Tamanho do arquivo: {file_size} bytes")
              if file_size > 15 * 1024 * 1024:
-                 logger.warning(f"Arquivo {filename} excede o limite de tamanho.")
+                 logger.warning(f"--- Arquivo {filename} excede o limite de tamanho.")
                  return "⚠️ O arquivo é muito grande. Máx. 15 MB."
         except OSError as size_e:
-             logger.warning(f"Não foi possível verificar o tamanho do arquivo: {size_e}")
+             logger.warning(f"--- Não foi possível verificar o tamanho do arquivo: {size_e}")
 
+        result_text = ""
         if filename.endswith('.pdf'):
-            return extract_text_from_pdf(file_path)
+            logger.info("--- Chamando extract_text_from_pdf")
+            result_text = extract_text_from_pdf(file_path)
         elif filename.endswith('.docx'):
-            return extract_text_from_docx(file_path)
+            logger.info("--- Chamando extract_text_from_docx")
+            result_text = extract_text_from_docx(file_path)
         elif filename.endswith('.txt'):
-             return extract_text_from_txt(file_path)
+            logger.info("--- Chamando extract_text_from_txt")
+            result_text = extract_text_from_txt(file_path)
         else:
-            logger.warning(f"Formato de arquivo não suportado: {filename}")
-            return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
+            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
+        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
         return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
 
+# --- Funções de Estruturação de Prompt (mantidas) ---
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     base = """
     **Estrutura da Avaliação:**
@@ -277,7 +304,7 @@ 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).
@@ -470,6 +497,7 @@ 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).
@@ -621,6 +649,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}]}],
@@ -651,8 +680,13 @@ def chamar_api(prompt):
                     return "❌ Erro 429: Muitas requisições. Tente novamente mais tarde."
 
             if response.status_code != 200:
-                error_info = response.json()
-                error_msg = error_info.get("error", {}).get("message", "Erro desconhecido na API")
+                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...")
@@ -723,34 +757,36 @@ def chamar_api(prompt):
 
     return "❌ Falha ao chamar a API após todas as tentativas."
 
+# --- Função Principal de Correção (com log adicionado) ---
 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}, Modo Treinamento: {modo_treinamento}")
+    logger.info(f">>> CORRIGIR PETICAO INICIADO - Tipo: {tipo_peticao}, Treinamento: {modo_treinamento}")
     start_time = time.time()
 
     if not caso or not caso.strip():
-        logger.warning("Caso não fornecido.")
+        logger.warning("--- Caso não fornecido.")
         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}")
+         logger.warning(f"--- Tipo de petição inválido ou não fornecido: {tipo_peticao}")
          return "⚠️ Selecione um tipo de petição válido.", "", "", "", "", ""
 
     peticao_conteudo = ""
     if peticao_arquivo is not None:
-        logger.info("Processando arquivo de petição...")
-        # O objeto peticao_arquivo aqui é o próprio arquivo temporário do Gradio
+        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)
         if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
-            logger.error(f"Erro ao processar arquivo: {peticao_conteudo}")
+            logger.error(f"--- Erro ao processar arquivo: {peticao_conteudo}")
             return peticao_conteudo, "", "", "", "", ""
-        logger.info(f"Texto extraído do arquivo ({len(peticao_conteudo)} caracteres).")
+        logger.info(f"--- Texto extraído do arquivo ({len(peticao_conteudo)} caracteres).")
     elif peticao_texto and peticao_texto.strip():
          peticao_conteudo = peticao_texto
-         logger.info(f"Usando texto da petição fornecido ({len(peticao_conteudo)} caracteres).")
+         logger.info(f"--- Usando texto da petição fornecido ({len(peticao_conteudo)} caracteres).")
     else:
-        logger.warning("Nenhuma petição fornecida (nem texto, nem arquivo).")
+        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)
     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",
@@ -769,40 +805,43 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
             "💡 Dica de ouro: Comece! Esboce a peça, mesmo que imperfeita. Depois a gente lapida juntos. Mande bala!",
             "😂 Pedir pra IA fazer a peça é tipo pedir pro GPS dirigir o carro. Ele te guia, mas quem tá no volante é você! Escreva aí!",
         ]
-        logger.info("Detectado pedido para escrever petição. Retornando resposta troll.")
+        logger.info("--- Detectado pedido para escrever petição. Retornando resposta troll.")
         return random.choice(respostas_troll), "", "", "", "", ""
 
     aviso_validacao = ""
 
+    # Cache Check (mantido)
     cache_key = f"{tipo_peticao}|{caso[:100]}|{peticao_conteudo[:100]}|{modo_treinamento}"
     if cache_key in CORRECAO_CACHE:
-        logger.info("Correção encontrada no cache.")
+        logger.info("--- Correção encontrada no cache.")
         cached_data = CORRECAO_CACHE[cache_key]
         diff_html_cache, _, _ = calcular_diff_interno(cached_data["peticao_original"], cached_data["peticao_corrigida"])
+        logger.info("<<< CORRIGIR PETICAO FINALIZADO (CACHE HIT)")
         return cached_data["analise_formatada"], cached_data["peticao_original"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"], diff_html_cache
 
-
-    logger.info("Gerando prompt de análise...")
+    # Chamada para Análise (mantida)
+    logger.info("--- Gerando prompt de análise...")
     prompt_analise = estruturar_prompt_analise(caso, peticao_conteudo, tipo_peticao, modo_treinamento)
-    logger.info("Enviando para análise da API...")
+    logger.info("--- Enviando para análise da API...")
     analise = chamar_api(prompt_analise)
     if analise.startswith("❌") or analise.startswith("⏱️") or analise.startswith("⚠️"):
-        logger.error(f"Erro na análise da petição: {analise}")
+        logger.error(f"--- Erro na análise da petição: {analise}")
         return aviso_validacao + analise, peticao_conteudo, "", "", "", ""
-    logger.info("Análise recebida da API.")
+    logger.info("--- Análise recebida da API.")
     analise_formatada = formatar_correcao(analise)
 
-    logger.info("Gerando prompt para peça corrigida...")
+    # Chamada para Gerar Petição Corrigida (mantida)
+    logger.info("--- Gerando prompt para peça corrigida...")
     prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo, tipo_peticao)
-    logger.info("Enviando para geração da peça corrigida API...")
+    logger.info("--- Enviando para geração da peça corrigida API...")
     peticao_corrigida_bruta = chamar_api(prompt_peticao)
 
     peticao_corrigida_final = ""
     if peticao_corrigida_bruta.startswith("❌") or peticao_corrigida_bruta.startswith("⏱️") or peticao_corrigida_bruta.startswith("⚠️"):
-        logger.error(f"Erro ao gerar peça corrigida: {peticao_corrigida_bruta}")
+        logger.error(f"--- Erro ao gerar peça corrigida: {peticao_corrigida_bruta}")
         peticao_corrigida_final = f"⚠️ Falha ao gerar a versão corrigida:\n{peticao_corrigida_bruta}"
     else:
-        logger.info("Peça corrigida recebida, aplicando pós-correção...")
+        logger.info("--- Peça corrigida recebida, aplicando pós-correção...")
         start_markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
         start_index = -1
         peticao_lower_corr = peticao_corrigida_bruta.lower()
@@ -818,12 +857,14 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
              peticao_extraida = peticao_corrigida_bruta
 
         peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
-        logger.info("Pós-correção aplicada.")
+        logger.info("--- Pós-correção aplicada.")
 
-    logger.info("Calculando diferenças...")
+    # Cálculo de Diferenças (mantido)
+    logger.info("--- Calculando diferenças...")
     diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-    logger.info("Diferenças calculadas.")
+    logger.info("--- Diferenças calculadas.")
 
+    # Histórico e Cache (mantidos)
     correcao_completa_formatada = aviso_validacao + analise_formatada
     resultado_historico = {
         "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
@@ -848,10 +889,10 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     }
 
     end_time = time.time()
-    logger.info(f"Correção concluída em {end_time - start_time:.2f} segundos.")
-
+    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) ---
 def formatar_correcao(texto):
     texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
     texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
@@ -1028,7 +1069,7 @@ 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']
+        # 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"])
@@ -1043,10 +1084,10 @@ def mostrar_historico():
     return historico_md
 
 def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info("Iniciando salvamento de progresso...")
+    logger.info(">>> SALVAR PROGRESSO INICIADO")
     try:
         if not caso or not peticao or not tipo_peticao:
-            logger.warning("Inputs insuficientes para salvar progresso.")
+            logger.warning("--- Inputs insuficientes para salvar progresso.")
             return "", "⚠️ Caso, Petição e Tipo de Petição são necessários para salvar.", None
 
         dados_progresso = {
@@ -1065,25 +1106,28 @@ def salvar_progresso(caso, peticao, tipo_peticao):
         with open(temp_file_path, 'w', encoding='utf-8') as f:
             f.write(json_content)
 
-        logger.info(f"Progresso salvo com sucesso no arquivo temporário: {temp_file_path}")
+        logger.info(f"--- Progresso salvo com sucesso no arquivo temporário: {temp_file_path}")
         success_message = (
             f"✅ Progresso salvo! Baixe o arquivo `{filename}`. "
             "Use o botão 'Carregar Progresso' e selecione este arquivo para restaurar."
         )
+        logger.info("<<< SALVAR PROGRESSO FINALIZADO COM SUCESSO")
         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")
         return "", f"❌ Erro ao salvar o progresso: {str(e)}", None
 
 def carregar_progresso(arquivo_entrada):
-    logger.info("Iniciando carregamento de progresso...")
+    logger.info(">>> CARREGAR PROGRESSO INICIADO")
     if arquivo_entrada is None:
+        logger.warning("--- Nenhum arquivo selecionado para carregar.")
         return "", "", "", "⚠️ Nenhum arquivo selecionado para carregar."
 
     try:
         file_path = arquivo_entrada.name
-        logger.info(f"Carregando progresso do arquivo: {file_path}")
+        logger.info(f"--- Carregando progresso do arquivo: {file_path}")
 
         with open(file_path, 'r', encoding='utf-8') as f:
             dados = json.load(f)
@@ -1093,14 +1137,14 @@ def carregar_progresso(arquivo_entrada):
         tipo_peticao = dados.get("tipo_peticao")
 
         if caso is None or peticao is None or tipo_peticao is None:
-             logger.warning(f"Arquivo JSON carregado não contém as chaves esperadas: {dados.keys()}")
+             logger.warning(f"--- Arquivo JSON carregado não contém as chaves esperadas: {dados.keys()}")
              return "", "", "", "❌ Erro: Arquivo de progresso inválido ou incompleto."
 
         if tipo_peticao not in TIPOS_DE_PETICAO:
-             logger.warning(f"Tipo de petição '{tipo_peticao}' do arquivo não é válido.")
+             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.")
+        logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM SUCESSO")
         return tipo_peticao, caso, peticao, "✅ Progresso carregado com sucesso!"
 
     except json.JSONDecodeError:
@@ -1108,96 +1152,49 @@ def carregar_progresso(arquivo_entrada):
         return "", "", "", "❌ Erro: Arquivo selecionado não é um JSON válido."
     except Exception as e:
         logger.error(f"Erro ao carregar o progresso: {str(e)}", exc_info=True)
+        logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM ERRO")
         return "", "", "", f"❌ Erro inesperado ao carregar o progresso: {str(e)}"
 
-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).
+# --- Função de Geração de Caso (com log adicionado) ---
+def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
+    logger.info(f">>> GERAR CASO FICTICIO INICIADO para: {tipo_peticao}")
+    if not tipo_peticao:
+        logger.error("--- Tipo de petição não selecionado para gerar caso.")
+        return "Erro: Tipo de petição não selecionado para gerar caso."
+    prompt = estruturar_prompt_geracao_caso(tipo_peticao)
+    logger.info("--- Prompt de geração de caso estruturado.")
+    caso_gerado = chamar_api(prompt)
+    logger.info(f"--- Resultado da chamada API para gerar caso: {caso_gerado[:100]}...") # Log reduzido para não poluir
 
-    **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}**.
+    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}"
 
-    **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."
+    frase_final_padrao = f"**Situação-Problema:** Na qualidade de advogado(a) de"
+    if frase_final_padrao.lower() not in caso_gerado.lower():
+        logger.warning("--- Frase 'Situação-Problema' não encontrada. Adicionando manualmente.")
+        nomes_possiveis = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
+        cliente_nome = nomes_possiveis[0] if nomes_possiveis else "[Cliente]"
+        caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente_nome}, elabore a peça processual cabível ({tipo_peticao})."
 
-    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})."
+    logger.info("<<< GERAR CASO FICTICIO FINALIZADO COM SUCESSO")
+    return caso_gerado
 
-    **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
+# --- Validação Básica (mantida) ---
+def validar_peticao_basica(peticao):
+    problemas = []
+    peticao_lower = peticao.lower()
+    if "excelentíssimo" not in peticao_lower and "eméritos" not in peticao_lower and "meritíssimo" not in peticao_lower :
+        problemas.append("Endereçamento inicial parece ausente ou incompleto.")
+    if "valor da causa" not in peticao_lower and "valor à causa" not in peticao_lower:
+        problemas.append("Atribuição de Valor da Causa não encontrada (essencial na Inicial).")
+    if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower :
+        problemas.append("Pedido de juntada de custas ou gratuidade de justiça não encontrado (essencial na Inicial).")
+    if "nestes termos" not in peticao_lower and "pede deferimento" not in peticao_lower:
+        problemas.append("Fechamento formal padrão ('Nestes termos pede deferimento') parece ausente.")
+    return problemas
 
+# --- Interface Gradio (com correção do Checkbox e logs nas wrappers) ---
 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 ⚖️")
@@ -1256,7 +1253,8 @@ def interface_gradio():
                         btn_corrigir = gr.Button("🚀 CORRIGIR E ANALISAR!", variant="primary")
 
                     with gr.TabItem("📎 Anexar Arquivo"):
-                        peticao_arquivo_input = gr.File(label="Arquivo da Peça (.pdf, .docx, .txt - Máx 15MB)", file_types=[".pdf", ".docx", ".txt"])
+                        # 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")
 
@@ -1281,27 +1279,33 @@ def interface_gradio():
 
         clear_btn = gr.Button("🗑️ Limpar Tudo")
 
-        # --- FUNÇÕES WRAPPER ---
+        # --- FUNÇÕES WRAPPER (com logs adicionados) ---
         def corrigir_peticao_wrapper_texto(caso, tipo_peticao, peticao_texto, peticao_arquivo_state):
-            # Acessa o valor atual do componente checkbox
-            is_treinamento = modo_treinamento.value
-            # Chama a função original passando o valor booleano
-            return corrigir_peticao(caso, tipo_peticao, peticao_texto, peticao_arquivo_state, is_treinamento)
+            logger.info(">>> WRAPPER TEXTO INICIADO")
+            is_treinamento = modo_treinamento.value # Acessa o valor do componente checkbox
+            logger.info(f"--- Modo Treinamento (Texto): {is_treinamento}")
+            resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto, peticao_arquivo_state, is_treinamento)
+            logger.info("<<< WRAPPER TEXTO FINALIZADO")
+            return resultado
 
         def corrigir_peticao_wrapper_arquivo(caso, tipo_peticao, peticao_texto_state, peticao_arquivo):
-            # Acessa o valor atual do componente checkbox
-            is_treinamento = modo_treinamento.value
-            # Chama a função original passando o valor booleano
-            return corrigir_peticao(caso, tipo_peticao, peticao_texto_state, peticao_arquivo, is_treinamento)
+            logger.info(">>> WRAPPER ARQUIVO INICIADO")
+            is_treinamento = modo_treinamento.value # Acessa o valor do componente checkbox
+            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)
+            logger.info("<<< WRAPPER ARQUIVO FINALIZADO")
+            return resultado
         # --- FIM DAS FUNÇÕES WRAPPER ---
 
 
-        # --- LÓGICA DOS BOTÕES E EVENTOS (COM CORREÇÃO) ---
+        # --- LÓGICA DOS BOTÕES E EVENTOS (COM CORREÇÃO E LOGS) ---
 
         caso_btn.click(
              fn=gerar_caso_ficticio,
              inputs=[tipo_peticao_input],
-             outputs=[caso_input]
+             outputs=[caso_input],
+             show_progress="full" # Mostra progresso no botão
         )
 
         peticao_texto_input.change(
@@ -1318,39 +1322,40 @@ def interface_gradio():
         peticao_arquivo_input.change(
              fn=process_file,
              inputs=[peticao_arquivo_input],
-             outputs=[arquivo_preview_output]
+             outputs=[arquivo_preview_output],
+             show_progress="minimal" # Mostra progresso no botão
         )
 
-        # Botão Corrigir (Texto) - MODIFICADO PARA USAR WRAPPER
+        # Botão Corrigir (Texto) - Usando wrapper
         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]
+            outputs=[processing_message],
+            show_progress=False # Mensagem customizada já existe
         ).then(
-            fn=corrigir_peticao_wrapper_texto, # Chama a função wrapper
-            # Inputs SEM o componente modo_treinamento
+            fn=corrigir_peticao_wrapper_texto,
             inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None)],
-            # Outputs permanecem os mesmos
             outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output]
+                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
+            show_progress="full" # Mostra progresso durante a execução da função principal
         ).then(
             fn=lambda: gr.update(value="", visible=False),
             inputs=None,
             outputs=[processing_message]
         )
 
-        # Botão Corrigir (Arquivo) - MODIFICADO PARA USAR WRAPPER
+        # Botão Corrigir (Arquivo) - Usando wrapper
         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]
+            outputs=[processing_message],
+            show_progress=False # Mensagem customizada já existe
         ).then(
-            fn=corrigir_peticao_wrapper_arquivo, # Chama a função wrapper
-             # Inputs SEM o componente modo_treinamento
+            fn=corrigir_peticao_wrapper_arquivo,
             inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input],
-             # Outputs permanecem os mesmos
             outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output]
+                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
+             show_progress="full" # Mostra progresso durante a execução da função principal
         ).then(
             fn=lambda: gr.update(value="", visible=False),
             inputs=None,
@@ -1376,11 +1381,12 @@ def interface_gradio():
 
         salvar_btn.click(
              fn=lambda: gr.update(value="⏳ Salvando progresso atual...", visible=True),
-             inputs=None, outputs=processing_message
+             inputs=None, outputs=processing_message, show_progress=False
         ).then(
              fn=salvar_progresso,
              inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
+             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file],
+             show_progress="minimal"
         ).then(
             fn=lambda x: gr.update(visible=bool(x)),
             inputs=[progresso_download_file],
@@ -1391,53 +1397,31 @@ def interface_gradio():
 
         carregar_btn.click(
              fn=lambda: gr.update(value="⏳ Carregando progresso do arquivo...", visible=True),
-             inputs=None, outputs=processing_message
+             inputs=None, outputs=processing_message, show_progress=False
         ).then(
              fn=carregar_progresso,
              inputs=[arquivo_progresso_upload],
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
+             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status],
+             show_progress="minimal"
          ).then(
             lambda: gr.update(value="", visible=False), None, processing_message
         )
 
     return demo
 
-def validar_peticao_basica(peticao):
-    problemas = []
-    peticao_lower = peticao.lower()
-    if "excelentíssimo" not in peticao_lower and "eméritos" not in peticao_lower and "meritíssimo" not in peticao_lower :
-        problemas.append("Endereçamento inicial parece ausente ou incompleto.")
-    if "valor da causa" not in peticao_lower and "valor à causa" not in peticao_lower:
-        problemas.append("Atribuição de Valor da Causa não encontrada (essencial na Inicial).")
-    if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower :
-        problemas.append("Pedido de juntada de custas ou gratuidade de justiça não encontrado (essencial na Inicial).")
-    if "nestes termos" not in peticao_lower and "pede deferimento" not in peticao_lower:
-        problemas.append("Fechamento formal padrão ('Nestes termos pede deferimento') parece ausente.")
-    return problemas
-
-def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    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)
-
-    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}"
-
-    frase_final_padrao = f"**Situação-Problema:** Na qualidade de advogado(a) de"
-    if frase_final_padrao.lower() not in caso_gerado.lower():
-        logger.warning("Frase 'Situação-Problema' não encontrada na geração do caso. Adicionando manualmente.")
-        nomes_possiveis = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
-        cliente_nome = nomes_possiveis[0] if nomes_possiveis else "[Cliente]"
-        caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente_nome}, elabore a peça processual cabível ({tipo_peticao})."
-
-    logger.info("Caso fictício gerado com sucesso.")
-    return caso_gerado
-
+# --- Bloco de Execução Principal ---
 if __name__ == "__main__":
-    # A configuração do Tesseract agora depende do packages.txt no Hugging Face
-    # Não é necessário configurar o caminho no código Python aqui.
+    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.")
+    except Exception as e:
+         logger.warning(f"Tesseract não encontrado ou erro ao verificar versão: {e}. OCR de PDFs pode falhar. Verifique packages.txt.")
+
     app = interface_gradio()
-    app.launch()
+    # 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
+    logger.info("Aplicação Gradio encerrada.")