Update app.py

app.py

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
 import gradio as gr
-import google.generativeai as genai
-from google.api_core import exceptions as google_exceptions
+import requests
 import os
 import json
+import PyPDF2
 import docx
 import io
 import time
@@ -12,534 +11,799 @@ from dotenv import load_dotenv
 from pdfplumber import open as pdfplumber_open
 from PIL import Image
 import pytesseract
-try:
-    import cv2
-    import numpy as np
-    CV2_AVAILABLE = True
-except ImportError:
-    CV2_AVAILABLE = False
-    print("Aviso: OpenCV (cv2) não encontrado.")
+import cv2
+import numpy as np
 from datetime import datetime
 from ratelimiter import RateLimiter
 import difflib
 from html import escape
 import random
 import logging
-import traceback
-import re
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - [%(funcName)s] - %(message)s')
+# Configura o logging para depuração
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 load_dotenv()
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.environ.get("GEMINI_API_KEY")
-if not GEMINI_API_KEY:
-    raise ValueError("❌ Chave GEMINI_API_KEY não encontrada.")
 
-try:
-    genai.configure(api_key=GEMINI_API_KEY)
-    logger.info("Biblioteca google-generativeai configurada.")
-except Exception as e:
-    raise ValueError(f"❌ Erro config google-generativeai: {e}")
+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.")
 
-GEMINI_MODEL_NAME = "gemini-1.5-flash-latest"
-CONFIG = {"max_retry_attempts": 3, "retry_delay": 5, "timeout_api": 120, "temperatura": 0.3, "max_tokens": 8192}
-rate_limiter = RateLimiter(max_calls=15, period=60)
+GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
 
-SAFETY_SETTINGS = [
-    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-]
+CONFIG = {
+    "max_retry_attempts": 3,
+    "retry_delay": 5,
+    "timeout": 60,
+    "temperatura": 0.2,
+    "max_tokens": 12882
+}
 
-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"]
+rate_limiter = RateLimiter(max_calls=60, period=60)
 
 DICAS_OAB_MELHORADO = {
-    "Clareza e Concisão": "Direto, evite jargões.",
-    "Fundamentação Legal": "Cite leis, súmulas, jurisprudência.",
-    "Revisão Ortográfica": "Evite erros de português.",
-    "Endereçamento (Inicial)": "Verifique competência.",
-    "Pedidos (Inicial)": "Certos, determinados, líquidos.",
-    "Preliminares (Contestação)": "Art. 337 CPC antes do mérito.",
-    "Impugnação Específica (Contestação)": "Conteste cada fato (Art. 341)."
+    "Endereçamento": "Em relações de consumo, prefira o foro do domicílio do autor (Art. 101, I, CDC). Exemplo: 'Excelentíssimo Senhor Juiz de Direito da Vara Cível da Comarca de [Cidade do Autor]'.",
+    "Qualificação": "Mencione nome, estado civil (se informado), endereço (use 'Rua XXX' se não fornecido). Dica: Verifique se todos os dados estão corretos.",
+    "Fatos": "Descreva os fatos cronologicamente, sem inventar informações. Exemplo: 'Em [data], o autor celebrou contrato com o réu para [descrição]'.",
+    "Pedidos": "Seja específico nos pedidos (ex.: 'condenação ao pagamento de R$ X'). Inclua danos morais e materiais, se aplicável.",
+    "Custas": "Inclua 'Requer a juntada da guia de custas devidamente recolhida'. Nunca omita para evitar extinção do processo.",
+    "Fundamentação": "Baseie-se em artigos do CPC ou CDC e súmulas do STJ (ex.: Súmula 387 para danos morais).",
+    "Fechamento": "Finalize com 'Nestes termos pede deferimento', sem vírgula. Evite erros de pontuação.",
+    "Estratégia Jurídica": "Utilize precedentes e súmulas para fortalecer a argumentação.",
+    "Provas": "Especifique as provas a produzir. Inclua testemunhas, documentos e perícias, se necessário.",
+    "Contra-argumentação": "Antecipe defesas da parte contrária e prepare respostas."
 }
 
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-def preprocess_image_for_ocr(img_pil):
-    if not CV2_AVAILABLE:
-        logger.warning("OpenCV indisponível, usando conversão simples.")
-        return img_pil.convert('L')
+def preprocess_image_for_ocr(img):
     try:
-        img_cv = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2GRAY)
-        _, thresh = cv2.threshold(img_cv, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        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 pré-processamento OpenCV: {e}")
-        return img_pil.convert('L')
+        logger.error(f"Erro no pré-processamento da imagem: {str(e)}")
+        return f"❌ Erro no pré-processamento: {str(e)}"
 
 def extract_text_from_pdf(file_path_or_obj):
-    text = ""; ocr_text_parts = []
     try:
-        logger.info(f"Abrindo PDF: {getattr(file_path_or_obj, 'name', file_path_or_obj)}")
-        with pdfplumber_open(file_path_or_obj) as pdf:
-            logger.info(f"PDF com {len(pdf.pages)} páginas.")
-            for i, page in enumerate(pdf.pages):
-                page_text = page.extract_text(x_tolerance=2, y_tolerance=2)
-                if page_text and len(page_text.strip()) > 20: text += page_text + "\n"
-                else:
-                    logger.warning(f"Pág {i+1} sem texto, tentando OCR.")
-                    try:
-                        img = page.to_image(resolution=200)
-                        preprocessed_img = preprocess_image_for_ocr(img.original)
-                        page_ocr = pytesseract.image_to_string(preprocessed_img, lang='por', config='--psm 6')
-                        if page_ocr and page_ocr.strip(): ocr_text_parts.append(page_ocr)
-                        else: logger.warning(f"OCR vazio pág {i+1}."); ocr_text_parts.append(f"[OCR P{i+1}: Vazio]")
-                    except Exception as e: logger.error(f"Erro OCR pág {i+1}: {e}"); ocr_text_parts.append(f"[Erro OCR P{i+1}: {e}]")
-        ocr_text = "\n".join(ocr_text_parts)
-        len_text, len_ocr = len(text.strip()), len(ocr_text.strip())
-        if len_text > len_ocr * 0.7: logger.info(f"Usando texto PDF ({len_text} chars)."); return text
-        elif len_ocr > 0: logger.info(f"Usando OCR PDF ({len_ocr} chars)."); return ocr_text
-        elif len_text > 0: logger.info("Usando texto curto PDF."); return text
-        else: logger.warning("PDF sem texto."); return "⚠️ PDF sem texto (extração/OCR falharam)."
-    except Exception as e: logger.error(f"Erro PDF: {e}", exc_info=True); return f"❌ Erro PDF: {e}"
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                text = ""
+                with pdfplumber_open(f) as pdf:
+                    for page in pdf.pages:
+                        text += (page.extract_text() or "") + "\n"
+                if not text.strip():
+                    images = pdfplumber_open(f).pages
+                    for i, image in enumerate(images):
+                        try:
+                            img = image.to_image()
+                            preprocessed_img = preprocess_image_for_ocr(img)
+                            text += pytesseract.image_to_string(preprocessed_img) + "\n"
+                        except Exception as e:
+                            text += f"[Erro na página {i+1}: {str(e)}]\n"
+        else:
+            text = ""
+            with pdfplumber_open(file_path_or_obj) as pdf:
+                for page in pdf.pages:
+                    text += (page.extract_text() or "") + "\n"
+                if not text.strip():
+                    images = pdfplumber_open(file_path_or_obj).pages
+                    for i, image in enumerate(images):
+                        try:
+                            img = image.to_image()
+                            preprocessed_img = preprocess_image_for_ocr(img)
+                            text += pytesseract.image_to_string(preprocessed_img) + "\n"
+                        except Exception as e:
+                            text += f"[Erro na página {i+1}: {str(e)}]\n"
+        return text if text.strip() else "⚠️ Não foi possível extrair texto do PDF."
+    except Exception as e:
+        logger.error(f"Erro ao processar o PDF: {str(e)}")
+        return f"❌ Erro 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([p.text for p in doc.paragraphs if p.text])
-        return text if text.strip() else "⚠️ DOCX vazio."
-    except Exception as e: logger.error(f"Erro DOCX: {e}", exc_info=True); return f"❌ Erro DOCX: {e}"
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                doc = docx.Document(f)
+                text = ""
+                for para in doc.paragraphs:
+                    text += para.text + "\n"
+                for table in doc.tables:
+                    for row in table.rows:
+                        for cell in row.cells:
+                            text += cell.text + " "
+                        text += "\n"
+        else:
+            doc = docx.Document(file_path_or_obj)
+            text = ""
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+            for table in doc.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text += cell.text + " "
+                    text += "\n"
+        return text if text.strip() else "⚠️ Não foi possível extrair texto do DOCX."
+    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):
     try:
-        content = b''; encodings = ['utf-8', 'latin-1', 'cp1252']
         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'):
-            if hasattr(file_path_or_obj, 'seek') and callable(file_path_or_obj.seek):
-                try: file_path_or_obj.seek(0)
-                except Exception as seek_e: logger.warning(f"Não foi possível resetar ponteiro TXT: {seek_e}")
+            with open(file_path_or_obj, 'rb') as f:
+                content = f.read()
+                encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+                for encoding in encodings:
+                    try:
+                        return content.decode(encoding)
+                    except UnicodeDecodeError:
+                        continue
+                return "❌ Não foi possível decodificar o arquivo TXT."
+        else:
             content = file_path_or_obj.read()
-        else: return "❌ Input TXT inválido."
-        for enc in encodings:
-            try:
-                decoded = content.decode(enc)
-                logger.info(f"TXT decodificado: {enc}.")
-                return decoded if decoded.strip() else "⚠️ TXT vazio."
-            except UnicodeDecodeError: continue
-        return "❌ Não foi possível decodificar TXT."
-    except Exception as e: logger.error(f"Erro TXT: {e}", exc_info=True); return f"❌ Erro TXT: {e}"
+            encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+            for encoding in encodings:
+                try:
+                    return content.decode(encoding)
+                except UnicodeDecodeError:
+                    continue
+            return "❌ Não foi possível decodificar o arquivo TXT."
+    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: return "⚠️ Nenhum arquivo."
+    if file_obj is None:
+        return "Nenhum arquivo enviado."
     try:
-        fpath = getattr(file_obj, 'name', None);
-        if not fpath: return "❌ Erro: Não identificou arquivo."
-        fname = os.path.basename(fpath).lower(); logger.info(f"Processando: {fname}")
-        try:
-             fsize = os.path.getsize(fpath); logger.info(f"Tamanho: {fsize} bytes")
-             if fsize > 15*1024*1024: return "⚠️ Arquivo grande (Máx 15MB)."
-        except OSError as e: logger.warning(f"Erro tamanho arquivo: {e}")
-        if fname.endswith('.pdf'): return extract_text_from_pdf(fpath)
-        elif fname.endswith('.docx'): return extract_text_from_docx(fpath)
-        elif fname.endswith('.txt'): return extract_text_from_txt(fpath)
-        else: return "⚠️ Formato não suportado (PDF, DOCX, TXT)."
-    except Exception as e: logger.error(f"Erro process_file: {e}", exc_info=True); return f"❌ Erro processar arquivo: {e}"
-
-def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
-    base = """
-    **Estrutura:** 1.Análise Geral. 2.Nota Final(0-10). 3.Pontos Positivos. 4.Pontos a Melhorar(Desc, Fund., Impacto, Sug.). 5.Análise Requisitos.
-    **Critérios:** Coerência, Fundamentação, Linguagem, Pedidos. NÃO INVENTAR FATOS(-3a-5). NÃO SE IDENTIFICAR(Nota ZERO)."""
-    if modo_treinamento: base += "\n**Treinamento:** Detalhar Pontos a Melhorar(a-e). Destacar inconsistências. Sugerir estratégias."
-    return base
-
-def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
-    instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
-    prompt = f"## Análise: {tipo_peticao}\n**Caso:**\n```\n{caso}\n```\n**Peça Aluno:**\n```\n{peticao}\n```\n{instrucoes_gerais}\n**Requisitos({tipo_peticao}):**\n"
-    if tipo_peticao == "Petição Inicial": prompt += "-End. Comp(319,I;CDC101,I).\n-Qualif(319,II).\n-Fatos.\n-Fundam(319,III).\n-Pedidos(319,IV).\n-Vlr Causa(291-2,319,V).\n-Provas(319,VI).\n-Aud(319,VII).\n-Citação.\n-Docs essenc.\n-Fecho.\n**Adic:**'XXX'.Falta custas/JG(-1).Vírgula pede defer.(-0.2)."
-    elif tipo_peticao == "Contestação": prompt += "-End. Qualif réu. Proc nº. Temp.\n-Prelim(337):TODAS.\n-Impug.Esp Fatos(341):PONTOxPONTO.\n-Mérito:Versão réu;defesa dir/indir.\n-Fundam defesa.\n-Pedidos:Acolher prelim;IMPROC TOTAL;Sucumb(85).\n-Provas.\n**Adic:**Prelim preclui?Falha impug(-2a-4).Sem ped improc(-1.5)."
-    elif tipo_peticao == "Reconvenção": prompt += "-NA MESMA PEÇA(343).End. Proc nº.Qualif.\n-Conexão(343).\n-Estrut PI:Fatos,Fund,Ped,Vlr,Provas(reconv).\n-Ped intim(343§1).\n**Adic:**S/conex(-2).Falta ped/vlr/prov(-1/item).Peça separada(-3)."
-    elif tipo_peticao == "Impugnação à Contestação": prompt += "-End.Proc nº.Autor.Temp(15d-350/1).\n-Resp Prelim.\n-Resp Fatos Novos(350).\n-Resp Docs(437).\n-Ratific Inicial.\n-Espec Provas.\n-Peds:Rej prelim;refutar def;proced inicial.\n**Adic:**Ñ resp prelim(-1.5).Ñ manif fato novo(-2).Ñ ratificar(-0.5)."
-    elif tipo_peticao == "Embargos de Declaração": prompt += "-Contra Decisão Espec.End juiz prolator.Proc nº.Partes.Temp(5d-1023).\n-Cabim(1022):Apontar PRECISAMENTE:Omissão/Contrad/Obscur/ErroMat.\n-NÃO REJULGAR.\n-Ped:Conhec e ACOLHER p/ sanar vício.\n**Adic:**Rediscutir mérito(-4).Ñ apontar vício(-3)."
-    elif tipo_peticao == "Recurso de Apelação": prompt += "-Interpos:Juízo a quo.Proc nº.Partes.Pressup(cabim 1009;temp 15d;prep/JG).Ped receb/remessa.\n-Razões:TRIBUNAL.Relato.Fundam Reforma/Anul(1010):Error in proc/judic.DIALETICIDADE.\n-Peds:Conhec;PROVIM(anul/ref);Inv sucumb.\n**Adic:**Falta peça(-10).End razões(-1).S/dialetic(-3a-5)."
-    elif tipo_peticao == "Agravo de Instrumento": prompt += "-Peça única TRIBUNAL.Proc origem.Partes+Advs(end 1016).Cópia Decisão(1017,I).\n-Cabim(1015/mitig).Temp(15d).Prep/JG.\n-Peças Obrig(1017,I):Dec,Intim,Proc.Facult(III).\n-Razões(1016):Motivos ref/inval.\n-Efeito Susp/Tut Antecip Rec(1019,I)(se risco).\n-Peds Finais:Conhec;Efeito/Tut;PROVIM;Comunic juiz.\n**Adic:**Falta peça obrig(-4).S/cabim(-3)."
-    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "-Tipo(Urg/Evid).Caráter(Antec/Incid).End.Qualif.Proc(se incid).\n-Urg(300):Fumus Boni Iuris E Periculum in Mora.Reversib(300§3).\n-Evid(311):Hipótese I-IV.NÃO precisa periculum.\n-Ped Específico:Medida liminar CLARA.\n-Se Antec(303/5):Indicar ped final ou aditar.Vlr Causa.\n-Peds:Concessão tutela;cit/intim;indic ação/adit.\n**Adic:**S/Fumus/Peric(-3a-5).Erro Evid(-3).Ped genérico(-2)."
-    else: prompt += "-Adequação? Clareza? Fundam? Pedido?"
-    prompt += "\n\n**Instruções Finais:** Analise estritamente. Rigoroso e construtivo. Gere **exclusivamente** no formato solicitado."
-    return prompt
-
-def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
-    prompt = f"**Caso:**\n```\n{caso}\n```\n**Peça Original ({tipo_peticao}):**\n```\n{peticao_original}\n```\n**Tarefa:** Gere versão corrigida ({tipo_peticao}), seguindo práticas OAB.\n**Instruções ({tipo_peticao}):**\n"
-    if tipo_peticao == "Petição Inicial": prompt += "1.End. 2.Qualif(319,II,'XXX'). 3.Fatos. 4.Fundam. 5.Pedidos(quantif). 6.Vlr Causa(292). 7.Provas. 8.Aud(319,VII). 9.Citação(246,I). 10.Custas/JG(NÃO OMITIR). 11.Fecho('Nestes termos...')."
-    elif tipo_peticao == "Contestação": prompt += "1.End. 2.ID(proc nº,réu). 3.Temp. 4.Estrut:Síntese;Prelim(337);Mérito(Impug+Defesa);Reconv(se antes peds cont). 5.Peds Cont:Acolher prelim;IMPROC TOTAL;Sucumb. 6.Provas réu. 7.Fecho."
-    elif tipo_peticao == "Reconvenção": prompt += "*Parte da Contest.* 1.Após mérito cont, antes peds: 'DA RECONVENÇÃO'. 2.Qualif Recvte/Recvdo. 3.Conexão. 4.Fatos/Dir Recv. 5.Peds Recv. 6.Vlr Causa/Provas Recv. 7.Intim Recvdo. 8.Peds Cont. 9.Fecho."
-    elif tipo_peticao == "Impugnação à Contestação": prompt += "1.End,proc,autor,temp. 2.Tópico PRELIM - Rebater. 3.Tópico MÉRITO/FATOS NOVOS - Manifestar. 4.Tópico RATIFICAÇÃO. 5.Tópico PROVAS. 6.Peds:Rej prelim, refutar def, proced inicial. 7.Fecho."
-    elif tipo_peticao == "Embargos de Declaração": prompt += "1.End juiz prolator.Proc,Partes.Decisão ID.Temp(5d). 2.Tópico p/ vício(1022):OMISSÃO/CONTRAD/OBSCUR/ERRO MAT. 3.Dentro:Trecho + Explicar vício. Ñ REJULGAR. 4.Ped:Conhec e ACOLHER p/ sanar. 5.Fecho."
-    elif tipo_peticao == "Recurso de Apelação": prompt += "1.Interpos:Juízo a quo.Proc,Partes.Pressup(cab,temp,prep/JG).Ped receb/remessa. 2.Razões:Tribunal.Relato.FUND REFORMA/ANUL(Error in proc/judic).DIALETICIDADE. 3.Peds:Conhec;PROVIM(anul/ref);Inv sucumb. 4.Fecho."
-    elif tipo_peticao == "Agravo de Instrumento": prompt += "1.Peça única Trib.Proc origem,Partes,Advs(ends).Decisão ID(cópia). 2.CABIM(1015/mitig).TEMP.PREP/JG.PEÇAS OBRIG/FACULT. 3.RAZÕES:Motivos ref/inval. 4.EFEITO SUSP/TUT ANTEC(se cabível). 5.PEDS:Conhec;Efeito/Tut;PROVIM;Comunic juiz. 6.Fecho."
-    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "1.TIPO(Urg/Evid) e CARÁTER(Antec/Incid).End.Qualif.Proc(se incid). 2.REQUISITOS:Urg=Fumus+Peric(+Reversib).Evid=Hipót 311. 3.PED LIMINAR:Medida CLARA. 4.Se Antec:Indic ped final/aditar.Vlr Causa. 5.PEDS:Concessão tutela;cit/intim;indic ação/adit. 6.Fecho."
-    else: prompt += "1.Estrutura. 2.Args Claros. 3.Ped Claro. 4.Formais OAB."
-    prompt += "\n\n**Instrução Final:** Gere **APENAS** texto da peça corrigida (endereçamento até 'OAB/...'). Sem comentários."
-    return prompt
-
-def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
+        if hasattr(file_obj, 'name'):
+            file_path = file_obj.name
+            filename = os.path.basename(file_path).lower()
+            file_size = os.path.getsize(file_path)
+            if file_size > 10 * 1024 * 1024:
+                return "⚠️ O arquivo é muito grande. Máx. 10 MB."
+            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:
+                return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
+        else:
+            return "❌ Erro: Objeto de arquivo inválido."
+    except Exception as e:
+        logger.error(f"Erro ao processar o arquivo: {str(e)}")
+        return f"❌ Erro ao processar o arquivo: {str(e)}"
+
+def estruturar_prompt_analise(caso, peticao, modo_treinamento=False):
+    base_prompt = f"""
+    ## Correção Avançada de Petição Inicial Cível (Critérios Realistas da OAB)
+    **Caso Fornecido:**
+    {caso}
+    **Petição do Aluno:**
+    {peticao}
+    **Estrutura da Avaliação:**
+    ### Análise da Petição
+    1. Análise Geral (Visão geral sobre a petição - máximo 3 linhas, destacando adequação ao caso e consistência jurídica)
+    2. Nota Final (0 a 10 com uma casa decimal, justificando brevemente a pontuação total)
+    3. Pontos Positivos (Liste pelo menos 3 aspectos bem executados com justificativa legal detalhada, incluindo artigos, súmulas ou precedentes aplicáveis)
+    4. Pontos a Melhorar (Liste todos os problemas encontrados em ordem de gravidade, com explicação detalhada, base legal e impacto na nota)
+    5. Análise Específica dos Requisitos:
+       - Endereçamento e qualificação do juízo (Art. 319, I, CPC; Art. 101, I, CDC se aplicável)
+       - Qualificação das partes (Art. 319, II, CPC)
+       - Fatos e fundamentos jurídicos (Art. 319, III, CPC; Art. 186, CC)
+       - Pedidos com especificações (Art. 319, IV, CPC)
+       - Valor da causa (Art. 319, V, CPC)
+       - Provas com que o autor pretende demonstrar os fatos (Art. 319, VI, CPC)
+       - Opção pela realização ou não de audiência de conciliação (Art. 319, VII, CPC)
+       - Pedido de citação do réu
+       - Juntada da guia de custas
+       - Fechamento formal da petição
+
+    **Critérios Fundamentais:**
+    1. Identificação do candidato (nome, CPF, RG ou número real na seção final): nota máxima 3,0
+    2. Invenção de fatos não constantes no caso: -5,0 pontos
+    3. Falta de pedido de juntada de custas: -1,0 ponto
+    4. Use marcadores para dados não fornecidos (ex.: "Rua XXX"): penalize invenção de dados (-0,5 por ocorrência)
+    5. Não penalize por informações ausentes no caso original, mas alerte se a omissão compromete a petição
+    6. "Nestes termos, pede deferimento" com vírgula é incorreto: corrija e penalize com -0,2 ponto
+    7. Fechamento deve ser "Local e data.\nADVOGADO.\nOAB." sem identificação específica (ex.: "OAB/SP" ou "12345"): zere a nota (0,0) se houver
+
+    **Instruções Especiais:**
+    - Avalie o foro com base no Art. 46 do CPC (domicílio do réu) ou Art. 101, I do CDC (domicílio do autor, em relações de consumo). Ambas as escolhas são válidas se fundamentadas e aplicáveis ao caso; NÃO penalize a escolha do foro do autor com base no CDC, pois é uma prerrogativa legal do consumidor. Apenas alerte se a escolha puder gerar dificuldades práticas (ex.: produção de provas), mas sem dedução de pontos.
+    - Compare fatos narrados com o caso
+    - Exija citação de pelo menos um artigo específico
+    - Verifique pedidos quantificados e fundamentados para danos
+    - Avalie formalidade e precisão da linguagem
+    - Inclua precedentes quando aplicável
+    """
+    if modo_treinamento:
+        base_prompt += f"""
+        **Modo de Treinamento:**
+        - Para cada item com problemas, forneça:
+          a) Explicação detalhada com base legal
+          b) Sugestão de redação corrigida
+          c) Exemplo prático
+          d) Dica prática do banco ({json.dumps(DICAS_OAB_MELHORADO, ensure_ascii=False)})
+          e) Estratégia jurídica avançada
+        - Liste inconsistências com trechos específicos
+        - Sugira estratégias adicionais (ex.: cumulação de pedidos, Art. 327, CPC)
+        """
+    return base_prompt
+
+def estruturar_prompt_peticao_corrigida(caso, peticao):
+    return f"""
+    **Caso Fornecido:**
+    {caso}
+    **Petição do Aluno:**
+    {peticao}
+    ### Petição Corrigida
+    Gere a petição corrigida abaixo desta seção, intitulada '### Petição Corrigida'. Siga TODOS os critérios abaixo:
+    1. Endereçamento correto: Respeite o foro escolhido pelo aluno na petição original (Art. 46 do CPC ou Art. 101, I do CDC) se estiver fundamentado e aplicável ao caso. Em relações de consumo, o foro do domicílio do autor (Art. 101, I, CDC) é válido e deve be mantido se escolhido; não altere para o foro do réu (Art. 46, CPC) a menos que a escolha original seja juridicamente inválida (ex.: falta de relação de consumo quando o CDC é citado).
+    2. Qualificação completa: Nome, estado civil, endereço (use "XXX" para dados ausentes), Art. 319, II, CPC
+    3. Fatos fiéis ao caso: Ordem cronológica, sem invenção, Art. 319, III, CPC
+    4. Fundamentação jurídica: Cite pelo menos um artigo (ex.: Art. 186, CC) e súmulas, se aplicável
+    5. Pedidos específicos: Detalhe valores (ex.: "R$ 50.000,00 por danos morais"), Art. 319, IV, CPC
+    6. Valor da causa realista: Soma do benefício econômico, Art. 319, V, CPC
+    7. Provas detalhadas: "Prova documental e testemunhal", Art. 319, VI, CPC
+    8. Opção por audiência: "Requer a designação" ou "Dispensa", Art. 319, VII, CPC
+    9. Pedido de citação: "Via postal, Art. 246, I, CPC"
+    10. Juntada da guia: "Requer a juntada da guia de custas devidamente recolhida"
+    11. Fechamento: "Local e data.\nADVOGADO.\nOAB." sem identificação específica; corrija "Nestes termos, pede deferimento" para "Nestes termos pede deferimento"
+    """
+
+def pos_corrigir_peticao(peticao_corrigida):
     if "Nestes termos, pede deferimento" in peticao_corrigida:
         peticao_corrigida = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
-    if tipo_peticao == "Petição Inicial":
-        p_lower = peticao_corrigida.lower()
-        if "juntada da guia de custas" not in p_lower and "gratuidade de justiça" not in p_lower:
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes)==2: peticao_corrigida = partes[0].strip()+"\nRequer, ainda, a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento"+partes[1]
-             else: peticao_corrigida = peticao_corrigida.replace("Local, data.","Requer, ainda, a juntada da guia de custas devidamente recolhida.\n\nLocal, data.")
-        if "audiência de conciliação" not in p_lower and "audiência de mediação" not in p_lower:
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes)==2: peticao_corrigida = partes[0].strip()+"\nOpta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\nNestes termos pede deferimento"+partes[1]
-             else: peticao_corrigida = peticao_corrigida.replace("Local, data.","Opta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\n\nLocal, data.")
-    linhas = [l.strip() for l in peticao_corrigida.strip().split('\n') if l.strip()]
-    fechamento = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
-    while linhas and any(t in linhas[-1] for t in ["ADVOGADO","OAB","Local","data"]): linhas.pop()
-    linhas.extend(fechamento)
-    return "\n".join(linhas)
+    if "juntada da guia de custas" not in peticao_corrigida.lower():
+        peticao_corrigida = peticao_corrigida.replace("Nestes termos pede deferimento", "Requer a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento")
+    if not peticao_corrigida.strip().endswith("Local e data.\nADVOGADO.\nOAB."):
+        linhas = peticao_corrigida.split('\n')
+        while linhas and not linhas[-1].strip():
+            linhas.pop()
+        if len(linhas) >= 3:
+            linhas[-3:] = ["Local e data.", "ADVOGADO.", "OAB."]
+        else:
+            linhas.extend(["Local e data.", "ADVOGADO.", "OAB."])
+        peticao_corrigida = "\n".join(linhas)
+    if "audiência de conciliação" not in peticao_corrigida.lower():
+        peticao_corrigida = peticao_corrigida.replace("Nestes termos pede deferimento", "Requer a designação de audiência de conciliação, Art. 319, VII, CPC.\nNestes termos pede deferimento")
+    return peticao_corrigida
 
 def chamar_api(prompt):
-    logger.info(f"Chamando API Gemini (Modelo: {GEMINI_MODEL_NAME})...")
-    model = genai.GenerativeModel(GEMINI_MODEL_NAME, safety_settings=SAFETY_SETTINGS)
-    gen_config = genai.types.GenerationConfig(temperature=CONFIG["temperatura"], max_output_tokens=CONFIG["max_tokens"], top_p=0.95)
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {"temperature": CONFIG["temperatura"], "maxOutputTokens": CONFIG["max_tokens"], "topP": 0.95}
+    }
+    headers = {"Content-Type": "application/json"}
     for tentativa in range(CONFIG["max_retry_attempts"]):
         try:
             with rate_limiter:
-                logger.debug(f"API Tentativa {tentativa + 1}")
-                response = model.generate_content(contents=prompt, generation_config=gen_config)
-            if response.prompt_feedback.block_reason:
-                logger.error(f"Prompt bloqueado: {response.prompt_feedback.block_reason}")
-                return f"❌ Prompt bloqueado: {response.prompt_feedback.block_reason}. Reformule."
-            if not response.text:
-                 if response.candidates and response.candidates[0].finish_reason != genai.types.FinishReason.STOP:
-                      finish_reason = response.candidates[0].finish_reason.name
-                      logger.error(f"Geração interrompida (s/ texto): {finish_reason}")
-                      safety = response.candidates[0].safety_ratings
-                      harms = [r.category.name for r in safety if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
-                      if harms: return f"❌ Bloqueado segurança: {finish_reason} ({','.join(harms)})."
-                      else: return f"❌ Geração interrompida: {finish_reason}."
-                 else: logger.warning("API retornou s/ texto ou bloqueio."); return "⚠️ API retornou resposta vazia."
-            logger.info(f"API OK ({len(response.text)} chars).")
-            return response.text
-        except google_exceptions.ResourceExhausted as e:
-            logger.warning(f"Erro 429 - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: wait = CONFIG['retry_delay']*(2**tentativa); logger.info(f"Aguardando {wait}s..."); time.sleep(wait); continue
-            return "❌ Erro 429: Muitas requisições."
-        except google_exceptions.PermissionDenied as e: logger.error(f"Erro Permissão API: {e}"); return f"❌ Erro Permissão: Verifique API Key/acesso modelo '{GEMINI_MODEL_NAME}'."
-        except google_exceptions.InvalidArgument as e: logger.error(f"Erro Argumento API: {e}"); return f"❌ Erro parâmetros API: {e}"
-        except genai.types.BlockedPromptException as e: logger.error(f"Prompt bloqueado (exc): {e}"); return f"❌ Prompt bloqueado. Reformule."
-        except genai.types.StopCandidateException as e: logger.error(f"Geração interrompida (exc): {e}"); return f"❌ Geração interrompida (segurança/outro)."
-        except google_exceptions.GoogleAPIError as e:
-            logger.error(f"Erro API Google - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay']*(tentativa + 1)); continue
-            return f"❌ Erro API Google: {e}"
+                response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
+            if response.status_code != 200:
+                error_msg = response.json().get("error", {}).get("message", "Erro desconhecido")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return f"❌ Erro da API: {error_msg}"
+            response_data = response.json()
+            if "candidates" not in response_data or not response_data["candidates"]:
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return "❌ Resposta vazia da API."
+            return response_data["candidates"][0]["content"]["parts"][0]["text"].strip()
+        except requests.Timeout:
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return "⏱️ Tempo esgotado."
+        except requests.RequestException as e:
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return f"❌ Erro na requisição: {e}"
         except Exception as e:
-            logger.exception(f"Erro inesperado API - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1: time.sleep(CONFIG['retry_delay']*(tentativa + 1)); continue
-            return f"❌ Erro inesperado API: {e}"
-    logger.error("Falha API após todas as tentativas.")
-    return "❌ Falha API após múltiplas tentativas."
-
-def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
-    logger.info(f"Correção: Tipo={tipo_peticao}, Treinamento={modo_treinamento}")
-    start = time.time()
-    analise_fmt, pet_corr, res_diff, crit_diff, html_diff = "", "", "", "", ""
-    pet_cont = ""
-    try:
-        if not caso or not caso.strip(): return "⚠️ Forneça caso.", "", "", "", ""
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo.", "", "", "", ""
-        if peticao_arquivo: pet_cont = process_file(peticao_arquivo)
-        elif peticao_texto: pet_cont = peticao_texto
-        else: return "⚠️ Forneça petição.", "", "", "", ""
-        if pet_cont.startswith(("❌", "⚠️")): return pet_cont, "", "", "", ""
-        logger.info(f"Petição recebida ({len(pet_cont)} chars).")
-        troll = ["escreva a petição", "faça a petição", "gere a petição"]
-        if any(t in pet_cont.lower() for t in troll): return random.choice(["Hummm 😉","🚫 Corrijo, não crio."]), "", "", "", ""
-        cache_key = f"{tipo_peticao}|{caso[:100]}|{pet_cont[:100]}|{modo_treinamento}"
-        if cache_key in CORRECAO_CACHE:
-            logger.info("Cache hit.")
-            cached = CORRECAO_CACHE[cache_key]
-            return cached["analise_formatada"], cached["peticao_corrigida"], cached["resumo_diff"], cached["criticas_diff"], cached["diff_html"]
-        prompt_analise = estruturar_prompt_analise(caso, pet_cont, tipo_peticao, modo_treinamento)
-        analise_bruta = chamar_api(prompt_analise)
-        if analise_bruta.startswith(("❌", "⏱️", "⚠️")): return analise_bruta, "", "", "", ""
-        analise_fmt = formatar_correcao(analise_bruta)
-        prompt_peticao = estruturar_prompt_peticao_corrigida(caso, pet_cont, tipo_peticao)
-        pet_corr_bruta = chamar_api(prompt_peticao)
-        if pet_corr_bruta.startswith(("❌", "⏱️", "⚠️")): pet_corr = f"⚠️ Falha gerar corrigida:\n{pet_corr_bruta}"
-        else:
-            markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
-            start_index = -1
-            p_lower = pet_corr_bruta.lower()
-            # CORRIGIDO: Bloco for com indentação correta
-            for m in markers:
-                idx = p_lower.find(m)
-                if idx != -1:
-                    start_index = idx
-                    break
-            pet_extr = pet_corr_bruta[start_index:] if start_index != -1 else pet_corr_bruta
-            pet_corr = pos_corrigir_peticao(pet_extr, tipo_peticao)
-        html_diff, res_diff, crit_diff = calcular_diff_interno(pet_cont, pet_corr)
-        res_cache = {"analise_formatada":analise_fmt,"peticao_corrigida":pet_corr,"resumo_diff":res_diff,"criticas_diff":crit_diff,"diff_html":html_diff}
-        CORRECAO_CACHE[cache_key] = res_cache
-        HISTORICO.append({"data":datetime.now().strftime("%Y%m%d_%H%M%S"),"tipo_peticao":tipo_peticao,"caso":caso,"peticao_original":pet_cont,**res_cache})
-        if len(HISTORICO) > 10: HISTORICO.pop(0)
-        logger.info(f"Correção concluída em {time.time() - start:.2f}s.")
-        return analise_fmt, pet_corr, res_diff, crit_diff, html_diff
-    except Exception as e: logger.exception("Erro GERAL corrigir_peticao:"); return f"❌ Erro correção: {e}", "", "", "", ""
+            logger.error(f"Erro inesperado na chamada da API: {str(e)}")
+            return f"❌ Erro inesperado: {str(e)}"
+
+def corrigir_peticao(caso, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
+    logger.info("Iniciando correção de petição...")
+    if not caso.strip():
+        logger.warning("Caso não fornecido.")
+        return "⚠️ Forneça o caso da banca."
+
+    troll_triggers = [
+        "escreva a petição", "faça a petição", "redija a petição",
+        "elabore a petição", "crie a petição", "gere a petição",
+        "3scr3v4 a p3t1çã0", "f4ç4 a p3t1çã0", "r3d1j4 a p3t1çã0",
+        "3lab0r3 a p3t1çã0", "cr13 a p3t1çã0", "g3r3 a p3t1çã0",
+        "formule", "produza a petição", "desenvolva a petição",
+    ]
+    peticao_conteudo = ""
+    if peticao_arquivo is not None:
+        peticao_conteudo = process_file(peticao_arquivo)
+        if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
+            logger.error(f"Erro ao processar arquivo: {peticao_conteudo}")
+            return peticao_conteudo
+    else:
+        peticao_conteudo = peticao_texto or ""
+
+    if peticao_conteudo.strip():
+        for trigger in troll_triggers:
+            if trigger in peticao_conteudo.lower():
+                respostas_troll = [
+                    "🍰 **Receita de Bolo de Chocolate**: Misture 2 xícaras de farinha, 1 xícara de açúcar, 3 ovos e chocolate a gosto. Asse e desista da petição!",
+                    "🎵 **Música**: 'Escreva a petição, eu não vou, eu não vou, eu sou IA, não sou seu advogado, não!'",
+                    "😞 **Frase Desanimadora**: 'Você achou mesmo que eu ia fazer seu trabalho? Melhor desistir agora.'",
+                    "🍕 **Receita de Pizza**: Pegue massa, molho e queijo, asse a 200°C e esqueça essa ideia de eu te ajudar.",
+                    "📜 **Poema**: 'Oh aluno preguiçoso, que pena me dá, sua petição eu não faço, vá estudar já!'",
+                    "🚫 **Aviso**: 'Petição não é self-service, escreva você mesmo ou chame um advogado de verdade!'",
+                    "😂 **Piada**: 'Por que o aluno pediu pra IA escrever a petição? Porque ele achou que OAB é brincadeira!'",
+                    "🎮 **Dica de Jogo**: 'Tente o nível fácil: abra o CPC, Art. 319, e escreva sozinho!'",
+                    "🍔 **Receita de Hambúrguer**: Carne, pão, alface e tomate. Frite e esqueça a petição, é mais fácil assim.",
+                    "😴 **Conselho**: 'Descanse, porque eu não vou fazer isso por você. Boa sorte na próxima tentativa!'",
+                    "📚 **Lição**: 'Aula 1: IA não é seu estagiário. Abra o livro e comece a escrever.'",
+                    "🌧️ **Previsão**: 'Dia nublado com 100% de chance de você ter que escrever a petição sozinho.'",
+                    "💡 **Ideia Brilhante**: 'Que tal estudar o caso e tentar de novo? Eu só corrijo, não escrevo!'",
+                    "🎸 **Rockstar**: 'Você queria uma petição, mas eu só toco guitarra. Tente de novo!'",
+                    "🌟 **Horóscopo**: 'As estrelas dizem: hoje não é dia de pedir ajuda para IA. Escreva você mesmo!'",
+                    "🏋️ **Dica de Treino**: 'Faça 10 flexões e tente escrever a petição novamente. Você consegue!'",
+                    "🎬 **Cena de Filme**: 'Em um mundo onde IAs ajudam, mas não escrevem petições. Você é o herói!'",
+                    "🎨 **Arte Abstrata**: 'Pegue um pincel e pinte sua petição. Talvez fique mais fácil de entender!'",
+                    "🎧 **Podcast**: 'Ouça nosso podcast: Como escrever sua petição sem ajuda de IA.'",
+                    "🏆 **Desafio**: 'Desafio aceito? Escreva a petição em 1 hora e ganhe um prêmio: satisfação pessoal!'",
+                    "🎭 **Teatro**: 'Ato 1, Cena 1: Você escreve a petição. Eu? Apenas assisto.'",
+                    "🎲 **Jogo de Dados**: 'Role os dados. Se der 6, eu ajudo. Se não, você escreve sozinho!'",
+                    "🎹 **Música Clássica**: 'Sonata em Petição Maior: composta por você, executada por você.'",
+                    "🌳 **Sabedoria da Floresta**: 'As árvores sussurram: escreva sua petição com calma e paciência.'",
+                    "🎓 **Aula de História**: 'Na época das cavernas, eles escreviam petições nas paredes. Sua vez!'",
+                    "🎬 **Trailer de Filme**: 'Em breve nos cinemas: A Petição Impossível. Escrita e dirigida por você!'",
+                    "🎮 **Nível Bônus**: 'Desbloqueie o nível bônus: escreva a petição sem ajuda e ganhe experiência!'",
+                    "🎧 **Música de Elevador**: 'Enquanto você escreve, eu toco uma música relaxante. Boa sorte!'"
+                ]
+                logger.info("Detectado pedido para escrever petição. Retornando resposta troll.")
+                return random.choice(respostas_troll)
+
+    if not peticao_conteudo.strip():
+        logger.warning("Petição não fornecida.")
+        return "⚠️ Forneça uma petição."
+
+    problemas = validar_peticao_basica(peticao_conteudo)
+    aviso_validacao = f"### Validação Inicial\n\n" + "\n".join(problemas) + "\n\n" if problemas else ""
+
+    cache_key = f"{caso[:50]}|{peticao_conteudo[:50]}|{modo_treinamento}"
+    if cache_key in CORRECAO_CACHE:
+        logger.info("Correção encontrada no cache.")
+        return aviso_validacao + CORRECAO_CACHE[cache_key]
+
+    prompt_analise = estruturar_prompt_analise(caso, peticao_conteudo, modo_treinamento)
+    analise = chamar_api(prompt_analise)
+    if "❌" in analise or "⏱️" in analise:
+        logger.error(f"Erro na análise da petição: {analise}")
+        return aviso_validacao + analise
+    analise_formatada = formatar_correcao(analise)
+
+    prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo)
+    peticao_corrigida = chamar_api(prompt_peticao)
+    if "❌" in peticao_corrigida or "⏱️" in peticao_corrigida:
+        logger.error(f"Erro ao gerar petição corrigida: {peticao_corrigida}")
+        return aviso_validacao + analise_formatada + "\n\n" + peticao_corrigida
+
+    peticao_corrigida = pos_corrigir_peticao(peticao_corrigida)
+
+    correcao_completa = analise + "\n\n" + peticao_corrigida
+    HISTORICO.append({
+        "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "caso": caso,
+        "peticao": peticao_conteudo,
+        "correcao_completa": correcao_completa
+    })
+    if len(HISTORICO) > 10:
+        HISTORICO.pop(0)
+    CORRECAO_CACHE[cache_key] = analise_formatada
+    logger.info("Correção de petição concluída com sucesso.")
+    return aviso_validacao + analise_formatada
 
 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")
-    linhas = texto.split('\n'); linhas_fmt = []
-    in_list = False
-    for l in linhas:
-        ls = l.strip()
-        if ls.startswith(("1.","2.","3.","4.","5.")): linhas_fmt.append(f"\n**{ls}**"); in_list = False
-        elif ls.startswith(("- ","* ")): prefix = "  * " if in_list else "* "; linhas_fmt.append(prefix + ls[2:]); in_list = True
-        elif ls.startswith(("a)","b)","c)","d)","e)")): linhas_fmt.append(f"    * {ls}"); in_list = True
-        else: linhas_fmt.append(l); in_list = False if not ls.startswith(("*","- ","a)","b)","c)","d)","e)"," ")) else in_list
-    txt_final = "\n".join(linhas_fmt)
-    m = re.search(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", txt_final, re.I)
-    if m: nota = m.group(2).replace(",","."); txt_final = re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", f"\\1**{nota}/10**", txt_final, count=1, flags=re.I)
-    return txt_final
-
-def fornecer_dica_contextual(texto_peticao, tipo_peticao):
-    if not texto_peticao or not texto_peticao.strip(): return "*Digite para dicas...*"
-    dicas = []; txt_l = texto_peticao.lower()
-    for k in ["Clareza e Concisão", "Fundamentação Legal", "Revisão Ortográfica"]:
-        if k in DICAS_OAB_MELHORADO: dicas.append(f"💡 **{k}:** {DICAS_OAB_MELHORADO[k]}")
-    kw = { "Petição Inicial": ["endereçamento","qualificação","fatos","pedidos","valor","provas","audiência","custas"],
-           "Contestação": ["preliminar","mérito","impugnação","art. 337"], "Embargos de Declaração": ["omissão","contradição","art. 1022"],
-           "Recurso de Apelação": ["sentença","reforma","dialeticidade","art. 1009"], "Agravo de Instrumento": ["interlocutória","cabimento","art. 1015"],
-           "Petição de Tutela Provisória": ["urgência","evidência","periculum","fumus","art. 300"]}
-    if tipo_peticao in kw:
-         for k, v in DICAS_OAB_MELHORADO.items():
-              cl = k.lower()
-              if f"({tipo_peticao.split()[0].lower()})" in cl or any(w in cl for w in kw[tipo_peticao] if w in txt_l):
-                    fmt = f"💡 **{k}:** {v}"
-                    if fmt not in dicas: dicas.append(fmt)
-    if not dicas: return "*Continue para dicas...*"
-    return "\n\n".join(dicas[:4])
-
-def calcular_diff_interno(texto_original, texto_corrigido):
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")): return "","",""
-    orig = texto_original.splitlines(); corr = texto_corrigido.splitlines()
-    diff = difflib.ndiff(orig, corr)
-    html, crit, rem, add = [], [], 0, 0
-    kw_r = ["invenção","identificação","erro","incorreto","prazo"]
-    kw_a = ["custas","art. 319","art. 337","art. 1022","art. 1015","art. 300","fumus","periculum","essencial","preliminar","tempestividade","cabimento"]
-    for l in diff:
-        txt = l[2:]; txt_esc = escape(txt)
-        if l.startswith('  '): html.append(f"<div class='linha-igual'>{txt_esc}</div>")
-        elif l.startswith('- '):
-            rem += 1; html.append(f"<div class='linha-removida'><del>{txt_esc}</del></div>")
-            if txt.strip() and any(kw in txt.lower() for kw in kw_r): crit.append(f"<span style='color:red'>🔴 REM:</span> {txt_esc}")
-        elif l.startswith('+ '):
-            add += 1; html.append(f"<div class='linha-adicionada'><ins>{txt_esc}</ins></div>")
-            if txt.strip() and any(kw in txt.lower() for kw in kw_a): crit.append(f"<span style='color:green'>🟢 ADD:</span> {txt_esc}")
-    resumo = f"**Resumo:** Rem={rem}, Add={add}, Saldo={add-rem}"
-    crit_txt = "### 🚨 Críticas:\n"+"\n".join(crit) if crit else "*Nenhuma crítica.*"
-    css = "<style>.diff-container{font-family:monospace;white-space:pre-wrap;border:1px solid #ccc;padding:10px;background-color:#f9f9f9;max-height:600px;overflow-y:auto}.linha-igual{color:#555}.linha-removida{background-color:#ffebee;color:#c62828}.linha-adicionada{background-color:#e8f5e9;color:#2e7d32}.linha-removida del,.linha-adicionada ins{text-decoration:none;padding:0 2px;border-radius:2px}.linha-removida del{background-color:#ffcdd2}.linha-adicionada ins{background-color:#c8e6c9}</style>"
-    html_diff = f"{css}<div class='diff-container'>{''.join(html)}</div>"
-    return html_diff, resumo, crit_txt
+    linhas = texto.split('\n')
+    texto_formatado = ""
+    for linha in linhas:
+        if "Análise Geral" in linha:
+            texto_formatado += f"### ℹ️ {linha.strip()}\n\n"
+        elif "Nota Final" in linha:
+            texto_formatado += f"### ⭐ {linha.strip()}\n\n"
+        elif "Pontos Positivos" in linha:
+            texto_formatado += f"### ✅ {linha.strip()}\n\n"
+        elif "Pontos a Melhorar" in linha:
+            texto_formatado += f"### ⚠️ {linha.strip()}\n\n"
+        elif "- Invenção de fatos" in linha:
+            texto_formatado += f"**🔴 {linha.strip()} (-5,0 pontos)**\n"
+        elif linha.strip().startswith('-') and any(termo in linha for termo in ["Endereçamento", "Qualificação", "Fatos", "Pedidos", "Valor", "Provas"]):
+            texto_formatado += f"**{linha.strip()}**\n"
+        elif "Explicação" in linha or "Sugestão" in linha or "Dica" in linha or "Exemplo" in linha:
+            texto_formatado += f"*{linha.strip()}*\n"
+        else:
+            texto_formatado += f"{linha}\n"
+    if "Nota Final" in texto_formatado:
+        import re
+        nota_pattern = r"### Nota Final.*?(\d+[.,]\d+|\d+)"
+        match = re.search(nota_pattern, texto_formatado, re.DOTALL)
+        if match:
+            nota = match.group(1)
+            texto_formatado = texto_formatado.replace(f"### ⭐ Nota Final\n\n{nota}", f"### ⭐ Nota Final: {nota}/10\n\n")
+    return texto_formatado
+
+def extrair_peticao_corrigida(correcao_completa):
+    try:
+        if "### Petição Corrigida" in correcao_completa:
+            inicio = correcao_completa.index("### Petição Corrigida") + len("### Petição Corrigida")
+            peticao_texto = correcao_completa[inicio:].strip()
+            fim = peticao_texto.find("###") if "###" in peticao_texto else len(peticao_texto)
+            return peticao_texto[:fim].strip()
+        return "⚠️ Seção '### Petição Corrigida' não encontrada."
+    except Exception as e:
+        logger.error(f"Erro ao extrair petição corrigida: {str(e)}")
+        return f"❌ Erro ao extrair petição: {str(e)}"
+
+def fornecer_dica_contextual(texto):
+    dicas = [f"💡 {chave}: {dica}" for chave, dica in DICAS_OAB_MELHORADO.items() if chave.lower() in texto.lower()]
+    return "\n".join(dicas) if dicas else "💡 Escreva mais para receber dicas."
 
 def calcular_progresso():
-    if not HISTORICO: return "📊 Nenhum progresso."
-    notas, tipos = [], set()
+    if not HISTORICO:
+        return "📊 Nenhum progresso registrado."
+    notas = []
     for entry in HISTORICO:
-        tipos.add(entry["tipo_peticao"])
-        m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
-        if m:
-            try: notas.append(float(m.group(1).replace(",", ".")))
-            except ValueError: pass
-    tot = len(HISTORICO); media = sum(notas)/len(notas) if notas else 0; tend = ""
-    if len(notas) > 1: tend = "⬆️" if notas[-1] > notas[-2] else ("⬇️" if notas[-1] < notas[-2] else "↔️")
-    return f"**📊 Resumo:** Corrs:{tot}, Tipos:{len(tipos)}, Média:{media:.1f}/10 ({len(notas)} val), Tend:{tend if tend else 'N/A'}"
-
-def mostrar_historico():
-    if not HISTORICO: return "📜 Histórico vazio."
-    md = "### 📜 Histórico (Últimas 10)\n---\n"
-    for i, entry in enumerate(reversed(HISTORICO)):
-        caso = (entry['caso'][:70] + '...') if len(entry['caso']) > 70 else entry['caso']
-        nota = "N/A"; m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
-        if m: nota = f"{m.group(1).replace(',', '.')}/10"
-        md += f"**{len(HISTORICO)-i}.** {entry['data']} | **{entry['tipo_peticao']}** | **Nota:{nota}**\n   **Caso:** _{caso}_\n---\n"
-    return md
-
-def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info("Salvando progresso...")
+        for line in entry["correcao_completa"].split("\n"):
+            if "Nota Final" in line:
+                try:
+                    nota = float(line.split()[-1].split("/")[0].replace(",", "."))
+                    notas.append(nota)
+                except:
+                    continue
+    media = sum(notas) / len(notas) if notas else 0
+    tendencia = "⬆️ Melhorando" if len(notas) > 1 and notas[-1] > notas[-2] else "⬇️ Estável ou piorando"
+    return f"📊 Progresso: Média {media:.1f}/10 | Tentativas: {len(notas)} | Tendência: {tendencia}"
+
+def comparar_peticao_melhorada(caso, peticao_texto, correcao):
+    if not caso:
+        return "⚠️ Forneça um caso antes de comparar.", "", "", "", ""
+    peticao = peticao_texto if peticao_texto else (HISTORICO[-1]["peticao"] if HISTORICO else "")
+    if not peticao:
+        return "⚠️ Forneça uma petição para comparar ou corrija uma antes.", "", "", "", ""
+    if not correcao:
+        return "⚠️ Corrija a petição antes de comparar.", "", "", "", ""
+    ultima_correcao = HISTORICO[-1]["correcao_completa"] if HISTORICO else ""
+    if not ultima_correcao:
+        return "⚠️ Nenhuma correção disponível no histórico.", "", "", "", ""
+
+    peticao_corrigida = extrair_peticao_corrigida(ultima_correcao)
+    if "⚠️" in peticao_corrigida or "❌" in peticao_corrigida:
+        return peticao_corrigida, "", "", "", ""
+
+    orig_lines = peticao.split('\n')
+    corr_lines = peticao_corrigida.split('\n')
+    start_orig = next((i for i, line in enumerate(orig_lines) if "AÇÃO" in line.upper() or "EXCELENTÍSSIMO" in line.upper()), 0)
+    start_corr = next((i for i, line in enumerate(corr_lines) if "AÇÃO" in line.upper() or "EXCELENTÍSSIMO" in line.upper()), 0)
+
+    orig_body = "\n".join(orig_lines[start_orig:]).strip()
+    corr_body = "\n".join(corr_lines[start_corr:]).strip()
+
+    diff = difflib.ndiff(orig_body.splitlines(), corr_body.splitlines())
+
+    resultado_diff = []
+    criticas = []
+    for linha in diff:
+        if linha.startswith('  '):
+            texto = linha[2:]
+            resultado_diff.append(f"<div class='linha-igual'>{escape(texto)}</div>")
+        elif linha.startswith('- '):
+            texto = linha[2:]
+            if any(kw in texto.lower() for kw in ["invenção", "custas", "art. 319"]):
+                criticas.append(f"🔴 REMOVIDO: {texto} (inconsistente ou incorreto)")
+            resultado_diff.append(f"<div class='linha-removida'><del>{escape(texto)}</del></div>")
+        elif linha.startswith('+ '):
+            texto = linha[2:]
+            if any(kw in texto.lower() for kw in ["custas", "art. 319"]):
+                criticas.append(f"🟢 ADICIONADO: {texto} (essencial para conformidade)")
+            resultado_diff.append(f"<div class='linha-adicionada'><ins>{escape(texto)}</ins></div>")
+        elif linha.startswith('? '):
+            continue
+
+    total_removidas = len([linha for linha in resultado_diff if "linha-removida" in linha])
+    total_adicionadas = len([linha for linha in resultado_diff if "linha-adicionada" in linha])
+
+    resumo_estatistico = f"""
+Linhas Removidas: {total_removidas}
+Linhas Adicionadas: {total_adicionadas}
+Diferença Líquida: {total_adicionadas - total_removidas} linhas
+"""
+
+    criticas_texto = "\n".join(criticas) if criticas else "Nenhuma mudança crítica detectada."
+
+    visualizacao_detalhada = f"""
+<style>
+.linha-igual {{ color: #000000; margin: 2px 0; }}
+.linha-removida {{ color: #ffffff; background-color: #b30000; margin: 2px 0; padding: 2px; }}
+.linha-adicionada {{ color: #ffffff; background-color: #006600; margin: 2px 0; padding: 2px; }}
+</style>
+{"".join(resultado_diff)}
+"""
+    return peticao, peticao_corrigida, resumo_estatistico, criticas_texto, visualizacao_detalhada
+
+def salvar_progresso(caso, peticao):
+    logger.info("Iniciando salvamento de progresso...")
+    logger.debug(f"Caso recebido: {caso[:100]}...")  # Log do caso (primeiros 100 caracteres)
+    logger.debug(f"Petição recebida: {peticao[:100]}...")  # Log da petição (primeiros 100 caracteres)
+
     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,"timestamp":datetime.now().isoformat()}
-        json_cont = json.dumps(dados, ensure_ascii=False, indent=4)
-        fname = f"progresso_peticao_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        fpath = os.path.join(tempfile.gettempdir(), fname)
-        with open(fpath, 'w', encoding='utf-8') as f: f.write(json_cont)
-        logger.info(f"Progresso salvo: {fpath}")
-        msg = f"✅ Salvo! Baixe `{fname}`."
-        return json_cont, msg, fpath
-    except Exception as e: logger.error(f"Erro salvar: {e}", exc_info=True); return "", f"❌ Erro salvar: {e}", None
+        # Verifica se os inputs estão vazios ou None
+        if not caso or not peticao:
+            logger.warning("Inputs vazios detectados: caso ou peticao estão vazios.")
+            return "", "⚠️ Caso ou petição estão vazios. Preencha ambos para salvar.", None
+
+        # Cria o conteúdo JSON como string
+        logger.debug("Gerando JSON content...")
+        json_content = json.dumps({"caso": caso, "peticao": peticao}, ensure_ascii=False, indent=4)
+        logger.debug(f"JSON content gerado: {json_content[:100]}...")
+
+        # Cria um arquivo temporário para salvar o JSON
+        logger.debug("Criando arquivo temporário...")
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json', prefix='progresso_', encoding='utf-8') as temp_file:
+            temp_file.write(json_content)
+            temp_file_path = temp_file.name
+        logger.debug(f"Arquivo temporário criado: {temp_file_path}")
+
+        # Mensagem de sucesso com instruções para download ou fallback
+        success_message = (
+            "✅ Progresso salvo! O download do arquivo `progresso.json` deve iniciar automaticamente. "
+            "Se o download não iniciar, copie o conteúdo abaixo e cole em um arquivo com extensão `.json` "
+            "(ex.: `progresso.json`). No celular, você pode copiar o texto, abrir um app de notas, colar o conteúdo, "
+            "e salvar como `progresso.json`. Use a opção 'Carregar Progresso' para restaurar."
+        )
+
+        logger.info("Progresso salvo com sucesso.")
+        return json_content, success_message, temp_file_path
+    except Exception as e:
+        logger.error(f"Erro ao salvar progresso: {str(e)}", exc_info=True)
+        return "", f"❌ Erro ao salvar o progresso: {str(e)}", None
 
 def carregar_progresso(arquivo_entrada):
-    logger.info("Carregando progresso...")
-    if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo."
-    try:
-        fpath = arquivo_entrada.name; logger.info(f"Carregando: {fpath}")
-        with open(fpath, 'r', encoding='utf-8') as f: dados = json.load(f)
-        caso, peticao, tipo = dados.get("caso"), dados.get("peticao"), dados.get("tipo_peticao")
-        if not all([caso, peticao, tipo]): return "", "", "", "❌ Arquivo inválido."
-        if tipo not in TIPOS_DE_PETICAO: return caso, peticao, "", f"⚠️ Tipo '{tipo}' inválido."
-        logger.info("Progresso carregado."); return tipo, caso, peticao, "✅ Progresso carregado!"
-    except Exception as e: logger.error(f"Erro carregar: {e}", exc_info=True); return "", "", "", f"❌ Erro carregar: {e}"
-
-def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
-    prompt = f"Crie caso fictício **detalhado e realista** p/ peça **'{tipo_peticao}'** (simulado OAB).\n**Geral:**\n1.Complexidade adequada (15-25l).\n2.Dados Essenciais (nomes,locais,datas,valores,relação,conflito).\n3.Coerência.\n4.Foco no Tipo Peça.\n**Específico '{tipo_peticao}':**\n"
-    if tipo_peticao == "Petição Inicial": prompt += "* Descreva violação. * Inclua danos. * Dados qualificação. * Tema: Consumo, Contrato, etc."
-    elif tipo_peticao == "Contestação": prompt += "* Resumo PI recebida. * Versão Réu (p/ prelim, impug, mérito). * Dados qualif réu."
-    elif tipo_peticao == "Reconvenção": prompt += "* Estrutura Contestação + Fatos/Fundamentos p/ pedido PRÓPRIO CONEXO do Réu contra Autor."
-    elif tipo_peticao == "Impugnação à Contestação": prompt += "* Resumo PI Autor. * Resumo Contestação Réu (prelim, fatos novos, docs). * Objetivo: Rebater."
-    elif tipo_peticao == "Embargos de Declaração": prompt += "* Breve caso. * TRECHO DECISÃO. * INDIQUE VÍCIO (omissão/contradição/obscuridade/erro material)."
-    elif tipo_peticao == "Recurso de Apelação": prompt += "* Caso original. * Resumo SENTENÇA. * ELEMENTOS ERRO (in judicando/procedendo). * Indique apelante."
-    elif tipo_peticao == "Agravo de Instrumento": prompt += "* Caso andamento. * DECISÃO INTERLOCUTÓRIA. * Enquadrar Art.1015/mitig. * ELEMENTOS ERRO + URGÊNCIA. * Indique agravante."
-    elif tipo_peticao == "Petição de Tutela Provisória": prompt += "* Situação URGENTE ou EVIDENTE. * ELEMENTOS: Urg=Fumus+Peric; Evid=Hipót Art.311. * Medida específica. * Antec/Incid."
-    else: prompt += "* Crie cenário cível com conflito."
-    prompt += f'\n**Finalize:**\n"**Situação-Problema:** Advogado(a) de [Nome Cliente], elabore a peça cabível ({tipo_peticao})."\n**Importante:** Temas comuns.'
-    return prompt
-
-def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    logger.info(f"Gerando caso para: {tipo_peticao}")
+    logger.info("Iniciando carregamento de progresso...")
     try:
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo válido."
-        prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-        caso_gerado = chamar_api(prompt)
-        if caso_gerado.startswith(("❌","⏱️","⚠️")): return f"⚠️ Falha gerar caso:\n{caso_gerado}"
-        frase = "**Situação-Problema:** Na qualidade de advogado(a) de"
-        if frase.lower() not in caso_gerado.lower():
-            logger.warning("Frase final não encontrada. Adicionando.")
-            nomes = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
-            cliente = nomes[0] if nomes else "[Cliente]"
-            caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente}, elabore a peça processual cabível ({tipo_peticao})."
-        logger.info("Caso gerado.")
-        return caso_gerado
-    except Exception as e: logger.exception("Erro gerar_caso:"); return f"❌ Erro gerar caso: {e}"
-
-def atualizar_config(temp, max_tokens):
-    CONFIG["temperatura"] = temp
-    CONFIG["max_tokens"] = max_tokens
-    logger.info(f"Configs: Temp={temp}, Max Tokens={max_tokens}")
-    return f"✅ Configs Atualizadas!"
+        with open(arquivo_entrada, 'r', encoding='utf-8') as f:
+            dados = json.load(f)
+        logger.info("Progresso carregado com sucesso.")
+        return dados.get("caso", ""), dados.get("peticao", ""), "Progresso carregado com sucesso."
+    except Exception as e:
+        logger.error(f"Erro ao carregar o progresso: {str(e)}")
+        return "", "", f"❌ Erro ao carregar o progresso: {str(e)}"
 
 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 ⚖️\nAnalise e aprimore suas peças processuais!")
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 📝 Corretor Avançado de Petições Iniciais (Critérios OAB)")
+        gr.Markdown("⚠️ Nota: Devido a limites da API, pode haver atrasos ou erros em muitas requisições rápidas.")
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("### ⚙️ Configs")
-                tipo_peticao_input = gr.Dropdown(label="1. Tipo Peça", choices=TIPOS_DE_PETICAO, value="Petição Inicial")
-                modo_treinamento = gr.Checkbox(label="🎓 Treinamento", value=False)
-                with gr.Accordion("🛠️ Opções IA", open=False):
-                    temperatura_slider = gr.Slider(0.0, 1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
-                    max_tokens_slider = gr.Slider(2048, 8192, value=CONFIG["max_tokens"], step=256, label="Max Tokens")
-                    config_update_btn = gr.Button("💾 Salvar Configs")
-                    config_status = gr.Textbox(label="Status", interactive=False, lines=1)
-                with gr.Accordion("📊 Dashboard", open=False):
-                    progresso_output = gr.Markdown("*Atualize...*")
-                    progresso_btn = gr.Button("🔄 Progresso")
-                with gr.Accordion("📜 Histórico", open=False):
-                    historico_output = gr.Markdown("*Atualize...*")
-                    historico_btn = gr.Button("🔄 Histórico")
-                with gr.Accordion("💾📂 Salvar/Carregar", open=False):
-                     salvar_btn = gr.Button("💾 Salvar")
-                     carregar_btn = gr.Button("📂 Carregar")
-                     arquivo_progresso_upload = gr.File(label=".json", file_types=[".json"])
-                     progresso_download_file = gr.File(label="Baixar", interactive=False)
-            with gr.Column(scale=3):
-                gr.Markdown("### 1. Caso / Contexto")
+                gr.Markdown("""
+                ### 🔍 Critérios de Avaliação
+                - ✅ Endereçamento correto (Art. 319, I, CPC)
+                - ✅ Qualificação das partes (Art. 319, II, CPC)
+                - ✅ Fatos e fundamentos (Art. 319, III, CPC)
+                - ✅ Pedidos claros e específicos (Art. 319, IV, CPC)
+                - ✅ Valor da causa (Art. 319, V, CPC)
+                - ✅ Provas pretendidas (Art. 319, VI, CPC)
+                - ✅ Opção sobre conciliação (Art. 319, VII, CPC)
+                - ✅ Pedido de citação adequado
+                - ✅ Juntada da guia de custas
+                - ✅ Fechamento formal
+                ### ⚖️ Penalizações
+                - ❌ Identificação do candidato: nota máxima 3,0
+                - ❌ Invenção de fatos: -5,0 pontos
+                - ❌ Sem pedido de custas: -1,0 ponto
+                - ❌ Identificação específica na OAB: nota 0,0
+                """)
+                modo_treinamento = gr.Checkbox(label="Modo de Treinamento Interativo", value=False)
+                with gr.Accordion("⚙️ Configurações", open=False):
+                    temperatura_slider = gr.Slider(minimum=0.0, maximum=1.0, value=CONFIG["temperatura"], step=0.1, label="Temperatura")
+                    timeout_slider = gr.Slider(minimum=30, maximum=120, value=CONFIG["timeout"], step=5, label="Timeout (segundos)")
+                    def atualizar_config(temp, timeout):
+                        CONFIG["temperatura"] = temp
+                        CONFIG["timeout"] = timeout
+                        return f"✅ Configurações atualizadas!"
+                    config_update_btn = gr.Button("📝 Atualizar Configurações")
+                    config_status = gr.Textbox(label="Status", visible=True)
+                    config_update_btn.click(atualizar_config, inputs=[temperatura_slider, timeout_slider], outputs=config_status)
+                with gr.Accordion("📊 Dashboard de Progresso", open=False):
+                    progresso_output = gr.Markdown()
+                    progresso_btn = gr.Button("🔄 Atualizar Progresso")
+                    progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
+
+            with gr.Column(scale=2):
                 with gr.Row():
-                     caso_input = gr.Textbox(label="📋 Caso", lines=8, placeholder="Insira o texto do caso...")
-                     caso_btn = gr.Button("🎲 Gerar", variant="secondary", scale=0)
-                gr.Markdown("### 2. Sua Peça")
+                    gr.Markdown("### 🧩 Gerar Caso Fictício")
+                    caso_btn = gr.Button("🔄 Gerar Novo Caso Fictício", variant="secondary")
+                caso_input = gr.Textbox(label="📋 Caso Fornecido pela Banca", lines=8, placeholder="Insira o texto COMPLETO do caso...")
                 with gr.Tabs():
-                    with gr.TabItem("✏️ Texto"):
-                        peticao_texto_input = gr.Textbox(label="Texto", lines=12, placeholder="Cole ou digite...")
-                        dica_contextual_output = gr.Markdown("*Dicas...*")
-                        btn_corrigir = gr.Button("🚀 CORRIGIR!", variant="primary")
-                    with gr.TabItem("📎 Arquivo"):
-                        peticao_arquivo_input = gr.File(label="Arquivo (.pdf,.docx,.txt)", file_types=[".pdf",".docx",".txt"])
-                        arquivo_preview_output = gr.Textbox(label="🔍 Prévia", lines=4, interactive=False)
-                        btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR ARQUIVO!", variant="primary")
-
-        processing_message = gr.Markdown("", visible=False)
-        gr.Markdown("--- \n ### 3. Resultados")
-        with gr.Tabs():
-             with gr.TabItem("📊 Análise e Correção"):
-                  resultado_analise_output = gr.Markdown(label="Análise e Nota")
-                  resultado_peticao_corrigida_output = gr.Textbox(label="✨ Versão Sugerida", lines=18, show_copy_button=True)
-             with gr.TabItem("⚖️ Comparativo"):
-                  gr.Markdown("### ↔️ Comparativo (Diff)")
-                  with gr.Row():
-                       with gr.Column(scale=1): resumo_alteracoes_output = gr.Markdown(label="Resumo"); criticas_output = gr.Markdown(label="Críticas")
-                       with gr.Column(scale=3): visualizacao_detalhada_output = gr.HTML(label="Detalhes")
-        clear_btn = gr.Button("🗑️ Limpar Tudo")
-
-        caso_btn.click(lambda: gr.update(value="⏳ Gerando...", visible=True), outputs=processing_message).then(
-             fn=gerar_caso_ficticio, inputs=[tipo_peticao_input], outputs=[caso_input]
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
-
-        peticao_texto_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
-        tipo_peticao_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
-        peticao_arquivo_input.change(process_file, [peticao_arquivo_input], [arquivo_preview_output])
-
-        btn_corrigir.click(lambda: gr.update(value="⏳ Processando texto...", visible=True), outputs=processing_message).then(
-            fn=corrigir_peticao,
-            inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None), modo_treinamento],
-            outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            concurrency_limit=1
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
-
-        btn_corrigir_arquivo.click(lambda: gr.update(value="⏳ Processando arquivo...", visible=True), outputs=processing_message).then(
-            fn=corrigir_peticao,
-            inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input, modo_treinamento],
-            outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            concurrency_limit=1
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
-
-        config_update_btn.click(atualizar_config, [temperatura_slider, max_tokens_slider], config_status)
-        progresso_btn.click(calcular_progresso, outputs=progresso_output)
-        historico_btn.click(mostrar_historico, outputs=historico_output)
-
-        salvar_btn.click(lambda: gr.update(value="⏳ Salvando...", visible=True), outputs=processing_message).then(
-             fn=salvar_progresso, inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
-        ).then(lambda x: gr.update(visible=bool(x)), [progresso_download_file], [progresso_download_file]
-        ).then(lambda: gr.update(value="", visible=False), None, processing_message)
-
-        carregar_btn.click(lambda: gr.update(value="⏳ Carregando...", visible=True), outputs=processing_message).then(
-             fn=carregar_progresso, inputs=[arquivo_progresso_upload],
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
-         ).then(lambda: gr.update(value="", visible=False), None, processing_message)
+                    with gr.TabItem("✏️ Inserir Texto"):
+                        peticao_texto = gr.Textbox(label="Texto da Petição do Aluno", lines=15, placeholder="Insira a petição completa...")
+                        dica_contextual = gr.Textbox(label="Dicas Contextuais", interactive=False)
+                        peticao_texto.change(fn=fornecer_dica_contextual, inputs=peticao_texto, outputs=dica_contextual)
+                        btn_texto = gr.Button("🔍 Corrigir Petição (Texto)", variant="primary")
+                    with gr.TabItem("📎 Enviar Arquivo"):
+                        gr.Markdown("**Envie um arquivo PDF, DOCX ou TXT contendo a petição do aluno.**")
+                        peticao_arquivo = gr.File(label="Arquivo da Petição", file_types=[".pdf", ".docx", ".txt"])
+                        arquivo_preview = gr.Textbox(label="Prévia do Conteúdo do Arquivo", lines=5, interactive=False)
+                        btn_arquivo = gr.Button("🔍 Corrigir Petição (Arquivo)", variant="primary")
+                        peticao_arquivo.change(fn=process_file, inputs=[peticao_arquivo], outputs=[arquivo_preview])
+                processing_message = gr.Markdown("", visible=False)
+
+        with gr.Row():
+            clear_btn = gr.Button("🗑️ Limpar Todos os Campos")
+            comparar_btn = gr.Button("⚖️ Comparar com Correção")
+            salvar_btn = gr.Button("💾 Salvar Progresso")
+            carregar_btn = gr.Button("📂 Carregar Progresso")
+            arquivo_progresso = gr.File(label="Arquivo de Progresso", file_types=[".json"])
+
+        resultado_output = gr.Markdown(label="📊 Correção Oficial e Nota", show_copy_button=True)
+
+        # Componentes para exibir o progresso salvo
+        progresso_json_output = gr.Textbox(label="Progresso Salvo (JSON)", lines=5, interactive=False, visible=False)
+        progresso_download_file = gr.File(label="Download do Progresso", visible=False)
 
+        with gr.Row():
+            peticao_aluno_output = gr.Textbox(label="Petição do Aluno", lines=15, interactive=False)
+            peticao_corrigida_output = gr.Textbox(label="Petição Corrigida", lines=15, interactive=False)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                resumo_alteracoes_output = gr.Markdown(label="📊 Resumo das Alterações")
+                criticas_output = gr.Markdown(label="🚨 Mudanças Críticas")
+            with gr.Column(scale=2):
+                visualizacao_detalhada_output = gr.HTML(label="📝 Alterações Detalhadas")
+
+        with gr.Accordion("📜 Histórico de Correções", open=False):
+            historico_output = gr.Markdown()
+            historico_btn = gr.Button("🔄 Ver Histórico")
+            historico_btn.click(
+                fn=lambda: "\n\n".join([f"**{h['data']}**\nCaso: {h['caso'][:100]}...\nCorreção: {h['correcao_completa'][:100]}..." for h in HISTORICO]),
+                outputs=historico_output
+            )
+
+        caso_btn.click(fn=gerar_caso_ficticio, inputs=[], outputs=[caso_input])
+        btn_texto.click(
+            fn=lambda: gr.update(value="⏳ Aguarde enquanto a correção é gerada...", visible=True),
+            inputs=None,
+            outputs=[processing_message]
+        ).then(
+            fn=lambda caso, texto, treinamento: corrigir_peticao(caso, texto, None, treinamento),
+            inputs=[caso_input, peticao_texto, modo_treinamento],
+            outputs=[resultado_output]
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            inputs=None,
+            outputs=[processing_message]
+        )
+        btn_arquivo.click(
+            fn=lambda: gr.update(value="⏳ Aguarde enquanto a correção é gerada...", visible=True),
+            inputs=None,
+            outputs=[processing_message]
+        ).then(
+            fn=lambda caso, arquivo, treinamento: corrigir_peticao(caso, None, arquivo, treinamento),
+            inputs=[caso_input, peticao_arquivo, modo_treinamento],
+            outputs=[resultado_output]
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            inputs=None,
+            outputs=[processing_message]
+        )
         clear_btn.click(
-            fn=lambda: ["Petição Inicial", False, None, None, None, None, "*Dicas...*", "", "", "", "", "", None, None, ""],
-            outputs=[tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
-                     arquivo_preview_output, dica_contextual_output, resultado_analise_output, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output,
-                     arquivo_progresso_upload, progresso_download_file, config_status]
+            fn=lambda: [None, None, None, None, "", "", "", "", "", gr.update(visible=False), gr.update(visible=False)],
+            inputs=None,
+            outputs=[caso_input, peticao_texto, peticao_arquivo, arquivo_preview, resultado_output, dica_contextual,
+                     peticao_aluno_output, peticao_corrigida_output, resumo_alteracoes_output, criticas_output,
+                     visualizacao_detalhada_output, progresso_json_output, progresso_download_file, processing_message]
         )
+        comparar_btn.click(
+            fn=comparar_peticao_melhorada,
+            inputs=[caso_input, peticao_texto, resultado_output],
+            outputs=[peticao_aluno_output, peticao_corrigida_output, resumo_alteracoes_output, criticas_output,
+                     visualizacao_detalhada_output]
+        )
+        salvar_btn.click(
+            fn=lambda: gr.update(value="⏳ Salvando progresso...", visible=True),
+            inputs=None,
+            outputs=[processing_message]
+        ).then(
+            fn=lambda caso, peticao: salvar_progresso(caso, peticao),
+            inputs=[caso_input, peticao_texto],
+            outputs=[progresso_json_output, resultado_output, progresso_download_file]
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            inputs=None,
+            outputs=[processing_message]
+        ).then(
+            fn=lambda: gr.update(visible=True),
+            inputs=None,
+            outputs=[progresso_json_output, progresso_download_file]
+        )
+        carregar_btn.click(
+            fn=lambda arquivo: carregar_progresso(arquivo.name),
+            inputs=[arquivo_progresso],
+            outputs=[caso_input, peticao_texto, resultado_output]
+        )
+
+        with gr.Accordion("📘 Critérios Detalhados", open=False):
+            gr.Markdown("""
+            ### 📋 Critérios Realistas para Correção
+            #### 1. Qualificação das Partes (Art. 319, II, CPC)
+            - ✅ CORRETO: Usar "Rua XXXX" se endereço não for fornecido
+            - ❌ INCORRETO: Inventar dados
+            #### 2. Citação
+            - ✅ CORRETO: Pedir citação conforme dados do caso
+            #### 3. Pedidos Obrigatórios
+            - ✅ OBRIGATÓRIO: Incluir "a juntada da guia de custas"
+            #### 4. Fechamento Formal
+            - ✅ OBRIGATÓRIO: Finalizar com "Local e data.\nADVOGADO.\nOAB." sem identificação específica
+            #### 5. Penalização Grave
+            - ❌ INCORRETO: Identificação do candidato (nome ou número)
+            - ❌ INCORRETO: Invenção de fatos
+            - ❌ INCORRETO: Identificação na OAB (número ou estado)
+            """)
+        gr.Markdown("""
+        ### ℹ️ Modo de Treinamento Interativo
+        Ative para explicações detalhadas com exemplos e sugestões.
+        ### 📋 Como usar
+        1. Gere ou cole o caso
+        2. Insira a petição
+        3. Corrija e compare
+        ### 📄 Formatos suportados
+        - PDF (texto e escaneados com OCR)
+        - DOCX
+        - TXT
+        """)
+
     return demo
 
-if __name__ == "__main__":
-    logger.info("Iniciando a aplicação Gradio...")
-    app = interface_gradio()
-    app.launch()
-    logger.info("Aplicação Gradio encerrada.")
+def gerar_caso_ficticio():
+    prompt = estruturar_prompt_geracao_caso()
+    return chamar_api(prompt)
+
+def estruturar_prompt_geracao_caso():
+    return """
+    Crie um caso fictício detalhado para uma petição inicial cível, similar ao exemplo:
+    "Ana, modelo profissional, residente em Manaus, viajou para São Paulo, para o casamento de sua filha. Para lavar, pintar seus cabelos e realizar um penteado para o casamento, Ana procurou os serviços de João Macedo, cabeleireiro e dono do salão de beleza 'Hair', sediado na cidade de São Paulo, que lhe cobrou R$500,00 (quinhentos reais) pela prestação do serviço. Após lavar os cabelos de Ana, João aplicou-lhe uma tintura da marca francesa ABC, importada pela empresa Brasil Connection Ltda, sediada na cidade de Curitiba (PR). Meia hora após a aplicação da tintura, Ana sofreu uma reação alérgica, que demandou atendimento médico-hospitalar, no valor de R$1.000,00 (um mil reais), bem como dois dias de absoluto repouso que impossibilitou sua presença no casamento de sua filha. Além disso, perdeu grande parte de seu cabelo, tendo permanecido com manchas em seu rosto por dois meses, perdendo um ensaio fotográfico, para o qual já havia sido contratada, pelo valor de R$50.000,00 (cinquenta mil reais). Posteriormente constatou-se que a tintura utilizada continha substâncias químicas extremamente perigosas à vida e à saúde das pessoas e a fabricante ABC já havia sido condenada pela justiça francesa a encerrar a fabricação e comercialização do produto. Indignada com os danos sofridos, Ana procura um advogado para pleitear o devido ressarcimento."
+    O caso deve:
+    1. Conter uma violação clara de direitos que justifique uma ação cível
+    2. Incluir valores específicos de danos materiais e/ou morais
+    3. Mencionar nomes completos, cidades e informações para identificar as partes
+    4. Estabelecer relação entre as partes (contratual, consumo, etc.)
+    5. Ter complexidade adequada para uma petição inicial de nível OAB
+    6. Ter entre 15-25 linhas
+    7. Focar em um tema aleatório: responsabilidade civil por acidente de consumo, inadimplemento contratual, dano ambiental, direitos da personalidade, vício de produto/serviço, ou danos patrimoniais
+    Termine com: "Situação problema: Como advogado(a) de [NOME DO CLIENTE], promova a demanda cabível."
+    """
+
+def validar_peticao_basica(peticao):
+    problemas = []
+    if "EXCELENTÍSSIMO" not in peticao.upper():
+        problemas.append("⚠️ Endereçamento ausente ou incompleto (Art. 319, I, CPC).")
+    if "Art. 319" not in peticao and "CPC" not in peticao:
+        problemas.append("⚠️ Fundamentação jurídica não menciona o CPC (Art. 319).")
+    if "Dá-se à causa o valor" not in peticao:
+        problemas.append("⚠️ Valor da causa não especificado (Art. 319, V, CPC).")
+    if "juntada da guia de custas" not in peticao.lower():
+        problemas.append("⚠️ Pedido de juntada da guia de custas ausente (-1,0 ponto).")
+    if "Nestes termos" not in peticao:
+        problemas.append("⚠️ Fechamento formal ausente.")
+    return problemas
+
+app = interface_gradio()
+app.launch()