Update app.py

app.py

@@ -7,35 +7,21 @@ import json
 import logging
 from typing import Dict, List, Optional, Union, Tuple, Any
 
-# --- Configuração de Logging ---
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
-)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
 logger = logging.getLogger(__name__)
 
-# --- Configuração da API Gemini ---
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-if not GEMINI_API_KEY:
-    logger.warning("ALERTA: GEMINI_API_KEY não encontrada como Secret no Hugging Face Space ou variável de ambiente.")
-    logger.warning("A aplicação não funcionará corretamente sem ela.")
-    # Para teste local:
-    # GEMINI_API_KEY = "SUA_CHAVE_AQUI"
-
-MODEL_NAME = "gemini-1.5-flash-latest" 
+MODEL_NAME = "gemini-1.5-flash-latest"
 API_URL_BASE = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL_NAME}:generateContent"
 
-# --- Constantes e configurações ---
 class Config:
     MAX_RETRIES = 1
-    REQUEST_TIMEOUT = 360 # Aumentado um pouco mais
+    REQUEST_TIMEOUT = 360
     DEFAULT_TEMPERATURE = 0.75
-    PETICAO_MAX_TOKENS = 2000
-    CONTESTACAO_MAX_TOKENS = 2000
-    AIJ_MAX_TOKENS = 5000 # Para AIJ detalhada
+    PETICAO_MAX_TOKENS = 2200 # Aumentado
+    CONTESTACAO_MAX_TOKENS = 2200 # Aumentado
+    AIJ_MAX_TOKENS = 6000 # Aumentado significativamente para AIJ completa e detalhada
 
-    # Marcadores para parsear as peças e a AIJ
     PETICAO_MARKERS_MAP = {
         "fatos_autor": "### DOS FATOS (Narrativa do Autor)",
         "direito_autor": "### DO DIREITO (Principais Fundamentos Jurídicos)",
@@ -44,7 +30,8 @@ class Config:
     }
     CONTESTACAO_MARKERS_MAP = {
         "sintese_reu": "### SÍNTESE DA DEFESA",
-        "fatos_reu": "### DA REALIDADE DOS FATOS (Narrativa do Réu)",
+        "preliminares_reu": "### PRELIMINARES", # Adicionado para parsing explícito
+        "fatos_reu": "### DA REALIDADE DOS FATOS (Narrativa do Réu e Impugnação Específica)",
         "direito_reu": "### DO DIREITO (Principais Fundamentos da Defesa)",
         "pedidos_reu": "### DOS PEDIDOS (Contrapedidos/Impugnações)",
         "estrategias_reu": "### PONTOS ESTRATÉGICOS ADICIONAIS PARA O RÉU"
@@ -61,514 +48,269 @@ class Config:
         "9_cenarios": "### 9. ANÁLISE DE CENÁRIOS E PONTOS DE INFLEXÃO"
     }
 
-# --- Dados do Caso Padrão ---
 class CasoPadrao:
-    RESUMO = """
-    Carlos Alberto Mendes processou o jornal "A Verdade Diária" por violação do direito ao esquecimento.
-    Há 15 anos, Carlos foi acusado de fraude em um caso de grande repercussão local, mas foi absolvido por falta de provas.
-    Recentemente, o jornal publicou uma matéria retrospectiva intitulada "Crimes que Marcaram a Cidade", que revisitou o caso de Carlos, mencionando sua absolvição, mas detalhando as acusações originais.
-    Carlos alega que a matéria, apesar de mencionar a absolvição, reacendeu o estigma, prejudicou sua reputação, dificultou a obtenção de novo emprego e causou-lhe profundo abalo emocional e constrangimento social.
-    Ele busca a remoção da matéria online e indenização por danos morais.
-    O jornal defende a liberdade de imprensa, o interesse público histórico da matéria e a veracidade dos fatos reportados, incluindo a absolvição.
-    """
-    AUTOR_PONTOS = """
-    1. Dano à honra e imagem pela reexposição de caso antigo superado. Prova: Laudo psicológico, prints de comentários online.
-    2. Sofrimento psicológico e constrangimento social. Prova: Depoimento de amigos/familiares.
-    3. Prejuízo profissional e dificuldades de reinserção. Prova: Cartas de recusa de emprego (se houver), depoimento sobre oportunidades perdidas.
-    4. Direito ao esquecimento como proteção da dignidade da pessoa humana e direito à privacidade (Art. 5º, X, CF).
-    5. Irrelevância atual da notícia, considerando o lapso temporal e a absolvição.
-    """
-    REU_PONTOS = """
-    1. Liberdade de imprensa (Art. 5º, IX, XIV, e Art. 220 CF) e direito à informação da sociedade.
-    2. Matéria de interesse público histórico e cultural, narrando fatos verídicos e de relevância para a memória coletiva.
-    3. Menção clara e inequívoca à absolvição do autor na matéria, afastando má-fé.
-    4. Ausência de intenção de difamar (animus narrandi).
-    5. Precedente do STF (RE 1.010.606) que pondera o direito ao esquecimento com a liberdade de expressão e informação, não o reconhecendo como absoluto.
-    Provas: Cópia da matéria publicada, documentos do processo original (públicos), parecer de historiador sobre a relevância do caso.
-    """
+    RESUMO = """Carlos Alberto Mendes processou o jornal "A Verdade Diária" por violação do direito ao esquecimento. Há 15 anos, Carlos foi absolvido de fraude. Recentemente, o jornal revisitou o caso numa matéria retrospectiva, mencionando a absolvição. Carlos alega danos (reputação, emprego, emocional) e pede remoção e indenização. O jornal defende liberdade de imprensa, interesse público histórico e veracidade."""
+    AUTOR_PONTOS = """1. Dano à honra e imagem. Prova: Laudo psicológico. 2. Sofrimento social. Prova: Depoimentos. 3. Prejuízo profissional. 4. Direito ao esquecimento (Art. 5º, X, CF; Enunciado 531). 5. Irrelevância atual da notícia."""
+    REU_PONTOS = """1. Liberdade de imprensa (Art. 5º, IX, XIV, 220 CF). 2. Interesse público histórico. 3. Menção à absolvição. 4. Animus narrandi. 5. Precedente STF (RE 1.010.606). Provas: Cópia da matéria, docs. processo original."""
 
-# Variável global para armazenar os textos completos para exportação/cópia
 _peticao_completa_exportar = ""
 _contestacao_completa_exportar = ""
 _aij_texto_completo_para_exportar = ""
 
-# --- Classe para Chamadas à API Gemini ---
 class GeminiAPI:
     @staticmethod
     def chamar_api(prompt_text: str, temperature: float = Config.DEFAULT_TEMPERATURE, 
                   max_output_tokens: int = 1500, retries: int = Config.MAX_RETRIES) -> str:
-        # ... (Implementação robusta da chamar_api como na resposta anterior) ...
         if not GEMINI_API_KEY:
             logger.error("ERRO_FATAL: API Key do Gemini não configurada.")
             return "ERRO_FATAL: API Key do Gemini não configurada."
-            
         api_url_com_chave = f"{API_URL_BASE}?key={GEMINI_API_KEY}"
         headers = {'Content-Type': 'application/json'}
-        data = {
-            "contents": [{"parts": [{"text": prompt_text}]}],
-            "generationConfig": {
-                "temperature": temperature, 
-                "maxOutputTokens": max_output_tokens, 
-                "topP": 0.95, 
-                "topK": 40
-            },
-            "safetySettings": [
-                {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-                {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-                {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
-                {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"}
-            ]
-        }
-        
-        attempts = 0
-        while attempts <= retries:
+        data = {"contents": [{"parts": [{"text": prompt_text}]}],
+                "generationConfig": {"temperature": temperature, "maxOutputTokens": max_output_tokens, "topP": 0.95, "topK": 40},
+                "safetySettings": [{"category": f"HARM_CATEGORY_{cat}", "threshold": "BLOCK_NONE"} for cat in ["HARASSMENT", "HATE_SPEECH", "SEXUALLY_EXPLICIT", "DANGEROUS_CONTENT"]]}
+        for attempt in range(retries + 1):
             try:
-                logger.info(f"Chamando API Gemini (tentativa {attempts+1}/{retries+1}) para prompt de {len(prompt_text)} caracteres, max_tokens: {max_output_tokens}")
-                
-                response = requests.post(
-                    api_url_com_chave, 
-                    headers=headers, 
-                    data=json.dumps(data), 
-                    timeout=Config.REQUEST_TIMEOUT
-                ) 
+                logger.info(f"API Gemini: Tentativa {attempt+1}/{retries+1}, Prompt: {len(prompt_text)} chars, Max Tokens: {max_output_tokens}")
+                response = requests.post(api_url_com_chave, headers=headers, json=data, timeout=Config.REQUEST_TIMEOUT)
                 response.raise_for_status()
                 response_json = response.json()
-
-                if response_json.get("candidates") and \
-                   isinstance(response_json["candidates"], list) and \
-                   len(response_json["candidates"]) > 0 and \
-                   response_json["candidates"][0].get("content") and \
-                   isinstance(response_json["candidates"][0]["content"].get("parts"), list) and \
-                   len(response_json["candidates"][0]["content"]["parts"]) > 0:
-                    
+                if response_json.get("candidates") and response_json["candidates"][0].get("content"):
                     generated_text = response_json["candidates"][0]["content"]["parts"][0].get("text", "").strip()
                     logger.info(f"API Gemini retornou {len(generated_text)} caracteres.")
-                    
                     finish_reason = response_json["candidates"][0].get("finishReason", "")
                     if finish_reason == "MAX_TOKENS":
                         logger.warning("Geração da API interrompida por MAX_TOKENS.")
-                        generated_text += "\n\n[AVISO: A IA pode ter interrompido a geração aqui devido ao limite de tokens de saída.]"
-                    elif finish_reason not in ["STOP", "OTHER", None]: # OTHER e None às vezes são usados para stop normal
-                         logger.warning(f"Geração da API terminou com razão incomum: {finish_reason}")
-                    
+                        generated_text += "\n\n[AVISO: Geração interrompida por limite de tokens.]"
+                    elif finish_reason not in ["STOP", "OTHER", None]:
+                         logger.warning(f"Geração da API terminou com razão: {finish_reason}")
                     return generated_text
-                    
                 elif response_json.get("promptFeedback"):
-                    block_reason = response_json["promptFeedback"].get("blockReason", "Não especificada")
-                    safety_ratings_str = str(response_json["promptFeedback"].get("safetyRatings", {}))
-                    error_detail = f"Razão do bloqueio: {block_reason}. Classificações de segurança: {safety_ratings_str}"
-                    logger.error(f"Conteúdo bloqueado pela API. {error_detail}")
-                    return f"ERRO_API: Conteúdo bloqueado pela API. {error_detail}"
-                
-                logger.error(f"Resposta inesperada ou malformada da API: {response_json}")
-                return "ERRO_API: Resposta inesperada ou malformada da API Gemini."
-
+                    feedback = response_json["promptFeedback"]
+                    error_detail = f"Bloqueio: {feedback.get('blockReason', 'N/A')}. Safety: {feedback.get('safetyRatings', 'N/A')}"
+                    logger.error(f"API: Conteúdo bloqueado. {error_detail}")
+                    return f"ERRO_API: Conteúdo bloqueado. {error_detail}"
+                logger.error(f"API: Resposta inesperada/vazia. JSON: {response_json}")
+                return "ERRO_API: Resposta inesperada/vazia da API."
             except requests.exceptions.Timeout:
-                logger.error(f"Timeout na tentativa {attempts+1} ao chamar a API Gemini.")
-                attempts += 1
-                if attempts > retries:
-                    return "ERRO_CONEXAO: Timeout excedido após múltiplas tentativas."
-                logger.info(f"Tentando novamente ({attempts+1}/{retries+1})...")
-                
+                logger.error(f"API: Timeout na tentativa {attempt+1}.")
+                if attempt == retries: return "ERRO_CONEXAO: Timeout excedido."
             except requests.exceptions.RequestException as e:
-                error_msg = f"ERRO_CONEXAO: {e}"
-                if e.response is not None:
-                    try:
-                        error_details = e.response.json().get('error', {}).get('message', e.response.text)
-                        error_msg += f" - Detalhes: {error_details}"
-                    except json.JSONDecodeError:
-                        error_msg += f" - Resposta não JSON: {e.response.text}"
-                logger.error(error_msg)
-                return error_msg 
-                
+                logger.error(f"API: Erro na requisição (tentativa {attempt+1}): {e}", exc_info=True)
+                if attempt == retries: return f"ERRO_CONEXAO: {e}"
             except Exception as e:
-                logger.exception(f"Erro desconhecido na API na tentativa {attempts+1}: {e}")
-                attempts += 1
-                if attempts > retries:
-                    return f"ERRO_DESCONHECIDO: {e}"
-        return "ERRO_API: Todas as tentativas de chamada à API falharam."
+                logger.exception(f"API: Erro desconhecido (tentativa {attempt+1}): {e}")
+                if attempt == retries: return f"ERRO_DESCONHECIDO: {e}"
+        return "ERRO_API: Todas as tentativas falharam."
 
-# --- Classes para geração de documentos ---
 class GeradorDocumentos:
     @staticmethod
-    def gerar_peticao_inicial(resumo_caso: str, pontos_autor: str) -> str:
-        prompt = f"""
-        **Persona:** Você é um advogado experiente e meticuloso, especializado em casos de Direitos da Personalidade e Responsabilidade Civil, redigindo os elementos chave de uma Petição Inicial para um caso de Direito ao Esquecimento vs. Liberdade de Imprensa.
-        **Caso:**
-        {resumo_caso}
-        **Principais Pontos e Provas do Autor (use-os para fundamentar a petição; se não fornecidos, infira do resumo do caso, focando em elementos que sustentem o pedido de esquecimento):**
-        {pontos_autor if pontos_autor else "Inferir do resumo do caso, focando nos danos alegados e na ausência de interesse público atual na informação."}
-
-        **Tarefa:** Gere os seguintes tópicos para uma Petição Inicial da parte AUTORA, de forma clara, objetiva e juridicamente fundamentada:
-        1.  **DOS FATOS (Narrativa do Autor):** (Descreva os fatos sob a ótica do autor, detalhando a publicação original, a absolvição, o lapso temporal, a republicação/nova matéria, e o impacto negativo específico e comprovável na vida do autor – profissional, social, emocional. Enfatize a desatualização da informação e a ausência de interesse público contemporâneo que justifique a nova exposição).
-        2.  **DO DIREITO (Principais Fundamentos Jurídicos):** (Cite e explique brevemente 3-4 fundamentos legais/constitucionais, como:
-            *   Dignidade da Pessoa Humana (Art. 1º, III, CF) como base para o direito ao esquecimento.
-            *   Direito à Privacidade, Intimidade, Honra e Imagem (Art. 5º, X, CF).
-            *   Direito ao Esquecimento (construção doutrinária e jurisprudencial, citar Enunciado 531 da VI Jornada de Direito Civil se pertinente).
-            *   Responsabilidade Civil por Dano Moral (Art. 186, 187 e 927 do Código Civil), explicando o ato ilícito (republicação indevida), o dano e o nexo causal.
-            *   Ponderação de direitos: argumentar por que, no caso concreto, o direito ao esquecimento/privacidade do autor deve prevalecer sobre a liberdade de imprensa, dada a ausência de interesse público atual e o dano causado).
-        3.  **DOS PEDIDOS:** (Liste os pedidos principais do autor de forma clara e específica:
-            *   Tutela de urgência para remoção imediata da matéria (se aplicável).
-            *   Confirmação da tutela e remoção definitiva da matéria de todas as plataformas do réu.
-            *   Condenação do réu ao pagamento de indenização por danos morais (sugerir um valor ou critério, justificando-o com base na extensão do dano, capacidade econômica do réu e caráter punitivo-pedagógico).
-            *   (Opcional) Publicação de direito de resposta ou retratação.
-            *   Condenação do réu em custas processuais e honorários advocatícios).
-        4.  **PONTOS ESTRATÉGICOS ADICIONAIS PARA O AUTOR:** (Sugira brevemente:
-            *   Outras linhas de argumentação (ex: abuso de direito do veículo de imprensa).
-            *   Tipos de provas adicionais cruciais (ex: perícia em prints para comprovar alcance, mais depoimentos específicos sobre o dano).
-            *   Principais contrapontos da defesa a serem antecipados e como refutá-los).
-
-        **Formato da Saída:**
-        Use os seguintes marcadores EXATOS para cada seção, iniciando em nova linha:
-        `{Config.PETICAO_MARKERS_MAP["fatos_autor"]}`
-        `{Config.PETICAO_MARKERS_MAP["direito_autor"]}`
-        `{Config.PETICAO_MARKERS_MAP["pedidos_autor"]}`
-        `{Config.PETICAO_MARKERS_MAP["estrategias_autor"]}`
-
-        O conteúdo de cada seção deve vir após o marcador. Seja completo e detalhado dentro de cada seção.
-        """
-        return GeminiAPI.chamar_api(
-            prompt, 
-            temperature=Config.DEFAULT_TEMPERATURE, 
-            max_output_tokens=Config.PETICAO_MAX_TOKENS
-        )
+    def gerar_peticao_inicial(resumo_caso: str, pontos_autor: str, modificacao_fato: Optional[str], abordagem_autor: str) -> str:
+        mod_prompt = f"\n**Modificação Fato:** {modificacao_fato}\n" if modificacao_fato else ""
+        ab_prompt = f"\n**Abordagem Autor:** {abordagem_autor}\n"
+        prompt = f"""**Persona:** Advogado experiente (Direitos da Personalidade), redigindo Petição Inicial (Esquecimento vs. Imprensa).
+{mod_prompt}{ab_prompt}**Caso Base:** {resumo_caso}
+**Pontos Autor:** {pontos_autor or "Inferir do resumo e abordagem."}
+**Tarefa:** Gere Petição Inicial com seções detalhadas (Fatos, Direito, Pedidos, Estratégias Adicionais), adaptando à modificação do fato e abordagem. Para o Direito, cite 3-4 fundamentos (Dignidade, Privacidade, Esquecimento, Resp. Civil) e explique sua aplicação. Nos Pedidos, seja específico (tutela, remoção, indenização, retratação). Em Estratégias, sugira argumentos/provas alternativas e riscos a antecipar.
+**Formato Saída (marcadores exatos):**
+`{Config.PETICAO_MARKERS_MAP["fatos_autor"]}`
+[Conteúdo]
+`{Config.PETICAO_MARKERS_MAP["direito_autor"]}`
+[Conteúdo]
+`{Config.PETICAO_MARKERS_MAP["pedidos_autor"]}`
+[Conteúdo]
+`{Config.PETICAO_MARKERS_MAP["estrategias_autor"]}`
+[Conteúdo]"""
+        return GeminiAPI.chamar_api(prompt, max_output_tokens=Config.PETICAO_MAX_TOKENS)
 
     @staticmethod
-    def gerar_contestacao(resumo_caso: str, pontos_reu: str, peticao_autor: str, tom_defesa: str) -> str:
-        prompt = f"""
-        **Persona:** Você é um advogado experiente e combativo, especializado em defender veículos de imprensa em casos envolvendo Liberdade de Expressão e Direito ao Esquecimento, redigindo os elementos chave de uma Contestação.
-        **Tom da Defesa Solicitado:** {tom_defesa}. Adapte a linguagem, a ênfase dos argumentos e a assertividade a este tom.
-
-        **Caso (Resumo Geral):**
-        {resumo_caso}
-        **Principais Pontos e Provas do Réu (use-os para fundamentar a contestação; se não fornecidos, infira do resumo do caso, focando em elementos que sustentem a liberdade de imprensa e o interesse público):**
-        {pontos_reu if pontos_reu else "Inferir do resumo do caso, focando na liberdade de imprensa, interesse público e veracidade."}
-
-        **Petição Inicial do Autor (para contextualizar a resposta e permitir refutação específica):**
-        ```
-        {peticao_autor}
-        ```
-
-        **Tarefa:** Gere os seguintes tópicos para uma Contestação da parte RÉ, de forma clara, objetiva e juridicamente robusta, refletindo o tom da defesa solicitado:
-        1.  **SÍNTESE DA DEFESA:** (Resumo assertivo da tese de defesa do réu, negando a pretensão autoral e afirmando a legalidade da publicação, alinhado ao tom).
-        2.  **PRELIMINARES (Se aplicável):** (Sugira brevemente se alguma preliminar seria cabível, ex: inépcia da inicial, ilegitimidade de parte – apenas se claramente inferível e relevante para o tom combativo).
-        3.  **DA REALIDADE DOS FATOS (Narrativa do Réu e Impugnação Específica):** (Apresente a versão dos fatos sob a ótica do réu, destacando a correção da matéria, o interesse público, a menção à absolvição, e o contexto da publicação. Impugne especificamente os fatos narrados pelo autor que sejam inverídicos ou distorcidos, usando o tom solicitado).
-        4.  **DO DIREITO (Principais Fundamentos da Defesa):** (Cite e explique brevemente 3-4 fundamentos legais/constitucionais robustos para a defesa:
-            *   Liberdade de Imprensa e de Informação (Art. 5º, IV, IX, XIV, e Art. 220 da CF/88). Argumentar sobre a impossibilidade de censura e o dever de informar.
-            *   Direito da Sociedade à Informação e à Memória Coletiva.
-            *   Veracidade dos Fatos Publicados e Animus Narrandi (intenção de informar, não de ofender). Destacar que a absolvição foi mencionada.
-            *   Inexistência de Ato Ilícito e de Dano Indenizável (ou, subsidiariamente, excesso no valor pleiteado).
-            *   Precedentes Relevantes (STF - RE 1.010.606, ADPF 130) que limitam o direito ao esquecimento frente à liberdade de imprensa em casos de interesse público.
-            *   Argumentar sobre a não configuração do direito ao esquecimento no caso concreto, pela relevância histórica ou pela natureza pública dos fatos).
-        5.  **DOS PEDIDOS (Contrapedidos/Impugnações):** (Peça a total improcedência dos pedidos do autor. Impugne especificamente o pedido de dano moral e seu valor, demonstrando sua exorbitância ou inexistência. Reitere a legalidade da conduta do jornal. Peça a condenação do autor em custas processuais e honorários advocatícios de sucumbência, de forma consistente com o tom).
-        6.  **PONTOS ESTRATÉGICOS ADICIONAIS PARA O RÉU:** (Sugira brevemente:
-            *   Outras teses de defesa (ex: culpa exclusiva da vítima pela forma como lidou com a exposição prévia, ausência de prova robusta do dano alegado).
-            *   Tipos de prova adicional (ex: parecer de especialista em comunicação/jornalismo sobre o interesse público, dados de acesso à matéria que demonstrem interesse).
-            *   Pontos fracos da petição inicial a serem explorados na instrução ou em alegações finais).
-
-        **Formato da Saída:**
-        Use os seguintes marcadores EXATOS para cada seção, iniciando em nova linha:
-        `{Config.CONTESTACAO_MARKERS_MAP["sintese_reu"]}`
-        (Se houver preliminares, use: `### PRELIMINARES`)
-        `{Config.CONTESTACAO_MARKERS_MAP["fatos_reu"]}`
-        `{Config.CONTESTACAO_MARKERS_MAP["direito_reu"]}`
-        `{Config.CONTESTACAO_MARKERS_MAP["pedidos_reu"]}`
-        `{Config.CONTESTACAO_MARKERS_MAP["estrategias_reu"]}`
-
-        O conteúdo de cada seção deve vir após o marcador. Seja completo, detalhado e assertivo dentro de cada seção, conforme o tom.
-        """
-        return GeminiAPI.chamar_api(
-            prompt, 
-            temperature=Config.DEFAULT_TEMPERATURE, 
-            max_output_tokens=Config.CONTESTACAO_MAX_TOKENS
-        )
+    def gerar_contestacao(resumo_caso: str, pontos_reu: str, peticao_autor: str, tom_defesa: str, modificacao_fato: Optional[str]) -> str:
+        mod_prompt = f"\n**Modificação Fato (do caso original):** {modificacao_fato}\n" if modificacao_fato else ""
+        prompt = f"""**Persona:** Advogado experiente (Liberdade de Imprensa), redigindo Contestação (Esquecimento vs. Imprensa).
+**Tom Defesa:** {tom_defesa}
+{mod_prompt}**Caso Base:** {resumo_caso}
+**Pontos Réu:** {pontos_reu or "Inferir do resumo."}
+**Petição Autor:** ```{peticao_autor}```
+**Tarefa:** Gere Contestação com seções (Síntese, Preliminares (se houver), Fatos (com impugnação), Direito, Pedidos, Estratégias Adicionais), adaptando ao tom e modificação do fato. No Direito, cite 3-4 fundamentos (Liberdade Imprensa/Info, Art. 5/220 CF, Ausência Ilicitude, Verdade, Animus Narrandi, Precedentes STF RE 1.010.606/ADPF 130). Nos Pedidos, peça improcedência total, impugne danos, peça custas/honorários. Em Estratégias, sugira teses/provas e pontos fracos da petição.
+**Formato Saída (marcadores exatos):**
+`{Config.CONTESTACAO_MARKERS_MAP["sintese_reu"]}`
+[Conteúdo]
+(Se houver preliminares: `{Config.CONTESTACAO_MARKERS_MAP["preliminares_reu"]}`\n[Conteúdo])
+`{Config.CONTESTACAO_MARKERS_MAP["fatos_reu"]}`
+[Conteúdo]
+`{Config.CONTESTACAO_MARKERS_MAP["direito_reu"]}`
+[Conteúdo]
+`{Config.CONTESTACAO_MARKERS_MAP["pedidos_reu"]}`
+[Conteúdo]
+`{Config.CONTESTACAO_MARKERS_MAP["estrategias_reu"]}`
+[Conteúdo]"""
+        return GeminiAPI.chamar_api(prompt, max_output_tokens=Config.CONTESTACAO_MAX_TOKENS)
 
     @staticmethod
     def simular_aij(resumo_caso: str, peticao_autor: str, contestacao_reu: str, 
-                   pontos_autor: str, pontos_reu: str, tom_defesa_reu: str) -> str:
-        prompt = f"""
-        **Persona:** Você é um Narrador Jurídico experiente e imparcial, simulando uma Audiência de Instrução e Julgamento (AIJ) em um caso de Direito ao Esquecimento vs. Liberdade de Imprensa.
-        **Contexto do Caso:**
-        {resumo_caso}
-
-        **Argumentos Chave do Autor (da Petição Inicial):**
-        ```
-        {peticao_autor}
-        ```
-        {("Pontos adicionais do Autor fornecidos: " + pontos_autor) if pontos_autor else ""}
-
-        **Argumentos Chave do Réu (da Contestação) - Tom da Defesa do Réu a ser refletido: {tom_defesa_reu}:**
-        ```
-        {contestacao_reu}
-        ```
-        {("Pontos adicionais do Réu fornecidos: " + pontos_reu) if pontos_reu else ""}
-
-        **Tarefa:** Narre resumidamente as seguintes etapas da AIJ. Para cada etapa, descreva as ações e falas principais do Juiz, Advogado do Autor e Advogado do Réu. O Advogado do Réu deve refletir o "Tom da Defesa" especificado. Para os depoimentos das testemunhas (inferir 1-2 testemunhas chave para cada parte com base nos "Pontos Chave/Provas" fornecidos ou no resumo do caso, focando em sua relevância para o tema de esquecimento vs. imprensa), resuma as perguntas chave e as respostas esperadas, bem como os pontos principais da contradita, destacando como cada advogado tenta fortalecer sua tese.
-
-        **Etapas a Narrar:**
-        1.  **ABERTURA E TENTATIVA DE CONCILIAÇÃO:** (Juiz abre a audiência, qualifica as partes e advogados. Juiz indaga sobre a possibilidade de conciliação. Advogado do Autor se manifesta sobre eventual proposta ou desinteresse. Advogado do Réu se manifesta, refletindo o tom da defesa e a posição do jornal sobre acordo).
-        2.  **DEPOIMENTO PESSOAL DO AUTOR (Resumido):** (Principais declarações do Autor sobre como a matéria o afetou, o que ele sentiu, os prejuízos que alega, e por que acredita que a informação não deveria mais ser pública).
-        3.  **DEPOIMENTO PESSOAL DO RÉU (Preposto do Jornal - Resumido):** (Principais declarações do preposto sobre a decisão de publicar a matéria, o processo editorial, a política do jornal sobre arquivos, a verificação da informação (incluindo a absolvição), e o interesse público percebido, refletindo a linha de defesa e o tom).
-        4.  **OITIVA DAS TESTEMUNHAS DO AUTOR (Simular 1 ou 2 testemunhas):**
-            *   (Identifique a Testemunha 1 do Autor - ex: Psicólogo do autor, amigo que presenciou constrangimento. Indique seu principal ponto a testemunhar em relação ao dano e à desatualização da notícia).
-            *   (Adv. Autor pergunta - foco da pergunta para confirmar o dano, o abalo emocional, a ausência de interesse público atual).
-            *   (Resposta resumida da Testemunha 1).
-            *   (Adv. Réu contradita/pergunta - foco da pergunta para desqualificar o testemunho, minimizar o dano, ou questionar a percepção da testemunha sobre o interesse público, usando o tom da defesa).
-            *   (Resposta resumida da Testemunha 1 à contradita).
-            *   (Se aplicável, repita para uma Testemunha 2 do Autor, ex: especialista em privacidade digital, ex-colega de trabalho).
-        5.  **OITIVA DAS TESTEMUNHAS DO RÉU (Simular 1 ou 2 testemunhas):**
-            *   (Identifique a Testemunha 1 do Réu - ex: Editor do jornal, jornalista que escreveu a matéria, historiador/especialista em mídia. Indique seu principal ponto a testemunhar sobre o interesse público, a veracidade, o processo editorial).
-            *   (Adv. Réu pergunta - foco da pergunta para sustentar a tese de defesa, usando o tom da defesa).
-            *   (Resposta resumida da Testemunha 1).
-            *   (Adv. Autor contradita/pergunta - foco da pergunta para questionar o alegado interesse público, a proporcionalidade da exposição, ou a diligência do jornal).
-            *   (Resposta resumida da Testemunha 1 à contradita).
-            *   (Se aplicável, repita para uma Testemunha 2 do Réu).
-        6.  **ALEGAÇÕES FINAIS DO AUTOR (Resumido):** (Advogado do Autor resume suas provas, reitera os fundamentos jurídicos do direito ao esquecimento e da responsabilidade civil, e os pedidos, enfatizando o dano e a falta de interesse público atual).
-        7.  **ALEGAÇÕES FINAIS DO RÉU (Resumido):** (Advogado do Réu resume suas provas, reitera os fundamentos da liberdade de imprensa, do direito à informação, da veracidade dos fatos, e os pedidos de improcedência, refletindo o tom da defesa).
-        8.  **CONCLUSÃO DO JUIZ PARA SENTENÇA (Simulada):** (Juiz faz uma ponderação analítica sobre os principais argumentos de ambas as partes, a força aparente das provas produzidas, os direitos fundamentais em conflito (esquecimento/privacidade vs. liberdade de imprensa/informação), e os desafios jurídicos para a decisão no caso concreto, citando a complexidade da matéria. Informa que o caso será decidido em sentença fundamentada).
-        9.  **ANÁLISE DE CENÁRIOS E PONTOS DE INFLEXÃO:** (Com base na simulação, descreva brevemente:
-            a) Um possível "ponto de virada" na audiência (ex: uma testemunha do autor que se mostra pouco crível sobre a extensão do dano; uma testemunha do réu que admite descuido editorial; uma pergunta da contradita que efetivamente abala um depoimento). Como isso alteraria a dinâmica?
-            b) Uma estratégia alternativa que o advogado do réu poderia ter adotado (ex: focar mais em demonstrar o contínuo, ainda que sutil, interesse público na história, ou oferecer uma forma de anonimização parcial como alternativa à remoção total). Qual seria seu potencial impacto?
-            c) Um fator externo (ex: uma decisão recente de um tribunal superior sobre um caso similar de direito ao esquecimento, ou uma grande repercussão negativa/positiva da matéria após ajuizamento da ação) que, se ocorresse, poderia influenciar significativamente a percepção do caso ou a decisão do juiz).
-
-        **Formato da Saída:**
-        Use os seguintes marcadores EXATOS para cada etapa, iniciando em nova linha:
-        `{Config.AIJ_MARKERS_MAP["1_abertura"]}`
-        `{Config.AIJ_MARKERS_MAP["2_dep_autor"]}`
-        `{Config.AIJ_MARKERS_MAP["3_dep_reu"]}`
-        `{Config.AIJ_MARKERS_MAP["4_test_autor"]}`
-        `{Config.AIJ_MARKERS_MAP["5_test_reu"]}`
-        `{Config.AIJ_MARKERS_MAP["6_aleg_autor"]}`
-        `{Config.AIJ_MARKERS_MAP["7_aleg_reu"]}`
-        `{Config.AIJ_MARKERS_MAP["8_conc_juiz"]}`
-        `{Config.AIJ_MARKERS_MAP["9_cenarios"]}`
-
-        Para as testemunhas, dentro das seções 4 e 5, use o seguinte formato para cada testemunha:
-        `- Testemunha do [Autor/Réu]: [Nome da Testemunha e seu Papel/Profissão]`
-          `- Ponto Chave do Depoimento: [Resumo do que ela testemunhou a favor da parte que a arrolou, focado no conflito esquecimento vs. imprensa].`
-          `- Perguntas da Defesa/Contradita (Foco e Resposta Resumida): [Advogado da parte contrária pergunta sobre X (ex: relevância atual, proporcionalidade, veracidade). Testemunha responde Y, mantendo/esclarecendo seu ponto].`
-        """
-        return GeminiAPI.chamar_api(
-            prompt, 
-            temperature=0.8, 
-            max_output_tokens=Config.AIJ_MAX_TOKENS
-        )
+                   pontos_autor: str, pontos_reu: str, tom_defesa_reu: str,
+                   modificacao_fato: Optional[str], abordagem_autor: str) -> str:
+        mod_prompt = f"\n**Modificação Fato (para AIJ):** {modificacao_fato}\n" if modificacao_fato else ""
+        ab_prompt = f"\n**Abordagem Autor (para AIJ):** {abordagem_autor}\n"
+        prompt = f"""**Persona:** Narrador Jurídico imparcial simulando AIJ (Esquecimento vs. Imprensa).
+{mod_prompt}{ab_prompt}**Contexto Caso Original:** {resumo_caso}
+**Petição Autor:** ```{peticao_autor}``` {("Pontos Autor: " + pontos_autor) if pontos_autor else ""}
+**Contestação Réu (Tom: {tom_defesa_reu}):** ```{contestacao_reu}``` {("Pontos Réu: " + pontos_reu) if pontos_reu else ""}
+**Tarefa:** Narre a AIJ. Advogados devem refletir abordagens/tons. Fato modificado deve influenciar depoimentos/perguntas/análise. Inferir 1-2 testemunhas relevantes (Autor: psicólogo, amigo; Réu: editor, jornalista) e seus depoimentos/contraditas no contexto do caso (esquecimento, dano, interesse público, veracidade). Juiz deve ponderar direitos conflitantes na conclusão. Seção de Cenários deve explorar 1 reviravolta, 1 estratégia alternativa, 1 fator externo.
+**Formato Saída (marcadores exatos):**
+`{Config.AIJ_MARKERS_MAP["1_abertura"]}` \n[Conteúdo]
+`{Config.AIJ_MARKERS_MAP["2_dep_autor"]}` \n[Conteúdo]
+`{Config.AIJ_MARKERS_MAP["3_dep_reu"]}` \n[Conteúdo]
+`{Config.AIJ_MARKERS_MAP["4_test_autor"]}` \n[Formato Testemunha: - Testemunha: [Nome/Papel]\n  - Ponto Chave: [Depoimento]\n  - Contradita: [Foco da pergunta do Adv. Réu e resposta]]
+`{Config.AIJ_MARKERS_MAP["5_test_reu"]}` \n[Formato Testemunha: - Testemunha: [Nome/Papel]\n  - Ponto Chave: [Depoimento]\n  - Contradita: [Foco da pergunta do Adv. Autor e resposta]]
+`{Config.AIJ_MARKERS_MAP["6_aleg_autor"]}` \n[Conteúdo]
+`{Config.AIJ_MARKERS_MAP["7_aleg_reu"]}` \n[Conteúdo]
+`{Config.AIJ_MARKERS_MAP["8_conc_juiz"]}` \n[Conteúdo]
+`{Config.AIJ_MARKERS_MAP["9_cenarios"]}` \n[a) Ponto de Virada: ... b) Estratégia Alternativa: ... c) Fator Externo: ...]"""
+        return GeminiAPI.chamar_api(prompt, temperature=0.8, max_output_tokens=Config.AIJ_MAX_TOKENS)
 
 class ProcessadorTexto:
     @staticmethod
     def _extrair_secao(texto_completo: str, texto_lower: str, marcador_inicio: str, marcadores_subsequentes: List[str]) -> Optional[str]:
-        """Helper para extrair conteúdo de uma seção."""
         start_idx = texto_lower.find(marcador_inicio.lower())
-        if start_idx == -1:
-            logger.warning(f"Marcador inicial não encontrado: '{marcador_inicio}'")
-            return None
-        
+        if start_idx == -1: return None
         content_start_idx = start_idx + len(marcador_inicio)
-        
         end_idx = len(texto_completo)
         for next_marcador in marcadores_subsequentes:
             next_marker_idx_found = texto_lower.find(next_marcador.lower(), content_start_idx)
             if next_marker_idx_found != -1:
                 end_idx = min(end_idx, next_marker_idx_found)
-        
         return texto_completo[content_start_idx:end_idx].strip()
 
     @staticmethod
     def processar_documento(texto_completo: str, markers_map: Dict[str, str]) -> Dict[str, str]:
-        """Processa um texto genérico (Petição, Contestação) e separa em seções."""
-        global _peticao_completa_exportar, _contestacao_completa_exportar
-        if markers_map == Config.PETICAO_MARKERS_MAP:
-            _peticao_completa_exportar = texto_completo
-        elif markers_map == Config.CONTESTACAO_MARKERS_MAP:
-            _contestacao_completa_exportar = texto_completo
+        global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
+        if markers_map == Config.PETICAO_MARKERS_MAP: _peticao_completa_exportar = texto_completo
+        elif markers_map == Config.CONTESTACAO_MARKERS_MAP: _contestacao_completa_exportar = texto_completo
+        elif markers_map == Config.AIJ_MARKERS_MAP: _aij_texto_completo_para_exportar = texto_completo
 
         if not texto_completo or "ERRO_" in texto_completo:
-            logger.error(f"Erro na entrada de processar_documento: {texto_completo}")
-            return {key: f"Erro ao gerar seção: {texto_completo}" for key in markers_map.keys()}
+            logger.error(f"Erro na entrada do processador: {texto_completo}")
+            return {key: f"Erro ao gerar/processar seção: {texto_completo}" for key in markers_map.keys()}
 
-        partes_documento = {
-            key: f"Seção '{marker_text}' não encontrada na simulação." 
-            for key, marker_text in markers_map.items()
-        }
+        partes_documento = {key: f"Seção '{marker_text}' não encontrada." for key, marker_text in markers_map.items()}
         texto_lower = texto_completo.lower()
-        sorted_marcadores_list = list(markers_map.items()) # Lista de tuplas (key, marker_text)
-
+        sorted_marcadores_list = list(markers_map.items())
         for i, (key, marcador_inicio) in enumerate(sorted_marcadores_list):
-            # Lista de marcadores subsequentes para definir o fim da seção atual
-            marcadores_subsequentes_text = [m_text for k, m_text in sorted_marcadores_list[i+1:]]
-            
+            marcadores_subsequentes_text = [m_text for _, m_text in sorted_marcadores_list[i+1:]]
             conteudo_secao = ProcessadorTexto._extrair_secao(texto_completo, texto_lower, marcador_inicio, marcadores_subsequentes_text)
-            if conteudo_secao is not None:
-                partes_documento[key] = conteudo_secao
-        
+            if conteudo_secao is not None: partes_documento[key] = conteudo_secao
+            else: logger.warning(f"Marcador não encontrado ao processar: '{marcador_inicio}' para '{key}'")
         return partes_documento
 
-
-    @staticmethod
-    def processar_aij(aij_texto_completo: str) -> Dict[str, str]:
-        global _aij_texto_completo_para_exportar
-        _aij_texto_completo_para_exportar = aij_texto_completo
-        return ProcessadorTexto.processar_documento(aij_texto_completo, Config.AIJ_MARKERS_MAP)
-
-
 class InterfaceProcesso:
-    
     @staticmethod
     def simular_processo_completo_ui_generator(resumo_caso_input: str, pontos_autor_input: str, 
-                                             pontos_reu_input: str, tom_defesa_reu_input: str):
+                                             pontos_reu_input: str, tom_defesa_reu_input: str,
+                                             modificacao_fato_input: Optional[str], 
+                                             abordagem_autor_input: Optional[str]):
         global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
+        _peticao_completa_exportar = _contestacao_completa_exportar = _aij_texto_completo_para_exportar = ""
+        
+        num_aij_outputs = len(Config.AIJ_MARKERS_MAP)
+        total_outputs = 2 + num_aij_outputs + 1 # Pet, Cont, AIJ_parts, Status
+        outputs_tuple_list = [""] * total_outputs 
 
-        # Limpar estados de exportação anteriores
-        _peticao_completa_exportar = ""
-        _contestacao_completa_exportar = ""
-        _aij_texto_completo_para_exportar = ""
-
-        # Definir o número total de saídas esperadas (1 para petição, 1 para contestação, 9 para AIJ, 1 para status)
-        total_outputs = 1 + 1 + len(Config.AIJ_MARKERS_MAP) + 1 
-        outputs_tuple = [""] * total_outputs 
-
-        def create_error_outputs(base_error_msg: str):
-            """Cria uma tupla de saída preenchida com mensagens de erro."""
-            error_list = [base_error_msg] * (total_outputs -1) # Para todas as saídas de texto
-            error_list.append(gr.update(value=base_error_msg)) # Para o status
-            return tuple(error_list)
+        def create_error_tuple(base_error_msg: str):
+            err_list = [base_error_msg] * (total_outputs -1)
+            err_list.append(gr.update(value=base_error_msg))
+            return tuple(err_list)
 
         if not GEMINI_API_KEY:
-            msg_erro_api = "ERRO FATAL: API Key do Gemini não configurada."
-            logger.critical(msg_erro_api)
-            yield create_error_outputs(msg_erro_api)
+            yield create_error_tuple("ERRO FATAL: API Key do Gemini não configurada.")
             return
-
         if not resumo_caso_input:
-            msg_erro = "Erro: O resumo do caso é obrigatório."
-            logger.error(msg_erro)
-            yield create_error_outputs(msg_erro)
+            yield create_error_tuple("Erro: O resumo do caso é obrigatório.")
             return
 
-        # Atualização inicial
-        outputs_tuple[total_outputs - 1] = gr.update(value="Iniciando simulação...")
-        outputs_tuple[0] = "Gerando Petição Inicial..." # output_peticao_inicial
-        yield tuple(outputs_tuple)
-
-        logger.info("Gerando Petição Inicial do Autor...")
-        peticao_autor_txt = GeradorDocumentos.gerar_peticao_inicial(resumo_caso_input, pontos_autor_input)
-        _peticao_completa_exportar = peticao_autor_txt # Salva para cópia
-        outputs_tuple[0] = peticao_autor_txt
+        outputs_tuple_list[total_outputs - 1] = gr.update(value="Iniciando: Gerando Petição Inicial...")
+        outputs_tuple_list[0] = "Gerando..."
+        yield tuple(outputs_tuple_list)
+        peticao_autor_txt = GeradorDocumentos.gerar_peticao_inicial(resumo_caso_input, pontos_autor_input, modificacao_fato_input, abordagem_autor_input)
+        outputs_tuple_list[0] = peticao_autor_txt
+        _peticao_completa_exportar = peticao_autor_txt
         if "ERRO_" in peticao_autor_txt:
-            error_msg = f"Falha ao gerar Petição Inicial: {peticao_autor_txt}"
-            logger.error(error_msg)
-            outputs_tuple[total_outputs-1] = gr.update(value=error_msg) # Status
-            # Preenche outras saídas de texto com o erro também
-            for i in range(1, total_outputs -1) : outputs_tuple[i] = error_msg
-            yield tuple(outputs_tuple)
+            logger.error(f"Falha Petição: {peticao_autor_txt}")
+            outputs_tuple_list[total_outputs-1] = gr.update(value=f"Erro Petição: {peticao_autor_txt[:100]}...")
+            for i in range(1, total_outputs -1) : outputs_tuple_list[i] = peticao_autor_txt 
+            yield tuple(outputs_tuple_list)
             return
         
-        outputs_tuple[1] = "Gerando Contestação..." # output_contestacao
-        outputs_tuple[total_outputs -1] = gr.update(value="Gerando Contestação...")
-        yield tuple(outputs_tuple)
-
-        logger.info("Gerando Contestação do Réu...")
-        contestacao_reu_txt = GeradorDocumentos.gerar_contestacao(resumo_caso_input, pontos_reu_input, peticao_autor_txt, tom_defesa_reu_input)
-        _contestacao_completa_exportar = contestacao_reu_txt # Salva para cópia
-        outputs_tuple[1] = contestacao_reu_txt
+        outputs_tuple_list[1] = "Gerando Contestação..."
+        outputs_tuple_list[total_outputs -1] = gr.update(value="Gerando Contestação...")
+        yield tuple(outputs_tuple_list)
+        contestacao_reu_txt = GeradorDocumentos.gerar_contestacao(resumo_caso_input, pontos_reu_input, peticao_autor_txt, tom_defesa_reu_input, modificacao_fato_input)
+        outputs_tuple_list[1] = contestacao_reu_txt
+        _contestacao_completa_exportar = contestacao_reu_txt
         if "ERRO_" in contestacao_reu_txt:
-            error_msg = f"Falha ao gerar Contestação: {contestacao_reu_txt}"
-            logger.error(error_msg)
-            outputs_tuple[total_outputs-1] = gr.update(value=error_msg)
-            for i in range(2, total_outputs -1) : outputs_tuple[i] = error_msg
-            yield tuple(outputs_tuple)
+            logger.error(f"Falha Contestação: {contestacao_reu_txt}")
+            outputs_tuple_list[total_outputs-1] = gr.update(value=f"Erro Contestação: {contestacao_reu_txt[:100]}...")
+            for i in range(2, total_outputs -1) : outputs_tuple_list[i] = contestacao_reu_txt
+            yield tuple(outputs_tuple_list)
             return
         
-        # Preencher AIJ parts com "Gerando..."
-        for i in range(len(Config.AIJ_MARKERS_MAP)):
-            outputs_tuple[2+i] = "Gerando AIJ (Etapa)..."
-        outputs_tuple[total_outputs -1] = gr.update(value="Simulando AIJ...")
-        yield tuple(outputs_tuple)
-
-        logger.info("Simulando Audiência de Instrução e Julgamento...")
-        aij_simulacao_txt_completa = GeradorDocumentos.simular_aij(resumo_caso_input, peticao_autor_txt, contestacao_reu_txt, pontos_autor_input, pontos_reu_input, tom_defesa_reu_input)
-        
+        for i in range(num_aij_outputs): outputs_tuple_list[2+i] = "Gerando AIJ..."
+        outputs_tuple_list[total_outputs -1] = gr.update(value="Simulando AIJ...")
+        yield tuple(outputs_tuple_list)
+        aij_simulacao_txt_completa = GeradorDocumentos.simular_aij(resumo_caso_input, peticao_autor_txt, contestacao_reu_txt, pontos_autor_input, pontos_reu_input, tom_defesa_reu_input, modificacao_fato_input, abordagem_autor_input)
         if "ERRO_" in aij_simulacao_txt_completa:
-            error_msg = f"Falha ao simular AIJ: {aij_simulacao_txt_completa}"
-            logger.error(error_msg)
-            for i in range(len(Config.AIJ_MARKERS_MAP)):
-                outputs_tuple[2+i] = error_msg
-            outputs_tuple[total_outputs-1] = gr.update(value=error_msg)
-            yield tuple(outputs_tuple)
+            logger.error(f"Falha AIJ: {aij_simulacao_txt_completa}")
+            for i in range(num_aij_outputs): outputs_tuple_list[2+i] = aij_simulacao_txt_completa
+            outputs_tuple_list[total_outputs-1] = gr.update(value=f"Erro AIJ: {aij_simulacao_txt_completa[:100]}...")
+            yield tuple(outputs_tuple_list)
             return
         
-        aij_partes_dict = ProcessadorTexto.processar_aij(aij_simulacao_txt_completa) # _aij_texto_completo_para_exportar é atualizado aqui
-        
-        # Mapear chaves do aij_partes_dict para os índices corretos de outputs_tuple
-        # outputs_tuple[0] = petição, outputs_tuple[1] = contestação
-        # outputs_tuple[2] = aij_abertura, ..., outputs_tuple[2 + N-1] = N-ésima parte da AIJ
-        # outputs_tuple[total_outputs-1] = status
+        aij_partes_dict = ProcessadorTexto.processar_aij(aij_simulacao_txt_completa)
         for i, key in enumerate(Config.AIJ_MARKERS_MAP.keys()):
-            outputs_tuple[2+i] = aij_partes_dict.get(key, f"Falha ao processar seção: {key}")
-
-        outputs_tuple[total_outputs-1] = gr.update(value="Simulação concluída com sucesso.")
-        
+            outputs_tuple_list[2+i] = aij_partes_dict.get(key, f"Falha ao processar seção AIJ: {key}")
+        outputs_tuple_list[total_outputs-1] = gr.update(value="Simulação concluída com sucesso.")
         logger.info("Simulação completa e UI atualizada.")
-        yield tuple(outputs_tuple)
+        yield tuple(outputs_tuple_list)
 
     @staticmethod
-    def limpar_campos_ui():
-        # Retorna valores para limpar todos os inputs e outputs
+    def limpar_interface_fn():
         num_aij_outputs = len(Config.AIJ_MARKERS_MAP)
-        return tuple( [""] * 3 + # resumo, pontos_autor, pontos_reu
-                      [""] * 2 + # peticao, contestacao
-                      [""] * num_aij_outputs + # todas as seções da AIJ
-                      [""] + # caixa de exportação AIJ
-                      [gr.update(value="Campos limpos. Aguardando nova simulação.")] # status
-                    )
+        return ("", "", "", "Padrão", "", "Técnica e Legalista", # Entradas
+                "", "", # Petição, Contestação
+                *[""] * num_aij_outputs, # AIJ parts
+                gr.update(value="Campos e saídas limpos."), # Status
+                "" # AIJ export box
+                )
 
     @staticmethod
-    def restaurar_caso_padrao_ui():
+    def restaurar_padrao_fn():
         num_aij_outputs = len(Config.AIJ_MARKERS_MAP)
-        return (
-            CasoPadrao.RESUMO, 
-            CasoPadrao.AUTOR_PONTOS, 
-            CasoPadrao.REU_PONTOS,
-            # Limpar outputs
-            "", "", # peticao, contestacao
-            *[""] * num_aij_outputs, # AIJ parts
-            "", # AIJ export box
-            gr.update(value="Caso padrão restaurado. Clique em Simular.") # status
-        )
+        return (CasoPadrao.RESUMO, "", CasoPadrao.AUTOR_PONTOS, "Padrão", CasoPadrao.REU_PONTOS, "Técnica e Legalista",
+                "", "", *[""] * num_aij_outputs,
+                gr.update(value="Caso padrão restaurado. Modifique e simule."), ""
+                )
 
     @staticmethod
     def criar_interface() -> gr.Blocks:
-        global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
-        
-        with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"), title="Simulador de Fluxo Processual") as demo:
-            gr.Markdown("# ⚖️ Simulador de Fluxo Processual e AIJ (IA-Powered)")
-            gr.Markdown("Forneça um resumo do caso e, opcionalmente, pontos chave das partes. A IA gerará as peças principais e simulará a AIJ.")
-            
-            if not GEMINI_API_KEY:
-                gr.Warning("ALERTA: GEMINI_API_KEY não configurada! A aplicação não funcionará adequadamente.")
+        with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"), title="Simulador de Fluxo Processual Avançado") as demo:
+            gr.Markdown("# ⚖️ Simulador Avançado de Fluxo Processual e AIJ (IA-Powered)")
+            gr.Markdown("Forneça um caso, modifique fatos, escolha abordagens e veja a IA simular o processo.")
+            if not GEMINI_API_KEY: gr.Warning("ALERTA: GEMINI_API_KEY não configurada!")
 
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("## Configuração do Caso")
-                    resumo_caso_input = gr.Textbox(
-                        lines=10, label="Resumo Detalhado do Caso:", 
-                        placeholder="Descreva os fatos principais...", value=CasoPadrao.RESUMO
-                    )
-                    pontos_autor_input = gr.Textbox(
-                        lines=5, label="Pontos Chave / Provas do AUTOR (Opcional):", 
-                        placeholder="Ex: Dano moral...", value=CasoPadrao.AUTOR_PONTOS
-                    )
-                    pontos_reu_input = gr.Textbox(
-                        lines=5, label="Pontos Chave / Provas do RÉU (Opcional):", 
-                        placeholder="Ex: Liberdade de imprensa...", value=CasoPadrao.REU_PONTOS
-                    )
-                    tom_defesa_reu_input = gr.Radio(
-                        choices=["Combativa e Firme", "Técnica e Legalista", "Ponderada/Buscando Acordo Sutil"],
-                        label="Tom da Defesa do Réu:", value="Técnica e Legalista"
-                    )
-                    btn_simular = gr.Button("🚀 Simular Processo Completo com IA", variant="primary")
+                    gr.Markdown("## Configuração do Caso e Variações")
+                    resumo_caso_input = gr.Textbox(lines=8, label="Resumo Detalhado do Caso Base:", value=CasoPadrao.RESUMO)
+                    modificacao_fato_input = gr.Textbox(lines=3, label="Modificação de Fato Chave (Opcional):", placeholder="Ex: A matéria foi publicada há apenas 1 ano.")
+                    with gr.Row():
+                        with gr.Column():
+                            pontos_autor_input = gr.Textbox(lines=4, label="Pontos/Provas do AUTOR (Opcional):", value=CasoPadrao.AUTOR_PONTOS)
+                            abordagem_autor_input = gr.Radio(choices=["Padrão", "Foco Máximo em Danos Morais", "Busca Principal pela Remoção", "Postura Conciliadora Inicial"], label="Abordagem Estratégica do Autor:", value="Padrão")
+                        with gr.Column():
+                            pontos_reu_input = gr.Textbox(lines=4, label="Pontos/Provas do RÉU (Opcional):", value=CasoPadrao.REU_PONTOS)
+                            tom_defesa_reu_input = gr.Radio(choices=["Combativa e Firme", "Técnica e Legalista", "Ponderada/Buscando Acordo Sutil"], label="Tom da Defesa do Réu:", value="Técnica e Legalista")
+                    btn_simular = gr.Button("🚀 Simular Processo com Variações", variant="primary")
                     status_output = gr.Label(value="Aguardando simulação...")
-                    
                     with gr.Row():
                         btn_limpar_entradas = gr.Button("🧹 Limpar Tudo", variant="secondary", size="sm")
                         btn_restaurar_padrao = gr.Button("🔄 Restaurar Caso Padrão", variant="secondary", size="sm")
@@ -578,94 +320,60 @@ class InterfaceProcesso:
                     with gr.Tabs():
                         with gr.TabItem("📜 Petição Inicial (Autor)"):
                             output_peticao_inicial = gr.Markdown(show_copy_button=True)
-                            # Opcional: Textbox para cópia se Markdown não for suficiente
-                            # output_peticao_copy_box = gr.Textbox(label="Petição para Copiar:", lines=1, interactive=False, show_copy_button=True)
                         with gr.TabItem("🛡️ Contestação (Réu)"):
                             output_contestacao = gr.Markdown(show_copy_button=True)
-                            # output_contestacao_copy_box = gr.Textbox(label="Contestação para Copiar:", lines=1, interactive=False, show_copy_button=True)
-                        with gr.TabItem("🎤 Audiência de Instrução e Julgamento (AIJ)"):
-                            output_aij_export_box = gr.Textbox(label="AIJ Completa (para copiar):", lines=1, info="Este campo será preenchido com o texto completo da AIJ após a simulação.", interactive=False, show_copy_button=True)
-                            
-                            # Criar dinamicamente os Accordions para AIJ
+                        with gr.TabItem("🎤 Audiência (AIJ)"):
+                            output_aij_export_box = gr.Textbox(label="AIJ Completa (para copiar):", lines=1, info="Texto completo da AIJ após simulação.", interactive=False, show_copy_button=True)
                             aij_outputs_ui = {}
                             for key, title in Config.AIJ_MARKERS_MAP.items():
-                                # Remove o "### X. " do título para o Accordion
                                 accordion_title = re.sub(r"### \d+\.\s*", "", title)
-                                with gr.Accordion(accordion_title, open=(key=="1_abertura")): # Abre o primeiro por padrão
+                                is_open = key in ["1_abertura", "9_cenarios"]
+                                with gr.Accordion(accordion_title, open=is_open):
                                     aij_outputs_ui[key] = gr.Markdown()
             
-            # Lista de todos os componentes de saída da simulação principal
-            # A ordem DEVE corresponder ao que simular_processo_completo_ui_generator retorna/yield
-            outputs_simulacao_list = [
-                output_peticao_inicial, 
-                output_contestacao,
-            ]
-            # Adicionar as saídas da AIJ na ordem correta
-            for key in Config.AIJ_MARKERS_MAP.keys(): # Garante a ordem
-                outputs_simulacao_list.append(aij_outputs_ui[key])
+            all_inputs = [resumo_caso_input, modificacao_fato_input, pontos_autor_input, abordagem_autor_input, pontos_reu_input, tom_defesa_reu_input]
             
+            # Construir lista de outputs na ordem correta
+            outputs_simulacao_list = [output_peticao_inicial, output_contestacao]
+            for key_aij in Config.AIJ_MARKERS_MAP.keys(): outputs_simulacao_list.append(aij_outputs_ui[key_aij])
             outputs_simulacao_list.append(status_output)
 
-            # Lista de componentes a serem limpos/restaurados (entradas + saídas)
-            componentes_para_limpar_ou_restaurar_entradas = [resumo_caso_input, pontos_autor_input, pontos_reu_input]
-            componentes_para_limpar_ou_restaurar_saidas = [
-                output_peticao_inicial, output_contestacao,
-                output_aij_export_box # Caixa de exportação da AIJ
-            ]
-            for key in Config.AIJ_MARKERS_MAP.keys():
-                componentes_para_limpar_ou_restaurar_saidas.append(aij_outputs_ui[key])
-            componentes_para_limpar_ou_restaurar_saidas.append(status_output)
+            # Saídas para limpar/restaurar (inclui a caixa de exportação da AIJ)
+            outputs_to_clear_restore = [output_peticao_inicial, output_contestacao]
+            for key_aij_clear in Config.AIJ_MARKERS_MAP.keys(): outputs_to_clear_restore.append(aij_outputs_ui[key_aij_clear])
+            outputs_to_clear_restore.extend([status_output, output_aij_export_box])
 
 
-            def update_export_boxes_fn():
-                global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
-                # As caixas de cópia para petição e contestação foram removidas para simplificar,
-                # pois gr.Markdown já tem botão de cópia.
-                # Se fossem mantidas, seriam atualizadas aqui:
-                # yield gr.update(value=_peticao_completa_exportar)
-                # yield gr.update(value=_contestacao_completa_exportar)
-                yield gr.update(value=_aij_texto_completo_para_exportar)
+            def update_export_box_after_sim():
+                global _aij_texto_completo_para_exportar
+                return _aij_texto_completo_para_exportar
 
             btn_simular.click(
                 InterfaceProcesso.simular_processo_completo_ui_generator,
-                inputs=[resumo_caso_input, pontos_autor_input, pontos_reu_input, tom_defesa_reu_input],
-                outputs=outputs_simulacao_list
-            ).then(update_export_boxes_fn, outputs=[output_aij_export_box])
-
+                inputs=all_inputs, outputs=outputs_simulacao_list
+            ).then(update_export_box_after_sim, outputs=[output_aij_export_box])
 
             btn_limpar_entradas.click(
-                lambda: tuple([""] * len(componentes_para_limpar_ou_restaurar_entradas) + 
-                              [""] * len(componentes_para_limpar_ou_restaurar_saidas - [status_output]) + # Exclui status da limpeza de texto
-                              [gr.update(value="Campos limpos. Aguardando nova simulação.")]), 
+                InterfaceProcesso.limpar_interface_fn, 
                 inputs=None, 
-                outputs=componentes_para_limpar_ou_restaurar_entradas + componentes_para_limpar_ou_restaurar_saidas
+                outputs=all_inputs + outputs_to_clear_restore
             )
-            
             btn_restaurar_padrao.click(
-                lambda: (CasoPadrao.RESUMO, CasoPadrao.AUTOR_PONTOS, CasoPadrao.REU_PONTOS) + 
-                        tuple([""] * (len(componentes_para_limpar_ou_restaurar_saidas) -1 )) + # Limpa outputs exceto status
-                        (gr.update(value="Caso padrão restaurado. Clique em Simular."),),
+                InterfaceProcesso.restaurar_padrao_fn, 
                 inputs=None, 
-                outputs=componentes_para_limpar_ou_restaurar_entradas + componentes_para_limpar_ou_restaurar_saidas
+                outputs=all_inputs + outputs_to_clear_restore
             )
         return demo
 
-# --- Ponto de Entrada Principal ---
 if __name__ == '__main__':
     if not GEMINI_API_KEY:
         logger.critical("A API Key do Gemini não está configurada. A aplicação não pode iniciar.")
-        # Cria uma demo de erro se a chave não estiver presente
         with gr.Blocks(theme=gr.themes.Soft(primary_hue="red")) as demo_erro:
             gr.Markdown("# ERRO DE CONFIGURAÇÃO CRÍTICO")
-            gr.Markdown("A chave `GEMINI_API_KEY` não foi configurada corretamente. "
-                        "Verifique os Secrets do seu Space (se estiver no Hugging Face) "
-                        "ou as variáveis de ambiente (se rodando localmente). "
-                        "A aplicação não pode funcionar sem esta chave.")
+            gr.Markdown("A chave `GEMINI_API_KEY` não foi configurada corretamente...") # Mensagem completa
         logger.info("Lançando interface de erro.")
-        demo_erro.launch(debug=True) # share=True para Colab/link público se necessário
+        demo_erro.launch(debug=True)
     else:
-        logger.info("Iniciando a interface Gradio do Simulador de Fluxo Processual...")
+        logger.info("Iniciando a interface Gradio do Simulador de Fluxo Processual Avançado...")
         simulador_interface = InterfaceProcesso.criar_interface()
-        simulador_interface.queue().launch(debug=True) 
-        # Para Hugging Face, share=False (ou omitir) é geralmente o correto.
-        # Para Colab, use share=True se o código de setup da API Key do Colab estiver ativo.
+        simulador_interface.queue().launch(debug=True)