Update app.py

app.py

@@ -21,6 +21,7 @@ from html import escape
 import random
 import logging
 import re
+from fpdf import FPDF # Import FPDF
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -29,991 +30,517 @@ load_dotenv()
 
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
-    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a no arquivo .env ou como Secret.")
+    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada.")
 
 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": 180,
-    "temperatura": 0.3,
-    "max_tokens": 8192
-}
-
-CONFIG_OAB = {
-    "temperatura": 0.2,
-    "max_tokens": 8192
-}
-
+CONFIG = {"max_retry_attempts": 3, "retry_delay": 5, "timeout": 180, "temperatura": 0.3, "max_tokens": 8192}
+CONFIG_OAB = {"temperatura": 0.2, "max_tokens": 8192}
 rate_limiter = RateLimiter(max_calls=30, period=60)
 
 TIPOS_DE_PETICAO = [
-    "Petição Inicial",
-    "Contestação",
-    "Reconvenção",
-    "Impugnação à Contestação",
-    "Embargos de Declaração",
-    "Recurso de Apelação",
-    "Agravo de Instrumento",
-    "Petição de Tutela Provisória",
-    "Ação de Alimentos Gravídicos",
+    "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", "Ação de Alimentos Gravídicos",
 ]
 
 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.",
-    "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.",
-    "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).",
-    "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.",
-    "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.",
-    "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).",
+    "Clareza e Concisão": "Seja direto e evite jargões excessivos.", "Fundamentação Legal": "Sempre cite lei/súmula/jurisprudência.",
+    "Coerência Argumentativa": "Mantenha linha lógica.", "Revisão Ortográfica e Gramatical": "Erros prejudicam credibilidade.",
+    "Formatação": "Parágrafos definidos, espaçamento, destaque moderado.",
+    "Endereçamento (Inicial)": "Verifique competência. Consumo: foro domicílio autor (Art. 101, I, CDC).",
+    "Qualificação (Inicial)": "Dados Art. 319, II, CPC. Use 'XXX'.", "Fatos (Inicial)": "Narrativa cronológica, clara, objetiva.",
+    "Pedidos (Inicial)": "Certos, determinados, líquidos. Cumule (Art. 327).", "Custas (Inicial)": "Peça juntada guia OU JG.",
+    "Valor da Causa (Inicial)": "Benefício econômico (Art. 292).", "Preliminares (Contestação)": "Art. 337 antes mérito.",
+    "Impugnação Específica (Contestação)": "Conteste cada fato (Art. 341).", "Mérito (Contestação)": "Sua versão + fundamento improcedência.",
+    "Pedidos (Contestação)": "Acolher prelim./improcedência total + custas/honorários.", "Pressupostos Recursais": "Cabimento, tempestiv., preparo, reg. formal, interesse.",
+    "Dialeticidade (Recurso)": "Impugne fundamentos decisão (Art. 1010 II/III Apel.).", "Delimitação da Matéria (Recurso)": "Indique parte recorrida.",
+    "Fumus Boni Iuris": "Plausibilidade direito (provas/argumentos).", "Periculum in Mora": "Risco dano irreparável/difícil reparação.",
+    "Reversibilidade": "Argumente reversibilidade (Art. 300, §3º).",
 }
 
 HISTORICO = []
 CORRECAO_CACHE = {}
 
 def preprocess_image_for_ocr(img):
-    try:
-        gray = img.convert('L')
-        np_img = np.array(gray)
-        _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        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)}"
+    try: gray = img.convert('L'); np_img = np.array(gray); _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU); return Image.fromarray(thresh)
+    except Exception as e: logger.error(f"Preprocess err: {e}"); return f"❌ Err preprocess: {e}"
 
 def extract_text_from_pdf(file_path_or_obj):
-    text = ""
-    ocr_text = ""
-    full_text = ""
+    text, ocr_text, full_text = "", "", ""
     try:
         pdf_reader = pdfplumber_open(file_path_or_obj)
         for i, page in enumerate(pdf_reader.pages):
-            page_full_text = ""
-            page_text = page.extract_text()
-            if page_text:
-                page_full_text += page_text + "\n"
-                text += page_text + "\n"
+            page_full_text = ""; page_text = page.extract_text()
+            if page_text: page_full_text += page_text + "\n"; text += page_text + "\n"
             else:
-                logger.warning(f"Página {i+1} sem texto extraível, tentando OCR.")
-                try:
-                    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')
-                    if page_ocr_text.strip():
-                        page_full_text += page_ocr_text + "\n"
-                        ocr_text += page_ocr_text + "\n"
-                    else:
-                        logger.warning(f"OCR falhou na página {i+1}.")
-                        page_full_text += f"[OCR falhou na página {i+1}]\n"
-                        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)}")
-                    page_full_text += f"[Erro no OCR da página {i+1}: {str(ocr_e)}]\n"
-                    ocr_text += f"[Erro no OCR da página {i+1}: {str(ocr_e)}]\n"
+                logger.warning(f"P{i+1} OCR try.")
+                try: img = page.to_image(resolution=300).original; page_ocr_text = pytesseract.image_to_string(preprocess_image_for_ocr(img), lang='por')
+                except Exception as ocr_setup_e: logger.error(f"Tesseract/Lang error? {ocr_setup_e}"); page_ocr_text = None # Handle potential Tesseract setup issues
+                if page_ocr_text and page_ocr_text.strip(): page_full_text += page_ocr_text + "\n"; ocr_text += page_ocr_text + "\n"
+                else: page_full_text += f"[OCR fail p{i+1}]\n"; ocr_text += f"[OCR fail p{i+1}]\n"
             full_text += page_full_text
         pdf_reader.close()
-
-        if full_text.strip():
-            logger.info("Texto combinado (extração/OCR) obtido do PDF.")
-            return full_text
-        else:
-            logger.warning("Não foi possível extrair texto significativo do PDF (nem extração, nem OCR).")
-            return "⚠️ Não foi possível extrair texto do PDF (tentativa de OCR falhou ou texto inexistente)."
-
+        if full_text.strip(): logger.info("Combined PDF text."); return full_text
+        else: logger.warning("No PDF text."); return "⚠️ No text extracted."
     except Exception as e:
-        logger.error(f"Erro geral ao processar o PDF: {str(e)}")
+        logger.error(f"PDF err: {e}")
         try:
-            logger.info("Tentando fallback com PyPDF2.")
-            text_fallback = ""
-            if isinstance(file_path_or_obj, str):
-                 with open(file_path_or_obj, 'rb') as f:
-                    reader = PyPDF2.PdfReader(f)
-                    for page in reader.pages: text_fallback += page.extract_text() or ""
-            else:
-                 file_path_or_obj.seek(0)
-                 reader = PyPDF2.PdfReader(file_path_or_obj)
-                 for page in reader.pages: text_fallback += page.extract_text() or ""
-
-            if text_fallback.strip():
-                logger.info("Texto extraído com fallback PyPDF2.")
-                return text_fallback
-            else:
-                 return f"❌ Erro ao processar o PDF e fallback falhou: {str(e)}"
-        except Exception as fallback_e:
-            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)
-        text = "\n".join([para.text for para in doc.paragraphs])
-        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)}")
-        return f"❌ Erro ao processar o DOCX: {str(e)}"
-
-def extract_text_from_txt(file_path_or_obj):
+            logger.info("PyPDF2 fallback.")
+            fb_text = ""; reader_args = file_path_or_obj;
+            if hasattr(reader_args, 'seek'): reader_args.seek(0)
+            reader = PyPDF2.PdfReader(reader_args)
+            for page in reader.pages: fb_text += page.extract_text() or ""
+            if fb_text.strip(): logger.info("Fallback ok."); return fb_text
+            else: return f"❌ PDF err & fallback fail: {e}"
+        except Exception as fb_e: logger.error(f"Fallback err: {fb_e}"); return f"❌ Critical PDF err: {e}"
+
+def extract_text_from_docx(f):
+    try: d=docx.Document(f); t="\n".join([p.text for p in d.paragraphs]); return t if t.strip() else "⚠️ DOCX empty."
+    except Exception as e: logger.error(f"DOCX err: {e}"); return f"❌ DOCX error: {e}"
+
+def extract_text_from_txt(f):
     try:
-        if isinstance(file_path_or_obj, str):
-            with open(file_path_or_obj, 'rb') as f:
-                content = f.read()
-        elif hasattr(file_path_or_obj, 'read'):
-            content = file_path_or_obj.read()
-            if hasattr(file_path_or_obj, 'seek'):
-                 try: file_path_or_obj.seek(0)
-                 except: pass
-        else:
-             return "❌ Tipo de entrada TXT inválido."
-
-        encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
-        for encoding in encodings:
-            try:
-                decoded_text = content.decode(encoding)
-                logger.info(f"Arquivo TXT decodificado com {encoding}.")
-                return decoded_text if decoded_text.strip() else "⚠️ Arquivo TXT vazio."
-            except UnicodeDecodeError:
-                continue
-        logger.error("Não foi possível decodificar o arquivo TXT com encodings comuns.")
-        return "❌ Não foi possível decodificar o arquivo TXT. Verifique o encoding."
-    except Exception as e:
-        logger.error(f"Erro ao processar o TXT: {str(e)}")
-        return f"❌ Erro ao processar o TXT: {str(e)}"
-
-def process_file(file_obj):
-    if file_obj is None:
-        logger.warning("Nenhum arquivo fornecido para processamento.")
-        return "⚠️ Nenhum arquivo enviado."
+        c = None
+        if isinstance(f, str):
+            with open(f, 'rb') as file: c = file.read()
+        elif hasattr(f, 'read'): c = f.read(); [getattr(f, 'seek', lambda x: None)(0)]
+        else: return "❌ Invalid TXT."
+        for enc in ['utf-8', 'latin-1', 'cp1252']:
+            try: dec = c.decode(enc); logger.info(f"TXT decoded {enc}."); return dec if dec.strip() else "⚠️ TXT empty."
+            except UnicodeDecodeError: continue
+        logger.error("Cannot decode TXT."); return "❌ Cannot decode TXT."
+    except Exception as e: logger.error(f"TXT err: {e}"); return f"❌ TXT error: {e}"
+
+def process_file(f):
+    if f is None: return "⚠️ No file."
     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."
-
-        filename = os.path.basename(file_path).lower()
-        logger.info(f"Processando arquivo: {filename}")
-
+        fp=getattr(f,'name',None); fn=os.path.basename(fp).lower() if fp else None
+        if not fp or not fn: return "❌ No file info."
+        logger.info(f"Processing: {fn}")
         try:
-             file_size = os.path.getsize(file_path)
-             logger.info(f"Tamanho do arquivo: {file_size} bytes")
-             if file_size > 15 * 1024 * 1024:
-                 logger.warning(f"Arquivo {filename} excede o limite de tamanho.")
-                 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}")
-
-        if filename.endswith('.pdf'):
-            return extract_text_from_pdf(file_path)
-        elif filename.endswith('.docx'):
-            return extract_text_from_docx(file_path)
-        elif filename.endswith('.txt'):
-            return extract_text_from_txt(file_path)
-        else:
-            logger.warning(f"Formato de arquivo não suportado: {filename}")
-            return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
-
-    except Exception as e:
-        logger.error(f"Erro geral ao processar o arquivo '{getattr(file_obj, 'name', 'N/A')}': {str(e)}", exc_info=True)
-        return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
+            fs=os.path.getsize(fp)
+            if fs > 15*1024*1024: return "⚠️ File >15MB."
+        except OSError as se: logger.warning(f"Size err: {se}")
+        if fn.endswith('.pdf'): return extract_text_from_pdf(fp)
+        if fn.endswith('.docx'): return extract_text_from_docx(fp)
+        if fn.endswith('.txt'): return extract_text_from_txt(fp)
+        return "⚠️ Format? (PDF,DOCX,TXT)."
+    except Exception as e: logger.error(f"File err: {e}", exc_info=True); return f"❌ File error: {e}"
 
 def chamar_api(prompt, use_oab_config=False):
-    config_to_use = CONFIG_OAB if use_oab_config else CONFIG
-    payload = {
-        "contents": [{"parts": [{"text": prompt}]}],
-        "generationConfig": {
-            "temperature": config_to_use["temperatura"],
-            "maxOutputTokens": config_to_use["max_tokens"],
-            "topP": 0.95,
-        }
-    }
-    headers = {"Content-Type": "application/json"}
-    logger.info(f"Chamando API Gemini com {len(prompt)} chars. Temp: {config_to_use['temperatura']}, MaxTokens: {config_to_use['max_tokens']}")
-
-    for tentativa in range(CONFIG["max_retry_attempts"]):
+    cfg = CONFIG_OAB if use_oab_config else CONFIG
+    payload = {"contents": [{"parts": [{"text": prompt}]}], "generationConfig": {"temperature": cfg["temperatura"], "maxOutputTokens": cfg["max_tokens"], "topP": 0.95}}
+    hdrs = {"Content-Type": "application/json"}
+    logger.info(f"API: {len(prompt)}c. T:{cfg['temperatura']}, MaxT:{cfg['max_tokens']}")
+    for att in range(CONFIG["max_retry_attempts"]):
         try:
-            with rate_limiter:
-                response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
-
-            if response.status_code == 429:
-                retry_after = int(response.headers.get("Retry-After", CONFIG["retry_delay"] * (tentativa + 1)))
-                logger.warning(f"Erro 429. 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."
-
-            if response.status_code != 200:
-                error_info = response.json()
-                error_msg = error_info.get("error", {}).get("message", "Erro desconhecido")
-                logger.error(f"Erro API (Status {response.status_code}): {error_msg}")
-                if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG["retry_delay"] * (tentativa + 1)); continue
-                return f"❌ Erro 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")
-                 logger.error(f"Resposta API sem 'candidates'. Block Reason: {block_reason}")
-                 return f"❌ Solicitação bloqueada pela API. Motivo: {block_reason}." if block_reason else "❌ Resposta vazia/inválida (sem 'candidates')."
-
-            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: {finish_reason}")
-                 safety_ratings = candidate.get("safetyRatings", [])
-                 harm_categories = [r['category'] for r in safety_ratings if r['probability'] not in ['NEGLIGIBLE', 'LOW']]
-                 return f"❌ Resposta bloqueada por segurança: {finish_reason} (Categorias: {', '.join(harm_categories)})." if harm_categories else f"❌ Geração interrompida: {finish_reason}."
-
-            if "content" not in candidate or "parts" not in candidate["content"] or not candidate["content"]["parts"]:
-                 logger.error("Estrutura de resposta inesperada.")
-                 if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG["retry_delay"] * (tentativa + 1)); continue
-                 return "❌ Resposta inválida (estrutura inesperada)."
-
-            texto_gerado = candidate["content"]["parts"][0]["text"].strip()
-            logger.info(f"API retornou com sucesso. Tamanho: {len(texto_gerado)} chars.")
-            return texto_gerado
-
-        except requests.Timeout:
-            logger.warning(f"Timeout tentativa {tentativa + 1}.")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG["retry_delay"] * (tentativa + 1)); continue
-            return "⏱️ Tempo esgotado."
-        except requests.RequestException as e:
-            logger.error(f"Erro de rede/requisição: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG["retry_delay"] * (tentativa + 1)); continue
-            return f"❌ Erro na requisição: {e}"
-        except json.JSONDecodeError as e:
-             logger.error(f"Erro JSON: {e}. Resposta: {response.text[:200]}...")
-             return f"❌ Erro processar resposta API (JSON inválido)."
-        except Exception as e:
-            logger.exception(f"Erro inesperado API: {str(e)}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG["retry_delay"] * (tentativa + 1)); continue
-            return f"❌ Erro inesperado: {str(e)}"
-
-    return "❌ Falha API após todas tentativas."
+            with rate_limiter: resp = requests.post(GEMINI_API_URL, headers=hdrs, json=payload, timeout=CONFIG["timeout"])
+            if resp.status_code==429:
+                wait=int(resp.headers.get("Retry-After", CONFIG["retry_delay"]*(att+1))); logger.warning(f"429. Wait {wait}s...");
+                if att < CONFIG["max_retry_attempts"]-1: time.sleep(wait); continue
+                else: return "❌ 429 Error."
+            if resp.status_code!=200:
+                try: msg=resp.json().get("error",{}).get("message","Unknown")
+                except: msg=resp.text[:100]
+                logger.error(f"API Err {resp.status_code}: {msg}");
+                if att < CONFIG["max_retry_attempts"]-1: time.sleep(CONFIG["retry_delay"]*(att+1)); continue
+                return f"❌ API Err {resp.status_code}: {msg}"
+            data = resp.json()
+            if not data.get("candidates"): reason=data.get("promptFeedback",{}).get("blockReason"); logger.error(f"No candidates. Block: {reason}"); return f"❌ Blocked: {reason}." if reason else "❌ Invalid (no candidates)."
+            cand=data["candidates"][0]; reason=cand.get("finishReason")
+            if reason not in [None,"STOP","MAX_TOKENS"]:
+                logger.error(f"Gen stop: {reason}"); cats=[r['category'] for r in cand.get("safetyRatings",[]) if r['probability'] not in ['NEGLIGIBLE','LOW']];
+                return f"❌ Safety block: {reason} ({','.join(cats)})." if cats else f"❌ Gen stop: {reason}."
+            if not cand.get("content",{}).get("parts"): logger.error("Bad structure."); if att < CONFIG["max_retry_attempts"]-1: time.sleep(CONFIG["retry_delay"]*(att+1)); continue; return "❌ Invalid structure."
+            txt=cand["content"]["parts"][0]["text"].strip(); logger.info(f"API ok. Len: {len(txt)}."); return txt
+        except requests.Timeout: logger.warning(f"Timeout {att+1}."); if att<CONFIG["max_retry_attempts"]-1: time.sleep(CONFIG["retry_delay"]*(att+1)); continue; return "⏱️ Timeout."
+        except requests.RequestException as e: logger.error(f"Net err: {e}"); if att<CONFIG["max_retry_attempts"]-1: time.sleep(CONFIG["retry_delay"]*(att+1)); continue; return f"❌ Net error: {e}"
+        except json.JSONDecodeError as e: logger.error(f"JSON err: {e}. Resp: {resp.text[:100]}..."); return "❌ API JSON err."
+        except Exception as e: logger.exception(f"API Unexpected: {e}"); if att<CONFIG["max_retry_attempts"]-1: time.sleep(CONFIG["retry_delay"]*(att+1)); continue; return f"❌ Unexpected: {e}"
+    return "❌ API fail all retries."
 
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
-    base = """
-    **Estrutura da Avaliação (Geral - IA):**
-    1.  **Análise Geral:** Visão geral concisa (2-3 linhas) sobre a adequação da peça ao caso e tipo, consistência e clareza.
-    2.  **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE dos principais fatores.
-    3.  **Pontos Positivos:** Liste pelo menos 2-3 aspectos bem executados, com justificativa (legal/técnica).
-    4.  **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade (erros crassos primeiro). Para cada ponto:
-        *   Descrição clara do erro/omissão.
-        *   Fundamentação legal/doutrinária do porquê é um erro.
-        *   **Impacto estimado na nota** (ex: -0.5, -1.0, -2.0).
-        *   Sugestão de correção ou como deveria ter sido feito.
-    5.  **Análise Específica dos Requisitos:** Avalie os itens chave da peça (listados abaixo para cada tipo).
-
-    **Critérios Fundamentais (Aplicáveis a Quase Todos):**
-    *   **Coerência:** A peça responde ao caso/situação processual? Os argumentos são lógicos?
-    *   **Fundamentação:** Usou a lei, doutrina e jurisprudência corretamente? Citou artigos relevantes?
-    *   **Linguagem:** Clareza, objetividade, correção gramatical e formalidade adequada?
-    *   **Pedidos:** São claros, certos, determinados e coerentes com a fundamentação?
-    *   **NÃO INVENTAR FATOS:** Penalidade severa (-3.0 a -5.0) se criar fatos não presentes no caso.
-    *   **NÃO SE IDENTIFICAR:** Nota ZERO se houver nome, OAB, CPF, etc., do aluno na peça (exceto nomes das partes do caso). Use "ADVOGADO(A)", "OAB/...".
-    """
-    if modo_treinamento:
-        base += """
-    **Modo de Treinamento:**
-    *   Para cada Ponto a Melhorar, detalhe AINDA MAIS:
-        a) Explicação aprofundada do erro e sua consequência prática.
-        b) Base legal/doutrinária específica.
-        c) **Exemplo de Redação Corrigida** para aquele trecho específico.
-        d) Dica prática relevante (use o banco de dicas se aplicável).
-        e) Possível estratégia alternativa.
-    *   Destaque inconsistências entre a peça e o caso com citações diretas.
-    *   Sugira estratégias jurídicas adicionais ou alternativas viáveis.
-        """
+    base = "**Estrutura Avaliação (IA):**\n1.Análise Geral.\n2.Nota Final(0-10, justif.).\n3.Pontos Positivos.\n4.Pontos a Melhorar(TODOS, descr, fundam, impacto, sugestão).\n5.Análise Requisitos.\n\n**Critérios:** Coerência? Fundam.? Linguagem? Pedidos? **NÃO INVENTAR**(-3a-5). **NÃO IDENTIFICAR**(ZERO).\n"
+    if modo_treinamento: base += "**Modo Treino:** Detalhar+: Explicação, Base legal, Ex.Corrigido, Dica, Estrat.alt. Destaque inconsist. Sugira estrat.adic.\n"
     return base
 
 def estruturar_prompt_analise_geral(caso, peticao, tipo_peticao, modo_treinamento=False):
-    instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
-    prompt_especifico = f"""
-    ## Análise de Peça Processual: {tipo_peticao} (Avaliação Geral IA - Critérios OAB Simulados)
-
-    **Caso/Contexto Fornecido:**
-    ```
-    {caso}
-    ```
-
-    **Peça do Aluno ({tipo_peticao}):**
-    ```
-    {peticao}
-    ```
-
-    {instrucoes_gerais}
-
-    **Requisitos Específicos para {tipo_peticao} (Considerados pela IA):**
-    """
-    if tipo_peticao == "Petição Inicial" or tipo_peticao == "Ação de Alimentos Gravídicos":
-        prompt_especifico += """
-       - Endereçamento e competência (Art. 319, I, CPC; leis especiais como CDC Art. 101, I, Lei 11.804/08).
-       - Qualificação completa das partes (Art. 319, II, CPC).
-       - Exposição clara e lógica dos fatos (causa de pedir remota).
-       - Fundamentação jurídica pertinente (causa de pedir próxima - Art. 319, III, CPC).
-       - Pedidos certos, determinados e líquidos (se possível) (Art. 319, IV, CPC). Incluir pedido de conversão se aplicável (Alimentos Gravídicos).
-       - Valor da causa correto e justificado (Art. 291-292, 319, V, CPC).
-       - Indicação das provas pretendidas (Art. 319, VI, CPC).
-       - Opção pela audiência de conciliação/mediação (Art. 319, VII, CPC).
-       - Pedido de citação do réu (forma específica se necessário).
-       - Requerimento de juntada de documentos essenciais (procuração, custas/JG).
-       - Fechamento formal ("Nestes termos pede deferimento", Local, data, Advogado, OAB).
-        """
-    elif tipo_peticao == "Contestação":
-         prompt_especifico += """
-       - Endereçamento ao juízo correto. Qualificação do réu. Indicação do processo. Tempestividade.
-       - **Preliminares (Art. 337):** Alegar TODAS aplicáveis.
-       - **Impugnação Específica dos Fatos (Art. 341):** Rebater PONTO A PONTO.
-       - **Mérito:** Defesa direta/indireta. Fundamentação jurídica.
-       - **Pedidos:** Acolhimento preliminares; IMPROCEDÊNCIA TOTAL; Condenação custas/honorários.
-       - Indicação de provas. Fechamento formal.
-         """
-    # Add other types...
-
-    prompt_especifico += "\n\n**Instruções Finais:** Analise a peça do aluno com base no caso e nos critérios gerais e específicos. Use seu conhecimento jurídico para simular um examinador da OAB. Forneça feedback construtivo e detalhado. Gere a resposta **exclusivamente** no formato solicitado (Análise Geral, Nota, Pontos Positivos, etc.)."
-    return prompt_especifico
+    instr = get_instrucoes_gerais_avaliacao(modo_treinamento)
+    prompt = f"## Análise Peça: {tipo_peticao} (IA)\n\n**Caso:**\n```\n{caso}\n```\n\n**Peça Aluno:**\n```\n{peticao}\n```\n\n{instr}\n\n**Reqs {tipo_peticao}(IA):**\n"
+    if tipo_peticao in ["Petição Inicial", "Ação de Alimentos Gravídicos"]: prompt += "- Ender/Comp(319 I; CDC 101 I; L.11804)\n- Qualif(319 II)\n- Fatos\n- Fundam(319 III)\n- Pedidos(319 IV; conversão?)\n- V.Causa(291-2; 319 V)\n- Provas(319 VI)\n- Aud(319 VII)\n- Citação\n- Docs(Proc; Custas/JG)\n- Fecho\n"
+    elif tipo_peticao == "Contestação": prompt += "- Ender.\n- Qualif.Réu; Proc#.\n- Tempest.\n- Prelim(337)\n- Impug.Esp(341)\n- Mérito(Defesa)\n- Fundam.\n- Pedidos(Acolh Prelim; IMPROCEDÊNCIA; Custas/Hon 85)\n- Provas.\n- Fecho.\n"
+    prompt += "\n\n**Instruções Finais:** Analise conf. caso/critérios. Simule OAB. Feedback construtivo. Formato solicitado."
+    return prompt
 
 def estruturar_prompt_peticao_corrigida_geral(caso, peticao_original, tipo_peticao):
-    prompt = f"""
-    **Caso/Contexto Fornecido:**
-    ```
-    {caso}
-    ```
-
-    **Peça Original do Aluno ({tipo_peticao}):**
-    ```
-    {peticao_original}
-    ```
-
-    **Tarefa:** Com base no caso e nos problemas identificados na peça original, **gere uma versão corrigida e aprimorada** da peça ({tipo_peticao}). Use seu conhecimento jurídico para aplicar as melhores práticas e os requisitos formais/materiais para este tipo de peça no exame da OAB.
-
-    **Instruções Específicas para a Peça Corrigida ({tipo_peticao}):**
-    """
-    if tipo_peticao == "Petição Inicial" or tipo_peticao == "Ação de Alimentos Gravídicos":
-        prompt += """
-    1. **Endereçamento:** Correto (Vara Cível/Família, Foro competente).
-    2. **Qualificação:** Completa (Art. 319, II), usando "XXX".
-    3. **Fatos:** Cronológicos, claros, fiéis ao caso. Indícios paternidade (Alim. Grav.).
-    4. **Fundamentação:** Artigos pertinentes (CC, CDC, CPC, Lei 11.804/08).
-    5. **Pedidos:** Claros, certos, determinados. Pedido alimentos gravídicos (valor provisório/definitivo), tutela urgência, conversão (Lei 11.804/08, Art. 6º, p. único).
-    6. **Valor da Causa:** Correto.
-    7. **Provas:** Indicar (genérico).
-    8. **Audiência:** Indicar opção (Art. 319, VII).
-    9. **Citação:** Pedido.
-    10. **Custas:** Pedido expresso juntada OU JG.
-    11. **Fechamento:** Padrão OAB.
-        """
-    elif tipo_peticao == "Contestação":
-         prompt += """
-    1. **Endereçamento:** Ao juízo da ação.
-    2. **Identificação:** Processo, qualificação réu.
-    3. **Tempestividade:** (Opcional).
-    4. **Estrutura:** Síntese; Preliminares (Art. 337); Mérito (Impugnação Específica, Defesa); Reconvenção (Se aplicável).
-    5. **Pedidos:** Acolhimento preliminares; **IMPROCEDÊNCIA TOTAL**; Condenação custas/honorários.
-    6. **Provas:** Indicar.
-    7. **Fechamento:** Padrão OAB.
-         """
-    # Add other types...
-
-    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."
+    prompt = f"**Caso:**\n```\n{caso}\n```\n\n**Peça Original({tipo_peticao}):**\n```\n{peticao_original}\n```\n\n**Tarefa:** Gere versão corrigida/aprimorada ({tipo_peticao}), baseada caso/problemas. Aplique práticas/reqs OAB.\n\n**Instruções Peça Corrigida({tipo_peticao}):**\n"
+    if tipo_peticao in ["Petição Inicial", "Ação de Alimentos Gravídicos"]: prompt += "1.Ender. ok\n2.Qualif. ok(319 II,'XXX')\n3.Fatos detalhados\n4.Fundam.(CC,CDC,CPC,L.11804)\n5.Pedidos ok(Alim.Grav prov/def;Tut Urg;Conversão L.11804)\n6.V.Causa ok\n7.Provas ok\n8.Aud ok(319 VII)\n9.Citação\n10.Custas ok(Req OU JG)\n11.Fecho OAB\n"
+    elif tipo_peticao == "Contestação": prompt += "1.Ender. ok\n2.Identif ok\n3.Tempest(opc)\n4.Estrut:Sínt;Prelim(337);Mérito(Impug/Def);Reconv?\n5.Pedidos ok(Acolh Prelim;IMPROCEDÊNCIA;Custas/Hon)\n6.Provas\n7.Fecho OAB\n"
+    prompt += "\n\n**Instrução Final:** Gere **APENAS** texto completo peça corrigida. Sem comentários extras."
     return prompt
 
 def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
-    if "Nestes termos, pede deferimento" in peticao_corrigida:
-        peticao_corrigida = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
-
+    pc = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
     if tipo_peticao in ["Petição Inicial", "Ação de Alimentos Gravídicos"]:
-        if "juntada da guia de custas" not in peticao_corrigida.lower() and "gratuidade de justiça" not in peticao_corrigida.lower():
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             prefixo = partes[0].strip() if len(partes) > 1 else peticao_corrigida.strip()
-             sufixo = "\nNestes termos pede deferimento" + partes[1] if len(partes) > 1 else ""
-             peticao_corrigida = prefixo + "\nRequer, ainda, a juntada da guia de custas devidamente recolhida." + sufixo
-
-        if "audiência de conciliação" not in peticao_corrigida.lower() and "audiência de mediação" not in peticao_corrigida.lower():
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             prefixo = partes[0].strip() if len(partes) > 1 else peticao_corrigida.strip()
-             sufixo = "\nNestes termos pede deferimento" + partes[1] if len(partes) > 1 else ""
-             peticao_corrigida = prefixo + "\nOpta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC)." + sufixo
-
-    linhas = [l.strip() for l in peticao_corrigida.strip().split('\n') if l.strip()]
-    fechamento_padrao = ["\nLocal, data.", "ADVOGADO(A)", "OAB/..."]
-
-    # Remove potential multiple closing lines before adding the standard one
-    while linhas and any(term.lower() in linhas[-1].lower() for term in ["advogado", "oab", "local", "data", "pede deferimento", "termos em que"]):
-        # More robust check to avoid removing essential content like the final request
-        last_line_lower = linhas[-1].lower()
-        is_closing_line = any(std_close.strip().lower() in last_line_lower for std_close in fechamento_padrao) or "pede deferimento" in last_line_lower or "termos em que" in last_line_lower
-        if not is_closing_line and len(linhas[-1]) > 30: # Heuristic: unlikely to be just closing
-             break
+        if "juntada da guia de custas" not in pc.lower() and "gratuidade de justiça" not in pc.lower():
+             partes=pc.split("Nestes termos pede deferimento"); pfx=partes[0].strip() if len(partes)>1 else pc.strip(); sfx="\nNestes termos pede deferimento"+partes[1] if len(partes)>1 else ""
+             pc=pfx+"\nRequer, ainda, a juntada da guia de custas devidamente recolhida."+sfx
+        if "audiência de conciliação" not in pc.lower() and "audiência de mediação" not in pc.lower():
+             partes=pc.split("Nestes termos pede deferimento"); pfx=partes[0].strip() if len(partes)>1 else pc.strip(); sfx="\nNestes termos pede deferimento"+partes[1] if len(partes)>1 else ""
+             pc=pfx+"\nOpta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC)."+sfx
+    linhas=[l.strip() for l in pc.strip().split('\n') if l.strip()]
+    fechamento=["\nLocal, data.","ADVOGADO(A)","OAB/..."]
+    while linhas and any(t.lower() in linhas[-1].lower() for t in ["advogado","oab","local","data","pede deferimento","termos em que"]):
+        last_lower=linhas[-1].lower(); is_close=any(std.strip().lower() in last_lower for std in fechamento) or "pede deferimento" in last_lower or "termos em que" in last_lower
+        if not is_close and len(linhas[-1]) > 30: break
         linhas.pop()
-
-    peticao_corrigida = "\n".join(linhas).strip() + "".join(fechamento_padrao) # Join directly
-
-    return peticao_corrigida.strip()
-
-def formatar_correcao(texto):
-    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")
-
-    linhas = texto.split('\n')
-    linhas_formatadas = []
-    in_list = False
-    for linha in linhas:
-        linha_strip = linha.strip()
-        if linha_strip.startswith(("1.","2.","3.","4.","5.")):
-             linhas_formatadas.append(f"\n**{linha_strip}**")
-             in_list = False
-        elif linha_strip.startswith(("- ","* ")):
-             prefix = "  * " if in_list else "* "
-             linhas_formatadas.append(prefix + linha_strip[2:])
-             in_list = True
-        elif linha_strip.startswith(("a)","b)","c)","d)","e)")):
-             linhas_formatadas.append(f"    * {linha_strip}")
-             in_list = True
-        else:
-            linhas_formatadas.append(linha)
-            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")):
-                 in_list = False
-
-    texto_final = "\n".join(linhas_formatadas)
-    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:
-        nota = match.group(2).replace(",",".")
-        texto_final = re.sub(nota_pattern, f"\\1**{nota}/10**", texto_final, count=1, flags=re.IGNORECASE)
-    return texto_final
+    return "\n".join(linhas).strip()+"".join(fechamento)
+
+def formatar_correcao(t):
+    t=t.replace("### Análise Geral","## 📝 Análise Geral").replace("### Nota Final","## ⭐ Nota Final").replace("### Pontos Positivos","## ✅ Pontos Positivos").replace("### Pontos a Melhorar","## ⚠️ Pontos a Melhorar").replace("### Análise Específica dos Requisitos","## 🔎 Análise Específica")
+    linhas=t.split('\n'); fmt_linhas=[]; in_list=False
+    for l in linhas:
+        ls=l.strip()
+        if ls.startswith(("1.","2.","3.","4.","5.")): fmt_linhas.append(f"\n**{ls}**"); in_list=False
+        elif ls.startswith(("- ","* ")): fmt_linhas.append(("  * " if in_list else "* ")+ls[2:]); in_list=True
+        elif ls.startswith(("a)","b)","c)","d)","e)")): fmt_linhas.append(f"    * {ls}"); in_list=True
+        else: fmt_linhas.append(l); in_list=False
+    tf="\n".join(fmt_linhas); m=re.search(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})",tf,re.I)
+    if m: nota=m.group(2).replace(",","."); tf=re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})",f"\\1**{nota}/10**",tf,1,re.I)
+    return tf
 
 def corrigir_peticao_geral_ia(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
-    logger.info(f"Iniciando correção GERAL (IA) para tipo: {tipo_peticao}")
-    start_time = time.time()
-
-    if not caso or not caso.strip(): return "⚠️ Forneça o caso.", "", "", "", "", "", ""
-    if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo.", "", "", "", "", "", ""
-
+    logger.info(f"Correção GERAL IA: {tipo_peticao}"); start=time.time()
+    if not caso or not caso.strip(): return "⚠️ Caso?", "", "", "", "", "", ""
+    if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Tipo?", "", "", "", "", "", ""
     peticao_conteudo = ""
-    if peticao_arquivo is not None:
-        peticao_conteudo = process_file(peticao_arquivo)
-        if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
-            return peticao_conteudo, "", "", "", "", "", ""
-    elif peticao_texto and peticao_texto.strip():
-         peticao_conteudo = peticao_texto
-    else: return "⚠️ Forneça a petição.", "", "", "", "", "", ""
-
-    troll_triggers = [ "escreva a petição", "faça a petição"]
-    if any(trigger in peticao_conteudo.lower() for trigger in troll_triggers):
-        return random.choice(["Nope! 😉", "Faça você e eu corrijo!"]), "", "", "", "", "", ""
-
-    aviso_validacao = ""
-
-    cache_key = f"geral|{tipo_peticao}|{caso[:50]}|{peticao_conteudo[:50]}|{modo_treinamento}"
-    if cache_key in CORRECAO_CACHE:
-        logger.info("Correção GERAL (IA) encontrada no cache.")
-        cached_data = CORRECAO_CACHE[cache_key]
-        return ( cached_data["analise_formatada"], cached_data["peticao_original"],
-                 cached_data["peticao_corrigida"], cached_data["resumo_diff"],
-                 cached_data["criticas_diff"], cached_data.get("avaliacao_criterios_ia", ""),
-                 cached_data["diff_html"] )
-
-    prompt_analise = estruturar_prompt_analise_geral(caso, peticao_conteudo, tipo_peticao, modo_treinamento)
-    analise = chamar_api(prompt_analise, use_oab_config=False)
-    if analise.startswith("❌") or analise.startswith("⏱️"): return aviso_validacao + analise, peticao_conteudo, "", "", "", "", ""
-    analise_formatada = formatar_correcao(analise)
-
-    prompt_peticao = estruturar_prompt_peticao_corrigida_geral(caso, peticao_conteudo, tipo_peticao)
-    peticao_corrigida_bruta = chamar_api(prompt_peticao, use_oab_config=False)
-    peticao_corrigida_final = ""
-    if peticao_corrigida_bruta.startswith("❌") or peticao_corrigida_bruta.startswith("⏱️"):
-        peticao_corrigida_final = f"⚠️ Falha gerar corrigida:\n{peticao_corrigida_bruta}"
-    else:
-        peticao_corrigida_final = pos_corrigir_peticao(peticao_corrigida_bruta, tipo_peticao)
-
-    avaliacao_criterios_md = ""
-
-    visualizacao_detalhada_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-
-    correcao_completa_formatada = aviso_validacao + analise_formatada
-    resultado_historico = { "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "modo": "Geral IA", "tipo_peticao": tipo_peticao, "caso": caso, "peticao_original": peticao_conteudo, "analise_formatada": correcao_completa_formatada, "peticao_corrigida": peticao_corrigida_final, "resumo_diff": resumo_diff,"criticas_diff": criticas_diff, "avaliacao_criterios_ia": avaliacao_criterios_md }
-    HISTORICO.append(resultado_historico)
-    if len(HISTORICO) > 10: HISTORICO.pop(0)
-
-    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, "avaliacao_criterios_ia": avaliacao_criterios_md, "diff_html": visualizacao_detalhada_html }
-
-    end_time = time.time()
-    logger.info(f"Correção GERAL (IA) concluída em {end_time - start_time:.2f}s.")
-
-    return ( correcao_completa_formatada, peticao_conteudo, peticao_corrigida_final,
-             resumo_diff, criticas_diff, avaliacao_criterios_md, visualizacao_detalhada_html )
-
-# --- Funções de Correção Padrão OAB ---
+    if peticao_arquivo: peticao_conteudo = process_file(peticao_arquivo)
+    elif peticao_texto: peticao_conteudo = peticao_texto
+    if not peticao_conteudo or peticao_conteudo.startswith(("❌","⚠️")): return peticao_conteudo or "⚠️ Petição?", "", "", "", "", "", ""
+    if any(tr in peticao_conteudo.lower() for tr in ["escreva a", "faça a"]): return random.choice(["Nope!", "Tente você!"]), "", "", "", "", "", ""
+    cache_key=f"geral|{tipo_peticao}|{caso[:50]}|{peticao_conteudo[:50]}|{modo_treinamento}"
+    if cache_key in CORRECAO_CACHE: logger.info("Cache GERAL hit."); return tuple(CORRECAO_CACHE[cache_key].get(k,"") for k in ["analise_formatada","peticao_original","peticao_corrigida","resumo_diff","criticas_diff","avaliacao_criterios_ia","diff_html"])
+    analise=chamar_api(estruturar_prompt_analise_geral(caso,peticao_conteudo,tipo_peticao,modo_treinamento),False)
+    if analise.startswith(("❌","⏱️")): return analise, peticao_conteudo, "", "", "", "", ""
+    analise_fmt=formatar_correcao(analise)
+    peticao_corr_bruta=chamar_api(estruturar_prompt_peticao_corrigida_geral(caso,peticao_conteudo,tipo_peticao),False)
+    peticao_corr_final = f"⚠️ Falha: {peticao_corr_bruta}" if peticao_corr_bruta.startswith(("❌","⏱️")) else pos_corrigir_peticao(peticao_corr_bruta, tipo_peticao)
+    aval_crit_md=""
+    html, resumo, crit = calcular_diff_interno(peticao_conteudo, peticao_corr_final if not peticao_corr_final.startswith("��️") else "")
+    hist = {"data":datetime.now().strftime("%Y%m%d %H%M"), "modo":"Geral IA", "tipo_peticao":tipo_peticao, "caso":caso, "peticao_original":peticao_conteudo, "analise_formatada":analise_fmt, "peticao_corrigida":peticao_corr_final, "resumo_diff":resumo,"criticas_diff":crit, "avaliacao_criterios_ia":aval_crit_md}
+    HISTORICO.append(hist); HISTORICO[:] = HISTORICO[-10:]
+    CORRECAO_CACHE[cache_key] = {**hist, "diff_html": html}
+    logger.info(f"Correção GERAL IA took {time.time()-start:.2f}s")
+    return analise_fmt, peticao_conteudo, peticao_corr_final, resumo, crit, aval_crit_md, html
+
 def parse_oab_pdf(file_obj):
     if file_obj is None: return None, None, None, "⚠️ Nenhum PDF OAB."
     try:
         full_text = extract_text_from_pdf(file_obj.name)
-        if full_text.startswith("❌") or full_text.startswith("⚠️"): return None, None, None, full_text
-
-        enunciado, gabarito, distribuicao = "", "", ""
-        current_section = None
-        lines = full_text.split('\n')
-
+        if full_text.startswith(("❌","⚠️")): return None, None, None, full_text
+        e, g, d = "", "", ""; current = None; lines = full_text.split('\n')
         for line in lines:
-            line_strip = line.strip()
-            line_lower = line_strip.lower()
-
-            if line_strip.startswith("Enunciado"): current_section = "enunciado"; continue
-            if line_strip.startswith("Gabarito comentado"): current_section = "gabarito"; continue
-            if line_strip.startswith("Distribuição dos Pontos"): current_section = "distribuicao"; continue
-            if line_strip.startswith("PADRÃO DE RESPOSTA – QUESTÃO"): current_section = None; break
-            if line_strip.startswith("Padrão de Resposta"): continue
-
-            if current_section == "enunciado": enunciado += line + "\n"
-            elif current_section == "gabarito": gabarito += line + "\n"
-            elif current_section == "distribuicao": distribuicao += line + "\n"
-
-        enunciado = enunciado.strip()
-        gabarito = gabarito.strip()
-        distribuicao = distribuicao.strip()
-
-        if not enunciado or not gabarito or not distribuicao:
-             logger.warning(f"Parse OAB PDF falhou. E:{bool(enunciado)}, G:{bool(gabarito)}, D:{bool(distribuicao)}")
-             return None, None, None, f"⚠️ Falha separar seções. Verifique o texto completo:\n\n{full_text[:500]}..."
-
-        logger.info("PDF OAB parseado.")
-        return enunciado, gabarito, distribuicao, "✅ PDF OAB carregado e seções extraídas."
-    except Exception as e:
-        logger.error(f"Erro parsear PDF OAB: {str(e)}", exc_info=True)
-        return None, None, None, f"❌ Erro processar PDF OAB: {str(e)}"
+            ls=line.strip(); ll=ls.lower()
+            if ls.startswith("Enunciado"): current="e"; continue
+            if ls.startswith("Gabarito comentado"): current="g"; continue
+            if ls.startswith("Distribuição dos Pontos"): current="d"; continue
+            if ls.startswith("PADRÃO DE RESPOSTA – QUESTÃO"): current=None; break
+            if current=="e": e+=line+"\n"
+            elif current=="g": g+=line+"\n"
+            elif current=="d": d+=line+"\n"
+        e,g,d = e.strip(), g.strip(), d.strip()
+        if not all([e,g,d]): logger.warning(f"Parse fail. E:{bool(e)}, G:{bool(g)}, D:{bool(d)}"); return None, None, None, f"⚠️ Falha separar. Txt:\n{full_text[:300]}..."
+        logger.info("PDF OAB parsed."); return e, g, d, "✅ PDF OAB carregado."
+    except Exception as ex: logger.error(f"Parse OAB err: {ex}", exc_info=True); return None,None,None,f"❌ Erro PDF OAB: {ex}"
 
 def estruturar_prompt_geracao_modelo_oab(enunciado, gabarito, distribuicao):
-    prompt = f"""
-    **Tarefa:** Elabore a peça processual completa e adequada para o **Enunciado**, seguindo **estritamente** as diretrizes do **Gabarito Comentado** e os critérios da **Distribuição dos Pontos**. Crie uma peça modelo perfeita para este caso OAB.
-
-    **Enunciado:**
-    ```
-    {enunciado}
-    ```
-
-    **Gabarito Comentado (Diretrizes Conteúdo/Fundamentação):**
-    ```
-    {gabarito}
-    ```
-
-    **Distribuição dos Pontos (Estrutura/Itens Essenciais):**
-    ```
-    {distribuicao}
-    ```
-
-    **Instruções:**
-    1. Use **exclusivamente** informações/requisitos dos textos fornecidos. **Não adicione nada externo.**
-    2. Incorpore **todos** argumentos/fundamentos do Gabarito.
-    3. Estruture a peça para contemplar **todos** itens da Distribuição.
-    4. Linguagem formal OAB.
-    5. Use "XXX" apenas se Enunciado omisso e necessário.
-    6. Finalize com "Local, data.", "ADVOGADO(A)", "OAB/...". **Não se identifique.**
-    7. Gere **apenas** o texto completo da peça. Sem comentários ou títulos fora da peça.
+    prompt = f"""**Tarefa:** Elabore a peça processual completa, **detalhada e bem fundamentada** para o **Enunciado**. Utilize o **Gabarito Comentado** como guia para argumentos e a **Distribuição dos Pontos** para estrutura/pedidos. Crie uma peça modelo que **desenvolva** os pontos OAB, usando os fatos.
+
+    **Enunciado:**\n```\n{enunciado}\n```
+    **Gabarito Comentado (DESENVOLVER):**\n```\n{gabarito}\n```
+    **Distribuição dos Pontos (INCLUIR):**\n```\n{distribuicao}\n```
+
+    **Instruções Detalhadas:**
+    1. **Qualificação:** Completa (319 II, 'XXX' se ausente).
+    2. **Fatos:** Narre **detalhadamente** do Enunciado (datas, locais, indícios, necessidade).
+    3. **Fundamentação Jurídica:** **Desenvolva** argumentos do Gabarito (Lei, binômio), **conectando aos fatos**. Cite artigos.
+    4. **Tutela de Urgência:** Se aplicável, **argumente** requisitos (fumus/periculum) com fatos.
+    5. **Pedidos:** **Todos** da Distribuição/Gabarito, claros/específicos (citação, provas, MP, JG, alimentos, conversão, custas/honorários).
+    6. **Valor da Causa:** Atribua e justifique se possível.
+    7. **Estrutura:** Lógica (Ender., Qualif., Fatos, Direito, Tutela, Pedidos, Valor, Fecho).
+    8. **Linguagem:** Formal OAB.
+    9. **Finalização:** "Local, data.", "ADVOGADO(A)", "OAB/...". Não se identifique.
+    10. **Exclusividade:** Baseie-se **somente** nos textos fornecidos.
+    11. **Output:** **Apenas** texto completo da peça. Sem comentários extras.
     """
     return prompt
 
 def gerar_peticao_modelo_oab(enunciado, gabarito, distribuicao):
-    if not enunciado or not gabarito or not distribuicao:
-        return "⚠️ Enunciado, Gabarito e Distribuição necessários."
-
-    logger.info("Gerando peça modelo OAB...")
+    if not all([enunciado, gabarito, distribuicao]): return "⚠️ E, G, D necessários."
+    logger.info("Gerando modelo OAB...")
     prompt = estruturar_prompt_geracao_modelo_oab(enunciado, gabarito, distribuicao)
-    peticao_modelo = chamar_api(prompt, use_oab_config=True)
-
-    if peticao_modelo.startswith("❌") or peticao_modelo.startswith("⏱️"):
-        logger.error(f"Erro API gerar modelo OAB: {peticao_modelo}")
-        return f"❌ Falha gerar modelo OAB:\n{peticao_modelo}"
-
-    logger.info("Peça modelo OAB gerada.")
-    peticao_modelo = pos_corrigir_peticao(peticao_modelo, "Petição Desconhecida")
-    return peticao_modelo
+    modelo = chamar_api(prompt, use_oab_config=True)
+    if modelo.startswith(("❌","⏱️")): logger.error(f"Erro gerar modelo OAB: {modelo}"); return f"❌ Falha: {modelo}"
+    logger.info("Modelo OAB gerado."); return pos_corrigir_peticao(modelo, "Petição Desconhecida")
 
 def estruturar_prompt_correcao_pela_oab(peticao_usuario, enunciado, gabarito, distribuicao):
-     prompt = f"""
-    **Tarefa:** Avalie a **Peça do Usuário**, comparando-a **estritamente** com o padrão OAB (Gabarito Comentado, Distribuição dos Pontos) em relação ao **Enunciado**.
-
-    **Enunciado:**
-    ```
-    {enunciado}
-    ```
-
-    **Gabarito Comentado (Esperado):**
-    ```
-    {gabarito}
-    ```
-
-    **Distribuição dos Pontos (Critérios):**
-    ```
-    {distribuicao}
-    ```
+     prompt = f"""**Tarefa:** Avalie **Peça do Usuário** vs padrão OAB (Gabarito, Distribuição) p/ **Enunciado**.
 
-    **Peça do Usuário (Avaliar):**
-    ```
-    {peticao_usuario}
-    ```
+    **Enunciado:**\n```\n{enunciado}\n```
+    **Gabarito (Esperado):**\n```\n{gabarito}\n```
+    **Distribuição (Critérios):**\n```\n{distribuicao}\n```
+    **Peça Usuário (Avaliar):**\n```\n{peticao_usuario}\n```
 
     **Instruções:**
-    1. **Avaliação Pontual:** Para **cada item** na **Distribuição**, verifique se foi abordado pelo Usuário conforme o Gabarito. Atribua a pontuação correspondente.
-    2. **Justificativa:** Justifique brevemente a pontuação de cada item.
-    3. **Feedback:** Aponte erros/omissões do Usuário vs Gabarito/Distribuição.
-    4. **Peça Corrigida (Opcional):** Se possível, sugira trechos corrigidos para alinhar ao padrão.
+    1. **Avaliação Pontual:** Para **cada item** Distribuição, verifique se Usuário abordou conf. Gabarito. Atribua pontuação.
+    2. **Justificativa:** Breve p/ cada item.
+    3. **Feedback:** Erros/omissões vs padrão.
+    4. **Peça Corrigida (Opcional):** Sugira trechos corrigidos p/ alinhar ao padrão.
     5. **Output Markdown:**
-
     ```markdown
-    ### 📊 Avaliação Detalhada Conforme Padrão OAB
-
+    ### 📊 Avaliação Conforme Padrão OAB
     **Pontuação por Item:**
-
     *   **[Item 1 Distribuição]:** [Pontos Obtidos] / [Máximo]
         *   *Justificativa:* [...]
-    *   **[Item 2 Distribuição]:** [...] / [...]
-        *   *Justificativa:* [...]
-    *   ... (Todos os itens)
-
+    *   ... (Todos itens)
     **Pontuação Total Estimada:** [Soma Obtidos] / [Soma Máximos]
-
-    **Comentários e Pontos de Melhoria:**
-    *   [...]
-
+    **Comentários e Pontos de Melhoria:** * [...]
     ---
-    ### ✨ Sugestões de Correção (Se aplicável)
-
-    [Sugestões ou trechos corrigidos]
+    ### ✨ Sugestões Correção
+    [Sugestões]
     ```
-    **Importante:** Baseie **toda** avaliação **exclusivamente** nos materiais OAB fornecidos.
+    **Importante:** Baseie **toda** avaliação **exclusivamente** materiais OAB.
     """
      return prompt
 
 def corrigir_pela_oab(peticao_usuario, enunciado, gabarito, distribuicao):
-    if not peticao_usuario or not enunciado or not gabarito or not distribuicao:
-        return "⚠️ Petição Usuário, Enunciado, Gabarito e Distribuição necessários."
-
+    if not all([peticao_usuario, enunciado, gabarito, distribuicao]): return "⚠️ Inputs OAB necessários."
     logger.info("Corrigindo pela OAB...")
     prompt = estruturar_prompt_correcao_pela_oab(peticao_usuario, enunciado, gabarito, distribuicao)
-    correcao_oab = chamar_api(prompt, use_oab_config=True)
-
-    if correcao_oab.startswith("❌") or correcao_oab.startswith("⏱️"):
-        logger.error(f"Erro API corrigir OAB: {correcao_oab}")
-        return f"❌ Falha corrigir/avaliar OAB:\n{correcao_oab}"
-
-    logger.info("Correção/Avaliação OAB concluída.")
-    return correcao_oab
-
-# --- Funções Auxiliares (Diff, Histórico, Salvar/Carregar, Gerar Caso Fictício, Dicas) ---
-def calcular_diff_interno(texto_original, texto_corrigido):
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith("⚠️") or texto_corrigido.startswith("❌"): return "","",""
-    orig_lines = texto_original.splitlines(); corr_lines = texto_corrigido.splitlines()
-    diff = difflib.ndiff(orig_lines, corr_lines)
-    resultado_diff_html = []; criticas = []; l_rem = 0; l_add = 0
-    kw_rem = ["invenção", "identificação", "erro crasso"]
-    kw_add = ["custas", "art. 319", "art. 337", "lei 11.804"]
-    for linha in diff:
-        texto = linha[2:]; texto_escaped = escape(texto)
-        if linha.startswith('  '): resultado_diff_html.append(f"<div class='linha-igual'>{texto_escaped}</div>")
-        elif linha.startswith('- '):
-            l_rem += 1; resultado_diff_html.append(f"<div class='linha-removida'><del>{texto_escaped}</del></div>")
-            if any(kw in texto.lower() for kw in kw_rem): criticas.append(f"<span style='color:red;'>🔴 REMOVIDO:</span> {texto_escaped}")
-        elif linha.startswith('+ '):
-            l_add += 1; resultado_diff_html.append(f"<div class='linha-adicionada'><ins>{texto_escaped}</ins></div>")
-            if any(kw in texto.lower() for kw in kw_add): criticas.append(f"<span style='color:green;'>🟢 ADICIONADO:</span> {texto_escaped}")
-    resumo = f"**Resumo:**\n* Removidas: {l_rem}\n* Adicionadas: {l_add}\n* **Net:** {l_add - l_rem}"
-    crit_txt = "### 🚨 Mudanças Chave:\n" + "\n".join(criticas) if criticas else "Nenhuma mudança chave detectada."
-    css = """<style>.diff-container{font-family:monospace;white-space:pre-wrap;border:1px solid #ccc;padding:10px;background:#f9f9f9;}.linha-igual{color:#555;}.linha-removida{background:#ffebee;color:#c62828;text-decoration:line-through;}.linha-adicionada{background:#e8f5e9;color:#2e7d32;}.linha-removida del,.linha-adicionada ins{text-decoration:none;padding:1px 3px;border-radius:3px;}.linha-removida del{background:#ffcdd2;}.linha-adicionada ins{background:#c8e6c9;}</style>"""
-    html = f"{css}<div class='diff-container'>{''.join(resultado_diff_html)}</div>"
-    return html, resumo, crit_txt
+    correcao = chamar_api(prompt, use_oab_config=True)
+    if correcao.startswith(("❌","⏱️")): logger.error(f"Erro corrigir OAB: {correcao}"); return f"❌ Falha OAB: {correcao}"
+    logger.info("Correção OAB concluída."); return correcao
+
+def fornecer_dica_contextual(texto_peticao, tipo_peticao):
+    if not texto_peticao or not texto_peticao.strip(): return "Digite algo..."
+    dicas = []; txt_low = texto_peticao.lower()
+    for k, d in DICAS_OAB_MELHORADO.items():
+        if k in ["Clareza e Concisão","Fundamentação Legal","Coerência Argumentativa","Revisão Ortográfica e Gramatical","Formatação"]: dicas.append(f"💡 **{k}:** {d}")
+    kws = {"Petição Inicial":["endereçamento","qualificação","fatos","pedidos","valor da causa","custas"], "Contestação":["preliminar","mérito","impugnação","improcedência"], "Ação de Alimentos Gravídicos":["gravídicos","nascituro","indícios","binômio","conversão"]}
+    if tipo_peticao in kws:
+        for kw in kws[tipo_peticao]:
+            if kw in txt_low:
+                for k,d in DICAS_OAB_MELHORADO.items():
+                    kl,tl=k.lower(),tipo_peticao.split()[0].lower() if tipo_peticao else ""
+                    if f"({tl})" in kl or kw in kl: df=f"💡 **{k}:** {d}"; [dicas.append(df) if df not in dicas else None]
+    return "\n\n".join(dicas[:5]) if dicas else "💡 Sem dicas específicas."
+
+def calcular_diff_interno(t1, t2):
+    if not t1 or not t2 or t2.startswith(("⚠️","❌")): return "","",""
+    l1,l2=t1.splitlines(),t2.splitlines();diff=difflib.ndiff(l1,l2);html,crit,lr,la=[],[],0,0
+    kw_rem=["invenção","identificação","erro crasso"]; kw_add=["custas","art. 319","art. 337","lei 11.804"]
+    for ln in diff:
+        txt=ln[2:];esc=escape(txt)
+        if ln.startswith('  '):html.append(f"<div class='l-i'>{esc}</div>")
+        elif ln.startswith('- '):lr+=1;html.append(f"<div class='l-r'><del>{esc}</del></div>");[crit.append(f"<span style='color:red'>🔴 REM:</span> {esc}") for k in kw_rem if k in txt.lower()]
+        elif ln.startswith('+ '):la+=1;html.append(f"<div class='l-a'><ins>{esc}</ins></div>");[crit.append(f"<span style='color:green'>🟢 ADD:</span> {esc}") for k in kw_add if k in txt.lower()]
+    res=f"**Diff:** Rem:{lr}, Add:{la}, Net:{la-lr}"; crit_t="### 🚨 Mudanças Chave:\n"+"\n".join(crit) if crit else "Nenhuma mudança chave."
+    css="<style>.l-i{color:#555}.l-r{background:#ffebee;color:#c62828;text-decoration:line-through}.l-a{background:#e8f5e9;color:#2e7d32}.l-r del,.l-a ins{text-decoration:none;padding:1px 3px;border-radius:3px}.l-r del{background:#ffcdd2}.l-a ins{background:#c8e6c9}</style>"
+    diff_html=f"{css}<div style='font-family:monospace;white-space:pre-wrap;border:1px solid #ccc;padding:10px;background:#f9f9f9;'>{''.join(html)}</div>"
+    return diff_html,res,crit_t
 
 def calcular_progresso():
     if not HISTORICO: return "📊 Progresso vazio."
-    notas_geral = []
-    tipos_geral = set()
-    count_geral = 0
-    for entry in HISTORICO:
-         if entry.get("modo", "Geral IA") == "Geral IA":
-             count_geral += 1
-             tipos_geral.add(entry["tipo_peticao"])
-             match = re.search(r"\*\*(\d{1,2}[,.]?\d?)/10\*\*", entry.get("analise_formatada",""))
-             if match:
-                 try: notas_geral.append(float(match.group(1).replace(",",".")))
-                 except: pass
-    media_geral = sum(notas_geral) / len(notas_geral) if notas_geral else 0
-    prog_txt = f"**📊 Progresso (Geral IA):**\n* Correções: {count_geral}\n* Tipos: {', '.join(sorted(list(tipos_geral)))}\n* Média Notas: {media_geral:.1f}/10"
-    return prog_txt
+    notas,tipos,count=[],set(),0
+    for e in HISTORICO:
+        if e.get("modo","Geral IA")=="Geral IA": count+=1;tipos.add(e["tipo_peticao"]); m=re.search(r"\*\*(\d{1,2}[,.]?\d?)/10\*\*",e.get("analise_formatada",""));
+        if m: try: notas.append(float(m.group(1).replace(",","."))) except: pass
+    media=sum(notas)/len(notas) if notas else 0
+    return f"**📊 Progresso (IA):** Corrs:{count}, Tipos:{', '.join(sorted(list(tipos)))}, Média:{media:.1f}/10"
 
 def mostrar_historico():
     if not HISTORICO: return "📜 Histórico vazio."
-    hist_md = "### 📜 Histórico (Últimas 10)\n\n---\n"
-    for i, entry in enumerate(reversed(HISTORICO)):
-        modo = entry.get("modo", "Geral IA")
-        nota_str = "N/A"
-        match = re.search(r"\*\*(\d{1,2}[,.]?\d?)/10\*\*", entry.get("analise_formatada",""))
-        if match: nota_str = f"{match.group(1).replace(',', '.')}/10"
-        hist_md += f"**{len(HISTORICO)-i}.** {entry['data']} ({modo})\n"
-        hist_md += f"**Tipo:** {entry['tipo_peticao']} **Nota (IA):** {nota_str}\n"
-        hist_md += f"**Caso:** _{entry['caso'][:60]}..._\n---\n"
-    return hist_md
+    md="### 📜 Histórico (Últimas 10)\n\n---\n"
+    for i, e in enumerate(reversed(HISTORICO)):
+        modo=e.get("modo","Geral IA"); nota="N/A"; m=re.search(r"\*\*(\d{1,2}[,.]?\d?)/10\*\*",e.get("analise_formatada",""))
+        if m: nota=f"{m.group(1).replace(',','.')}/10"
+        md+=f"**{len(HISTORICO)-i}.** {e['data']} ({modo}) | **Tipo:** {e['tipo_peticao']} | **Nota IA:** {nota}\n**Caso:** _{e['caso'][:60]}..._\n---\n"
+    return md
 
 def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info("Salvando progresso...")
+    logger.info("Salvando...")
+    try:
+        if not all([caso, peticao, tipo_peticao]): return "", "⚠️ Inputs?", None
+        d={"tipo_peticao":tipo_peticao, "caso":caso, "peticao":peticao, "ts":datetime.now().isoformat()}; js=json.dumps(d, ensure_ascii=False, indent=2); ts=datetime.now().strftime("%Y%m%d%H%M"); fname=f"prog_{ts}.json"
+        fpath=os.path.join(tempfile.gettempdir(),fname);
+        with open(fpath,'w',encoding='utf-8') as f: f.write(js)
+        logger.info(f"Salvo: {fpath}"); return js, f"✅ Salvo `{fname}`", fpath
+    except Exception as e: logger.error(f"Salvar err: {e}"); return "", f"❌ Erro: {e}", None
+
+def carregar_progresso(fobj):
+    logger.info("Carregando...")
+    if fobj is None: return "", "", "", "⚠️ Nenhum arq."
+    try:
+        with open(fobj.name,'r',encoding='utf-8') as f: d=json.load(f)
+        c,p,t=d.get("caso"), d.get("peticao"), d.get("tipo_peticao")
+        if not all([c,p,t]): return "", "", "", "❌ Arq inválido."
+        if t not in TIPOS_DE_PETICAO: return c,p,"",f"⚠️ Tipo '{t}' inválido."
+        logger.info("Carregado."); return t, c, p, "✅ Carregado!"
+    except Exception as e: logger.error(f"Carregar err: {e}"); return "", "", "", f"❌ Erro: {e}"
+
+def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
+    if not tipo_peticao: return "Erro: Tipo?"
+    logger.info(f"Gerando caso: {tipo_peticao}")
+    prompt=estruturar_prompt_geracao_caso(tipo_peticao); caso=chamar_api(prompt,False)
+    if caso.startswith(("❌","⏱️")): return f"Falha:\n{caso}"
+    final="**Situação-Problema:** Na qualidade de advogado(a) de";
+    if final.lower() not in caso.lower(): nomes=re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+",caso); cli=nomes[0] if nomes else "[Cliente]"; caso+=f"\n\n{final} {cli}, elabore a peça cabível ({tipo_peticao})."
+    logger.info("Caso gerado."); return caso
+
+def export_to_txt(content, filename_prefix):
+    if not content: return None, "⚠️ Conteúdo vazio para exportar."
     try:
-        if not caso or not peticao or not tipo_peticao: return "", "⚠️ Inputs necessários.", None
-        dados = { "tipo_peticao": tipo_peticao, "caso": caso, "peticao": peticao, "ts": datetime.now().isoformat()}
-        js = json.dumps(dados, ensure_ascii=False, indent=4)
         ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-        fname = f"progresso_{ts}.json"
-        fpath = os.path.join(tempfile.gettempdir(), fname)
-        with open(fpath, 'w', encoding='utf-8') as f: f.write(js)
-        logger.info(f"Progresso salvo: {fpath}")
-        msg = f"✅ Salvo! Baixe `{fname}`."
-        return js, msg, fpath
+        filename = f"{filename_prefix}_{ts}.txt"
+        temp_dir = tempfile.gettempdir()
+        file_path = os.path.join(temp_dir, filename)
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        logger.info(f"Exportado para TXT: {file_path}")
+        return file_path, f"✅ Exportado para {filename}"
     except Exception as e:
-        logger.error(f"Erro salvar: {str(e)}", exc_info=True)
-        return "", f"❌ Erro salvar: {str(e)}", None
+        logger.error(f"Erro exportar TXT: {e}")
+        return None, f"❌ Erro TXT: {e}"
 
-def carregar_progresso(arquivo_entrada):
-    logger.info("Carregando progresso...")
-    if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo."
+def export_to_pdf(content, filename_prefix):
+    if not content: return None, "⚠️ Conteúdo vazio para exportar."
     try:
-        fpath = arquivo_entrada.name
-        with open(fpath, 'r', encoding='utf-8') as f: dados = json.load(f)
-        caso = dados.get("caso")
-        pet = dados.get("peticao")
-        tipo = dados.get("tipo_peticao")
-        if not all([caso, pet, tipo]): return "", "", "", "❌ Arquivo inválido."
-        if tipo not in TIPOS_DE_PETICAO: return caso, pet, "", f"⚠️ Tipo '{tipo}' inválido."
-        logger.info("Progresso carregado.")
-        return tipo, caso, pet, "✅ Progresso carregado!"
-    except Exception as e:
-        logger.error(f"Erro carregar: {str(e)}", exc_info=True)
-        return "", "", "", f"❌ Erro carregar: {str(e)}"
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{filename_prefix}_{ts}.pdf"
+        temp_dir = tempfile.gettempdir()
+        file_path = os.path.join(temp_dir, filename)
 
-def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    if not tipo_peticao: return "Erro: Tipo não selecionado."
-    logger.info(f"Gerando caso para: {tipo_peticao}")
-    prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-    caso = chamar_api(prompt, use_oab_config=False)
-    if caso.startswith("❌") or caso.startswith("⏱️"): return f"Falha gerar caso:\n{caso}"
-    frase_final = f"**Situação-Problema:** Na qualidade de advogado(a) de"
-    if frase_final.lower() not in caso.lower():
-        nomes = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso)
-        cliente = nomes[0] if nomes else "[Cliente]"
-        caso += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente}, elabore a peça cabível ({tipo_peticao})."
-    logger.info("Caso gerado.")
-    return caso
+        pdf = FPDF()
+        pdf.add_page()
+        # Use a font that supports UTF-8 characters, handle potential missing font file
+        try:
+            # Try adding DejaVu, assuming the .ttf file is accessible
+            # Download from: https://dejavu-fonts.github.io/
+            # Place DejaVuSans.ttf in the same directory or provide the full path
+            pdf.add_font('DejaVu', '', 'DejaVuSans.ttf', uni=True)
+            pdf.set_font('DejaVu', size=11)
+        except RuntimeError:
+            logger.warning("Fonte DejaVuSans.ttf não encontrada. Usando Arial (pode ter problemas com caracteres especiais).")
+            pdf.set_font('Arial', size=11)
+
+        # Use multi_cell for automatic line breaks and UTF-8 handling
+        # Encode to latin-1 with error replacement if using standard fonts without proper UTF-8 support
+        # If using DejaVu, encoding might not be strictly necessary but good practice
+        try:
+            # Use write for better Markdown basic handling (bold/italic if font supports)
+             pdf.write(h=5, txt=content) # h is line height
+        except UnicodeEncodeError:
+             # Fallback if write fails with current font
+             pdf.multi_cell(0, 5, txt=content.encode('latin-1', 'replace').decode('latin-1'))
 
-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..."
-    dicas_relevantes = []
-    texto_lower = texto_peticao.lower()
-    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}")
-    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"],
-        "Reconvenção": ["reconvinte", "reconvindo", "conexão", "pedidos reconvencionais"],
-        "Impugnação à Contestação": ["réplica", "preliminar", "fatos novos", "documentos", "ratifica"],
-        "Embargos de Declaração": ["omissão", "contradição", "obscuridade", "erro material", "decisão embargada"],
-        "Recurso de Apelação": ["sentença", "reforma", "anulação", "dialeticidade", "preparo", "tribunal", "razões"],
-        "Agravo de Instrumento": ["decisão interlocutória", "tribunal", "cabimento", "urgência", "efeito suspensivo", "peças obrigatórias"],
-        "Petição de Tutela Provisória": ["urgência", "evidência", "liminar", "periculum", "fumus boni", "probabilidade", "risco"],
-        "Ação de Alimentos Gravídicos": ["gravídicos", "nascituro", "indícios de paternidade", "binômio", "conversão", "lei 11.804"],
-    }
-    if tipo_peticao in keywords_por_tipo:
-         for keyword in keywords_por_tipo[tipo_peticao]:
-              if keyword in texto_lower:
-                   for chave, dica in DICAS_OAB_MELHORADO.items():
-                        chave_lower = chave.lower()
-                        tipo_simples = tipo_peticao.split()[0].lower() if tipo_peticao else ""
-                        if f"({tipo_simples})" in chave_lower or keyword in chave_lower:
-                            dica_formatada = f"💡 **{chave}:** {dica}"
-                            if dica_formatada not in dicas_relevantes:
-                                 dicas_relevantes.append(dica_formatada)
-    if not dicas_relevantes:
-        return "💡 Continue escrevendo ou selecione o tipo de peça para dicas mais específicas."
-    return "\n\n".join(dicas_relevantes[:5])
+
+        pdf.output(file_path)
+        logger.info(f"Exportado para PDF: {file_path}")
+        return file_path, f"✅ Exportado para {filename}"
+    except Exception as e:
+        logger.error(f"Erro exportar PDF: {e}", exc_info=True)
+        return None, f"❌ Erro PDF: {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).
-    **Instruções Gerais para o Caso:**
-    1.  **Complexidade Adequada:** (Ideal: 15-25 linhas).
-    2.  **Dados Essenciais:** Nomes, locais, datas, valores, relação jurídica, conflito.
-    3.  **Coerência:** Fatos lógicos para a peça indicada.
-    4.  **Foco no Tipo de Peça:** Cenário exige **{tipo_peticao}**.
-    **Instruções Específicas para Gerar Caso para "{tipo_peticao}":**
-    """
-    if tipo_peticao == "Petição Inicial" or tipo_peticao == "Ação de Alimentos Gravídicos":
-        prompt += "* Descreva violação de direitos, busca inicial da tutela. Elementos para danos. Dados para qualificação. Temas: consumo, contrato, cobrança, despejo, família (alimentos gravídicos - incluir indícios paternidade, necessidade mãe/nascituro)."
-    elif tipo_peticao == "Contestação":
-        prompt += "* Resumo da Inicial recebida. Versão dos fatos do RÉU. Elementos para Preliminares (Art. 337), Impugnação Específica, Defesa de Mérito (direta/indireta). Dados qualificação réu."
-    # ... (Add other types as before) ...
-    else: prompt += "* Crie um cenário jurídico cível com conflito claro."
-
-    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 temas excessivamente específicos. Foco em Civil/Processo Civil comum.
-    """
+    prompt = f"Crie caso fictício detalhado/realista p/ peça **{tipo_peticao}** (simulando OAB).\n**Instruções:**\n1.Complexidade adequada (15-25l).\n2.Dados essenciais(nomes,locais,datas,valores,conflito).\n3.Coerência.\n4.Foco em **{tipo_peticao}**.\n**Específico p/ {tipo_peticao}:**\n"
+    if tipo_peticao in ["Petição Inicial","Ação de Alimentos Gravídicos"]: prompt+="* Descreva violação direitos,1ª busca tutela. Elem. p/ danos. Qualif. partes. Temas:consumo,contrato,cobrança,despejo,família(alim.grav:indícios patern.,necess. mãe/nascituro)."
+    elif tipo_peticao=="Contestação": prompt+="* Resumo Inicial recebida. Versão RÉU. Elem. p/ Prelim(337),Impug.Esp,Def.Mérito. Qualif.réu."
+    else: prompt+="* Cenário cível c/ conflito claro."
+    prompt+=f'\n**Finalize:** "**Situação-Problema:** Na qualidade de advogado(a) de [Cliente], elabore a peça cabível ({tipo_peticao})."\n**Importante:** Temas comuns Civil/Proc.Civil.'
     return prompt
 
-
-# --- Interface Gradio ---
 def interface_gradio():
     with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange")) as demo:
         gr.Markdown("# ⚖️ Corretor Jurídico OAB Master ⚖️")
-        gr.Markdown("Use a **Correção Geral (IA)** para feedback amplo ou a **Correção Baseada no Padrão OAB** para avaliação específica.")
-
+        gr.Markdown("Use **Correção Geral (IA)** ou **Correção Padrão OAB**.")
         with gr.Tabs() as main_tabs:
             with gr.TabItem("🤖 Correção Geral (IA)", id=0):
                 with gr.Row():
                     with gr.Column(scale=1):
-                        gr.Markdown("### 1. Configurações (Geral)")
-                        tipo_peticao_input_geral = gr.Dropdown(label="Tipo de Peça", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
-                        modo_treinamento_geral = gr.Checkbox(label="🎓 Modo Treinamento", value=False)
-                        with gr.Accordion("⚙️ Configs IA", open=False):
-                            temperatura_slider = gr.Slider(0.0, 1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
-                            timeout_slider = gr.Slider(30, 300, value=CONFIG["timeout"], step=10, label="Timeout (s)")
-                            max_tokens_slider = gr.Slider(2048, 8192, value=CONFIG["max_tokens"], step=256, label="Max Tokens")
-                            def atualizar_config(temp, timeout, tokens): CONFIG["temperatura"], CONFIG["timeout"], CONFIG["max_tokens"] = temp, timeout, tokens; return "✅"
-                            config_update_btn = gr.Button("💾 Salvar")
-                            config_status_geral = gr.Textbox(label="Status", interactive=False)
-                            config_update_btn.click(atualizar_config, [temperatura_slider, timeout_slider, max_tokens_slider], config_status_geral)
-                        with gr.Accordion("📊 Progresso/Histórico", open=False):
-                             progresso_output = gr.Markdown("...")
-                             progresso_btn = gr.Button("🔄 Progresso")
-                             historico_output = gr.Markdown("...")
-                             historico_btn = gr.Button("🔄 Histórico")
-                             progresso_btn.click(calcular_progresso, outputs=progresso_output)
-                             historico_btn.click(mostrar_historico, outputs=historico_output)
-                        with gr.Accordion("💾/📂 Salvar/Carregar", open=False):
-                             salvar_btn_geral = gr.Button("💾 Salvar Inputs")
-                             carregar_btn_geral = gr.Button("📂 Carregar Inputs")
-                             arquivo_progresso_upload_geral = gr.File(label=".json", file_types=[".json"])
-                             progresso_download_file_geral = gr.File(label="Baixar", interactive=False)
-
+                        gr.Markdown("### 1. Configs (Geral)")
+                        tipo_peticao_input_geral=gr.Dropdown("Tipo Peça", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
+                        modo_treinamento_geral=gr.Checkbox("🎓 Treinamento", value=False)
+                        with gr.Accordion("⚙️ IA", open=False):
+                            temp_s=gr.Slider(0.0, 1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
+                            tout_s=gr.Slider(30, 300, value=CONFIG["timeout"], step=10, label="Timeout(s)")
+                            maxt_s=gr.Slider(2048, 8192, value=CONFIG["max_tokens"], step=256, label="MaxTokens")
+                            def upd_cfg(t,o,m): CONFIG["temperatura"],CONFIG["timeout"],CONFIG["max_tokens"]=t,o,m; return "✅"
+                            cfg_btn=gr.Button("💾 Salvar"); cfg_stat=gr.Textbox("Status", interactive=False)
+                            cfg_btn.click(upd_cfg, [temp_s, tout_s, maxt_s], cfg_stat)
+                        with gr.Accordion("📊 Prog/Hist", open=False): prog_out=gr.Markdown("..."); prog_btn=gr.Button("🔄 Prog"); hist_out=gr.Markdown("..."); hist_btn=gr.Button("🔄 Hist"); prog_btn.click(calcular_progresso,outputs=prog_out); hist_btn.click(mostrar_historico,outputs=hist_out)
+                        with gr.Accordion("💾/📂 I/O", open=False): sv_btn=gr.Button("💾 Salvar"); ld_btn=gr.Button("📂 Carregar"); upld=gr.File(".json",ft=[".json"]); dwnld=gr.File("Baixar", interactive=False, visible=False)
                     with gr.Column(scale=3):
-                        gr.Markdown("### 2. Insira Caso e Sua Peça")
-                        with gr.Row():
-                             caso_input_geral = gr.Textbox(label="📋 Caso", lines=8)
-                             caso_btn_geral = gr.Button("🎲 Gerar", variant="secondary", scale=0)
+                        gr.Markdown("### 2. Caso e Peça")
+                        with gr.Row(): caso_in=gr.Textbox("📋 Caso", lines=8); caso_btn=gr.Button("🎲",variant="secondary",scale=0)
                         with gr.Tabs():
-                             with gr.TabItem("✏️ Texto"):
-                                 peticao_texto_input_geral = gr.Textbox(label="Sua Peça", lines=12)
-                                 dica_contextual_output_geral = gr.Markdown("*Dicas...*")
-                                 btn_corrigir_geral = gr.Button("🚀 Corrigir (IA)", variant="primary")
-                             with gr.TabItem("📎 Arquivo"):
-                                 peticao_arquivo_input_geral = gr.File(label="Arquivo", file_types=[".pdf",".docx",".txt"])
-                                 arquivo_preview_output_geral = gr.Textbox(label="🔍 Prévia", lines=3, interactive=False)
-                                 btn_corrigir_arquivo_geral = gr.Button("🚀 Corrigir Arquivo (IA)", variant="primary")
-
-                processing_message_geral = gr.Markdown("", visible=False)
+                             with gr.TabItem("✏️ Texto"): pet_txt_in=gr.Textbox("Sua Peça", lines=12); dicas_out=gr.Markdown("*Dicas...*"); btn_corr=gr.Button("🚀 Corrigir (IA)", variant="primary")
+                             with gr.TabItem("📎 Arquivo"): pet_f_in=gr.File("Arquivo", ft=[".pdf",".docx",".txt"]); prev_out=gr.Textbox("🔍 Prévia", lines=3, interactive=False); btn_f_corr=gr.Button("🚀 Corrigir Arq (IA)", variant="primary")
+                msg_geral=gr.Markdown("", visible=False)
                 with gr.Tabs():
-                     with gr.TabItem("📊 Análise IA"): resultado_analise_output_geral = gr.Markdown()
-                     with gr.TabItem("✨ Correção IA"): resultado_peticao_corrigida_output_geral = gr.Textbox(lines=15, show_copy_button=True)
-                     with gr.TabItem("⚖️ Diff"):
-                          with gr.Row():
-                               with gr.Column(scale=1): resumo_alteracoes_output_geral = gr.Markdown()
-                               with gr.Column(scale=3): visualizacao_detalhada_output_geral = gr.HTML()
-                          criticas_output_geral = gr.Markdown()
-
+                     with gr.TabItem("📊 Análise IA"): an_out=gr.Markdown(); with gr.Row(): exp_an_txt_btn=gr.Button("Export TXT"); exp_an_pdf_btn=gr.Button("Export PDF"); an_file_out=gr.File(label="Download Análise", interactive=False, visible=False)
+                     with gr.TabItem("✨ Correção IA"): corr_out=gr.Textbox(lines=15, show_copy_button=True); with gr.Row(): exp_corr_txt_btn=gr.Button("Export TXT"); exp_corr_pdf_btn=gr.Button("Export PDF"); corr_file_out=gr.File(label="Download Correção", interactive=False, visible=False)
+                     with gr.TabItem("⚖️ Diff"): with gr.Row(): with gr.Column(scale=1): res_out=gr.Markdown(); with gr.Column(scale=3): diff_out=gr.HTML(); crit_out=gr.Markdown()
             with gr.TabItem("📄 Correção Padrão OAB", id=1):
-                gr.Markdown("Forneça o material oficial (PDF ou texto) e sua peça.")
+                gr.Markdown("Forneça material oficial (PDF/texto) e sua peça.")
                 with gr.Row():
                     with gr.Column(scale=2):
-                        gr.Markdown("### 1. Material Oficial OAB")
-                        with gr.Tabs():
-                            with gr.TabItem("📎 PDF Oficial"):
-                                oab_pdf_input = gr.File(label="Padrão Resposta OAB (.pdf)", file_types=[".pdf"])
-                                parse_status_output = gr.Textbox(label="Status PDF", interactive=False)
-                            with gr.TabItem("✏️ Manual"):
-                                oab_enunciado_input = gr.Textbox(label="Enunciado", lines=5)
-                                oab_gabarito_input = gr.Textbox(label="Gabarito", lines=8)
-                                oab_distribuicao_input = gr.Textbox(label="Distribuição", lines=8)
+                        gr.Markdown("### 1. Material OAB");
+                        with gr.Tabs(): with gr.TabItem("📎 PDF"): oab_pdf=gr.File("Padrão OAB (.pdf)", ft=[".pdf"]); parse_st=gr.Textbox("Status PDF", interactive=False); with gr.TabItem("✏️ Manual"): oab_e=gr.Textbox("Enunciado", lines=5); oab_g=gr.Textbox("Gabarito", lines=8); oab_d=gr.Textbox("Distribuição", lines=8)
                     with gr.Column(scale=2):
-                        gr.Markdown("### 2. Ações")
-                        btn_gerar_modelo_oab = gr.Button("📝 Gerar Peça Modelo OAB")
-                        gr.Markdown("---")
-                        peticao_usuario_oab_input = gr.Textbox(label="Sua Peça (para corrigir pela OAB)", lines=10)
-                        btn_corrigir_pela_oab = gr.Button("🎯 Corrigir pela OAB", variant="primary")
-
-                processing_message_oab = gr.Markdown("", visible=False)
+                        gr.Markdown("### 2. Ações"); btn_mod=gr.Button("📝 Gerar Modelo OAB"); gr.Markdown("---"); pet_usr=gr.Textbox("Sua Peça p/ OAB", lines=10); btn_corr_oab=gr.Button("🎯 Corrigir pela OAB", variant="primary")
+                msg_oab=gr.Markdown("", visible=False)
                 with gr.Tabs():
-                    with gr.TabItem("📝 Modelo OAB"): resultado_modelo_oab_output = gr.Textbox(lines=20, show_copy_button=True)
-                    with gr.TabItem("🎯 Avaliação OAB"): resultado_correcao_oab_output = gr.Markdown()
-
-        clear_btn = gr.Button("🗑️ Limpar Tudo")
-
-        caso_btn_geral.click(gerar_caso_ficticio, [tipo_peticao_input_geral], [caso_input_geral])
-        peticao_texto_input_geral.change(fornecer_dica_contextual, [peticao_texto_input_geral, tipo_peticao_input_geral], dica_contextual_output_geral)
-        tipo_peticao_input_geral.change(fornecer_dica_contextual, [peticao_texto_input_geral, tipo_peticao_input_geral], dica_contextual_output_geral)
-        peticao_arquivo_input_geral.change(process_file, [peticao_arquivo_input_geral], arquivo_preview_output_geral)
-
-        btn_corrigir_geral.click( lambda: gr.update(value="⏳ Processando IA...", visible=True), None, processing_message_geral).then(
-            corrigir_peticao_geral_ia,
-            [caso_input_geral, tipo_peticao_input_geral, peticao_texto_input_geral, gr.State(None), modo_treinamento_geral],
-            [resultado_analise_output_geral, gr.Textbox(visible=False), resultado_peticao_corrigida_output_geral,
-             resumo_alteracoes_output_geral, criticas_output_geral, gr.Markdown(visible=False), visualizacao_detalhada_output_geral]
-        ).then( lambda: gr.update(visible=False), None, processing_message_geral )
-
-        btn_corrigir_arquivo_geral.click( lambda: gr.update(value="⏳ Processando IA...", visible=True), None, processing_message_geral).then(
-            corrigir_peticao_geral_ia,
-            [caso_input_geral, tipo_peticao_input_geral, gr.State(None), peticao_arquivo_input_geral, modo_treinamento_geral],
-            [resultado_analise_output_geral, gr.Textbox(visible=False), resultado_peticao_corrigida_output_geral,
-             resumo_alteracoes_output_geral, criticas_output_geral, gr.Markdown(visible=False), visualizacao_detalhada_output_geral]
-        ).then( lambda: gr.update(visible=False), None, processing_message_geral )
-
-        salvar_btn_geral.click( lambda: gr.update(value="⏳ Salvando...", visible=True), None, processing_message_geral).then(
-             salvar_progresso, [caso_input_geral, peticao_texto_input_geral, tipo_peticao_input_geral],
-             [gr.Textbox(visible=False), config_status_geral, progresso_download_file_geral]
-        ).then( lambda x: gr.update(visible=bool(x)), [progresso_download_file_geral], [progresso_download_file_geral]
-        ).then( lambda: gr.update(visible=False), None, processing_message_geral )
-        carregar_btn_geral.click( lambda: gr.update(value="⏳ Carregando...", visible=True), None, processing_message_geral).then(
-             carregar_progresso, [arquivo_progresso_upload_geral],
-             [tipo_peticao_input_geral, caso_input_geral, peticao_texto_input_geral, config_status_geral]
-         ).then( lambda: gr.update(visible=False), None, processing_message_geral )
-
-        oab_pdf_input.change(parse_oab_pdf, [oab_pdf_input], [oab_enunciado_input, oab_gabarito_input, oab_distribuicao_input, parse_status_output])
-        btn_gerar_modelo_oab.click( lambda: gr.update(value="⏳ Gerando Modelo...", visible=True), None, processing_message_oab).then(
-            gerar_peticao_modelo_oab, [oab_enunciado_input, oab_gabarito_input, oab_distribuicao_input], [resultado_modelo_oab_output]
-        ).then( lambda: gr.update(visible=False), None, processing_message_oab )
-        btn_corrigir_pela_oab.click( lambda: gr.update(value="⏳ Corrigindo OAB...", visible=True), None, processing_message_oab).then(
-             corrigir_pela_oab, [peticao_usuario_oab_input, oab_enunciado_input, oab_gabarito_input, oab_distribuicao_input], [resultado_correcao_oab_output]
-         ).then( lambda: gr.update(visible=False), None, processing_message_oab )
-
-        clear_btn.click( fn=lambda: [
-                "Petição Inicial", False, None, None, None, None, "", "", "", "", "", "", "", None, None,
-                None, "", None, None, None, "", "", "", ""
-            ], inputs=None, outputs=[
-                tipo_peticao_input_geral, modo_treinamento_geral, caso_input_geral, peticao_texto_input_geral, peticao_arquivo_input_geral,
-                arquivo_preview_output_geral, processing_message_geral, resultado_analise_output_geral,
-                resultado_peticao_corrigida_output_geral, resumo_alteracoes_output_geral, criticas_output_geral,
-                visualizacao_detalhada_output_geral, dica_contextual_output_geral, arquivo_progresso_upload_geral,
-                progresso_download_file_geral,
-                oab_pdf_input, parse_status_output, oab_enunciado_input, oab_gabarito_input, oab_distribuicao_input,
-                peticao_usuario_oab_input, processing_message_oab, resultado_modelo_oab_output, resultado_correcao_oab_output
-            ])
-
+                    with gr.TabItem("📝 Modelo OAB"): mod_out=gr.Textbox(lines=20, show_copy_button=True); with gr.Row(): exp_mod_txt_btn=gr.Button("Export TXT"); exp_mod_pdf_btn=gr.Button("Export PDF"); mod_file_out=gr.File("Download Modelo", interactive=False, visible=False)
+                    with gr.TabItem("🎯 Avaliação OAB"): corr_oab_out=gr.Markdown(); with gr.Row(): exp_avaoab_txt_btn=gr.Button("Export TXT"); exp_avaoab_pdf_btn=gr.Button("Export PDF"); avaoab_file_out=gr.File("Download Avaliação", interactive=False, visible=False)
+        clr_btn = gr.Button("🗑️ Limpar Tudo")
+
+        caso_btn.click(gerar_caso_ficticio, [tipo_peticao_input_geral], [caso_in])
+        pet_txt_in.change(fornecer_dica_contextual, [pet_txt_in, tipo_peticao_input_geral], dicas_out)
+        tipo_peticao_input_geral.change(fornecer_dica_contextual, [pet_txt_in, tipo_peticao_input_geral], dicas_out)
+        pet_f_in.change(process_file, [pet_f_in], prev_out)
+
+        corr_inputs=[caso_in, tipo_peticao_input_geral, pet_txt_in, gr.State(None), modo_treinamento_geral]
+        corr_outputs=[an_out, gr.Textbox(visible=False), corr_out, res_out, crit_out, gr.Markdown(visible=False), diff_out]
+        btn_corr.click(lambda: gr.update(value="⏳ IA...", visible=True), None, msg_geral).then(corrigir_peticao_geral_ia, corr_inputs, corr_outputs).then(lambda: gr.update(visible=False), None, msg_geral)
+        corr_f_inputs=[caso_in, tipo_peticao_input_geral, gr.State(None), pet_f_in, modo_treinamento_geral]
+        btn_f_corr.click(lambda: gr.update(value="⏳ IA...", visible=True), None, msg_geral).then(corrigir_peticao_geral_ia, corr_f_inputs, corr_outputs).then(lambda: gr.update(visible=False), None, msg_geral)
+
+        sv_btn.click(lambda: gr.update(value="⏳...", visible=True), None, msg_geral).then(salvar_progresso, [caso_in, pet_txt_in, tipo_peticao_input_geral], [gr.Textbox(visible=False), cfg_stat, dwnld]).then(lambda x: gr.update(value=x, visible=bool(x)), [dwnld], [dwnld]).then(lambda: gr.update(visible=False), None, msg_geral)
+        ld_btn.click(lambda: gr.update(value="⏳...", visible=True), None, msg_geral).then(carregar_progresso, [upld], [tipo_peticao_input_geral, caso_in, pet_txt_in, cfg_stat]).then(lambda: gr.update(visible=False), None, msg_geral)
+
+        oab_pdf.change(parse_oab_pdf, [oab_pdf], [oab_e, oab_g, oab_d, parse_st])
+        btn_mod.click(lambda: gr.update(value="⏳...", visible=True), None, msg_oab).then(gerar_peticao_modelo_oab, [oab_e, oab_g, oab_d], [mod_out]).then(lambda: gr.update(visible=False), None, msg_oab)
+        btn_corr_oab.click(lambda: gr.update(value="⏳...", visible=True), None, msg_oab).then(corrigir_pela_oab, [pet_usr, oab_e, oab_g, oab_d], [corr_oab_out]).then(lambda: gr.update(visible=False), None, msg_oab)
+
+        def export_wrapper(func, content, prefix): status_msg = ""; file_path = None; if content: file_path, status_msg = func(content, prefix); else: status_msg = "⚠️ Nada para exportar."; return file_path, status_msg
+        exp_an_txt_btn.click(export_wrapper, [gr.State(export_to_txt), an_out, gr.State("analise_ia")], [an_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [an_file_out], [an_file_out])
+        exp_an_pdf_btn.click(export_wrapper, [gr.State(export_to_pdf), an_out, gr.State("analise_ia")], [an_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [an_file_out], [an_file_out])
+        exp_corr_txt_btn.click(export_wrapper, [gr.State(export_to_txt), corr_out, gr.State("correcao_ia")], [corr_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [corr_file_out], [corr_file_out])
+        exp_corr_pdf_btn.click(export_wrapper, [gr.State(export_to_pdf), corr_out, gr.State("correcao_ia")], [corr_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [corr_file_out], [corr_file_out])
+        exp_mod_txt_btn.click(export_wrapper, [gr.State(export_to_txt), mod_out, gr.State("modelo_oab")], [mod_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [mod_file_out], [mod_file_out])
+        exp_mod_pdf_btn.click(export_wrapper, [gr.State(export_to_pdf), mod_out, gr.State("modelo_oab")], [mod_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [mod_file_out], [mod_file_out])
+        exp_avaoab_txt_btn.click(export_wrapper, [gr.State(export_to_txt), corr_oab_out, gr.State("avaliacao_oab")], [avaoab_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [avaoab_file_out], [avaoab_file_out])
+        exp_avaoab_pdf_btn.click(export_wrapper, [gr.State(export_to_pdf), corr_oab_out, gr.State("avaliacao_oab")], [avaoab_file_out, cfg_stat]).then(lambda x: gr.update(visible=bool(x)), [avaoab_file_out], [avaoab_file_out])
+
+        clr_btn.click(lambda: ["Petição Inicial",False,None,None,None,None,"","","","","","",None,None,None,None,"",None,None,None,"","","","",None,None,None,None], None, [
+            tipo_peticao_input_geral,modo_treinamento_geral,caso_in,pet_txt_in,pet_f_in,prev_out,msg_geral,an_out,corr_out,res_out,crit_out,diff_out,dwnld,an_file_out,corr_file_out,
+            oab_pdf,parse_st,oab_e,oab_g,oab_d,pet_usr,msg_oab,mod_out,corr_oab_out,mod_file_out,avaoab_file_out])
     return demo
 
 if __name__ == "__main__":
+    # Ensure Tesseract path is set if needed, or handle OCR errors gracefully
+    # try: pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract' # Example for Linux
+    # except: logger.warning("Tesseract not configured/found. OCR might fail.")
     app = interface_gradio()
     app.launch()