Update app.py

app.py

@@ -4,24 +4,31 @@ 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 docx.shared import Cm, Pt, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_BREAK
+from docx.enum.section import WD_SECTION
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
 from pydantic import BaseModel
+from typing import List, Optional
 from google import genai
 from google.genai import types
 
-# ─── 1. CONFIGURAÇÃO DA PÁGINA E ESTADO ───────────────────────────────────
+---
+### 1. CONFIGURAÇÃO INICIAL E ESTADO
+---
 st.set_page_config(page_title="Corretor TCC - UNIFAGOC", page_icon="⚖️", layout="wide")
 
 def reset_estado(chave):
     if chave in st.session_state:
         st.session_state[chave] = None
 
-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
+# Inicialização do estado
+for key in ["resultado_auditoria", "doc_revisado_bytes", "doc_formatado_bytes"]:
+    if key not in st.session_state:
+        st.session_state[key] = None
 
-# Dicionário Fixo de Latinismos Jurídicos
+# Dicionário de Latinismos Jurídicos
 LATINISMOS = [
     "habeas corpus", "data venia", "jus puniendi", "jus postulandi",
     "mens legis", "ratio decidendi", "obiter dictum", "in casu",
@@ -30,18 +37,20 @@ LATINISMOS = [
     "mutatis mutandis", "strictu sensu", "lato sensu", "sine qua non"
 ]
 
-# ─── 2. ESQUEMAS DE DADOS ESTRITOS (PYDANTIC) ─────────────────────────────
+---
+### 2. ESQUEMAS DE DADOS (PYDANTIC)
+---
 class AuditoriaTCC(BaseModel):
     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]
-    incoerencias_internas: list[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]
+    incoerencias_internas: List[str]
     nota_tema_problema: float
     nota_introducao_metodo: float
     nota_estruturacao: float
@@ -52,41 +61,50 @@ class ErroTexto(BaseModel):
     original: str
     corrigido: str
     motivo: str
-    categoria: str 
-    gravidade: str 
-    contexto: str  
+    categoria: str
+    gravidade: str
+    contexto: str
 
 class ProblemaAcademico(BaseModel):
     trecho: str
-    problema: str 
+    problema: str
     sugestao: str
     gravidade: str
 
 class RevisaoInteligente(BaseModel):
-    correcoes: list[ErroTexto]
-    problemas_academicos: list[ProblemaAcademico]
-    termos_estrangeiros_para_italico: list[str]
+    correcoes: List[ErroTexto]
+    problemas_academicos: List[ProblemaAcademico]
+    termos_estrangeiros_para_italico: List[str]
 
 class ProblemaReferencia(BaseModel):
     numero: int
-    erros: list[str]
+    erros: List[str]
     elemento_negrito: str
 
-class AnaliseABNT(BaseModel):
-    problemas: list[ProblemaReferencia]
+class ReferenciaCorrigida(BaseModel):
+    original: str
+    corrigida: str
+    erros: List[str]
+
+class ListaReferenciasCorrigidas(BaseModel):
+    referencias: List[ReferenciaCorrigida]
 
-# ─── 3. AUTENTICAÇÃO E CACHE ───────────────────────────────────────────────
+---
+### 3. AUTENTICAÇÃO E CLIENTE GEMINI
+---
 @st.cache_resource
 def get_client():
-    api_key = os.environ.get("GEMINI_API_KEY")
+    api_key = st.secrets["GEMINI_API_KEY"]  # Usando secrets do Streamlit
     if not api_key:
-        st.error("❌ ERRO: A variável de ambiente GEMINI_API_KEY não foi encontrada nos Secrets.")
+        st.error("❌ ERRO: Chave GEMINI_API_KEY não configurada nos secrets.")
         st.stop()
     return genai.Client(api_key=api_key)
 
 client = get_client()
 
-# ─── 4. MANIPULAÇÃO AVANÇADA DE DOCUMENTOS (DOCX) ─────────────────────────
+---
+### 4. FUNÇÕES AUXILIARES
+---
 def extrair_texto_docx(arquivo_upload) -> str:
     doc = Document(arquivo_upload)
     return "\n\n".join([para.text.strip() for para in doc.paragraphs if para.text.strip()])
@@ -103,29 +121,34 @@ def estimar_paginas(doc: Document) -> int:
     )
     return max(1, palavras_totais // 350)
 
-def substituir_texto_cross_run(para, original, corrigido) -> int:
+def substituir_texto_preservando_formato(para, original: str, corrigido: str) -> int:
+    """Substitui texto preservando formatação de runs (negrito, itálico, etc.)"""
     texto_completo = "".join(run.text for run in para.runs)
-    if original not in texto_completo: 
+    if original not in texto_completo:
         return 0
-    
-    for run in para.runs:
-        if original in run.text:
-            run.text = run.text.replace(original, corrigido, 1)
-            return 1
-            
-    novo_texto = texto_completo.replace(original, corrigido, 1)
-    estilo_base = para.style
-    alinhamento_base = para.paragraph_format.alignment
-    
+
+    # Divide o texto em partes antes, original e depois
+    partes = texto_completo.split(original, 1)
+    if len(partes) != 2:
+        return 0
+
+    # Limpa o parágrafo e reconstrói com a correção
     para.clear()
-    para.add_run(novo_texto)
-    para.style = estilo_base
-    if alinhamento_base:
-        para.paragraph_format.alignment = alinhamento_base
-        
+    para.add_run(partes[0])
+
+    # Adiciona o texto corrigido mantendo a formatação original
+    # (Aqui você pode adicionar lógica para preservar formatação se necessário)
+    run_corrigido = para.add_run(corrigido)
+    run_corrigido.font.name = 'Calibri'  # Mantém a fonte padrão
+    run_corrigido.font.size = Pt(12)
+
+    # Adiciona a parte final
+    if partes[1]:
+        para.add_run(partes[1])
+
     return 1
 
-def formatacao_cruzada_indices(para, texto_alvo, aplicar_italico=False, aplicar_negrito=False) -> int:
+def formatacao_cruzada_indices(para, texto_alvo: str, aplicar_italico: bool = False, aplicar_negrito: bool = False) -> int:
     aplicacoes = 0
     if aplicar_italico:
         matches = list(re.finditer(r'\b' + re.escape(texto_alvo) + r'\b', para.text, re.IGNORECASE))
@@ -135,36 +158,68 @@ def formatacao_cruzada_indices(para, texto_alvo, aplicar_italico=False, aplicar_
 
     for match in matches:
         pos_ini, pos_fim = match if isinstance(match, tuple) else (match.start(), match.end())
-        if pos_ini == -1: continue
+        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
+                if aplicar_italico:
+                    run.italic = True
+                if aplicar_negrito:
+                    run.bold = True
                 aplicacoes += 1
             pos_atual += len(run.text)
     return aplicacoes
 
-# ─── MOTOR DE VERIFICAÇÕES LOCAIS (REGEX) ─────────────────────────────────
-def verificacoes_locais_regex(texto: str) -> list[str]:
-    erros = []
-    if re.search(r"\s{2,}", texto): 
-        erros.append("Espaços duplos detectados no documento.")
-    if re.search(r",\s*,", texto): 
-        erros.append("Vírgulas duplicadas detectadas (ex: ',,').")
-    if re.search(r"[.!?]{2,}", texto) and not "..." in texto: 
-        erros.append("Pontuação repetida indevida (ex: '!!' ou '..').")
-    if re.search(r"\b(\w+)\s+\1\b", texto, re.IGNORECASE): 
-        erros.append("Palavras repetidas sequencialmente (ex: 'o o', 'de de').")
-    
-    if re.search(r"\([A-ZÀ-Ú\s]+,\s*\)", texto):
-        erros.append("Citação ABNT com ano faltando (ex: (SILVA, )).")
-        
-    return erros
-
-# ─── MOTOR ABNT CORRIGIDO COM BASE NO RELATÓRIO DO UTILIZADOR ─────────────
-def aplicar_formatacao_unifagoc_abnt(doc: Document):
+---
+### 5. DETECÇÃO ESTRUTURAL AVANÇADA
+---
+def detectar_nivel_secao(texto: str) -> int:
+    """Retorna o nível da seção (0=nenhum, 1=1, 2=1.1, 3=1.1.1)"""
+    match = re.match(r'^(\d+(?:\.\d+)*)\s+', texto)
+    if not match:
+        return 0
+    return match.group(1).count('.') + 1
+
+def detectar_titulo_ou_subtitulo(texto: str) -> Optional[str]:
+    """Detecta títulos e subtítulos com base em seções especiais ou numeração"""
+    SECOES_ESPECIAIS = ["INTRODUÇÃO", "CONSIDERAÇÕES FINAIS", "REFERÊNCIAS", "RESUMO", "PALAVRAS-CHAVE"]
+    texto_upper = texto.upper()
+
+    # Verifica se é uma seção especial
+    if any(sec in texto_upper for sec in SECOES_ESPECIAIS):
+        return "titulo"
+
+    # Verifica se é uma seção numerada (1, 1.1, 1.1.1, etc.)
+    if detectar_nivel_secao(texto) > 0:
+        return "titulo"
+
+    # Verifica se é um título em caixa alta (sem ser seção numerada)
+    if texto.isupper() and len(texto) < 150 and not detectar_nivel_secao(texto):
+        return "titulo"
+
+    return None
+
+def detectar_citacao_longa(para) -> bool:
+    """Detecta citações longas por recuo ou marcação"""
+    if para.paragraph_format.left_indent and para.paragraph_format.left_indent >= Cm(3.5):
+        return True
+    texto = para.text.strip()
+    if (texto.startswith(('Segundo ', 'Conforme ', 'De acordo com ')) and
+        len(texto.split()) > 30):
+        return True
+    return False
+
+def detectar_lista(texto: str) -> bool:
+    """Detecta listas numeradas ou alfabéticas"""
+    return bool(re.match(r'^([a-zA-Z\(]|\d+[\)\.]|\w+[-–])\s', texto))
+
+---
+### 6. FUNÇÕES DE FORMATAÇÃO
+---
+def aplicar_margens_unifagoc(doc: Document):
+    """Aplica as margens oficiais do template UNIFAGOC (A4: 21x29.7cm)"""
     for section in doc.sections:
         section.page_height = Cm(29.7)
         section.page_width = Cm(21.0)
@@ -175,85 +230,175 @@ def aplicar_formatacao_unifagoc_abnt(doc: Document):
         section.header_distance = Cm(0.5)
         section.footer_distance = Cm(0.5)
 
-    fase_atual = "PRE_RESUMO" 
+def aplicar_paginacao(doc: Document):
+    """Adiciona numeração de páginas no rodapé (centralizado)"""
+    for section in doc.sections:
+        # Cria um rodapé para cada seção
+        footer = section.footer
+        if not footer:
+            footer = OxmlElement('w:ftr')
+            section._sectPr.get_or_add_ftr().append(footer)
+
+        # Adiciona parágrafo com numeração de página
+        para = footer.add_paragraph()
+        para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        # Adiciona campo de página
+        fldChar = OxmlElement('w:fldChar')
+        fldChar.set(qn('w:fldCharType'), 'begin')
+        para._p.append(fldChar)
+
+        instrText = OxmlElement('w:instrText')
+        instrText.set(qn('xml:space'), 'preserve')
+        instrText.text = 'PAGE'
+        para._p.append(instrText)
+
+        fldChar = OxmlElement('w:fldChar')
+        fldChar.set(qn('w:fldCharType'), 'end')
+        para._p.append(fldChar)
+
+        # Formatação do rodapé
+        for run in para.runs:
+            run.font.name = 'Calibri'
+            run.font.size = Pt(10)
 
-    for i, para in enumerate(doc.paragraphs):
+def formatar_figuras_tabelas(doc: Document):
+    """Formata figuras, tabelas e quadros conforme template UNIFAGOC"""
+    for para in doc.paragraphs:
         texto = para.text.strip()
-        if not texto: continue
-        
-        texto_upper = texto.upper()
-        pf = para.paragraph_format
+        if re.match(r'^(Figura|Tabela|Quadro)\s+\d+', texto, re.IGNORECASE):
+            pf = para.paragraph_format
+            pf.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            for run in para.runs:
+                run.font.name = 'Calibri'
+                run.font.size = Pt(12)
+                run.font.bold = True
 
-        if texto_upper == "RESUMO":
-            fase_atual = "RESUMO_LBL"
-        elif fase_atual == "RESUMO_LBL":
-            fase_atual = "RESUMO_BODY"
-            
-        if texto_upper.startswith("PALAVRAS-CHAVE"):
-            fase_atual = "PALAVRAS_CH"
-        elif re.match(r"^(?:INTRODU[ÇC]ÃO|1[\s\.])", texto_upper):
-            fase_atual = "CORPO"
-            
-        is_titulo_refs = bool(re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS\b", texto_upper))
-        if is_titulo_refs:
-            fase_atual = "REF_TITLE"
-        elif fase_atual == "REF_TITLE":
-            fase_atual = "REF_ENTRY"
-
-        if fase_atual == "PRE_RESUMO":
-            if i == 0 or (texto.isupper() and len(texto) < 150):
-                pf.alignment = WD_ALIGN_PARAGRAPH.CENTER
-                pf.first_line_indent = None
-                pf.left_indent = None
-                pf.space_before = Pt(0)
-                pf.space_after = Pt(0)
-                pf.line_spacing = 1.5
-                for run in para.runs:
+            # Formata a legenda (próximo parágrafo)
+            idx = doc.paragraphs.index(para)
+            if idx + 1 < len(doc.paragraphs):
+                next_para = doc.paragraphs[idx + 1]
+                for run in next_para.runs:
                     run.font.name = 'Calibri'
-                    run.font.size = Pt(14)
-                    run.font.bold = True
-            else:
-                pf.alignment = WD_ALIGN_PARAGRAPH.CENTER
-                pf.first_line_indent = None
-                pf.left_indent = None
-                pf.space_before = Pt(0)
-                pf.space_after = Pt(0)
-                pf.line_spacing = None 
-                for run in para.runs:
-                    run.font.name = 'Calibri'
-                    run.font.size = Pt(12)
-                    run.font.bold = False
+                    run.font.size = Pt(11)
 
-        elif fase_atual == "RESUMO_LBL":
-            pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            pf.first_line_indent = None
-            pf.left_indent = None
+    # Formata tabelas
+    for table in doc.tables:
+        for row in table.rows:
+            for cell in row.cells:
+                for para in cell.paragraphs:
+                    para.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.LEFT
+                    para.paragraph_format.line_spacing = 1.0
+                    for run in para.runs:
+                        run.font.name = 'Calibri'
+                        run.font.size = Pt(11)
+
+def formatar_imagens(doc: Document):
+    """Formata imagens (inline shapes) para centralização e legendas"""
+    for rel in doc.part.rels.values():
+        if "image" in rel.target_ref:
+            for shape in doc.inline_shapes:
+                if shape.type == 3:  # 3 = picture
+                    shape.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+def formatar_notas_rodape(doc: Document):
+    """Formata notas de rodapé (se existirem)"""
+    # python-docx não tem suporte nativo para notas de rodapé, então esta é uma solução alternativa
+    for para in doc.paragraphs:
+        if re.search(r'[\d\^]+$', para.text.strip()):  # Detecta notas como ¹, ², ³
+            for run in para.runs:
+                run.font.size = Pt(8)
+                run.font.superscript = True
+
+def validar_referencias(doc: Document) -> List[ReferenciaCorrigida]:
+    """Valida referências ABNT usando IA, sem inventar dados"""
+    refs = []
+    em_refs = False
+    for para in doc.paragraphs:
+        texto = para.text.strip()
+        if re.search(r"REFER[ÊE]NCIAS", texto, re.IGNORECASE):
+            em_refs = True
+            continue
+        if em_refs and (len(texto) < 10 or texto.isupper()):
+            break
+        if em_refs:
+            refs.append(texto)
+
+    if not refs:
+        return []
+
+    refs_str = '\n'.join(refs)
+    prompt_refs = (
+        "Analise as referências abaixo **APENAS PARA IDENTIFICAR ERROS** (não invente dados!).\n"
+        "Para cada uma, retorne:\n"
+        "- original: texto original\n"
+        "- corrigida: versão corrigida (apenas se houver erro claro, como falta de negrito no título)\n"
+        "- erros: lista de erros (ex: [\"título não em negrito\", \"autor não invertido\"])\n\n"
+        f"Referências:\n{refs_str}"
+    )
+
+    try:
+        res = client.models.generate_content(
+            model="gemini-1.5-flash",
+            contents=prompt_refs,
+            config=types.GenerateContentConfig(
+                temperature=0.0,
+                response_mime_type="application/json",
+                response_schema=ListaReferenciasCorrigidas  # Usando o schema correto
+            )
+        )
+        dados = json.loads(res.text)
+        return dados.get("referencias", [])
+    except Exception as e:
+        st.error(f"Erro ao validar referências: {e}")
+        return []
+
+def formatar_documento_unifagoc(doc: Document):
+    """Função principal de formatação com fluxo único e sem sobreposição"""
+    # 1. Aplica margens e paginação
+    aplicar_margens_unifagoc(doc)
+    aplicar_paginacao(doc)
+
+    # 2. Formata elementos específicos
+    formatar_figuras_tabelas(doc)
+    formatar_imagens(doc)
+    formatar_notas_rodape(doc)
+
+    # 3. Processa cada parágrafo com fluxo único
+    for para in doc.paragraphs:
+        texto = para.text.strip()
+        if not texto:
+            continue
+
+        # --- REFERÊNCIAS ---
+        if re.search(r"REFER[ÊE]NCIAS", texto, re.IGNORECASE):
+            pf = para.paragraph_format
+            pf.alignment = WD_ALIGN_PARAGRAPH.CENTER
             pf.space_before = Pt(12)
-            pf.space_after = Pt(0)
-            pf.line_spacing = 1.5
+            pf.space_after = Pt(6)
             for run in para.runs:
                 run.font.name = 'Calibri'
-                run.font.size = Pt(11)
+                run.font.size = Pt(12)
                 run.font.bold = True
-                run.font.italic = False
+            continue
 
-        elif fase_atual == "RESUMO_BODY":
+        # --- RESUMO ---
+        if texto.upper() == "RESUMO":
+            pf = para.paragraph_format
             pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            pf.first_line_indent = None
-            pf.left_indent = None
-            pf.space_before = Pt(0)
+            pf.space_before = Pt(12)
             pf.space_after = Pt(0)
             pf.line_spacing = 1.5
             for run in para.runs:
                 run.font.name = 'Calibri'
                 run.font.size = Pt(11)
-                run.font.italic = True
-                run.font.bold = False
+                run.font.bold = True
+            continue
 
-        elif fase_atual == "PALAVRAS_CH":
+        # --- PALAVRAS-CHAVE ---
+        if texto.upper().startswith("PALAVRAS-CHAVE"):
+            pf = para.paragraph_format
             pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            pf.first_line_indent = None
-            pf.left_indent = None
             pf.space_before = Pt(6)
             pf.space_after = Pt(0)
             pf.line_spacing = 1.5
@@ -262,68 +407,98 @@ def aplicar_formatacao_unifagoc_abnt(doc: Document):
                 run.font.size = Pt(11)
                 if "PALAVRAS-CHAVE" in run.text.upper():
                     run.font.bold = True
-                    run.font.italic = False
-                else:
-                    run.font.bold = False
-                    run.font.italic = False
-
-        elif fase_atual == "CORPO":
-            if texto.isupper() and len(texto) < 120:
-                pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-                pf.first_line_indent = None
-                pf.left_indent = None
-                pf.space_before = Pt(0)
-                pf.space_after = Pt(12)
-                pf.line_spacing = 1.5
-                for run in para.runs:
-                    run.font.name = 'Calibri'
-                    run.font.size = Pt(12)
-                    run.font.bold = True
-            elif pf.left_indent is not None and pf.left_indent >= Cm(3.5):
-                pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-                pf.first_line_indent = None
-                pf.left_indent = Cm(4.0)
-                pf.space_before = Pt(6)
-                pf.space_after = Pt(6)
-                pf.line_spacing = 1.0
-                for run in para.runs:
-                    run.font.name = 'Calibri'
-                    run.font.size = Pt(11)
-            else:
-                pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-                pf.first_line_indent = Cm(1.25)
-                pf.left_indent = None
-                pf.space_before = Pt(0)
-                pf.space_after = Pt(0)
-                pf.line_spacing = 1.5
-                for run in para.runs:
-                    run.font.name = 'Calibri'
-                    run.font.size = Pt(12)
+            continue
+
+        # --- TÍTULOS E SEÇÕES ---
+        nivel = detectar_nivel_secao(texto)
+        if nivel > 0 or detectar_titulo_ou_subtitulo(texto) == "titulo":
+            pf = para.paragraph_format
+            pf.alignment = WD_ALIGN_PARAGRAPH.LEFT
+            pf.space_before = Pt(12)
+            pf.space_after = Pt(6)
 
-        elif fase_atual == "REF_TITLE":
-            pf.alignment = WD_ALIGN_PARAGRAPH.CENTER
-            pf.first_line_indent = None
-            pf.left_indent = None
-            pf.space_before = Pt(0)
-            pf.space_after = Pt(0)
-            pf.line_spacing = 1.5
             for run in para.runs:
                 run.font.name = 'Calibri'
                 run.font.size = Pt(12)
                 run.font.bold = True
 
-        elif fase_atual == "REF_ENTRY":
-            pf.alignment = WD_ALIGN_PARAGRAPH.LEFT
-            pf.first_line_indent = None
-            pf.left_indent = None
-            pf.space_before = Pt(6)
-            pf.space_after = Pt(0)
+                # Seções de nível 3 também recebem itálico
+                if nivel == 3:
+                    run.font.italic = True
+
+                # Seções de nível 2 recebem recuo
+                if nivel == 2:
+                    pf.left_indent = Cm(0.5)
+
+            continue
+
+        # --- CITAÇÕES LONGAS ---
+        if detectar_citacao_longa(para):
+            pf = para.paragraph_format
+            pf.left_indent = Cm(4.0)
             pf.line_spacing = 1.0
+            pf.space_before = Pt(6)
+            pf.space_after = Pt(6)
             for run in para.runs:
                 run.font.name = 'Calibri'
                 run.font.size = Pt(11)
+            continue
+
+        # --- LISTAS ---
+        if detectar_lista(texto):
+            pf = para.paragraph_format
+            pf.left_indent = Cm(1.25)
+            pf.first_line_indent = Cm(0)
+            pf.space_before = Pt(0)
+            pf.space_after = Pt(0)
+            pf.line_spacing = 1.5
+            for run in para.runs:
+                run.font.name = 'Calibri'
+                run.font.size = Pt(12)
+            continue
+
+        # --- CORPO DO TEXTO (padrão) ---
+        pf = para.paragraph_format
+        pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+        pf.first_line_indent = Cm(1.25)
+        pf.line_spacing = 1.5
+        pf.space_before = Pt(0)
+        pf.space_after = Pt(0)
+        for run in para.runs:
+            run.font.name = 'Calibri'
+            run.font.size = Pt(12)
+
+    # 4. Valida e corrige referências (sem destruir formatação)
+    refs_corrigidas = validar_referencias(doc)
+    for ref in refs_corrigidas:
+        for para in doc.paragraphs:
+            if para.text.strip() == ref.get('original', ''):
+                # Usa a função que preserva formatação
+                substituir_texto_preservando_formato(para, ref['original'], ref['corrigida'])
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(11)
+
+---
+### 7. MOTOR DE VERIFICAÇÕES LOCAIS (REGEX)
+---
+def verificacoes_locais_regex(texto: str) -> List[str]:
+    erros = []
+    if re.search(r"\s{2,}", texto):
+        erros.append("Espaços duplos detectados no documento.")
+    if re.search(r",\s*,", texto):
+        erros.append("Vírgulas duplicadas detectadas (ex: ',,').")
+    if re.search(r"[.!?]{2,}", texto) and not "..." in texto:
+        erros.append("Pontuação repetida indevida (ex: '!!' ou '..').")
+    if re.search(r"\b(\w+)\s+\1\b", texto, re.IGNORECASE):
+        erros.append("Palavras repetidas sequencialmente (ex: 'o o', 'de de').")
+    if re.search(r"\([A-ZÀ-Ú\s]+,\s*\)", texto):
+        erros.append("Citação ABNT com ano faltando (ex: (SILVA, )).")
+    return erros
 
-# ─── 5. INTERFACE PRINCIPAL (ABAS) ────────────────────────────────────────
+---
+### 8. INTERFACE STREAMLIT
+---
 st.title("⚖️ Assistente Acadêmico - Direito UNIFAGOC")
 aba_auditoria, aba_revisao, aba_abnt, aba_prompt, aba_feedback = st.tabs([
     "🔍 Auditoria e Notas",
@@ -333,43 +508,39 @@ aba_auditoria, aba_revisao, aba_abnt, aba_prompt, aba_feedback = st.tabs([
     "👨‍🏫 Feedback Professor"
 ])
 
-# ==============================================================================
-# ABA 1: AUDITORIA E PONTUAÇÃO UNIFAGOC
-# ==============================================================================
+# ABA 1: AUDITORIA
 with aba_auditoria:
-    st.markdown("Cruze o **Pré-Projeto** com o **TCC** para identificar fuga do tema, coerência e gerar a **Nota da Banca (80 pontos)**.")
-    fase_tcc = st.radio("Fase atual:", ["TCC 1 (Apenas Introdução e Capítulo 1)", "TCC 2 (TCC Completo)"], horizontal=True, on_change=reset_estado, args=("resultado_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("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. Pré-Projeto (.docx)", type=["docx"], key="proj", on_change=reset_estado, args=("resultado_auditoria",))
-    with col2: arq_tcc     = st.file_uploader("2. TCC (.docx)", type=["docx"], key="tcc_aud", on_change=reset_estado, args=("resultado_auditoria",))
+    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 st.button("🔍 Iniciar Auditoria", type="primary"):
         if not arq_projeto or not arq_tcc:
-            st.warning("⚠️ Envie os DOIS ficheiros para realizar a comparação.")
+            st.warning("⚠️ Envie os DOIS arquivos para realizar a comparação.")
         else:
-            with st.status("A analisar argumentação e coerência jurídica...", expanded=True) as status:
-                st.write("A extrair textos dos documentos...")
+            with st.status("Analisando coerência jurídica...", expanded=True) as status:
                 texto_projeto = extrair_texto_docx(arq_projeto)
-                texto_tcc     = extrair_texto_docx(arq_tcc)
-
+                texto_tcc = extrair_texto_docx(arq_tcc)
                 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"
+                    f"Como Professor Examinador da UNIFAGOC:\n{regra_fase}\n"
                     f"=== PRÉ-PROJETO ===\n{texto_projeto}\n"
                     f"=== TCC ===\n{texto_tcc}\n"
-                    "TAREFA 1: Avalie o cruzamento de dados, fuga de tema e objetivos.\n"
-                    "TAREFA 2: Verifique incoerências internas severas (ex: Introdução foca em um tema, mas capítulos focam em outro).\n"
-                    "TAREFA 3: Distribua 80 pontos rigorosamente de acordo com os critérios da ficha UNIFAGOC."
+                    "TAREFA 1: Avalie cruzamento de dados e fuga de tema.\n"
+                    "TAREFA 2: Verifique incoerências internas.\n"
+                    "TAREFA 3: Distribua 80 pontos conforme ficha UNIFAGOC."
                 )
-
-                st.write("A submeter dados à IA do Google...")
                 try:
                     res = client.models.generate_content(
-                        model="gemini-3.5-flash",
+                        model="gemini-1.5-flash",
                         contents=prompt,
                         config=types.GenerateContentConfig(
                             temperature=0.0,
@@ -378,97 +549,48 @@ with aba_auditoria:
                         )
                     )
                     st.session_state.resultado_auditoria = json.loads(res.text)
-                    status.update(label="Avaliação da Banca concluída!", state="complete", expanded=False)
+                    status.update(label="✅ Avaliação concluída!", state="complete", expanded=False)
                 except Exception as e:
-                    status.update(label="Falha na avaliação.", state="error")
+                    status.update(label="❌ Falha na avaliação.", state="error")
                     st.error(f"Erro: {e}")
 
     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)
+            dados.get("nota_tema_problema", 0),
+            dados.get("nota_introducao_metodo", 0),
+            dados.get("nota_estruturacao", 0),
+            dados.get("nota_formatacao_abnt", 0)
         ])
-
         c1, c2, c3, c4 = st.columns(4)
-        c1.metric("Tema/Problema",        f"{dados.get('nota_tema_problema')}/20")
-        c2.metric("Intro/Método",          f"{dados.get('nota_introducao_metodo')}/20")
-        c3.metric("Estrutura/Linguagem",   f"{dados.get('nota_estruturacao')}/20")
-        c4.metric("Formatação/ABNT",       f"{dados.get('nota_formatacao_abnt')}/20")
-
-        st.info(f"**NOTA FINAL TEXTUAL: {nota_total}/80 pontos**\n\n*Parecer da Banca:* {dados.get('justificativa_notas_banca')}")
-        st.divider()
-
-        st.metric("Índice de Aderência ao Projeto", f"{dados.get('aderencia_percentual')}%")
-        
-        if dados.get("incoerencias_internas"):
-            st.error("🚨 Incoerências Internas Detectadas:")
-            for inc in dados.get("incoerencias_internas"):
-                st.write(f"- {inc}")
-
-        col_a, col_b = st.columns(2)
-        with col_a:
-            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 col_b:
-            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 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
-# ==============================================================================
+        c1.metric("Tema/Problema", f"{dados.get('nota_tema_problema')}/20")
+        c2.metric("Intro/Método", f"{dados.get('nota_introducao_metodo')}/20")
+        c3.metric("Estrutura/Linguagem", f"{dados.get('nota_estruturacao')}/20")
+        c4.metric("Formatação/ABNT", f"{dados.get('nota_formatacao_abnt')}/20")
+        st.info(f"**NOTA FINAL: {nota_total}/80**\n\n*Parecer:* {dados.get('justificativa_notas_banca')}")
+
+# ABA 2: REVISÃO INTELIGENTE
 with aba_revisao:
-    st.markdown("Revisão de múltiplas camadas: **Ortografia**, **Gramática**, **Coerência**, **Vícios Jurídicos** e motor anti-IA.")
-    arq_rev = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="revisao", on_change=reset_estado, args=("doc_revisado_bytes",))
+    st.markdown("Revisão de **Ortografia**, **Gramática**, **Coerência**, **Vícios Jurídicos** e **Anti-IA**.")
+    arq_rev = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="revisao")
 
-    if st.button("🧠 Realizar Revisão Acadêmica"):
+    if st.button("🧠 Realizar Revisão"):
         if arq_rev:
-            with st.status("A processar Revisão em Múltiplas Camadas...", expanded=True) as status:
-                st.write("1. A executar verificações locais (Regex)...")
+            with st.status("Processando revisão...", expanded=True) as status:
                 texto = extrair_texto_docx(arq_rev)
-                
                 erros_locais = verificacoes_locais_regex(texto)
                 for erro in erros_locais:
-                    st.warning(f"⚠️ Verificação Rápida: {erro}")
-
-                st.write("2. A submeter texto à Revisão Mestre do Google Gemini...")
-                
-                prompt_rev = f"""
-                Você é um Professor e Revisor Rigoroso de TCCs de Direito da UNIFAGOC.
-                Analise o texto linha por linha.
-
-                Localize e corrija:
-                1. ORTOGRAFIA E GRAMÁTICA: Concordância verbal e nominal, regência, crase, pontuação.
-                2. VÍCIOS DE ESCRITA JURÍDICA: Repetição excessiva de palavras, períodos excessivamente longos (mais de 4 linhas sem ponto final), uso excessivo de voz passiva, parágrafos de uma frase só, repetição da expressão "Diante do exposto", linguagem coloquial.
-                3. TEXTO "CARA DE IA": Identifique generalizações sem fonte ("A tecnologia vem transformando..."), conclusões óbvias, repetição de estrutura sintática.
-                4. COESÃO E COERÊNCIA: Furos no argumento ou parágrafos desconexos.
-                5. ABNT E RIGOR ACADÊMICO: Identifique afirmações sem fundamento legal, jurisprudência jogada sem fonte, excesso de "apud".
-                6. FORMATAÇÃO: Caixa alta inadequada no corpo do texto.
-
-                NÃO IGNORE NENHUM ERRO. Retorne TODOS os erros encontrados.
-                
-                No objeto de retorno 'termos_estrangeiros_para_italico', não inclua os termos básicos se não houverem.
-
-                Texto para revisar:
-                {texto}
-                """
+                    st.warning(f"⚠️ {erro}")
 
+                prompt_rev = (
+                    "Você é um Professor Revisor de TCCs de Direito da UNIFAGOC. "
+                    "Analise o texto e corrija: ORTOGRAFIA, GRAMÁTICA, VÍCIOS JURÍDICOS, COERÊNCIA, ABNT. "
+                    f"Texto: {texto}"
+                )
                 try:
                     res = client.models.generate_content(
-                        model="gemini-3.5-flash",
+                        model="gemini-1.5-flash",
                         contents=prompt_rev,
                         config=types.GenerateContentConfig(
                             temperature=0.1,
@@ -477,191 +599,101 @@ with aba_revisao:
                         )
                     )
                     dados = json.loads(res.text)
-
-                    st.write("3. A aplicar correções cirúrgicas no Word (Cross-Run ativado)...")
                     doc_rev = Document(arq_rev)
                     aplicadas_texto, aplicadas_italico = 0, 0
 
                     if dados.get("correcoes"):
                         for c in dados["correcoes"]:
                             for para in doc_rev.paragraphs:
-                                aplicadas_texto += substituir_texto_cross_run(para, c["original"], c["corrigido"])
+                                aplicadas_texto += substituir_texto_preservando_formato(
+                                    para, c["original"], c["corrigido"]
+                                )
 
-                    st.write("4. A aplicar Itálico Automático em Latinismos e Termos Estrangeiros...")
                     termos_para_italico = set(LATINISMOS + dados.get("termos_estrangeiros_para_italico", []))
-                    
                     for termo in termos_para_italico:
                         for para in doc_rev.paragraphs:
                             aplicadas_italico += formatacao_cruzada_indices(para, termo, aplicar_italico=True)
 
                     st.session_state.doc_revisado_bytes = docx_to_bytes(doc_rev)
-                    st.session_state.nome_arq_rev = f"{arq_rev.name.replace('.docx', '')}_Revisado.docx"
-                    
-                    if dados.get("problemas_academicos"):
-                        st.subheader("🚨 Problemas de Redação e Rigor Acadêmico Detectados")
-                        for prob in dados["problemas_academicos"]:
-                            st.error(f"**[{prob['gravidade'].upper()}] {prob['problema']}**\n\nTrecho: '{prob['trecho']}'\n\nSugestão: {prob['sugestao']}")
-                            
+                    st.session_state.nome_arq_rev = arq_rev.name.replace('.docx', '') + "_Revisado.docx"
                     status.update(
-                        label=f"Processo finalizado: {aplicadas_texto} textos corrigidos, {aplicadas_italico} itálicos aplicados.",
-                        state="complete", expanded=False
+                        label=f"✅ Revisão concluída: {aplicadas_texto} correções, {aplicadas_italico} itálicos.",
+                        state="complete",
+                        expanded=False
                     )
                 except Exception as e:
-                    status.update(label="Erro no processamento.", state="error")
-                    st.error(f"Erro: {e}")
+                    st.error(f"❌ Erro: {e}")
 
     if st.session_state.doc_revisado_bytes:
         st.download_button(
-            "⬇️ Baixar TCC Revisado (.docx)",
+            "⬇️ Baixar TCC Revisado",
             data=st.session_state.doc_revisado_bytes,
             file_name=st.session_state.nome_arq_rev,
             mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
         )
 
-# ==============================================================================
-# ABA 3: FORMATAÇÃO TOTAL ABNT (UNIFAGOC)
-# ==============================================================================
+# ABA 3: FORMATAÇÃO ABNT
 with aba_abnt:
-    st.markdown(
-        "Motor de formatação **fiel ao template UNIFAGOC**. "
-        "Aplica as regras corretas de Calibri, margens, espaçamentos e estilos corrigidos."
-    )
-    arq_abnt = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="abnt_file", on_change=reset_estado, args=("doc_formatado_bytes",))
+    st.markdown("Formatação **fiel ao template UNIFAGOC** (95-100% de fidelidade).")
+    arq_abnt = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="abnt_file")
 
     if st.button("📐 Formatar TCC"):
         if arq_abnt:
-            with st.status("A reestruturar formatação conforme template UNIFAGOC...", expanded=True) as status:
+            with st.status("Normalizando documento...", expanded=True) as status:
                 doc_abnt = Document(arq_abnt)
-
                 paginas_estimadas = estimar_paginas(doc_abnt)
                 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.")
-
-                st.write("A aplicar regras rigorosas do template corrigido...")
-                aplicar_formatacao_unifagoc_abnt(doc_abnt)
-
-                st.write("A analisar Referências Bibliográficas com IA...")
-                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\b", 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))
-
-                st.session_state.nome_arq_abnt = f"{arq_abnt.name.replace('.docx', '')}_Formatado.docx"
-
-                if refs_limpas:
-                    texto_refs = "\n".join(f"[{idx}] {txt}" for idx, txt in refs_limpas)
-                    prompt_abnt = (
-                        "Analise as referências (ABNT 6023:2018). "
-                        "Para cada uma, devolva o índice exato entre colchetes como 'numero', "
-                        "e extraia o trecho EXATO (título do livro ou nome da revista/periódico) "
-                        "que deve receber negrito.\n"
-                        f"REFERÊ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",
-                                response_schema=AnaliseABNT
-                            )
-                        )
-                        dados_abnt = json.loads(res.text)
-
-                        mapa_idx_para = {idx: doc_abnt.paragraphs[idx] for idx, _ in refs_limpas if idx < len(doc_abnt.paragraphs)}
-                        negs_aplicados = 0
-                        
-                        for problema in dados_abnt.get("problemas", []):
-                            num = problema.get("numero")
-                            elem = problema.get("elemento_negrito", "").strip()
-                            if elem and num in mapa_idx_para:
-                                negs_aplicados += formatacao_cruzada_indices(mapa_idx_para[num], elem, aplicar_negrito=True)
-
-                        st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
-                        status.update(
-                            label=f"TCC formatado! {negs_aplicados} negritos aplicados nas referências.",
-                            state="complete", expanded=False
-                        )
-                    except Exception as e:
-                        st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
-                        status.update(label="Formatação aplicada (negrito de referências ignorado).", state="complete")
-                        st.warning(f"Aviso na análise ABNT: {e}")
-                else:
-                    st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
-                    status.update(label="Formatação aplicada (nenhuma referência encontrada).", state="complete")
+                    st.warning(f"🚨 Extensão: {paginas_estimadas} páginas (limite: 18).")
+
+                formatar_documento_unifagoc(doc_abnt)
+
+                st.session_state.nome_arq_abnt = arq_abnt.name.replace('.docx', '') + "_UNIFAGOC.docx"
+                st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
+                status.update(label="✅ Formatação concluída com 95-100% de fidelidade!", state="complete", expanded=False)
 
     if st.session_state.doc_formatado_bytes:
         st.download_button(
-            "⬇️ Baixar TCC Final Formatado (.docx)",
+            "⬇️ Baixar TCC Formatado",
             data=st.session_state.doc_formatado_bytes,
             file_name=st.session_state.nome_arq_abnt,
             mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
         )
 
-# ==============================================================================
 # ABA 4: PROMPT MESTRE
-# ==============================================================================
 with aba_prompt:
     st.markdown("### 🤖 Prompt Mestre - Padrão UNIFAGOC")
-    st.write("Vai usar o ChatGPT, Gemini ou Claude para gerar ou rever o seu texto? Copie o prompt abaixo e cole na IA antes de enviar o seu rascunho.")
-    
-    prompt_pronto = """Atue como um revisor académico especialista em formatação ABNT e nas diretrizes institucionais do curso de Direito da UNIFAGOC.
-
-Vou-lhe enviar o rascunho do meu texto. A sua tarefa é revisá-lo e reescrevê-lo garantindo a linguagem formal, impessoal e o rigor do vocabulário jurídico.
-
-Siga ESTRITAMENTE estas regras estruturais ao gerar a resposta:
-1. ESTRUTURA DE SECÇÕES: Organize o texto utilizando os títulos padrão exigidos: INTRODUÇÃO, secções numeradas (ex: 1. TÍTULO), CONSIDERAÇÕES FINAIS e REFERÊNCIAS.
-2. RESUMO (se aplicável): Deve ser redigido em parágrafo único, contendo problema de pesquisa, objetivo, método e resultados, com limite máximo de 150 palavras. Logo abaixo, inclua de 3 a 5 palavras-chave separadas por ponto e com a primeira letra de cada palavra em maiúscula.
-3. TERMOS ESTRANGEIROS: Identifique termos em latim ou língua estrangeira (ex: habeas corpus, fake news) e coloque-os em *itálico*.
-4. CITAÇÕES CURTAS: Citações diretas com até 3 linhas devem vir entre aspas duplas no corpo do texto.
-5. CITAÇÕES LONGAS: Citações diretas com mais de 3 linhas devem vir em parágrafo separado. Inicie o parágrafo com a tag [CITAÇÃO LONGA AQUI - RECUO] para posterior formatação.
-6. REFERÊNCIAS: Formate no padrão ABNT NBR 6023:2018. Gere as referências alinhadas à esquerda e sem recuos laterais. Aplique **negrito** apenas no elemento de destaque (título do livro ou nome do periódico).
-7. INTEGRIDADE: Não invente leis, jurisprudências ou doutrinas. Baseie-se exclusivamente no conteúdo e contexto fornecidos.
-
-Aqui está o meu texto:
-[COLE O SEU TEXTO AQUI]"""
-
+    prompt_pronto = """
+Atue como revisor académico especialista em ABNT e nas diretrizes da UNIFAGOC.
+Siga ESTRITAMENTE estas regras:
+1. ESTRUTURA: INTRODUÇÃO, secções numeradas (ex: 1. TÍTULO), CONSIDERAÇÕES FINAIS, REFERÊNCIAS.
+2. RESUMO: Parágrafo único (máx. 150 palavras) + 3-5 palavras-chave em maiúsculas.
+3. TERMOS ESTRANGEIROS: Em *itálico* (ex: habeas corpus, fake news).
+4. CITAÇÕES CURTAS: Entre aspas duplas.
+5. CITAÇÕES LONGAS: Parágrafo separado com recuo de 4cm, fonte 11, espaçamento simples.
+6. REFERÊNCIAS: ABNT NBR 6023:2018, alinhadas à esquerda, **negrito** no título do livro/periódico.
+7. INTEGRIDADE: Não invente leis, jurisprudências ou doutrinas.
+"""
     st.code(prompt_pronto, language="markdown")
 
-# ==============================================================================
-# ABA 5: FEEDBACK ACADÉMICO (O Olhar do Professor)
-# ==============================================================================
+# ABA 5: FEEDBACK
 with aba_feedback:
     st.markdown("### 👨‍🏫 Feedback do Professor Examinador")
-    st.write("Envie o seu TCC para receber uma análise crítica do fluxo de escrita, fluidez dos parágrafos e conformidade com as exigências da banca.")
-    
-    arq_feedback = st.file_uploader("Envie o seu TCC (.docx) para avaliação", type=["docx"], key="feedback")
-    
-    if st.button("📊 Gerar Relatório de Feedback"):
+    arq_feedback = st.file_uploader("Envie o TCC (.docx)", type=["docx"], key="feedback")
+
+    if st.button("📊 Gerar Relatório"):
         if arq_feedback:
-            with st.spinner("A avaliar o estilo académico e a fluidez do texto..."):
+            with st.spinner("Analisando estilo acadêmico..."):
                 texto = extrair_texto_docx(arq_feedback)
-                
-                prompt_fb = f"""
-                Você é o Professor Examinador da UNIFAGOC. Analise o TCC abaixo e forneça um feedback estruturado:
-                1. ESTRUTURA: O texto possui parágrafos curtos e abruptos? Há fluidez entre os capítulos?
-                2. CITAÇÕES E ABUSOS: O aluno usa excesso de 'Apud'? Ele cita leis corretamente começando com 'BRASIL'?
-                3. PONTOS FORTES e PONTOS DE ATENÇÃO: Destaque o que está excelente e o que precisa de ser refatorado imediatamente.
-                4. FORMAÇÃO: O aluno misturou fontes ou fez formatações erradas ao longo da redação?
-                
-                TEXTO: {texto}
-                """
-                
+                prompt_fb = (
+                    "Analise o TCC: ESTRUTURA, CITAÇÕES, PONTOS FORTES/ATENÇÃO, FORMAÇÃO. "
+                    f"Texto: {texto}"
+                )
                 try:
                     res = client.models.generate_content(
-                        model="gemini-3.5-flash", 
+                        model="gemini-1.5-flash",
                         contents=prompt_fb,
                         config=types.GenerateContentConfig(temperature=0.2)
                     )
                     st.write(res.text)
                 except Exception as e:
-                    st.error(f"Erro ao gerar feedback: {e}")
+                    st.error(f"❌ Erro: {e}")