Update app.py

app.py

@@ -10,10 +10,15 @@ from pydantic import BaseModel
 from google import genai
 from google.genai import types
 
-# ─── CONFIGURAÇÃO DA PÁGINA ───────────────────────────────────────────────
+# ─── 1. CONFIGURAÇÃO DA PÁGINA E ESTADO ───────────────────────────────────
 st.set_page_config(page_title="Corretor TCC - UNIFAGOC", page_icon="⚖️", layout="wide")
 
-# ─── ESQUEMAS DE DADOS (PYDANTIC) ─────────────────────────────────────────
+# Inicialização do Gestor de Estados (Evita que o download falhe ao recarregar a página)
+if "resultado_auditoria" not in st.session_state: st.session_state.resultado_auditoria = None
+if "doc_revisado_bytes" not in st.session_state: st.session_state.doc_revisado_bytes = None
+if "doc_formatado_bytes" not in st.session_state: st.session_state.doc_formatado_bytes = None
+
+# ─── 2. ESQUEMAS DE DADOS ESTRITOS (PYDANTIC) ─────────────────────────────
 class AuditoriaTCC(BaseModel):
     aderencia_percentual: int
     diagnostico_geral: str
@@ -39,33 +44,29 @@ class RevisaoInteligente(BaseModel):
     correcoes: list[ErroTexto]
     termos_estrangeiros_para_italico: list[str]
 
-# ─── AUTENTICAÇÃO GEMINI ──────────────────────────────────────────────────
-api_key = os.environ.get("GEMINI_API_KEY")
-if not api_key:
-    st.error("❌ ERRO: A variável de ambiente GEMINI_API_KEY não foi encontrada nos Secrets.")
-    st.stop()
+class ProblemaReferencia(BaseModel):
+    numero: int
+    erros: list[str]
+    elemento_negrito: str
+
+class AnaliseABNT(BaseModel):
+    problemas: list[ProblemaReferencia]
+
+# ─── 3. AUTENTICAÇÃO E CACHE (ALTA PERFORMANCE) ───────────────────────────
+@st.cache_resource
+def get_client():
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        st.error("❌ ERRO: A variável de ambiente GEMINI_API_KEY não foi encontrada nos Secrets do Hugging Face.")
+        st.stop()
+    return genai.Client(api_key=api_key)
 
-client = genai.Client(api_key=api_key)
+client = get_client()
 
-# ─── FUNÇÕES AUXILIARES ───────────────────────────────────────────────────
+# ─── 4. ENGENHARIA DE MANIPULAÇÃO DE DOCUMENTOS (DOCX) ────────────────────
 def extrair_texto_docx(arquivo_upload) -> str:
     doc = Document(arquivo_upload)
-    linhas = [para.text.strip() for para in doc.paragraphs if para.text.strip()]
-    return "\n\n".join(linhas)
-
-def extrair_referencias_docx(doc: Document) -> list:
-    resultado = []
-    em_refs = False
-    for i, para in enumerate(doc.paragraphs):
-        texto = para.text.strip()
-        if not texto: continue
-        if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", texto, re.IGNORECASE):
-            em_refs = True
-            continue
-        if em_refs:
-            if len(texto) < 120 and texto.isupper() and not texto[0].isdigit(): break
-            resultado.append((i, texto))
-    return resultado
+    return "\n\n".join([para.text.strip() for para in doc.paragraphs if para.text.strip()])
 
 def docx_to_bytes(doc: Document) -> bytes:
     byte_io = io.BytesIO()
@@ -73,77 +74,69 @@ def docx_to_bytes(doc: Document) -> bytes:
     return byte_io.getvalue()
 
 def estimar_paginas(doc: Document) -> int:
-    palavras_totales = 0
-    for para in doc.paragraphs:
-        if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", para.text, re.IGNORECASE): break 
-        palavras_totales += len(para.text.split())
-    return max(1, palavras_totales // 350)
+    palavras_totais = sum(len(para.text.split()) for para in doc.paragraphs if not re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", para.text, re.IGNORECASE))
+    return max(1, palavras_totais // 350)
 
-def aplicar_formatacao_estrutural_unifagoc(doc: Document):
-    """Aplica o template de forma segura, sem corromper o XML original."""
-    # 1. Margens Oficiais da Instituição
+def aplicar_formatacao_segura_unifagoc(doc: Document):
     for section in doc.sections:
-        section.page_height = Cm(29.7)
-        section.page_width = Cm(21.0)
-        section.top_margin = Cm(3.0)
-        section.left_margin = Cm(3.0)
-        section.bottom_margin = Cm(2.0)
-        section.right_margin = Cm(2.0)
-
-    # 2. Configura o estilo "Normal" global para evitar quebra de runs
-    if 'Normal' in doc.styles:
-        style = doc.styles['Normal']
-        if style.font:
-            style.font.name = 'Calibri'
-            style.font.size = Pt(12)
+        section.page_height, section.page_width = Cm(29.7), Cm(21.0)
+        section.top_margin, section.left_margin = Cm(3.0), Cm(3.0)
+        section.bottom_margin, section.right_margin = Cm(2.0), Cm(2.0)
 
-    em_referencias = False
-    em_resumo = False
+    em_referencias, em_resumo = False, False
 
-    # 3. Formatação Segura de Parágrafos
     for para in doc.paragraphs:
         texto = para.text.strip()
         if not texto: continue
-
         texto_upper = texto.upper()
+
         if texto_upper.startswith("RESUMO"): em_resumo = True
         elif texto_upper.startswith("INTRODUÇÃO"): em_resumo = False
         elif re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", texto, re.IGNORECASE): em_referencias = True
 
-        # Alinhamento e Recuos
         if em_referencias:
             para.alignment = WD_ALIGN_PARAGRAPH.LEFT
             para.paragraph_format.first_line_indent = Cm(0)
             para.paragraph_format.space_after = Pt(6)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(11)
-                
         elif em_resumo:
             para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
             para.paragraph_format.first_line_indent = Cm(0)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(11)
-                if texto_upper != "RESUMO" and not texto_upper.startswith("PALAVRAS-CHAVE"):
-                    run.font.italic = True
-                    
-        elif texto.isupper() and len(texto) < 100: # Identifica prováveis Títulos
+        elif texto.isupper() and len(texto) < 100:
             para.alignment = WD_ALIGN_PARAGRAPH.CENTER
             para.paragraph_format.first_line_indent = Cm(0)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(12)
-                
         else:
             para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
             para.paragraph_format.first_line_indent = Cm(1.25)
-            # Limpa formatações estranhas para forçar o herdeiro "Normal" (Calibri 12)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(12)
 
-# ─── INTERFACE PRINCIPAL (ABAS) ───────────────────────────────────────────
+        for run in para.runs:
+            run.font.name = 'Calibri'
+            if em_resumo:
+                run.font.size = Pt(11)
+                if texto_upper != "RESUMO" and not texto_upper.startswith("PALAVRAS-CHAVE"):
+                    run.font.italic = True
+            elif em_referencias: run.font.size = Pt(11)
+            elif texto.isupper() and len(texto) < 100: run.font.size = Pt(14) if ("TULO" in texto_upper or "DIREITO" in texto_upper) else Pt(12)
+            else: run.font.size = Pt(12)
+
+def formatacao_cruzada_indices(para, texto_alvo, aplicar_italico=False, aplicar_negrito=False) -> int:
+    aplicacoes = 0
+    matches = list(re.finditer(r'\b' + re.escape(texto_alvo) + r'\b', para.text, re.IGNORECASE)) if aplicar_italico else [(para.text.find(texto_alvo), para.text.find(texto_alvo) + len(texto_alvo))]
+    
+    for match in matches:
+        pos_ini, pos_fim = match if isinstance(match, tuple) else (match.start(), match.end())
+        if pos_ini == -1: continue 
+        
+        pos_atual = 0
+        for run in para.runs:
+            fim_run = pos_atual + len(run.text)
+            if pos_atual < pos_fim and fim_run > pos_ini:
+                if aplicar_italico: run.italic = True
+                if aplicar_negrito: run.bold = True
+                aplicacoes += 1
+            pos_atual += len(run.text)
+    return aplicacoes
+
+# ─── 5. INTERFACE PRINCIPAL (ABAS) ────────────────────────────────────────
 st.title("⚖️ Assistente Acadêmico - Direito UNIFAGOC")
 aba_auditoria, aba_revisao, aba_abnt = st.tabs(["🔍 Auditoria de Conteúdo e Notas", "🧠 Revisão Textual Inteligente", "📐 Formatação Total ABNT"])
 
@@ -152,225 +145,164 @@ aba_auditoria, aba_revisao, aba_abnt = st.tabs(["🔍 Auditoria de Conteúdo e N
 # ==============================================================================
 with aba_auditoria:
     st.markdown("Cruze o **Pré-Projeto** com o **TCC** para identificar fuga do tema e gerar a **Nota da Banca (80 pontos)**.")
-    fase_tcc = st.radio("Selecione a fase atual do trabalho:", ["TCC 1 (Apenas Introdução e Capítulo 1)", "TCC 2 (TCC Completo com Resumo e Conclusão)"], horizontal=True)
+    fase_tcc = st.radio("Fase atual:", ["TCC 1 (Apenas Introdução e Capítulo 1)", "TCC 2 (TCC Completo)"], horizontal=True)
     
     col1, col2 = st.columns(2)
-    with col1: arq_projeto = st.file_uploader("1. Envie o Pré-Projeto (.docx)", type=["docx"], key="proj")
-    with col2: arq_tcc = st.file_uploader("2. Envie os Capítulos do TCC (.docx)", type=["docx"], key="tcc_aud")
+    with col1: arq_projeto = st.file_uploader("1. Pré-Projeto (.docx)", type=["docx"], key="proj")
+    with col2: arq_tcc = st.file_uploader("2. TCC (.docx)", type=["docx"], key="tcc_aud")
 
     if st.button("🔍 Iniciar Auditoria e Avaliação", type="primary"):
         if not arq_projeto or not arq_tcc:
-            st.warning("⚠️ Envie os DOIS arquivos para realizar a comparação.")
+            st.warning("⚠️ Envie os DOIS ficheiros para realizar a comparação.")
         else:
-            with st.spinner("Avaliando argumentos e calculando notas da banca..."):
+            with st.status("A analisar argumentação jurídica...", expanded=True) as status:
+                st.write("A extrair textos dos documentos...")
                 texto_projeto = extrair_texto_docx(arq_projeto)
                 texto_tcc = extrair_texto_docx(arq_tcc)
-                regra_fase = "ATENÇÃO: O aluno está em TCC 1 (Apenas Introdução e Capítulo 1). NÃO penalize a ausência de Resumo e Conclusão." if "TCC 1" in fase_tcc else "O aluno está em TCC 2. O trabalho deve estar completo (Resumo, Introdução, Desenvolvimento, Conclusão e Referências)."
-                
-                prompt = f"""Você é um Professor Examinador de Direito da UNIFAGOC.
-                {regra_fase}
                 
-                === PRÉ-PROJETO ===
-                {texto_projeto}
-                
-                === TCC ===
-                {texto_tcc}
-                
-                TAREFA 1: Identifique o Problema, Objetivos e procure por fugas de tema genéricas.
-                TAREFA 2: Avalie o TCC conforme os 80 pontos da FICHA DE AVALIAÇÃO DA UNIFAGOC:
-                - Tema, Delimitação do Problema e Objeto (0 a 20 pts)
-                - Introdução e Método (0 a 20 pts)
-                - Estruturação e Desenvolvimento (0 a 20 pts)
-                - Formatação e ABNT (0 a 20 pts)
-                Seja rigoroso e acadêmico na atribuição das notas.
-                """
-                config = types.GenerateContentConfig(temperature=0.0, response_mime_type="application/json", response_schema=AuditoriaTCC)
+                regra_fase = "ATENÇÃO: O aluno está em TCC 1. NÃO penalize a ausência de Resumo e Conclusão." if "TCC 1" in fase_tcc else "O aluno está em TCC 2. Exija o trabalho completo."
+                prompt = f"""Como Professor Examinador titular da banca de Direito da UNIFAGOC:\n{regra_fase}\n=== PRÉ-PROJETO ===\n{texto_projeto}\n=== TCC ===\n{texto_tcc}\nTAREFA 1: Avalie o cruzamento de dados, fuga de tema e objetivos.\nTAREFA 2: Distribua 80 pontos rigorosamente de acordo com os critérios da ficha UNIFAGOC."""
                 
+                st.write("A submeter dados à IA do Google...")
                 try:
-                    resposta = client.models.generate_content(model="gemini-3.5-flash", contents=prompt, config=config)
-                    dados = json.loads(resposta.text)
-                    
-                    st.success(f"Auditoria e Avaliação concluídas para {fase_tcc.split(' ')[0]}!")
-                    
-                    st.header("🏆 Avaliação da Banca UNIFAGOC")
-                    st.markdown("*Distribuição de 80 pontos textuais (20 pts de apresentação não inclusos).*")
-                    
-                    nota_total = sum([
-                        dados.get('nota_tema_problema', 0),
-                        dados.get('nota_introducao_metodo', 0),
-                        dados.get('nota_estruturacao', 0),
-                        dados.get('nota_formatacao_abnt', 0)
-                    ])
-                    
-                    c_nota1, c_nota2, c_nota3, c_nota4 = st.columns(4)
-                    c_nota1.metric("Tema/Problema", f"{dados.get('nota_tema_problema')}/20")
-                    c_nota2.metric("Intro/Método", f"{dados.get('nota_introducao_metodo')}/20")
-                    c_nota3.metric("Estrutura/Linguagem", f"{dados.get('nota_estruturacao')}/20")
-                    c_nota4.metric("Formatação/ABNT", f"{dados.get('nota_formatacao_abnt')}/20")
-                    
-                    st.info(f"**NOTA TEXTUAL FINAL: {nota_total}/80 pontos** \n*Justificativa da Banca:* {dados.get('justificativa_notas_banca')}")
-                    st.divider()
-                    
-                    st.metric(label="Índice de Aderência ao Projeto", value=f"{dados.get('aderencia_percentual')}%")
-                    st.write(f"**Diagnóstico:** {dados.get('diagnostico_geral')}")
-                    
-                    c1, c2 = st.columns(2)
-                    with c1:
-                        st.subheader("🎯 Problema de Pesquisa")
-                        st.write(f"**Promessa:** {dados.get('problema_identificado_no_projeto')}")
-                        if dados.get("tcc_respondeu_ao_problema"): st.success(f"✅ O TCC respondeu: {dados.get('justificativa_problema')}")
-                        else: st.error(f"❌ Não respondeu: {dados.get('justificativa_problema')}")
-                    with c2:
-                        st.subheader("📋 Objetivos")
-                        for f in dados.get("objetivos_nao_cumpridos_no_tcc", []): st.error(f"Faltou: {f}")
-                        if not dados.get("objetivos_nao_cumpridos_no_tcc"): st.success("✅ Objetivos abordados.")
-                    st.subheader("🚨 Filtro Anti-Embromação")
-                    for fuga in dados.get("desvios_de_tema_ou_linguica", []): st.warning(f"Fuga de Tema: {fuga}")
-                    for ia in dados.get("indicios_texto_generico_ia", []): st.error(f"Texto Genérico/IA: {ia}")
+                    res = client.models.generate_content(model="gemini-3.5-flash", contents=prompt, config=types.GenerateContentConfig(temperature=0.0, response_mime_type="application/json", response_schema=AuditoriaTCC))
+                    st.session_state.resultado_auditoria = json.loads(res.text)
+                    status.update(label="Avaliação da Banca concluída!", state="complete", expanded=False)
                 except Exception as e:
-                    if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
-                    else: st.error(f"Erro: {e}")
+                    status.update(label="Falha na avaliação.", state="error")
+                    st.error(f"Erro: {e}")
+
+    # Apresenta os resultados guardados na Sessão (mesmo se a página atualizar)
+    if st.session_state.resultado_auditoria:
+        dados = st.session_state.resultado_auditoria
+        st.header("🏆 Avaliação da Banca UNIFAGOC")
+        nota_total = sum([dados.get('nota_tema_problema', 0), dados.get('nota_introducao_metodo', 0), dados.get('nota_estruturacao', 0), dados.get('nota_formatacao_abnt', 0)])
+        
+        c_nota1, c_nota2, c_nota3, c_nota4 = st.columns(4)
+        c_nota1.metric("Tema/Problema", f"{dados.get('nota_tema_problema')}/20")
+        c_nota2.metric("Intro/Método", f"{dados.get('nota_introducao_metodo')}/20")
+        c_nota3.metric("Estrutura/Linguagem", f"{dados.get('nota_estruturacao')}/20")
+        c_nota4.metric("Formatação/ABNT", f"{dados.get('nota_formatacao_abnt')}/20")
+        
+        st.info(f"**NOTA FINAL TEXTUAL: {nota_total}/80 pontos** \n*Parecer da Banca:* {dados.get('justificativa_notas_banca')}")
+        st.divider()
+        
+        st.metric("Índice de Aderência ao Projeto", f"{dados.get('aderencia_percentual')}%")
+        c1, c2 = st.columns(2)
+        with c1:
+            st.subheader("🎯 Problema de Pesquisa")
+            if dados.get("tcc_respondeu_ao_problema"): st.success(f"✅ O TCC respondeu: {dados.get('justificativa_problema')}")
+            else: st.error(f"❌ Não respondeu: {dados.get('justificativa_problema')}")
+        with c2:
+            st.subheader("📋 Objetivos")
+            for f in dados.get("objetivos_nao_cumpridos_no_tcc", []): st.error(f"Faltou: {f}")
+            if not dados.get("objetivos_nao_cumpridos_no_tcc"): st.success("✅ Todos os objetivos foram abordados.")
+        
+        st.subheader("🚨 Filtro Anti-Embromação")
+        for fuga in dados.get("desvios_de_tema_ou_linguica", []): st.warning(f"Fuga: {fuga}")
+        for ia in dados.get("indicios_texto_generico_ia", []): st.error(f"Indício de IA/Texto Genérico: {ia}")
 
 # ==============================================================================
 # ABA 2: REVISÃO TEXTUAL INTELIGENTE
 # ==============================================================================
 with aba_revisao:
-    st.markdown("A IA analisa o contexto para corrigir **Ortografia**, parágrafos indevidamente em **CAIXA ALTA** e aplica **Itálico** em termos estrangeiros/latinos.")
-    arq_revisao = st.file_uploader("Envie o TCC (.docx) para revisão inteligente", type=["docx"], key="rev")
+    st.markdown("A IA analisa o contexto para corrigir **Ortografia**, **CAIXA ALTA** indevida e aplica **Itálico** em termos latinos/estrangeiros.")
+    arq_rev = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="revisao")
     
-    if st.button("🧠 Realizar Revisão Inteligente"):
-        if arq_revisao:
-            with st.spinner("Lendo o documento para identificar jargões, caixa alta e erros..."):
-                texto = extrair_texto_docx(arq_revisao)
-                prompt_rev = f"""Analise o texto acadêmico de Direito abaixo e identifique:
-                1. Erros ortográficos e gramaticais.
-                2. Trechos do corpo do texto que estão indevidamente em CAIXA ALTA (retorne a versão corrigida). Ignore títulos.
-                3. Termos estrangeiros ou jargões em latim (ex: habeas corpus, fake news) que necessitam de itálico.
-                TEXTO: {texto[:25000]}"""
+    if st.button("🧠 Realizar Revisão"):
+        if arq_rev:
+            with st.status("A processar Inteligência de Revisão...", expanded=True) as status:
+                st.write("A ler o documento completo...")
+                texto = extrair_texto_docx(arq_rev)
+                # Removido o limite de 25000 caracteres! Envia o documento inteiro.
+                prompt_rev = f"Localize erros ortográficos, textos em CAIXA ALTA no corpo do texto e termos estrangeiros (ex: habeas corpus) que precisam de itálico.\nTEXTO:\n{texto}"
                 
+                st.write("A aguardar correções da Inteligência Artificial...")
                 try:
-                    res = client.models.generate_content(
-                        model="gemini-3.5-flash", 
-                        contents=prompt_rev, 
-                        config=types.GenerateContentConfig(temperature=0.1, response_mime_type="application/json", response_schema=RevisaoInteligente)
-                    )
-                    dados_rev = json.loads(res.text)
-                    correcoes = dados_rev.get("correcoes", [])
-                    italicos = dados_rev.get("termos_estrangeiros_para_italico", [])
+                    res = client.models.generate_content(model="gemini-3.5-flash", contents=prompt_rev, config=types.GenerateContentConfig(temperature=0.1, response_mime_type="application/json", response_schema=RevisaoInteligente))
+                    dados = json.loads(res.text)
                     
-                    if not correcoes and not italicos:
-                        st.success("🎉 O texto está perfeitamente revisado e sem jargões para formatar.")
-                    else:
-                        doc_rev = Document(arq_revisao)
-                        aplicadas_texto, aplicadas_italico = 0, 0
-                        
-                        if correcoes:
-                            st.subheader("📝 Correções de Texto e Caixa Alta")
-                            for c in correcoes:
-                                orig, corr = c.get("original", ""), c.get("corrigido", "")
-                                st.write(f"❌ `{orig}` ➔ ✅ `{corr}` (*{c.get('motivo')}*)")
-                                for para in doc_rev.paragraphs:
-                                    if orig in para.text:
-                                        for run in para.runs:
-                                            if orig in run.text:
-                                                run.text = run.text.replace(orig, corr, 1)
-                                                aplicadas_texto += 1
-                                                break
+                    st.write("A aplicar correções cirúrgicas no Word...")
+                    doc_rev = Document(arq_rev)
+                    aplicadas_texto, aplicadas_italico = 0, 0
+                    
+                    if dados.get("correcoes"):
+                        for c in dados.get("correcoes"):
+                            for para in doc_rev.paragraphs:
+                                if c['original'] in para.text:
+                                    for run in para.runs:
+                                        if c['original'] in run.text:
+                                            run.text = run.text.replace(c['original'], c['corrigido'], 1)
+                                            aplicadas_texto += 1
 
-                        if italicos:
-                            st.subheader("🪄 Termos Estrangeiros (Itálico Aplicado)")
-                            st.write(", ".join([f"*{i}*" for i in italicos]))
-                            for termo in italicos:
-                                for para in doc_rev.paragraphs:
-                                    matches = list(re.finditer(r'\b' + re.escape(termo) + r'\b', para.text, re.IGNORECASE))
-                                    for match in matches:
-                                        pos_ini, pos_fim, pos_atual = match.start(), match.end(), 0
-                                        for run in para.runs:
-                                            fim_run = pos_atual + len(run.text)
-                                            if pos_atual < pos_fim and fim_run > pos_ini:
-                                                run.italic = True
-                                                aplicadas_italico += 1
-                                            pos_atual += len(run.text)
-                        
-                        st.success(f"✅ {aplicadas_texto} correções de texto e {aplicadas_italico} itálicos aplicados!")
-                        st.download_button("⬇️ Baixar Documento Revisado (.docx)", data=docx_to_bytes(doc_rev), file_name="TCC_Revisado.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+                    if dados.get("termos_estrangeiros_para_italico"):
+                        for termo in dados.get("termos_estrangeiros_para_italico"):
+                            for para in doc_rev.paragraphs:
+                                aplicadas_italico += formatacao_cruzada_indices(para, termo, aplicar_italico=True)
+                    
+                    # Guarda em memória para o botão de download
+                    st.session_state.doc_revisado_bytes = docx_to_bytes(doc_rev)
+                    status.update(label=f"Processo finalizado com {aplicadas_texto+aplicadas_italico} intervenções automáticas.", state="complete", expanded=False)
                 except Exception as e:
-                    if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
-                    else: st.error(f"Erro ao processar: {e}")
+                    status.update(label="Erro no processamento.", state="error")
+                    st.error(f"Erro: {e}")
+
+    # O botão de Download fora do 'if st.button' garante que o Streamlit não falhe
+    if st.session_state.doc_revisado_bytes:
+        st.download_button("⬇️ Baixar TCC Revisado (.docx)", data=st.session_state.doc_revisado_bytes, file_name="TCC_Revisado.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
 
 # ==============================================================================
-# ABA 3: FORMATAÇÃO TOTAL E REFERÊNCIAS ABNT
+# ABA 3: FORMATAÇÃO TOTAL ABNT
 # ==============================================================================
 with aba_abnt:
-    st.markdown("Varre todo o documento forçando a fonte **Calibri**, Margens **3x2**, Alinhamento e Espaçamentos do edital.")
-    st.warning("⏱️ **Aviso:** Se muitos alunos tentarem formatar ao mesmo tempo, aguarde 60 segundos.")
+    st.markdown("Motor seguro de formatação. Aplica Margens (3x2), Calibri e destaques nas Referências.")
+    arq_abnt = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="abnt_file")
     
-    arq_abnt = st.file_uploader("Envie o TCC (.docx) para formatar o layout estrutural", type=["docx"], key="abnt")
-    
-    if st.button("📐 Formatar Layout e Referências"):
+    if st.button("📐 Formatar TCC"):
         if arq_abnt:
-            with st.spinner("Padronizando fontes, margens e referências... Isso pode levar um minuto."):
+            with st.status("A reestruturar metadados e diagramação do Word...", expanded=True) as status:
                 doc_abnt = Document(arq_abnt)
                 
                 paginas_estimadas = estimar_paginas(doc_abnt)
-                if paginas_estimadas > 18: st.error(f"🚨 **Atenção:** Seu TCC tem aprox. {paginas_estimadas} páginas. O limite da banca é 18.")
+                if paginas_estimadas > 18: st.warning(f"🚨 Extensão de {paginas_estimadas} páginas. O limite recomendado é 18.")
                 else: st.info(f"📄 Extensão estimada: {paginas_estimadas} páginas.")
                 
-                aplicar_formatacao_estrutural_unifagoc(doc_abnt)
-                st.success("✅ Estrutura Física (Margens, Fontes e Alinhamento) salva com sucesso!")
+                st.write("A aplicar regras físicas (Margens, Calibri, Alinhamentos)...")
+                aplicar_formatacao_segura_unifagoc(doc_abnt)
                 
-                referencias = extrair_referencias_docx(doc_abnt)
-                if not referencias:
-                    st.warning("Aviso: Nenhuma seção com o título 'REFERÊNCIAS' foi localizada.")
-                    st.download_button("⬇️ Baixar TCC Formatado", data=docx_to_bytes(doc_abnt), file_name="TCC_Padrao_UNIFAGOC.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
-                else:
-                    texto_refs = "\n".join(f"{i+1}. {texto}" for i, (_, texto) in enumerate(referencias))
-                    prompt_abnt = f"Verifique as referências abaixo seguindo a ABNT NBR 6023:2018. Retorne um JSON:\n{{\"problemas\": [{{\"numero\": int, \"erros\": [\"erro\"], \"elemento_negrito\": \"palavra destaque\"}}]}}\nREFERÊNCIAS:\n{texto_refs}"
-                    
+                st.write("A analisar Referências Bibliográficas...")
+                referencias = [(i, para.text.strip()) for i, para in enumerate(doc_abnt.paragraphs) if para.text.strip() and not re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", para.text, re.IGNORECASE) == False] # Simplificado para leitura lógica
+                # Nota: A lógica real de extração já garante que só pegamos o que vem depois do título Referências.
+                # Refazendo a lógica de extração limpa:
+                refs_limpas = []
+                em_refs = False
+                for i, para in enumerate(doc_abnt.paragraphs):
+                    txt = para.text.strip()
+                    if not txt: continue
+                    if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", txt, re.IGNORECASE): em_refs = True; continue
+                    if em_refs:
+                        if len(txt) < 120 and txt.isupper() and not txt[0].isdigit(): break
+                        refs_limpas.append((i, txt))
+                
+                if refs_limpas:
+                    texto_refs = "\n".join(f"[{idx}] {txt}" for idx, txt in refs_limpas)
+                    prompt_abnt = f"Analise as referências (ABNT 6023:2018). Para cada uma, devolva o número da referência, e extraia o trecho EXATO (título do livro ou nome da revista) que deve receber negrito.\nREFERÊNCIAS:\n{texto_refs}"
                     try:
-                        res = client.models.generate_content(
-                            model="gemini-3.5-flash", 
-                            contents=prompt_abnt, 
-                            config=types.GenerateContentConfig(temperature=0.0, response_mime_type="application/json")
-                        )
-                        problemas = json.loads(res.text).get("problemas", [])
-                        
-                        def aplicar_negrito_ref(doc, refs_problematicas):
-                            em_refs, ref_idx = False, 0
-                            for para in doc.paragraphs:
-                                texto = para.text.strip()
-                                if not texto: continue
-                                if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", texto, re.IGNORECASE):
-                                    em_refs = True
-                                    continue
-                                if not em_refs or len(texto) < 10: continue
-                                
-                                nums_prob = {p.get("numero", 0) - 1 for p in refs_problematicas}
-                                if ref_idx in nums_prob:
-                                    match = re.match(r"^((?:[A-ZÁÉÍÓÚÀÂÊÔÃÕÇ][^.;]+[.;]\s*)+)\s*(.+?)(\.\s+(?:\d+\.\s+ed|[A-Z]).*|$)", para.text)
-                                    if match:
-                                        autoria, titulo = match.group(1).strip(), match.group(2).strip()
-                                        pos_atual, pos_ini = 0, para.text.find(titulo, len(autoria))
-                                        pos_fim = pos_ini + len(titulo)
-                                        for run in para.runs:
-                                            fim_run = pos_atual + len(run.text)
-                                            if pos_atual >= pos_ini and fim_run <= pos_fim: run.bold = True
-                                            elif pos_atual < pos_fim and fim_run > pos_ini: run.bold = True
-                                            pos_atual += len(run.text)
-                                ref_idx += 1
-
-                        aplicar_negrito_ref(doc_abnt, problemas)
+                        res = client.models.generate_content(model="gemini-3.5-flash", contents=prompt_abnt, config=types.GenerateContentConfig(temperature=0.0, response_mime_type="application/json", response_schema=AnaliseABNT))
+                        dados_abnt = json.loads(res.text)
                         
-                        if problemas:
-                            for p in problemas: st.write(f"⚠️ Referência #{p['numero']} ajustada: {', '.join(p['erros'])}")
-                        st.success("✅ Formatação de destaque (negrito) nas referências aplicada!")
+                        for problema in dados_abnt.get("problemas", []):
+                            if problema.get("elemento_negrito") and problema.get("numero") < len(doc_abnt.paragraphs):
+                                formatacao_cruzada_indices(doc_abnt.paragraphs[problema.get("numero")], problema.get("elemento_negrito"), aplicar_negrito=True)
                         
-                        st.download_button(
-                            label="⬇️ Baixar TCC Totalmente Formatado (.docx)",
-                            data=docx_to_bytes(doc_abnt),
-                            file_name="TCC_Padrao_UNIFAGOC.docx",
-                            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-                        )
+                        st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
+                        status.update(label="TCC formatado com sucesso!", state="complete", expanded=False)
                     except Exception as e:
-                        if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
-                        else: st.error(f"Erro na verificação pela IA: {e}")
+                        status.update(label="Erro na IA de formatação.", state="error")
+                        st.error(f"Erro: {e}")
+                else:
+                    st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
+                    status.update(label="Estrutura salva (Nenhuma referência encontrada para negrito).", state="complete")
+
+    if st.session_state.doc_formatado_bytes:
+        st.download_button("⬇️ Baixar TCC Final Formatado (.docx)", data=st.session_state.doc_formatado_bytes, file_name="TCC_Final_Formatado.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")