Update app.py

app.py

@@ -1,178 +1,376 @@
 import os
 import io
 import re
+import json
 import streamlit as st
 from docx import Document
 from docx.shared import Cm, Pt
 from docx.enum.text import WD_ALIGN_PARAGRAPH
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from google import genai
 from google.genai import types
-from tenacity import retry, stop_after_attempt, wait_exponential
 
-# ─── CONFIG ───────────────────────────────────────────────────────────────
-st.set_page_config(page_title="Corretor TCC - UNIFAGOC", page_icon="⚖", layout="wide")
-api_key = st.secrets.get("GEMINI_API_KEY", os.environ.get("GEMINI_API_KEY"))
-if not api_key:
-    st.error("❌ Defina GEMINI_API_KEY nos Secrets do Streamlit.")
-    st.stop()
-client = genai.Client(api_key=api_key)
-MODEL = "gemini-3.5-flash"
+# ─── CONFIGURAÇÃO DA PÁGINA ───────────────────────────────────────────────
+st.set_page_config(page_title="Corretor TCC - UNIFAGOC", page_icon="⚖️", layout="wide")
 
-# ─── MODELOS ──────────────────────────────────────────────────────────────
+# ─── ESQUEMAS DE DADOS (PYDANTIC) ─────────────────────────────────────────
 class AuditoriaTCC(BaseModel):
-    aderencia_percentual: int = Field(ge=0, le=100)
-    diagnostico_geral: str = ""
-    problema_identificado_no_projeto: str = ""
-    tcc_respondeu_ao_problema: bool = False
-    justificativa_problema: str = ""
-    objetivos_especificos_identificados: list[str] = Field(default_factory=list)
-    objetivos_nao_cumpridos_no_tcc: list[str] = Field(default_factory=list)
-    desvios_de_tema_ou_linguica: list[str] = Field(default_factory=list)
-    indicios_texto_generico_ia: list[str] = Field(default_factory=list)
-    nota_tema_problema: float = 0.0
-    nota_introducao_metodo: float = 0.0
-    nota_estruturacao: float = 0.0
-    nota_formatacao_abnt: float = 0.0
-    justificativa_notas_banca: str = ""
+    aderencia_percentual: int
+    diagnostico_geral: str
+    problema_identificado_no_projeto: str
+    tcc_respondeu_ao_problema: bool
+    justificativa_problema: str
+    objetivos_especificos_identificados: list[str]
+    objetivos_nao_cumpridos_no_tcc: list[str]
+    desvios_de_tema_ou_linguica: list[str]
+    indicios_texto_generico_ia: list[str]
+    nota_tema_problema: float
+    nota_introducao_metodo: float
+    nota_estruturacao: float
+    nota_formatacao_abnt: float
+    justificativa_notas_banca: str
 
 class ErroTexto(BaseModel):
     original: str
     corrigido: str
-    motivo: str = ""
+    motivo: str
 
 class RevisaoInteligente(BaseModel):
-    correcoes: list[ErroTexto] = Field(default_factory=list)
-    termos_estrangeiros_para_italico: list[str] = Field(default_factory=list)
-
-# ─── HELPERS ──────────────────────────────────────────────────────────────
-@retry(wait=wait_exponential(2, 30), stop=stop_after_attempt(3))
-def chamar_gemini(prompt, schema, temp=0.0):
-    return client.models.generate_content(
-        model=MODEL,
-        contents=prompt,
-        config=types.GenerateContentConfig(
-            temperature=temp,
-            response_mime_type="application/json",
-            response_schema=schema
-        )
-    )
-
-@st.cache_data(show_spinner=False)
-def extrair_texto_docx(_bytes) -> str:
-    doc = Document(io.BytesIO(_bytes))
-    return "\n\n".join(p.text.strip() for p in doc.paragraphs if p.text.strip())
+    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()
+
+client = genai.Client(api_key=api_key)
+
+# ─── FUNÇÕES AUXILIARES ───────────────────────────────────────────────────
+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
 
 def docx_to_bytes(doc: Document) -> bytes:
-    bio = io.BytesIO()
-    doc.save(bio)
-    return bio.getvalue()
+    byte_io = io.BytesIO()
+    doc.save(byte_io)
+    return byte_io.getvalue()
 
 def estimar_paginas(doc: Document) -> int:
-    chars = 0
-    for p in doc.paragraphs:
-        if re.search(r"REFER[ÊE]NCIAS", p.text, re.I): break
-        chars += len(p.text)
-    return max(1, chars // 1800)
-
-def extrair_referencias_docx(doc: Document):
-    refs, em_refs = [], False
-    for i, p in enumerate(doc.paragraphs):
-        t = p.text.strip()
-        if not t: continue
-        if re.match(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", t, re.I):
-            em_refs = True; continue
-        if em_refs:
-            if re.match(r"^(ANEXOS?|AP[ÊE]NDICES?|APENDICE)$", t, re.I): break
-            if len(t) < 80 and t.isupper(): break
-            refs.append((i, t))
-    return refs
-
-def aplicar_formatacao_unifagoc(doc: Document):
-    for s in doc.sections:
-        s.top_margin = s.left_margin = Cm(3)
-        s.bottom_margin = s.right_margin = Cm(2)
-    normal = doc.styles['Normal']
-    normal.font.name = 'Calibri'
-    normal.font.size = Pt(12)
-    normal.paragraph_format.line_spacing = 1.5
-    normal.paragraph_format.first_line_indent = Cm(1.25)
-
-    em_ref, em_resumo = False, False
-    for p in doc.paragraphs:
-        txt = p.text.strip()
-        if not txt: continue
-        up = txt.upper()
-        if up.startswith("RESUMO"): em_resumo = True
-        elif up.startswith("INTRODUÇÃO"): em_resumo = False
-        elif re.match(r"REFER[ÊE]NCIAS", txt, re.I): em_ref = True
-
-        if em_ref:
-            p.alignment = WD_ALIGN_PARAGRAPH.LEFT
-            p.paragraph_format.first_line_indent = Cm(0)
-            for r in p.runs: r.font.size = Pt(11)
-        elif em_resumo and up not in ("RESUMO",) and not up.startswith("PALAVRAS"):
-            p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            for r in p.runs: r.font.italic = True; r.font.size = Pt(11)
-        elif txt.isupper() and len(txt) < 120:
-            p.alignment = WD_ALIGN_PARAGRAPH.CENTER
-            p.paragraph_format.first_line_indent = Cm(0)
-
-def aplicar_italico_seguro(paragrafo, termo):
-    texto = paragrafo.text
-    if not re.search(rf'\b{re.escape(termo)}\b', texto, re.I): return False
-    partes = re.split(rf'(\b{re.escape(termo)}\b)', texto, flags=re.I)
-    paragrafo.clear()
-    for parte in partes:
-        run = paragrafo.add_run(parte)
-        if parte.lower() == termo.lower(): run.italic = True
-    return True
-
-# ─── UI ───────────────────────────────────────────────────────────────────
-st.title("⚖ Assistente Acadêmico - Direito UNIFAGOC")
-aba1, aba2, aba3 = st.tabs(["🔍 Auditoria", "🧠 Revisão", "📐 ABNT"])
-
-with aba1:
-    fase = st.radio("Fase:", ["TCC 1", "TCC 2"], horizontal=True)
-    c1, c2 = st.columns(2)
-    with c1: proj = st.file_uploader("Pré-Projeto", type="docx", key="p1")
-    with c2: tcc = st.file_uploader("TCC", type="docx", key="t1")
-    if st.button("Auditar", type="primary", disabled=not(proj and tcc)):
-        with st.status("Auditando...", expanded=True) as s:
-            txt_p = extrair_texto_docx(proj.getvalue())
-            txt_t = extrair_texto_docx(tcc.getvalue())
-            regra = "TCC 1: não penalize ausência de Resumo/Conclusão." if fase=="TCC 1" else "TCC 2: trabalho completo."
-            prompt = f"Você é examinador UNIFAGOC. {regra}\nPROJETO:\n{txt_p}\n\nTCC:\n{txt_t}\nAvalie 80 pontos."
-            resp = chamar_gemini(prompt, AuditoriaTCC, 0.0)
-            dados: AuditoriaTCC = resp.parsed
-            s.update(label="Concluído", state="complete")
-        st.metric("Aderência", f"{dados.aderencia_percentual}%")
-        total = sum([dados.nota_tema_problema, dados.nota_introducao_metodo, dados.nota_estruturacao, dados.nota_formatacao_abnt])
-        st.info(f"Nota textual: {total}/80 — {dados.justificativa_notas_banca}")
-
-with aba2:
-    arq = st.file_uploader("TCC para revisão", type="docx", key="r1")
-    if st.button("Revisar", disabled=not arq):
-        with st.spinner("Revisando texto integral..."):
-            txt = extrair_texto_docx(arq.getvalue())
-            prompt = f"Revise ortografia, CAIXA ALTA indevida e liste termos latinos/estrangeiros para itálico. Texto:\n{txt}"
-            resp = chamar_gemini(prompt, RevisaoInteligente, 0.1)
-            rev: RevisaoInteligente = resp.parsed
-            doc = Document(io.BytesIO(arq.getvalue()))
-            mapa = {e.original: e.corrigido for e in rev.correcoes}
-            for p in doc.paragraphs:
-                for orig, corr in mapa.items():
-                    if orig in p.text:
-                        for r in p.runs: r.text = r.text.replace(orig, corr)
-            for termo in rev.termos_estrangeiros_para_italico:
-                for p in doc.paragraphs: aplicar_italico_seguro(p, termo)
-            st.download_button("Baixar revisado", docx_to_bytes(doc), "TCC_Revisado.docx")
-
-with aba3:
-    arq3 = st.file_uploader("TCC para ABNT", type="docx", key="a1")
-    if st.button("Formatar", disabled=not arq3):
-        doc = Document(io.BytesIO(arq3.getvalue()))
-        st.write(f"Páginas estimadas: {estimar_paginas(doc)}")
-        aplicar_formatacao_unifagoc(doc)
-        refs = extrair_referencias_docx(doc)
-        st.download_button("Baixar formatado", docx_to_bytes(doc), "TCC_ABNT.docx")
+    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)
+
+def aplicar_formatacao_estrutural_unifagoc(doc: Document):
+    """Aplica o template de forma segura, sem corromper o XML original."""
+    # 1. Margens Oficiais da Instituição
+    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)
+
+    em_referencias = False
+    em_resumo = 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
+            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) ───────────────────────────────────────────
+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"])
+
+# ==============================================================================
+# ABA 1: AUDITORIA E PONTUAÇÃO UNIFAGOC
+# ==============================================================================
+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)
+    
+    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")
+
+    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.")
+        else:
+            with st.spinner("Avaliando argumentos e calculando notas da banca..."):
+                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)
+                
+                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}")
+                except Exception as e:
+                    if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
+                    else: st.error(f"Erro: {e}")
+
+# ==============================================================================
+# 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")
+    
+    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]}"""
+                
+                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", [])
+                    
+                    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
+
+                        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")
+                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}")
+
+# ==============================================================================
+# ABA 3: FORMATAÇÃO TOTAL E REFERÊNCIAS 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.")
+    
+    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 arq_abnt:
+            with st.spinner("Padronizando fontes, margens e referências... Isso pode levar um minuto."):
+                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.")
+                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!")
+                
+                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}"
+                    
+                    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)
+                        
+                        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!")
+                        
+                        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"
+                        )
+                    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}")