app.py

import gradio as gr
import os
import re
import requests
import json
import logging
from typing import Dict, List, Optional, Union, Tuple, Any
import io
import zipfile
import traceback
from datetime import datetime

# Configuração do Logging
logging.basicConfig(
    level=logging.INFO, # Mude para logging.DEBUG para ver mais detalhes
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger(__name__)

print("🏛️  INICIANDO SIMULADOR AVANÇADO DE AIJ")
print("=" * 50)

# --- Variáveis Globais ---
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    logger.warning("ALERTA: GEMINI_API_KEY não encontrada como variável de ambiente.")

MODEL_NAME = "gemini-1.5-flash-latest"
API_URL_BASE = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL_NAME}:generateContent"

DADOS_PI_STR_GLOBAL = ""
DADOS_CONTESTACAO_STR_GLOBAL = ""
ARQUIVO_PETICAO_INICIAL_NOME = 'dados_peticao_inicial.txt'
ARQUIVO_CONTESTACAO_NOME = 'dados_contestacao.txt'

# --- ESTILOS CSS ---
STYLE_CSS = """
<style>
    /* ... SEU CSS COMPLETO (COLE AQUI O CSS DA MENSAGEM ANTERIOR) ... */
    body { background-color: #1e1e2f !important; color: #f0f0f0 !important; }
    .gradio-container { background-color: #121212 !important; color: #e0e0e0 !important; border-radius: 0px !important; }
    .aij-container { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: #1e1e2f; padding: 20px; border-radius: 15px; margin: 10px auto; max-width: 1800px; box-shadow: 0 8px 25px rgba(0,0,0,0.3); color: #e0e0e0; }
    .aij-header h1 { text-align: center; color: #ffffff; margin-bottom: 15px; font-size: 2.2em; text-shadow: 2px 2px 4px rgba(0,0,0,0.5); }
    .aij-header p { text-align: center; color: #b0b0b0; margin-bottom: 25px; font-size: 1.1em; }
    .sidebar { background: #282a36; padding: 20px; border-radius: 10px; margin-bottom: 20px; border: 1px solid #44475a; }
    .sidebar label.svelte-1gfkn6j, .sidebar div[data-testid="radio"] span, .sidebar div[data-testid="slider"] span, .sidebar .gr-checkbox-label span { color: #f8f8f2 !important; font-size: 0.95em; }
    .gr-input input[type="text"], .gr-input input[type="number"], .gr-textarea textarea, .gr-dropdown select { background-color: #44475a !important; color: #f8f8f2 !important; border: 1px solid #6272a4 !important; border-radius: 5px !important; }
    .gr-button { border-radius: 5px !important; font-weight: bold !important; transition: all 0.2s ease-in-out !important; }
    .gr-button.primary { background: #50fa7b !important; color: #282a36 !important; border-color: #50fa7b !important;}
    .gr-button.secondary { background: #6272a4 !important; color: #f8f8f2 !important; border-color: #6272a4 !important;}
    .gr-button.warning { background: #ffb86c !important; color: #282a36 !important; border-color: #ffb86c !important;}
    .gr-button:hover { filter: brightness(1.15); transform: translateY(-1px); }
    .tabs > .tab-buttons > button { background-color: #282a36 !important; color: #bd93f9 !important; border-bottom: 3px solid transparent !important; font-weight: bold; }
    .tabs > .tab-buttons > button.selected { background-color: #44475a !important; color: #50fa7b !important; border-bottom: 3px solid #50fa7b !important; }
    .tabitem { background-color: #282a36 !important; border: 1px solid #44475a !important; border-top: none !important; padding: 20px !important; }
    .gr-accordion > .gr-button, .gradio-accordion > button { background: #44475a !important; color: #f8f8f2 !important; border: 1px solid #6272a4 !important; border-radius: 6px !important; }
    .gr-accordion > div, .gradio-accordion > div[style*="overflow-y: auto;"] { background-color: #21222c !important; border: 1px solid #44475a !important; border-top: none !important; padding: 15px; }
    .gradio-markdown, .gradio-markdown p, .gradio-markdown li { color: #f8f8f2 !important; }
    .gradio-markdown h1, .gradio-markdown h2, .gradio-markdown h3 { color: #8be9fd !important; }
    .gradio-markdown strong { color: #ff79c6 !important; } .gradio-markdown a { color: #8be9fd !important; }
    .gradio-markdown pre { background-color: #191a21 !important; border: 1px solid #44475a; border-radius: 5px; padding: 10px; }
    .gradio-markdown pre code { color: #f8f8f2 !important; }
    .status-card { background: #44475a; padding: 12px; border-radius: 8px; margin: 10px 0; border-left: 5px solid #50fa7b; color: #f8f8f2;}
    .error-card { background: #ff5555; border-left-color: #ff5555 !important; color: #f8f8f2; }
    .warning-card { background: #f1fa8c; border-left-color: #f1fa8c !important; color: #282a36; }
    .info-card { background: #8be9fd; border-left-color: #8be9fd !important; color: #282a36; }
    .etapa-badge { background: #bd93f9; color: #282a36; display: inline-block; padding: 6px 12px; border-radius: 16px; font-size: 0.85em; font-weight: 600; }
    .timestamp { font-size: 0.8em; color: #6272a4; float: right; }
    .dica-container { background: #44475a; color: #f8f8f2; border-left: 5px solid #ff79c6; padding: 15px; border-radius: 8px; margin: 15px 0; box-shadow: 0 4px 10px rgba(0,0,0,0.2); position: relative; }
    .dica-container::before { content: "💡"; font-size: 20px; position: absolute; top: 12px; right: 15px; opacity: 0.8; }
    .progress-container { background: #6272a4; height: 10px; border-radius: 5px; margin: 20px 0; overflow: hidden; }
    .progress-bar { height: 100%; background: linear-gradient(90deg, #50fa7b, #8be9fd); border-radius: 5px; transition: width 0.5s ease; }
    #btn_simular_grande { font-size: 1.1em !important; padding: 12px 20px !important; }
    @keyframes fadeIn { from { opacity: 0; transform: translateY(5px); } to { opacity: 1; transform: translateY(0); } }
</style>
"""

# --- Classe de Configuração ---
class Config:
    # ... (COLE A CLASSE Config COMPLETA DA MENSAGEM ANTERIOR AQUI) ...
    MAX_RETRIES = 1; REQUEST_TIMEOUT = 420; DEFAULT_TEMPERATURE = 0.7
    PETICAO_MAX_TOKENS = 5500; CONTESTACAO_MAX_TOKENS = 5500; AIJ_MAX_TOKENS = 8100
    REFINAMENTO_MAX_TOKENS = 4500; CONTRA_ARG_MAX_TOKENS = 3500
    PECA_INTERM_MAX_TOKENS = 3000; VALIDACAO_MAX_TOKENS = 3000
    PETICAO_MARKERS_MAP = {
        "enderecamento_qualificacao": "### ENDEREÇAMENTO E QUALIFICAÇÃO DAS PARTES",
        "nome_acao_fundamento": "### NOME DA AÇÃO E FUNDAMENTO LEGAL PRINCIPAL",
        "fatos_autor": "### I - DOS FATOS (Narrativa Detalhada do Autor)",
        "direito_autor": "### II - DO DIREITO (Fundamentação Jurídica Detalhada)",
        "tutela_urgencia_autor": "### III - DA TUTELA DE URGÊNCIA (se houver)",
        "pedidos_autor": "### IV - DOS PEDIDOS",
        "valor_causa_provas_autor": "### V - DO VALOR DA CAUSA E DAS PROVAS",
        "fechamento_data_assinatura_autor": "### VI - FECHAMENTO, DATA E ASSINATURA"
    }
    CONTESTACAO_MARKERS_MAP = {
        "enderecamento_qualificacao_reu": "### ENDEREÇAMENTO E QUALIFICAÇÃO DO RÉU",
        "sintese_inicial_contestacao": "### SÍNTESE DA PETIÇÃO INICIAL (Breve resumo sob a ótica da defesa)",
        "preliminares_contestacao": "### I - DAS PRELIMINARES DE MÉRITO (Ex: Prescrição, Ilegitimidade)",
        "merito_fatos_reu": "### II - DO MÉRITO - DA REALIDADE DOS FATOS (Narrativa do Réu e Impugnação Específica)",
        "merito_direito_reu": "### III - DO MÉRITO - DO DIREITO (Fundamentação da Defesa)",
        "pedidos_reu": "### IV - DOS PEDIDOS E REQUERIMENTOS FINAIS (Contrapedidos/Impugnações)",
        "provas_reu": "### V - DAS PROVAS QUE PRETENDE PRODUZIR",
        "fechamento_data_assinatura_reu": "### VI - FECHAMENTO, DATA E ASSINATURA"
    }
    AIJ_MARKERS_MAP = {
        "1_abertura": "### 1. ABERTURA E TENTATIVA DE CONCILIAÇÃO DETALHADA",
        "2_dep_autor": "### 2. DEPOIMENTO PESSOAL DO AUTOR (Resumido)",
        "3_dep_reu": "### 3. DEPOIMENTO PESSOAL DO RÉU (Preposto - Resumido)",
        "4_test_autor": "### 4. OITIVA DAS TESTEMUNHAS DO AUTOR (Contextualizada)",
        "5_test_reu": "### 5. OITIVA DAS TESTEMUNHAS DO RÉU (Contextualizada)",
        "6_aleg_autor": "### 6. ALEGAÇÕES FINAIS DO AUTOR (Resumido)",
        "7_aleg_reu": "### 7. ALEGAÇÕES FINAIS DO RÉU (Resumido)",
        "8_conc_juiz": "### 8. CONCLUSÃO DO JUIZ PARA SENTENÇA (Considerando Perfil)",
        "9_cenarios_riscos_estrategias": "### 9. ANÁLISE DE CENÁRIOS, RISCOS, ESTRATÉGIAS GERAIS",
        "10_imprevistos_reacoes": "### 10. SIMULAÇÃO DE EVENTOS IMPREVISTOS E REAÇÕES ESTRATÉGICAS",
        "11_analise_pos_audiencia": "### 11. ANÁLISE ESTRATÉGICA PÓS-AUDIÊncia E PRÓXIMOS PASSOS"
    }

# --- Dados Específicos do Caso ---
class CasoPedroVsPortal:
    # ... (COLE A CLASSE CasoPedroVsPortal COMPLETA E ATUALIZADA DA MENSAGEM ANTERIOR AQUI) ...
    NOME_CASO = "Pedro Vinícius Souza vs. Portal de Notícias LTDA."
    RESUMO_INPUT_UI = f"""AÇÃO DE OBRIGAÇÃO DE FAZER C/C PEDIDO DE DANOS MORAIS E PEDIDO DE TUTELA PROVISÓRIA DE URGÊNCIA ANTECIPADA. Autor: Pedro Vinícius Souza (contador). Advogado: IV ADV. Réu: Portal de Notícias LTDA. Advogado: LUIZ GAMA ADVOGADOS ASSOCIADOS. Fato Principal: Matéria jornalística publicada pelo Réu em 10/03/2020, com o título (conforme contestação) "Pedro Vinícius Souza, Servidor é acusado de desviar recursos públicos da Prefeitura de Ubá". Alegações do Autor (PI): Notícia com linguagem sensacionalista e ofensiva ("rosto mais abjeto", "canalha", etc.), causando dano à honra e imagem. Investigação criminal original foi arquivada por falta de provas. Notícia original permaneceu acessível e desatualizada, causando dano contínuo. Pedidos do Autor: Remoção/desindexação da matéria original, indenização por danos morais de R$ 80.000,00. Principais Teses da Defesa (Contestação): 1. PRELIMINAR DE PRESCRIÇÃO. 2. MÉRITO: a. Portal publicou ATUALIZAÇÃO em 15/07/2021 sobre o arquivamento, linkando-a na matéria original. b. Matéria original era VERÍDICA À ÉPOCA. c. Exercício regular do direito de informar. d. DIREITO AO ESQUECIMENTO não aplicável (Tema 786 STF). e. Contradições do Autor. f. Inexistência de dano moral indenizável ou valor excessivo."""
    AUTOR_PONTOS_INPUT_UI = """- Gravidade da linguagem ofensiva da matéria original. - Dano à honra e reputação mesmo após arquivamento. - Insuficiência da atualização linkada para reparar o dano. - Necessidade de remoção da matéria original. - Indenização de R$ 80.000,00. - Argumentar contra a prescrição (dano contínuo/renovado). - Docs da PI: Arquivamento MP, Antecedentes Criminais."""
    REU_PONTOS_INPUT_UI = """- PRESCRIÇÃO (principal tese). - ATUALIZAÇÃO sobre arquivamento JÁ REALIZADA e linkada. - VERACIDADE da notícia original à época (investigação existia, MPMG consultado). - LIBERDADE DE IMPRENSA. - TEMA 786 STF. - CONTRADIÇÕES do Autor. - INEXISTÊNCIA de dano moral atual ou valor excessivo. - Docs da Contestação."""
    ADV_AUTOR_PAPEIS_PADRAO = "Dr. Felipe Gonçalves da Silva (IV ADV) - Estratégia e Fundamentação\nDr. Gabriel Filgueira de Almeida (IV ADV) - Atuação em Audiência"
    ADV_REU_PAPEIS_PADRAO = "Dra. Jessica Barbosa (LUIZ GAMA ADV) - Defesa e Preliminares\nDr. Guilherme Ayupp (LUIZ GAMA ADV) - Provas e Alegações Finais"
    TEST_AUTOR_DETALHES_PADRAO = "Maria Eduarda Silva (Hipotética) - Ex-colega de Pedro - Ponto Chave: Relatar o abalo emocional e profissional de Pedro após a notícia de 2020.\nJoão Ferreira (Hipotético) - Cidadão de Ubá - Ponto Chave: Comentar sobre a percepção da comunidade e se a atualização foi suficiente."
    TEST_REU_DETALHES_PADRAO = "Paulo Thomas Rodrigo Porto - Sócio Administrador do Portal (Preposto) - Ponto Chave: Política editorial, apuração da matéria original, decisão e forma de publicação da atualização. Negar motivação política.\nAndré Pinto Rebouças - Jornalista (hipotético) - Ponto Chave: Processo de apuração e publicação da notícia de arquivamento."
    PERFIL_JUIZ_PADRAO = "Legalista Estrito"

# --- Variáveis globais para exportação ---
_peticao_completa_exportar = ""
_contestacao_completa_exportar = ""
_aij_texto_completo_para_exportar = ""

# --- Classe GeminiAPI ---
class GeminiAPI:
    # (COLE A CLASSE GeminiAPI COMPLETA DA MENSAGEM ANTERIOR AQUI)
    @staticmethod
    def chamar_api(prompt_text: str, temperature: float = Config.DEFAULT_TEMPERATURE,
                  max_output_tokens: int = 2000, retries: int = Config.MAX_RETRIES) -> str:
        global GEMINI_API_KEY, API_URL_BASE
        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:
            try:
                logger.info(f"API Gemini (tentativa {attempts+1}/{retries+1}), prompt: {len(prompt_text)} chars, max_tokens: {max_output_tokens}")
                response = requests.post(api_url_com_chave, headers=headers, data=json.dumps(data), timeout=Config.REQUEST_TIMEOUT)
                response.raise_for_status()
                response_json = response.json()
                if response_json.get("candidates") and response_json["candidates"][0].get("content") and response_json["candidates"][0]["content"].get("parts"):
                    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 API interrompida por MAX_TOKENS."); generated_text += "\n\n[AVISO: IA pode ter interrompido aqui devido ao limite de tokens.]"
                    elif finish_reason not in ["STOP", "OTHER", None, "", "FINISH_REASON_UNSPECIFIED"]: logger.warning(f"Geração API terminou: {finish_reason}")
                    return generated_text
                elif response_json.get("promptFeedback"):
                    error_detail = f"Bloqueio: {response_json['promptFeedback'].get('blockReason', 'N/E')}. Ratings: {response_json['promptFeedback'].get('safetyRatings', [])}"
                    logger.error(f"Conteúdo bloqueado API. {error_detail}"); return f"ERRO_API: Conteúdo bloqueado. {error_detail}"
                logger.error(f"Resposta API inesperada: {response_json}"); return "ERRO_API: Resposta API inesperada."
            except requests.exceptions.Timeout: logger.error(f"Timeout tentativa {attempts+1}."); attempts += 1;
            except requests.exceptions.RequestException as e:
                error_msg = f"ERRO_CONEXAO_HTTP: {e}"; logger.error(error_msg); return error_msg
            except Exception as e: logger.exception(f"Erro API tentativa {attempts+1}: {e}"); attempts += 1;
            if attempts > retries: return f"ERRO_API: Falha após {retries+1} tentativas."
        return "ERRO_API: Falha na chamada à API."


# --- Classe GeradorDocumentos ---
class GeradorDocumentos:
    # ... (COLE A CLASSE GeradorDocumentos COMPLETA E ATUALIZADA DA MENSAGEM ANTERIOR AQUI,
    #      COM OS PROMPTS PARA gerar_peticao_inicial, gerar_contestacao e simular_aij
    #      COM A INSTRUÇÃO REFORÇADA SOBRE OS MARCADORES) ...
    @staticmethod
    def _construir_prompt_base_com_contexto(contexto_caso: dict, instrucao_principal: str) -> str:
        global DADOS_PI_STR_GLOBAL, DADOS_CONTESTACAO_STR_GLOBAL
        return f"""**Contexto Detalhado (Baseado nos arquivos PI e Contestação para o caso {CasoPedroVsPortal.NOME_CASO}):**
PETIÇÃO INICIAL (AUTOR: Pedro Vinícius Souza): {DADOS_PI_STR_GLOBAL if DADOS_PI_STR_GLOBAL and not DADOS_PI_STR_GLOBAL.startswith("ERRO:") else "Informações da PI não carregadas."}
CONTESTAÇÃO (RÉU: Portal de Notícias LTDA.): {DADOS_CONTESTACAO_STR_GLOBAL if DADOS_CONTESTACAO_STR_GLOBAL and not DADOS_CONTESTACAO_STR_GLOBAL.startswith("ERRO:") else "Informações da Contestação não carregadas."}
**Configurações da Simulação:** Lado do Usuário: {contexto_caso.get('lado_representado', 'N/A')}, Tom Defesa Réu: {contexto_caso.get('tom_defesa_reu', 'N/A')}, Perfil Juiz: {contexto_caso.get('perfil_juiz', 'N/A')}
Adv. Autor: {contexto_caso.get('adv_autor_papeis', 'N/A')}, Test. Autor: {contexto_caso.get('test_autor_detalhes', 'N/A')}
Adv. Réu: {contexto_caso.get('adv_reu_papeis', 'N/A')}, Test. Réu: {contexto_caso.get('test_reu_detalhes', 'N/A')}
{instrucao_principal}"""

    @staticmethod
    def gerar_peticao_inicial(contexto_caso_completo: dict) -> str:
        instrucao = f"""
        **Persona:** Advogado do Autor (Pedro Vinícius Souza - IV ADV). Redija a Petição Inicial para o caso {CasoPedroVsPortal.NOME_CASO}, baseando-se ESTRITAMENTE no conteúdo do arquivo da Petição Inicial já fornecido no contexto global.
        Sua tarefa é REESTRUTURAR e COMPLEMENTAR o conteúdo da PI fornecida, organizando-o nos seguintes tópicos formais.
        PARA CADA SEÇÃO, VOCÊ DEVE OBRIGATORIAMENTE INICIÁ-LA COM O MARCADOR CORRESPONDENTE EXATAMENTE COMO LISTADO ABAIXO. NÃO OMITE NENHUM MARCADOR E NÃO PULE LINHAS ENTRE O MARCADOR E O INÍCIO DO TEXTO DA SEÇÃO.
        Se uma seção não estiver explicitamente detalhada na PI fornecida, indique APÓS O MARCADOR: "[Informação não detalhada na Petição Inicial original para esta seção]".

        **Estrutura da Petição Inicial a ser Gerada (Use os marcadores EXATOS):**
        `{Config.PETICAO_MARKERS_MAP["enderecamento_qualificacao"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Extraia e formate o endereçamento ao juízo, qualificação completa do Autor Pedro Vinícius Souza e do Réu Portal de Notícias LTDA. conforme a PI fornecida.)

        `{Config.PETICAO_MARKERS_MAP["nome_acao_fundamento"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Declare o nome da ação e seu principal fundamento legal, ex: "AÇÃO DE OBRIGAÇÃO DE FAZER C/C PEDIDO DE DANOS MORAIS E TUTELA PROVISÓRIA DE URGÊNCIA, com fulcro nos arts. ...")

        `{Config.PETICAO_MARKERS_MAP["fatos_autor"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Narre os fatos sob a ótica do Autor, detalhando a publicação da matéria, seu conteúdo ofensivo, o arquivamento da investigação, a permanência da notícia e os danos sofridos. Baseie-se nos FATOS da PI fornecida.)

        `{Config.PETICAO_MARKERS_MAP["direito_autor"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Desenvolva a fundamentação jurídica para cada ponto: Direito à honra e imagem, dano moral, responsabilidade civil do portal, inaplicabilidade da liberdade de imprensa como escudo para ofensas, direito ao esquecimento (com ressalvas do STF), abuso de direito. Cite os artigos mencionados na PI original: Art. 5º, V e X CF; Arts. 12, 20, 186, 187, 927 CC; arts. 300 e ss CPC para tutela. Fundamente com base no DIREITO da PI fornecida.)

        `{Config.PETICAO_MARKERS_MAP["tutela_urgencia_autor"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Justifique o pedido de tutela de urgência para remoção/desindexação, demonstrando a probabilidade do direito e o perigo de dano, conforme a PI.)

        `{Config.PETICAO_MARKERS_MAP["pedidos_autor"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Liste os pedidos: gratuidade, tutela de urgência, confirmação da tutela, remoção/desindexação definitiva, indenização por danos morais de R$ 80.000,00, condenação em custas e honorários. Se houver pedido subsidiário de atualização, mencione-o. Baseie-se nos PEDIDOS da PI fornecida.)

        `{Config.PETICAO_MARKERS_MAP["valor_causa_provas_autor"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Indique o valor da causa (R$ 80.000,00) e proteste pela produção de todas as provas admitidas em direito, especialmente documental (já anexada - Docs. 1 a 6 da PI), testemunhal (se houver rol), e pericial (se aplicável).)

        `{Config.PETICAO_MARKERS_MAP["fechamento_data_assinatura_autor"]}`
        (CONTEÚDO DA SEÇÃO AQUI: Termos em que pede deferimento. Local e data: Ubá/MG, 20 de maio de 2025. Nome dos advogados do IV ADV.)

        ATENÇÃO FINAL: CUMPRA RIGOROSAMENTE A INSTRUÇÃO DE INICIAR CADA SEÇÃO COM SEU MARCADOR EXATO (EX: `{Config.PETICAO_MARKERS_MAP["enderecamento_qualificacao"]}`) SEGUIDO DO CONTEÚDO DAQUELA SEÇÃO. NÃO PULE LINHAS DESNECESSARIAMENTE ENTRE O MARCADOR E O CONTEÚDO.
        """
        prompt_completo = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso_completo, instrucao)
        return GeminiAPI.chamar_api(prompt_completo, temperature=0.3, max_output_tokens=Config.PETICAO_MAX_TOKENS)

    @staticmethod
    def gerar_contestacao(contexto_caso_completo: dict, _peticao_nao_usada: str) -> str:
        instrucao = f"""
        **Persona:** Advogado do Réu (Portal de Notícias - LUIZ GAMA ADV). Redija a Contestação para o caso {CasoPedroVsPortal.NOME_CASO}, baseando-se ESTRITAMENTE no conteúdo do arquivo da Contestação já fornecido no contexto global.
        Sua tarefa é REESTRUTURAR e COMPLEMENTAR o conteúdo da Contestação fornecida, organizando-o nos seguintes tópicos formais.
        PARA CADA SEÇÃO, VOCÊ DEVE OBRIGATORIAMENTE INICIÁ-LA COM O MARCADOR CORRESPONDENTE EXATAMENTE COMO LISTADO ABAIXO. NÃO OMITE NENHUM MARCADOR E NÃO PULE LINHAS ENTRE O MARCADOR E O INÍCIO DO TEXTO DA SEÇÃO.
        Se uma seção não estiver explicitamente detalhada na Contestação fornecida, indique APÓS O MARCADOR: "[Informação não detalhada na Contestação original para esta seção]".

        **Estrutura da Contestação a ser Gerada (Use os marcadores EXATOS):**
        `{Config.CONTESTACAO_MARKERS_MAP["enderecamento_qualificacao_reu"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["sintese_inicial_contestacao"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["preliminares_contestacao"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["merito_fatos_reu"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["merito_direito_reu"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["pedidos_reu"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["provas_reu"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        `{Config.CONTESTACAO_MARKERS_MAP["fechamento_data_assinatura_reu"]}`
        (CONTEÚDO DA SEÇÃO AQUI...)
        ATENÇÃO FINAL: CUMPRA RIGOROSAMENTE A INSTRUÇÃO DE INICIAR CADA SEÇÃO COM SEU MARCADOR EXATO.
        """
        prompt_completo = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso_completo, instrucao)
        return GeminiAPI.chamar_api(prompt_completo, temperature=0.35, max_output_tokens=Config.CONTESTACAO_MAX_TOKENS)

    @staticmethod
    def simular_aij(contexto_caso_completo: dict, _p:str, _c:str) -> str: # PROMPT CORRIGIDO
        lado_representado = contexto_caso_completo.get('lado_representado', ''); perfil_juiz = contexto_caso_completo.get('perfil_juiz', CasoPedroVsPortal.PERFIL_JUIZ_PADRAO)
        num_adv_autor = contexto_caso_completo.get('num_adv_autor', 2); adv_autor_papeis = contexto_caso_completo.get('adv_autor_papeis', CasoPedroVsPortal.ADV_AUTOR_PAPEIS_PADRAO)
        num_test_autor = contexto_caso_completo.get('num_test_autor', 2); test_autor_detalhes = contexto_caso_completo.get('test_autor_detalhes', CasoPedroVsPortal.TEST_AUTOR_DETALHES_PADRAO)
        num_adv_reu = contexto_caso_completo.get('num_adv_reu', 2); adv_reu_papeis = contexto_caso_completo.get('adv_reu_papeis', CasoPedroVsPortal.ADV_REU_PAPEIS_PADRAO)
        num_test_reu = contexto_caso_completo.get('num_test_reu', 2); test_reu_detalhes = contexto_caso_completo.get('test_reu_detalhes', CasoPedroVsPortal.TEST_REU_DETALHES_PADRAO)
        adv_autor_lista = [adv.split('-')[0].strip() for adv in adv_autor_papeis.splitlines()] if adv_autor_papeis else [f"Adv. Autor {i+1}" for i in range(num_adv_autor)]
        adv_reu_lista = [adv.split('-')[0].strip() for adv in adv_reu_papeis.splitlines()] if adv_reu_papeis else [f"Adv. Réu {i+1}" for i in range(num_adv_reu)]
        descricao_perfil_juiz = f"O Juiz da simulação deve refletir um perfil '{perfil_juiz}'.\n"
        if perfil_juiz == 'Conciliador': descricao_perfil_juiz += "- Buscará ativamente acordo.\n"
        elif perfil_juiz == 'Legalista Estrito': descricao_perfil_juiz += "- Focará na aplicação literal da lei e provas formais.\n"
        elif perfil_juiz == 'Garantista (foco em direitos fundamentais)': descricao_perfil_juiz += "- Atenção aos direitos fundamentais (privacidade vs. liberdade de imprensa).\n"
        elif perfil_juiz == 'Mais Rígido/Formal': descricao_perfil_juiz += "- Exigirá formalidades, controlará tempo.\n"
        else: descricao_perfil_juiz += "- Equilibrado, focado nos fatos e direito aplicável.\n"

        instrucao_principal_aij = f"""
        **Persona:** Narrador Jurídico para AIJ do caso {CasoPedroVsPortal.NOME_CASO}. Usuário é {lado_representado}. Perfil Juiz: {perfil_juiz}.
        DETALHE as falas e depoimentos com base nos arquivos PI e Contestação (no contexto global).
        PARA CADA ETAPA NUMERADA ABAIXO, INICIE A SEÇÃO COM O TEXTO DO MARCADOR EXATO FORNECIDO ENTRE ASPAS SIMPLES. NÃO OMITE NENHUM MARCADOR.
        NÃO INCLUA "Config.AIJ_MARKERS_MAP" OU QUALQUER NOME DE VARIÁVEL PYTHON NA SUA SAÍDA, APENAS O TEXTO DO MARCADOR.

        Etapas e Marcadores a Utilizar:
        1. Use o marcador '{Config.AIJ_MARKERS_MAP["1_abertura"]}' para a ABERTURA E CONCILIAÇÃO.
           (Conteúdo: Juiz indaga. Adv. Autor ({adv_autor_lista[0] if adv_autor_lista else 'Autor'}) propõe (ex: R$20mil+remoção da notícia original). Adv. Réu ({adv_reu_lista[0] if adv_reu_lista else 'Réu'}) contrapropõe (ex: só manter o maior destaque à atualização já feita, e reitera a prescrição). Juiz media.)

        2. Use o marcador '{Config.AIJ_MARKERS_MAP["2_dep_autor"]}' para o DEPOIMENTO PESSOAL DO AUTOR.
           (Conteúdo: Perguntas do Adv. Réu ({adv_reu_lista[0] if adv_reu_lista else 'Réu'}) sobre: ciência da atualização da notícia pelo Portal, por que demorou tanto para ajuizar a ação se o dano era contínuo, as contradições sobre seu status profissional em 2025. Respostas de Pedro reafirmando o dano e a insuficiência da atualização.)

        3. Use o marcador '{Config.AIJ_MARKERS_MAP["3_dep_reu"]}' para o DEPOIMENTO PESSOAL DO RÉU.
           (Conteúdo: Preposto Paulo Thomas R. Porto. Perguntas do Adv. Autor ({adv_autor_lista[0] if adv_autor_lista else 'Autor'}) sobre: processo de apuração da matéria original de 2020, conhecimento sobre o arquivamento da investigação, como e quando decidiram publicar a atualização em 2021, e se houve consideração da empresa sobre a motivação política alegada pelo Autor. Respostas do Preposto defendendo a diligência e boa-fé.)

        4. Use o marcador '{Config.AIJ_MARKERS_MAP["4_test_autor"]}' para a OITIVA DAS TESTEMUNHAS DO AUTOR.
           (Conteúdo: Usar de CasoPedroVsPortal.TEST_AUTOR_DETALHES_PADRAO. Adv. Autor ({adv_autor_lista[1] if len(adv_autor_lista)>1 else adv_autor_lista[0] if adv_autor_lista else 'Autor'}) pergunta para confirmar o abalo de Pedro. Adv. Réu ({adv_reu_lista[1] if len(adv_reu_lista)>1 else adv_reu_lista[0] if adv_reu_lista else 'Réu'}) repergunta para minar.)

        5. Use o marcador '{Config.AIJ_MARKERS_MAP["5_test_reu"]}' para a OITIVA DAS TESTEMUNHAS DO RÉU.
           (Conteúdo: Usar de CasoPedroVsPortal.TEST_REU_DETALHES_PADRAO. Adv. Réu ({adv_reu_lista[1] if len(adv_reu_lista)>1 else adv_reu_lista[0] if adv_reu_lista else 'Réu'}) pergunta para confirmar a diligência na apuração original e na publicação da atualização. Adv. Autor ({adv_autor_lista[1] if len(adv_autor_lista)>1 else adv_autor_lista[0] if adv_autor_lista else 'Autor'}) repergunta.)

        6. Use o marcador '{Config.AIJ_MARKERS_MAP["6_aleg_autor"]}' para as ALEGAÇÕES FINAIS DO AUTOR.
           (Conteúdo: Adv. Autor ({adv_autor_lista[0] if adv_autor_lista else 'Autor'}) deve: Reafirmar o dano causado pela linguagem da matéria original; Argumentar que a atualização não foi suficiente/tempestiva para reparar integralmente o dano; Tentar afastar a prescrição (dano contínuo/renovado ou ciência tardia da real extensão do dano); Reforçar pedido de R$80.000,00 e remoção da matéria original.)

        7. Use o marcador '{Config.AIJ_MARKERS_MAP["7_aleg_reu"]}' para as ALEGAÇÕES FINAIS DO RÉU.
           (Conteúdo: Adv. Réu ({adv_reu_lista[0] if adv_reu_lista else 'Réu'}) deve: PRIORIZAR a PRESCRIÇÃO como causa extintiva; Destacar a ATUALIZAÇÃO como cumprimento do dever de informar e demonstração de boa-fé; Reafirmar veracidade da notícia original à época; Invocar Tema 786 STF contra o direito ao esquecimento para fatos verídicos; Apontar ausência de dano moral atual ou valor excessivo. Pedir IMPROCEDÊNCIA e condenação do Autor por litigância de má-fé.)

        8. Use o marcador '{Config.AIJ_MARKERS_MAP["8_conc_juiz"]}' para a CONCLUSÃO DO JUIZ PARA SENTENÇA.
           (Conteúdo: Juiz (refletindo perfil '{perfil_juiz}') pondera: FORÇA DA PRESCRIÇÃO no caso concreto; EFEITOS DA ATUALIZAÇÃO DA NOTÍCIA PELO RÉU; APLICAÇÃO DO TEMA 786 STF; ANÁLISE DA LINGUAGEM DA MATÉRIA ORIGINAL (houve abuso?); IMPACTO DA DEMORA DO AUTOR em ajuizar a ação; CONSISTÊNCIA das alegações do Autor. Indica os pontos que serão decisivos.)

        9. Use o marcador '{Config.AIJ_MARKERS_MAP["9_cenarios_riscos_estrategias"]}' para a ANÁLISE DE CENÁRIOS, RISCOS, ESTRATÉGIAS GERAIS.
           (Conteúdo: Para o {lado_representado} no caso {CasoPedroVsPortal.NOME_CASO}.)

        10. Use o marcador '{Config.AIJ_MARKERS_MAP["10_imprevistos_reacoes"]}' para a SIMULAÇÃO DE EVENTOS IMPREVISTOS E REAÇÕES ESTRATÉGICAS.
            (Conteúdo: Para o {lado_representado} no caso {CasoPedroVsPortal.NOME_CASO}.)

        11. Use o marcador '{Config.AIJ_MARKERS_MAP["11_analise_pos_audiencia"]}' para a ANÁLISE ESTRATÉGICA PÓS-AUDIÊNCIA E PRÓXIMOS PASSOS.
            (Conteúdo: Para o {lado_representado} no caso {CasoPedroVsPortal.NOME_CASO}.)

        ATENÇÃO FINAL: CUMPRA RIGOROSAMENTE A INSTRUÇÃO DE INICIAR CADA SEÇÃO COM O TEXTO DO MARCADOR EXATO FORNECIDO ENTRE ASPAS SIMPLES. NÃO PULE LINHAS DESNECESSARIAMENTE ENTRE O MARCADOR E O CONTEÚDO DA SEÇÃO.
        """
        prompt_completo_aij = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso_completo, instrucao_principal_aij)
        return GeminiAPI.chamar_api(prompt_completo_aij, temperature=0.6, max_output_tokens=Config.AIJ_MAX_TOKENS)

    @staticmethod
    def refinar_documento(documento_original: str, tipo_documento: str, instrucoes_refinamento: str, contexto_caso: dict) -> str:
        prompt_refinamento = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso, f"**Tarefa:** Refinar {tipo_documento}.\n**Documento Original:**\n```\n{documento_original}\n```\n**Instruções:**\n{instrucoes_refinamento}\nReescreva o documento COMPLETO incorporando as instruções, MANTENDO OS MARCADORES DE SEÇÃO ORIGINAIS SE EXISTIREM.")
        return GeminiAPI.chamar_api(prompt_refinamento, temperature=0.6, max_output_tokens=Config.REFINAMENTO_MAX_TOKENS)

    @staticmethod
    def sugerir_contra_argumentos(documento_base: str, tipo_documento_base: str, contexto_caso: dict) -> str:
        parte_contraria = "Réu (Portal de Notícias)" if tipo_documento_base == "Petição Inicial" else "Autor (Pedro Vinícius Souza)"
        prompt_contra_args = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso, f"**Tarefa:** Agir como advogado do {parte_contraria}. Analise o documento ({tipo_documento_base} da parte adversa):\n```\n{documento_base}\n```\nIdentifique 3-5 pontos fracos e elabore contra-argumentos detalhados e fundamentados com base no caso {CasoPedroVsPortal.NOME_CASO}.")
        return GeminiAPI.chamar_api(prompt_contra_args, temperature=0.7, max_output_tokens=Config.CONTRA_ARG_MAX_TOKENS)

    @staticmethod
    def gerar_peca_intermediaria(tipo_peca: str, contexto_caso: dict, _peticao_original_nao_usada: str = "", _contestacao_original_nao_usada: str = "") -> str:
        instrucao_especifica = ""
        if tipo_peca == "Réplica à Contestação":
            if not (DADOS_PI_STR_GLOBAL and DADOS_CONTESTACAO_STR_GLOBAL): return "ERRO: PI ou Contestação global não carregada."
            instrucao_especifica = f"Pelo AUTOR (Pedro). Com base na Petição Inicial e na Contestação (ambas no contexto global), elabore a Réplica. REFUTE especificamente a PRELIMINAR DE PRESCRIÇÃO levantada. IMPUGNE os argumentos da defesa sobre a atualização da notícia ser suficiente. REAFIRME o dano moral e os pedidos da PI (detalhada no contexto global)."
        elif tipo_peca == "Tréplica (simplificada)":
            if not (DADOS_PI_STR_GLOBAL and DADOS_CONTESTACAO_STR_GLOBAL): return "ERRO: PI ou Contestação global não carregada."
            instrucao_especifica = f"Pelo RÉU (Portal). Com base na Petição Inicial e na Contestação (ambas no contexto global), elabore uma Tréplica concisa. INFERINDO que a Réplica do Autor tentou afastar a prescrição e minimizou a importância da atualização da notícia, REFORCE a tese da PRESCRIÇÃO e a SUFICIÊNCIA da atualização. REITERE o pedido de improcedência."
        elif tipo_peca == "Requerimento de Prova Pericial (simples)":
            instrucao_especifica = f"Considerando o caso {CasoPedroVsPortal.NOME_CASO}, elabore um requerimento simples de prova pericial. Se pelo Autor, poderia ser para aferir dano psicológico. Se pelo Réu, poderia ser para demonstrar o alcance limitado da matéria original após a atualização. Apresente 2-3 quesitos."
        elif tipo_peca == "Requerimento de Oitiva de Testemunha Referida (simples)":
             instrucao_especifica = f"No caso {CasoPedroVsPortal.NOME_CASO}, suponha que durante um depoimento uma pessoa não arrolada foi mencionada como tendo conhecimento crucial de um fato (ex: o 'morador ouvido' na matéria original, se identificado). Elabore o requerimento para sua oitiva, justificando a pertinência."
        elif tipo_peca == "Modelo de Ata Notarial (Simulada)":
            instrucao_especifica = f"Para o caso {CasoPedroVsPortal.NOME_CASO}, crie um modelo de Ata Notarial para o Autor constatar o conteúdo e acessibilidade da matéria original em um buscador em data RECENTE (ex: início de 2025), para tentar argumentar a continuidade do dano ou ciência tardia para fins de prescrição."
        else: return f"ERRO: Tipo '{tipo_peca}' não implementado para geração específica."
        prompt_peca = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso, f"**Tarefa:** Gerar esboço para: **{tipo_peca}**.\n{instrucao_especifica}")
        return GeminiAPI.chamar_api(prompt_peca, temperature=0.65, max_output_tokens=Config.PECA_INTERM_MAX_TOKENS)

    @staticmethod
    def validar_peca_gerada(peca_texto: str, tipo_peca: str, contexto_caso: dict) -> str:
        prompt_validacao = GeradorDocumentos._construir_prompt_base_com_contexto(contexto_caso, f"**Tarefa:** Revisar criticamente a {tipo_peca} (para o caso {CasoPedroVsPortal.NOME_CASO}):\n```\n{peca_texto}\n```\nIdentifique pontos fortes, 2-3 fragilidades/omissões com sugestões concretas de melhoria, e classifique a robustez (Sólida, Boa com ressalvas, Requer melhorias).")
        return GeminiAPI.chamar_api(prompt_validacao, temperature=0.6, max_output_tokens=Config.VALIDACAO_MAX_TOKENS)


# --- Classe ProcessadorTexto ---
class ProcessadorTexto:
    # (COLE A CLASSE ProcessadorTexto COMPLETA COM OS LOGS DE DEBUG DA MENSAGEM ANTERIOR AQUI)
    @staticmethod
    def _extrair_secao(texto_completo: str, texto_lower: str, marcador_inicio: str, marcadores_subsequentes: List[str]) -> Optional[str]:
        logger.debug(f"ProcessadorTexto: Tentando extrair seção para o marcador: '{marcador_inicio}'")
        start_idx = texto_lower.find(marcador_inicio.lower())
        if start_idx == -1:
            logger.warning(f"ProcessadorTexto: Marcador de início '{marcador_inicio}' NÃO encontrado.")
            return None
        content_start_idx = start_idx + len(marcador_inicio)
        end_idx = len(texto_completo)
        logger.debug(f"ProcessadorTexto: Marcador '{marcador_inicio}' encontrado em {start_idx}. Conteúdo começa em {content_start_idx}.")
        for next_marcador in marcadores_subsequentes:
            next_marker_idx_found = texto_lower.find(next_marcador.lower(), content_start_idx)
            logger.debug(f"  ProcessadorTexto: Checando próximo marcador '{next_marcador}', encontrado em: {next_marker_idx_found}")
            if next_marker_idx_found != -1:
                end_idx = min(end_idx, next_marker_idx_found)
        extracted_content = texto_completo[content_start_idx:end_idx].strip()
        logger.debug(f"  ProcessadorTexto: Índice final para '{marcador_inicio}': {end_idx}. Conteúdo extraído (primeiros 100 chars): '{extracted_content[:100]}'")
        return extracted_content

    @staticmethod
    def processar_documento(texto_completo: str, markers_map: Dict[str, str]) -> Dict[str, str]:
        global _peticao_completa_exportar, _contestacao_completa_exportar
        nome_doc_log = "Documento Desconhecido"
        if markers_map == Config.PETICAO_MARKERS_MAP:
            _peticao_completa_exportar = texto_completo; nome_doc_log = "Petição Inicial"
        elif markers_map == Config.CONTESTACAO_MARKERS_MAP:
            _contestacao_completa_exportar = texto_completo; nome_doc_log = "Contestação"
        logger.info(f"ProcessadorTexto: Processando {nome_doc_log}.")

        if not texto_completo or texto_completo.startswith("ERRO_"):
            logger.error(f"ProcessadorTexto: Erro na geração completa do {nome_doc_log} recebido: {texto_completo[:100]}")
            return {key: f"Erro na geração completa do {nome_doc_log}: {texto_completo}" for key in markers_map.keys()}

        partes = {key: f"⚠️ Seção '{marker}' não encontrada no texto gerado para {nome_doc_log}." for key, marker in markers_map.items()}
        texto_lower = texto_completo.lower()
        sorted_marcadores = list(markers_map.items())

        for i, (key, marcador_inicio) in enumerate(sorted_marcadores):
            marcadores_subs = [m_text for _, m_text in sorted_marcadores[i+1:]]
            conteudo = ProcessadorTexto._extrair_secao(texto_completo, texto_lower, marcador_inicio, marcadores_subs)
            if conteudo is not None: partes[key] = conteudo
            else: logger.warning(f"ProcessadorTexto: Conteúdo para marcador '{marcador_inicio}' (chave '{key}') em {nome_doc_log} não foi encontrado.")
        return partes

    @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
        logger.info("ProcessadorTexto: Processando AIJ.")
        return ProcessadorTexto.processar_documento(aij_texto_completo, Config.AIJ_MARKERS_MAP)

# --- Classe InterfaceProcesso ---
class InterfaceProcesso:
    # (COLE A CLASSE InterfaceProcesso COMPLETA DA MENSAGEM ANTERIOR AQUI,
    #  INCLUINDO carregar_e_validar_arquivos_caso, simular_processo_completo_ui_generator,
    #  TODOS os handlers (handle_refinamento_ui, etc.) E a função criar_interface() completa
    #  com os valores padrão de CasoPedroVsPortal e os .click() corretos)
    @staticmethod
    def carregar_e_validar_arquivos_caso(): # Função completa
        global DADOS_PI_STR_GLOBAL, DADOS_CONTESTACAO_STR_GLOBAL
        logger.info("Carregando dados dos arquivos do caso para uso global...")
        def _carregar_um_arquivo(caminho_arquivo):
            if not os.path.exists(caminho_arquivo): return f"❌ Arquivo '{caminho_arquivo}' não encontrado."
            try:
                with open(caminho_arquivo, 'r', encoding='utf-8') as f:
                    conteudo = f.read().strip()
                    if not conteudo: return f"⚠️  Arquivo '{caminho_arquivo}' está vazio"
                    logger.info(f"📄 Arquivo '{caminho_arquivo}' carregado ({len(conteudo)} caracteres)")
                    return conteudo
            except Exception as e: return f"❌ Erro ao ler '{caminho_arquivo}': {str(e)}"
        DADOS_PI_STR_GLOBAL = _carregar_um_arquivo(ARQUIVO_PETICAO_INICIAL_NOME)
        DADOS_CONTESTACAO_STR_GLOBAL = _carregar_um_arquivo(ARQUIVO_CONTESTACAO_NOME)
        if DADOS_PI_STR_GLOBAL.startswith("❌") or DADOS_PI_STR_GLOBAL.startswith("⚠️") or \
           DADOS_CONTESTACAO_STR_GLOBAL.startswith("❌") or DADOS_CONTESTACAO_STR_GLOBAL.startswith("⚠️"):
            msg = f"PI: {DADOS_PI_STR_GLOBAL[:100]}... | Contestação: {DADOS_CONTESTACAO_STR_GLOBAL[:100]}..."
            logger.error(f"Problema ao carregar arquivos de dados: {msg}")
            return False, f"Falha ao carregar arquivos. PI: {DADOS_PI_STR_GLOBAL}. Contestação: {DADOS_CONTESTACAO_STR_GLOBAL}"
        logger.info("Dados da PI e Contestação carregados e disponíveis globalmente."); return True, "Dados do caso carregados com sucesso."

    @staticmethod
    def simular_processo_completo_ui_generator( # Função completa
        resumo_caso_input: str, pontos_autor_input: str, pontos_reu_input: str, tom_defesa_reu_input: str,
        lado_representado_input: str,
        num_adv_autor_input: int, adv_autor_papeis_input: str,
        num_adv_reu_input: int, adv_reu_papeis_input: str,
        num_test_autor_input: int, test_autor_detalhes_input: str,
        num_test_reu_input: int, test_reu_detalhes_input: str,
        perfil_juiz_input: str
    ):
        global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
        _peticao_completa_exportar = ""; _contestacao_completa_exportar = ""; _aij_texto_completo_para_exportar = ""
        contexto_caso_completo = {
            "resumo_caso": resumo_caso_input, "pontos_autor": pontos_autor_input, "pontos_reu": pontos_reu_input,
            "tom_defesa_reu": tom_defesa_reu_input, "lado_representado": lado_representado_input,
            "num_adv_autor": num_adv_autor_input, "adv_autor_papeis": adv_autor_papeis_input,
            "num_adv_reu": num_adv_reu_input, "adv_reu_papeis": adv_reu_papeis_input,
            "num_test_autor": num_test_autor_input, "test_autor_detalhes": test_autor_detalhes_input,
            "num_test_reu": num_test_reu_input, "test_reu_detalhes": test_reu_detalhes_input,
            "perfil_juiz": perfil_juiz_input
        }
        num_peticao_outputs = len(Config.PETICAO_MARKERS_MAP)
        num_contestacao_outputs = len(Config.CONTESTACAO_MARKERS_MAP)
        num_aij_outputs = len(Config.AIJ_MARKERS_MAP)
        current_output_values = [gr.update(value="Processando...")] * (num_peticao_outputs + num_contestacao_outputs + num_aij_outputs) \
                              + [gr.update(value="Iniciando..."), "", "", {}]
        def create_error_outputs_tuple_local(base_error_msg: str):
            error_updates = [gr.update(value=base_error_msg)] * (num_peticao_outputs + num_contestacao_outputs + num_aij_outputs) \
                          + [gr.update(value=base_error_msg), "", "", {}]
            return tuple(error_updates)
        if not GEMINI_API_KEY: yield create_error_outputs_tuple_local("ERRO FATAL: API Key do Gemini não configurada."); return
        if not DADOS_PI_STR_GLOBAL or DADOS_PI_STR_GLOBAL.startswith("ERRO:") or DADOS_PI_STR_GLOBAL.startswith("⚠️") or \
           not DADOS_CONTESTACAO_STR_GLOBAL or DADOS_CONTESTACAO_STR_GLOBAL.startswith("ERRO:") or DADOS_CONTESTACAO_STR_GLOBAL.startswith("⚠️"):
             yield create_error_outputs_tuple_local(f"ERRO: Falha ao carregar arquivos de dados da PI ou Contestação. PI: '{DADOS_PI_STR_GLOBAL[:50]}...' Contestação: '{DADOS_CONTESTACAO_STR_GLOBAL[:50]}...'. Verifique os logs e se os arquivos existem."); return
        status_idx = num_peticao_outputs + num_contestacao_outputs + num_aij_outputs
        estado_peticao_idx = status_idx + 1; estado_contestacao_idx = status_idx + 2; estado_contexto_idx = status_idx + 3
        current_output_values[status_idx] = gr.update(value="Gerando Petição Inicial...")
        yield tuple(current_output_values)
        peticao_autor_txt = GeradorDocumentos.gerar_peticao_inicial(contexto_caso_completo)
        logger.info(f"\n\nDEBUG: TEXTO BRUTO DA PETIÇÃO GERADA PELA IA:\n==========\n{peticao_autor_txt}\n==========\n")
        peticao_partes_dict = ProcessadorTexto.processar_documento(peticao_autor_txt, Config.PETICAO_MARKERS_MAP)
        for i, key_p in enumerate(Config.PETICAO_MARKERS_MAP.keys()): current_output_values[i] = gr.update(value=peticao_partes_dict.get(key_p, f"⚠️ Seção '{Config.PETICAO_MARKERS_MAP[key_p]}' não encontrada na Petição."))
        current_output_values[estado_peticao_idx] = peticao_autor_txt
        if "ERRO_" in peticao_autor_txt:
            logger.error(f"Falha ao gerar Petição: {peticao_autor_txt}"); current_output_values[status_idx] = gr.update(value=f"Falha Petição: {peticao_autor_txt[:100]}...")
            for i_err in range(num_peticao_outputs, num_peticao_outputs + num_contestacao_outputs + num_aij_outputs): current_output_values[i_err] = gr.update(value="Erro na Petição.")
            yield tuple(current_output_values); return
        current_output_values[status_idx] = gr.update(value="Petição Gerada. Gerando Contestação...")
        yield tuple(current_output_values)
        contestacao_reu_txt = GeradorDocumentos.gerar_contestacao(contexto_caso_completo, peticao_autor_txt)
        logger.info(f"\n\nDEBUG: TEXTO BRUTO DA CONTESTAÇÃO GERADA PELA IA:\n==========\n{contestacao_reu_txt}\n==========\n")
        contestacao_partes_dict = ProcessadorTexto.processar_documento(contestacao_reu_txt, Config.CONTESTACAO_MARKERS_MAP)
        for i, key_c in enumerate(Config.CONTESTACAO_MARKERS_MAP.keys()): current_output_values[num_peticao_outputs + i] = gr.update(value=contestacao_partes_dict.get(key_c, f"⚠️ Seção '{Config.CONTESTACAO_MARKERS_MAP[key_c]}' não encontrada na Contestação."))
        current_output_values[estado_contestacao_idx] = contestacao_reu_txt
        if "ERRO_" in contestacao_reu_txt:
            logger.error(f"Falha Contestação: {contestacao_reu_txt}"); current_output_values[status_idx] = gr.update(value=f"Falha Contestação: {contestacao_reu_txt[:100]}...")
            for i_err in range(num_peticao_outputs + num_contestacao_outputs, num_peticao_outputs + num_contestacao_outputs + num_aij_outputs): current_output_values[i_err] = gr.update(value="Erro na Contestação.")
            yield tuple(current_output_values); return
        current_output_values[status_idx] = gr.update(value="Contestação Gerada. Simulando AIJ...")
        yield tuple(current_output_values)
        aij_simulacao_txt_completa = GeradorDocumentos.simular_aij(contexto_caso_completo, peticao_autor_txt, contestacao_reu_txt)
        logger.info(f"\n\nDEBUG: TEXTO BRUTO DA AIJ GERADA PELA IA:\n==========\n{aij_simulacao_txt_completa}\n==========\n")
        aij_partes_dict = ProcessadorTexto.processar_aij(aij_simulacao_txt_completa)
        for i, key_a in enumerate(Config.AIJ_MARKERS_MAP.keys()): current_output_values[num_peticao_outputs + num_contestacao_outputs + i] = gr.update(value=aij_partes_dict.get(key_a, f"⚠️ Seção '{Config.AIJ_MARKERS_MAP[key_a]}' não encontrada na AIJ."))
        if "ERRO_" in aij_simulacao_txt_completa:
            logger.error(f"Falha AIJ: {aij_simulacao_txt_completa}"); current_output_values[status_idx] = gr.update(value=f"Falha AIJ: {aij_simulacao_txt_completa[:100]}...")
            yield tuple(current_output_values); return
        current_output_values[status_idx] = gr.update(value="Simulação completa."); current_output_values[estado_contexto_idx] = contexto_caso_completo; yield tuple(current_output_values)

    @staticmethod
    def handle_refinamento_ui(documento_original_state, tipo_documento, instrucoes_refinamento, contexto_caso_state, status_output_comp): # Função completa
        if not GEMINI_API_KEY: return "ERRO_REFINAR: API Key não configurada.", documento_original_state, gr.update(component=status_output_comp, value="ERRO: API Key não configurada.")
        if not documento_original_state or documento_original_state.startswith("ERRO_") or documento_original_state.startswith("⚠️ Seção"): return f"ERRO_REFINAR: Documento '{tipo_documento}' original não gerado ou com erro.", documento_original_state, gr.update(component=status_output_comp, value=f"ERRO: {tipo_documento} original não gerado ou com erro.")
        if not instrucoes_refinamento: return documento_original_state, documento_original_state, gr.update(component=status_output_comp, value="AVISO: Forneça instruções para refinar.")
        if not contexto_caso_state: return "ERRO_REFINAR: Contexto do caso não encontrado.", documento_original_state, gr.update(component=status_output_comp, value="ERRO: Contexto do caso não encontrado.")
        logger.info(f"Refinando {tipo_documento}...")
        status_output_comp.update(value=f"Refinando {tipo_documento}...")
        documento_refinado = GeradorDocumentos.refinar_documento(documento_original_state, tipo_documento, instrucoes_refinamento, contexto_caso_state)
        novo_estado_para_peca = documento_refinado if "ERRO_" not in documento_refinado else documento_original_state
        status_msg = f"{tipo_documento} refinada com sucesso!" if "ERRO_" not in documento_refinado else f"Falha ao refinar {tipo_documento}: {documento_refinado}"
        if "ERRO_" not in documento_refinado:
            if tipo_documento == "Petição Inicial": global _peticao_completa_exportar; _peticao_completa_exportar = documento_refinado
            elif tipo_documento == "Contestação": global _contestacao_completa_exportar; _contestacao_completa_exportar = documento_refinado
        return documento_refinado, novo_estado_para_peca, gr.update(value=status_msg)

    @staticmethod
    def handle_sugerir_contra_argumentos_ui(documento_base_state, tipo_documento_base, contexto_caso_state, status_output_comp): # Função completa
        if not GEMINI_API_KEY: return "ERRO: API Key não configurada.", gr.update(component=status_output_comp, value="Erro API Key")
        if not documento_base_state or documento_base_state.startswith("ERRO_") or documento_base_state.startswith("⚠️ Seção"): return f"ERRO: {tipo_documento_base} base não gerada ou com erro.", gr.update(component=status_output_comp, value="Erro Doc Base")
        if not contexto_caso_state: return "ERRO: Contexto do caso não encontrado.", gr.update(component=status_output_comp, value="Erro Contexto")
        logger.info(f"Sugerindo contra-argumentos para {tipo_documento_base}...")
        status_output_comp.update(value=f"Analisando {tipo_documento_base}...")
        contra_argumentos_txt = GeradorDocumentos.sugerir_contra_argumentos(documento_base_state, tipo_documento_base, contexto_caso_state)
        novo_status = f"Análise de contra-argumentos para {tipo_documento_base} concluída."
        if "ERRO_" in contra_argumentos_txt: novo_status = f"Falha na análise: {contra_argumentos_txt}"
        return contra_argumentos_txt, gr.update(value=novo_status)

    @staticmethod
    def handle_gerar_peca_intermediaria_ui(tipo_peca, contexto_caso_state, estado_peticao_atual, estado_contestacao_atual, status_output_comp): # Função completa
        if not GEMINI_API_KEY: return "ERRO: API Key não configurada.", gr.update(component=status_output_comp, value="Erro API Key")
        if not contexto_caso_state: return "ERRO: Contexto do caso não encontrado.", gr.update(component=status_output_comp, value="Erro Contexto")
        if tipo_peca == "Réplica à Contestação" and (not estado_contestacao_atual or estado_contestacao_atual.startswith("ERRO_")): return "ERRO: Contestação não gerada ou com erro para basear a Réplica.", gr.update(component=status_output_comp, value="Gerar Contestação Primeiro")
        if tipo_peca == "Tréplica (simplificada)" and ((not estado_peticao_atual or estado_peticao_atual.startswith("ERRO_")) or (not estado_contestacao_atual or estado_contestacao_atual.startswith("ERRO_"))) : return "ERRO: Petição ou Contestação não gerada ou com erro para basear a Tréplica.", gr.update(component=status_output_comp, value="Gerar Peças Principais Primeiro")
        logger.info(f"Gerando peça intermediária: {tipo_peca}...")
        status_output_comp.update(value=f"Gerando {tipo_peca}...")
        peca_gerada_txt = GeradorDocumentos.gerar_peca_intermediaria(tipo_peca, contexto_caso_state, estado_peticao_atual, estado_contestacao_atual)
        novo_status = f"{tipo_peca} gerada com sucesso."
        if "ERRO_" in peca_gerada_txt: novo_status = f"Falha ao gerar {tipo_peca}: {peca_gerada_txt}"
        return peca_gerada_txt, gr.update(value=novo_status)

    @staticmethod
    def handle_validar_peca_ui(peca_state, tipo_peca, contexto_caso_state, status_output_comp): # Função completa
        if not GEMINI_API_KEY: return "ERRO: API Key não configurada.", gr.update(component=status_output_comp, value="Erro API Key")
        if not peca_state or peca_state.startswith("ERRO_") or peca_state.startswith("⚠️ Seção"): return f"ERRO: {tipo_peca} não gerada ou com erro para validação.", gr.update(component=status_output_comp, value=f"{tipo_peca} não existe/erro")
        if not contexto_caso_state: return "ERRO: Contexto do caso não encontrado.", gr.update(component=status_output_comp, value="Contexto não existe")
        logger.info(f"Validando {tipo_peca}...")
        status_output_comp.update(value=f"Validando {tipo_peca}...")
        texto_validacao = GeradorDocumentos.validar_peca_gerada(peca_state, tipo_peca, contexto_caso_state)
        status_msg = f"Validação da {tipo_peca} concluída."
        if "ERRO_" in texto_validacao: status_msg = f"Erro na validação da {tipo_peca}: {texto_validacao}"
        return texto_validacao, gr.update(value=status_msg)

    @staticmethod
    def criar_interface() -> Optional[gr.Blocks]: # Função completa
        global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
        logger.info("Iniciando a criação da interface Gradio...")
        try:
            with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="blue", neutral_hue="slate"), title="Simulador Jurídico Ultra") as demo:
                gr.HTML(STYLE_CSS)
                with gr.Column(elem_classes="aij-container"):
                    with gr.Row(elem_classes="aij-header"): gr.Markdown(f"<h1>⚖️ Simulador Jurídico Ultra IA</h1><p>Caso Específico: {CasoPedroVsPortal.NOME_CASO}</p>")
                    with gr.Row():
                        with gr.Column(scale=2, elem_classes="sidebar"):
                            gr.Markdown("## <span class='gradient-text'>⚙️ Configuração do Caso</span>")
                            with gr.Group():
                                lado_representado_input = gr.Radio(choices=["Autor", "Réu"], label="Você representa:", value="Autor", interactive=True)
                                resumo_caso_input = gr.Textbox(lines=6, label="Resumo do Caso (Pré-preenchido):", value=CasoPedroVsPortal.RESUMO_INPUT_UI, interactive=True)
                                pontos_autor_input = gr.Textbox(lines=3, label="Pontos Chave/Provas AUTOR:", value=CasoPedroVsPortal.AUTOR_PONTOS_INPUT_UI, interactive=True)
                                pontos_reu_input = gr.Textbox(lines=3, label="Pontos Chave/Provas RÉU:", value=CasoPedroVsPortal.REU_PONTOS_INPUT_UI, interactive=True)
                                tom_defesa_reu_input = gr.Radio(choices=["Combativa e Firme", "Técnica e Legalista", "Ponderada/Buscando Acordo"], label="Tom Defesa Réu:", value="Técnica e Legalista", interactive=True)
                                perfil_juiz_input = gr.Radio(choices=["Neutro e Técnico", "Conciliador", "Legalista Estrito", "Garantista (foco em direitos fundamentais)", "Mais Rígido/Formal"], label="Perfil Simulado do Juiz:", value=CasoPedroVsPortal.PERFIL_JUIZ_PADRAO, interactive=True)
                            with gr.Accordion("Configuração Avançada: Equipes e Testemunhas", open=False):
                                gr.Markdown("### Advogados do Autor"); num_adv_autor_input = gr.Slider(1, 3, value=2, step=1, label="Nº Adv. Autor:", interactive=True); adv_autor_papeis_input = gr.Textbox(lines=2, label="Papéis/Nomes Adv. Autor (1 por linha):", value=CasoPedroVsPortal.ADV_AUTOR_PAPEIS_PADRAO, interactive=True)
                                gr.Markdown("### Advogados do Réu"); num_adv_reu_input = gr.Slider(1, 3, value=2, step=1, label="Nº Adv. Réu:", interactive=True); adv_reu_papeis_input = gr.Textbox(lines=2, label="Papéis/Nomes Adv. Réu (1 por linha):", value=CasoPedroVsPortal.ADV_REU_PAPEIS_PADRAO, interactive=True)
                                gr.Markdown("### Testemunhas do Autor"); num_test_autor_input = gr.Slider(0, 3, value=2, step=1, label="Nº Test. Autor:", interactive=True); test_autor_detalhes_input = gr.Textbox(lines=3, label="Detalhes Test. Autor (Nome - Qualif. - Ponto Chave):", value=CasoPedroVsPortal.TEST_AUTOR_DETALHES_PADRAO, interactive=True)
                                gr.Markdown("### Testemunhas do Réu"); num_test_reu_input = gr.Slider(0, 3, value=2, step=1, label="Nº Test. Réu:", interactive=True); test_reu_detalhes_input = gr.Textbox(lines=3, label="Detalhes Test. Réu (Nome - Qualif. - Ponto Chave):", value=CasoPedroVsPortal.TEST_REU_DETALHES_PADRAO, interactive=True)
                            all_inputs_simulacao_principal = [resumo_caso_input, pontos_autor_input, pontos_reu_input, tom_defesa_reu_input, lado_representado_input, num_adv_autor_input, adv_autor_papeis_input, num_adv_reu_input, adv_reu_papeis_input, num_test_autor_input, test_autor_detalhes_input, num_test_reu_input, test_reu_detalhes_input, perfil_juiz_input]
                            status_output = gr.Label(value="Aguardando configuração da API Key e simulação...")
                            btn_simular = gr.Button("🚀 Simular Processo Completo com IA", variant="primary", elem_id="btn_simular_grande")
                            with gr.Row(): btn_limpar_entradas = gr.Button("🧹 Limpar Tudo", variant="secondary"); btn_restaurar_padrao = gr.Button("🔄 Restaurar Padrão", variant="secondary")
                            btn_exportar_zip = gr.Button("📄 Exportar Tudo como ZIP", variant="secondary"); output_arquivo_zip = gr.File(label="Baixar Simulação Completa", visible=False, interactive=False)
                        with gr.Column(scale=3):
                            gr.Markdown("## <span class='gradient-text'>📜 Resultados da Simulação e Ferramentas</span>")
                            peticao_outputs_ui_map = {}; contestacao_outputs_ui_map = {}; aij_outputs_ui_map = {}
                            with gr.TabItem("📜 Petição Inicial (Autor)"):
                                for key_p, title_p in Config.PETICAO_MARKERS_MAP.items():
                                    accordion_title_p = re.sub(r"### \d*\.*\s*", "", title_p).replace(" (Narrativa Detalhada do Autor)", "").replace(" (Fundamentação Jurídica Detalhada)", "")
                                    with gr.Accordion(accordion_title_p, open=(key_p=="fatos_autor")): peticao_outputs_ui_map[key_p] = gr.Markdown(show_copy_button=True)
                                with gr.Accordion("Refinar Petição", open=False):
                                    instrucao_refinamento_peticao = gr.Textbox(lines=2, label="Instruções para refinar:", placeholder="Ex: Adicione jurisprudência...")
                                    btn_refinar_peticao = gr.Button("Refinar Petição", variant="secondary")
                                    output_peticao_refinada_md = gr.Markdown(show_copy_button=True, label="Petição Refinada:")
                                btn_prever_defesa_peticao = gr.Button("🔍 Analisar Petição e Prever Contra-Argumentos do Réu", variant="secondary"); output_analise_peticao = gr.Markdown(label="Análise/Previsão:")
                                btn_validar_peticao = gr.Button("⚖️ Validar Petição (Revisão IA)", variant="secondary"); output_validacao_peticao = gr.Markdown(label="Validação:")
                            with gr.TabItem("🛡️ Contestação (Réu)"):
                                for key_c, title_c in Config.CONTESTACAO_MARKERS_MAP.items():
                                    with gr.Accordion(re.sub(r"### \d*\.*\s*", "", title_c), open=(key_c=="preliminares_contestacao")): contestacao_outputs_ui_map[key_c] = gr.Markdown(show_copy_button=True)
                                with gr.Accordion("Refinar Contestação", open=False):
                                    instrucao_refinamento_contestacao = gr.Textbox(lines=2, label="Instruções para refinar:", placeholder="Ex: Reforce a prescrição...")
                                    btn_refinar_contestacao = gr.Button("Refinar Contestação", variant="secondary")
                                    output_contestacao_refinada_md = gr.Markdown(show_copy_button=True, label="Contestação Refinada:")
                                btn_prever_ataque_contestacao = gr.Button("🎯 Analisar Contestação e Prever Réplica do Autor", variant="secondary"); output_analise_contestacao = gr.Markdown(label="Análise/Previsão:")
                                btn_validar_contestacao = gr.Button("⚖️ Validar Contestação (Revisão IA)", variant="secondary"); output_validacao_contestacao = gr.Markdown(label="Validação:")
                            with gr.TabItem("🎤 Audiência (AIJ)"):
                                output_aij_export_box = gr.Textbox(label="AIJ Completa (copiar):", lines=1, interactive=False, show_copy_button=True)
                                for key_a, title_a in Config.AIJ_MARKERS_MAP.items():
                                    with gr.Accordion(re.sub(r"### \d+\.\s*", "", title_a), open=(key_a=="1_abertura")): aij_outputs_ui_map[key_a] = gr.Markdown(show_copy_button=True)
                            with gr.TabItem("📝 Peças Intermediárias"):
                                tipo_peca_intermediaria_dd = gr.Dropdown(choices=["Réplica à Contestação", "Tréplica (simplificada)", "Requerimento de Prova Pericial (simples)", "Requerimento de Oitiva de Testemunha Referida (simples)", "Modelo de Ata Notarial (Simulada)"], label="Selecione Peça:", value="Réplica à Contestação")
                                btn_gerar_peca_intermediaria = gr.Button("Gerar Peça Intermediária", variant="secondary"); output_peca_intermediaria = gr.Markdown(label="Peça Gerada:", show_copy_button=True)
                    estado_peticao_atual = gr.State(value=""); estado_contestacao_atual = gr.State(value=""); estado_contexto_caso = gr.State(value={})
                    outputs_simulacao_principal_list_ui = list(peticao_outputs_ui_map.values()) + list(contestacao_outputs_ui_map.values()) + list(aij_outputs_ui_map.values()) + [status_output, estado_peticao_atual, estado_contestacao_atual, estado_contexto_caso]
                    def update_export_boxes_fn_wrapper(): global _aij_texto_completo_para_exportar; return gr.update(value=_aij_texto_completo_para_exportar if _aij_texto_completo_para_exportar else "AIJ ainda não gerada.")
                    btn_simular.click(InterfaceProcesso.simular_processo_completo_ui_generator, inputs=all_inputs_simulacao_principal, outputs=outputs_simulacao_principal_list_ui).then(update_export_boxes_fn_wrapper, outputs=[output_aij_export_box])
                    btn_refinar_peticao.click(fn=InterfaceProcesso.handle_refinamento_ui, inputs=[estado_peticao_atual, gr.Textbox(value="Petição Inicial", visible=False), instrucao_refinamento_peticao, estado_contexto_caso, status_output], outputs=[output_peticao_refinada_md, estado_peticao_atual, status_output])
                    btn_refinar_contestacao.click(fn=InterfaceProcesso.handle_refinamento_ui, inputs=[estado_contestacao_atual, gr.Textbox(value="Contestação", visible=False), instrucao_refinamento_contestacao, estado_contexto_caso, status_output], outputs=[output_contestacao_refinada_md, estado_contestacao_atual, status_output])
                    btn_prever_defesa_peticao.click(InterfaceProcesso.handle_sugerir_contra_argumentos_ui, inputs=[estado_peticao_atual, gr.Textbox(value="Petição Inicial", visible=False), estado_contexto_caso, status_output], outputs=[output_analise_peticao, status_output])
                    btn_prever_ataque_contestacao.click(InterfaceProcesso.handle_sugerir_contra_argumentos_ui, inputs=[estado_contestacao_atual, gr.Textbox(value="Contestação", visible=False), estado_contexto_caso, status_output], outputs=[output_analise_contestacao, status_output])
                    btn_gerar_peca_intermediaria.click(InterfaceProcesso.handle_gerar_peca_intermediaria_ui, inputs=[tipo_peca_intermediaria_dd, estado_contexto_caso, estado_peticao_atual, estado_contestacao_atual, status_output], outputs=[output_peca_intermediaria, status_output])
                    btn_validar_peticao.click(InterfaceProcesso.handle_validar_peca_ui, inputs=[estado_peticao_atual, gr.Textbox(value="Petição Inicial", visible=False), estado_contexto_caso, status_output], outputs=[output_validacao_peticao, status_output])
                    btn_validar_contestacao.click(InterfaceProcesso.handle_validar_peca_ui, inputs=[estado_contestacao_atual, gr.Textbox(value="Contestação", visible=False), estado_contexto_caso, status_output], outputs=[output_validacao_contestacao, status_output])
                    componentes_inputs_ui = all_inputs_simulacao_principal
                    componentes_outputs_md_ui = list(peticao_outputs_ui_map.values()) + list(contestacao_outputs_ui_map.values()) + list(aij_outputs_ui_map.values()) + \
                                                [output_analise_peticao, output_validacao_peticao, output_analise_contestacao, output_validacao_contestacao,
                                                 output_aij_export_box, output_peca_intermediaria, output_peticao_refinada_md, output_contestacao_refinada_md]
                    componentes_estados_ui = [estado_peticao_atual, estado_contestacao_atual, estado_contexto_caso]
                    componentes_status_ui = [status_output] # Apenas o Label de status
                    todos_componentes_para_reset = componentes_inputs_ui + componentes_outputs_md_ui + componentes_status_ui + componentes_estados_ui
                    def limpar_tudo_fn():
                        num_inputs = len(componentes_inputs_ui); num_ui_outputs_a_limpar = len(componentes_outputs_md_ui)
                        valores_limpos = ["", "", "", "Técnica e Legalista", "Autor", 1, "", 1, "", 0, "", 0, "", CasoPedroVsPortal.PERFIL_JUIZ_PADRAO][:num_inputs]
                        for _ in range(num_ui_outputs_a_limpar): valores_limpos.append(gr.update(value=""))
                        valores_limpos.append(gr.update(value="Campos limpos.")); valores_limpos.extend(["", "", {}]); return tuple(valores_limpos)
                    btn_limpar_entradas.click(limpar_tudo_fn, inputs=None, outputs=todos_componentes_para_reset)
                    def restaurar_padrao_fn():
                        num_inputs = len(componentes_inputs_ui); num_ui_outputs_a_limpar = len(componentes_outputs_md_ui)
                        restauracao_vals = [CasoPedroVsPortal.RESUMO_INPUT_UI, CasoPedroVsPortal.AUTOR_PONTOS_INPUT_UI, CasoPedroVsPortal.REU_PONTOS_INPUT_UI, "Técnica e Legalista", "Autor", 2, CasoPedroVsPortal.ADV_AUTOR_PAPEIS_PADRAO, 2, CasoPedroVsPortal.ADV_REU_PAPEIS_PADRAO, 2, CasoPedroVsPortal.TEST_AUTOR_DETALHES_PADRAO, 2, CasoPedroVsPortal.TEST_REU_DETALHES_PADRAO, CasoPedroVsPortal.PERFIL_JUIZ_PADRAO][:num_inputs]
                        for _ in range(num_ui_outputs_a_limpar): restauracao_vals.append(gr.update(value=""))
                        restauracao_vals.append(gr.update(value="Caso padrão restaurado.")); restauracao_vals.extend(["", "", {}]); return tuple(restauracao_vals)
                    btn_restaurar_padrao.click(restaurar_padrao_fn, inputs=None, outputs=todos_componentes_para_reset)
                    def exportar_tudo_zip_fn():
                        global _peticao_completa_exportar, _contestacao_completa_exportar, _aij_texto_completo_para_exportar
                        if not (_peticao_completa_exportar or _contestacao_completa_exportar or _aij_texto_completo_para_exportar): return gr.update(visible=False)
                        zip_buffer = io.BytesIO()
                        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
                            if _peticao_completa_exportar and not _peticao_completa_exportar.startswith("ERRO_"): zf.writestr("peticao_inicial.md", _peticao_completa_exportar)
                            if _contestacao_completa_exportar and not _contestacao_completa_exportar.startswith("ERRO_"): zf.writestr("contestacao.md", _contestacao_completa_exportar)
                            if _aij_texto_completo_para_exportar and not _aij_texto_completo_para_exportar.startswith("ERRO_"): zf.writestr("aij_completa.md", _aij_texto_completo_para_exportar)
                        if not zf.namelist(): return gr.update(visible=False)
                        zip_buffer.seek(0); temp_zip_filename = "simulacao_juridica_caso_pedro.zip"
                        with open(temp_zip_filename, "wb") as f: f.write(zip_buffer.getvalue())
                        return gr.File(value=temp_zip_filename, label="Baixar ZIP", visible=True) # Retorna o componente File com o valor
                    btn_exportar_zip.click(exportar_tudo_zip_fn, inputs=None, outputs=[output_arquivo_zip]) # Adicionado inputs=None

                demo.css = """ #btn_simular_grande { font-size: 1.1em !important; padding: 12px 20px !important; } .gradio-container { max-width: 1800px !important; margin: auto !important; } """
            logger.info("Interface Gradio definida.")
            return demo
        except Exception as e_interface:
            logger.error(f"ERRO CRÍTICO ao criar a interface Gradio: {e_interface}")
            traceback.print_exc()
            return None

# --- Bloco Principal ---
if __name__ == '__main__':
    logger.info(f"Executando bloco principal ({__name__})")
    try:
        from google.colab import userdata
        GEMINI_API_KEY = userdata.get('GOOGLE_API_KEY')
        if GEMINI_API_KEY: logger.info("API Key do Gemini carregada dos Secrets do Colab.")
        else: logger.warning("Secret 'GOOGLE_API_KEY' não encontrado/vazio no Colab.")
    except ImportError: logger.info("Não está em ambiente Colab (ou userdata não disponível).")
    except Exception as e: logger.error(f"Erro ao ler secret do Colab: {e}")

    if not GEMINI_API_KEY and "GEMINI_API_KEY" in os.environ:
        GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
        if GEMINI_API_KEY: logger.info("API Key do Gemini carregada de variável de ambiente.")
    
    if not GEMINI_API_KEY:
        logger.warning("API Key do Gemini NÃO ESTÁ CONFIGURADA. Se estiver no Hugging Face Spaces, configure o Secret 'GEMINI_API_KEY'. Para execução local, defina a variável de ambiente ou edite o script.")

    sucesso_carga_inicial, msg_carga_inicial = InterfaceProcesso.carregar_e_validar_arquivos_caso()
    if not sucesso_carga_inicial:
        logger.error(f"CRÍTICO - Falha no carregamento dos dados do caso: {msg_carga_inicial}")

    simulador_interface_obj = None
    try:
        simulador_interface_obj = InterfaceProcesso.criar_interface()
        if simulador_interface_obj:
            logger.info("Interface Gradio pronta. Lançando...")
            simulador_interface_obj.queue().launch(debug=True, share=os.getenv('GRADIO_SHARE', 'False').lower() == 'true')
        else:
            logger.error("A função criar_interface() retornou None. Verifique erros na definição da UI.")
            with gr.Blocks(theme=gr.themes.Soft(primary_hue="red")) as demo_erro_fatal:
                gr.Markdown("# ERRO FATAL NA APLICAÇÃO\nNão foi possível criar a interface principal. Verifique os logs.")
            demo_erro_fatal.launch(debug=True)
    except Exception as e_launch:
        logger.error(f"ERRO CRÍTICO GERAL ao tentar criar/lançar interface: {e_launch}"); traceback.print_exc()