Update app.py

app.py

@@ -6,28 +6,17 @@ import streamlit as st
 from docx import Document
 from docx.shared import Cm, Pt
 from docx.enum.text import WD_ALIGN_PARAGRAPH
-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 typing import List, Optional, Tuple
 from google import genai
 from google.genai import types
 
 # =====================================================
-# 1. CONFIGURAÇÃO INICIAL E ESTADO
+# CONFIGURAÇÕES GLOBAIS
 # =====================================================
-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
-
-# 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 de Latinismos Jurídicos
+MAX_CHARS_PER_CHUNK = 15000  # Limite para chunking de documentos grandes
 LATINISMOS = [
     "habeas corpus", "data venia", "jus puniendi", "jus postulandi",
     "mens legis", "ratio decidendi", "obiter dictum", "in casu",
@@ -37,7 +26,7 @@ LATINISMOS = [
 ]
 
 # =====================================================
-# 2. ESQUEMAS DE DADOS (PYDANTIC)
+# ESQUEMAS PYDANTIC
 # =====================================================
 class AuditoriaTCC(BaseModel):
     aderencia_percentual: int
@@ -76,414 +65,539 @@ class RevisaoInteligente(BaseModel):
     termos_estrangeiros_para_italico: List[str]
 
 class ProblemaReferencia(BaseModel):
-    numero: int
-    erros: List[str]
-    elemento_negrito: str
-
-class ReferenciaCorrigida(BaseModel):
     original: str
-    erros: List[str]  # Apenas aponta erros, NÃO reescreve a referência
+    erros: List[str]
 
 class ListaReferencias(BaseModel):
-    referencias: List[ReferenciaCorrigida]
+    referencias: List[ProblemaReferencia]
 
 # =====================================================
-# 3. AUTENTICAÇÃO E CLIENTE GEMINI
+# CLASSE REVISOR IA (Responsável por interações com Gemini)
 # =====================================================
-@st.cache_resource
-def get_client():
-    api_key = st.secrets["GEMINI_API_KEY"]  # Usando secrets do Streamlit
-    if not api_key:
-        st.error("❌ ERRO: Chave GEMINI_API_KEY não configurada nos secrets.")
-        st.stop()
-    return genai.Client(api_key=api_key)
-
-client = get_client()
+class RevisorIA:
+    def __init__(self):
+        self.client = genai.Client(api_key=st.secrets["GEMINI_API_KEY"])
+
+    def auditar_tcc(self, texto_projeto: str, texto_tcc: str, fase_tcc: str) -> Optional[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 da UNIFAGOC:\n{regra_fase}\n"
+            f"=== PRÉ-PROJETO ===\n{texto_projeto}\n"
+            f"=== TCC ===\n{texto_tcc}\n"
+            "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."
+        )
+        try:
+            res = self.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
+                )
+            )
+            return AuditoriaTCC(**json.loads(res.text))
+        except Exception as e:
+            st.error(f"Erro na auditoria: {e}")
+            return None
+
+    def revisar_texto(self, texto: str) -> Optional[RevisaoInteligente]:
+        prompt = (
+            "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 = self.client.models.generate_content(
+                model="gemini-3.5-flash",
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    temperature=0.1,
+                    response_mime_type="application/json",
+                    response_schema=RevisaoInteligente
+                )
+            )
+            return RevisaoInteligente(**json.loads(res.text))
+        except Exception as e:
+            st.error(f"Erro na revisão: {e}")
+            return None
+
+    def validar_referencias(self, referencias: List[str]) -> ListaReferencias:
+        refs_str = '\n'.join(referencias)
+        prompt = (
+            "Analise as referências abaixo **APENAS PARA IDENTIFICAR ERROS** (NÃO reescreva, NÃO invente dados!).\n"
+            "Para cada uma, retorne:\n"
+            "- original: texto original\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 = self.client.models.generate_content(
+                model="gemini-3.5-flash",
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    temperature=0.0,
+                    response_mime_type="application/json",
+                    response_schema=ListaReferencias
+                )
+            )
+            return ListaReferencias(**json.loads(res.text))
+        except Exception as e:
+            st.error(f"Erro na validação de referências: {e}")
+            return ListaReferencias(referencias=[])
 
 # =====================================================
-# 4. FUNÇÕES AUXILIARES
+# CLASSE FORMATADOR UNIFAGOC (Responsável por formatação DOCX)
 # =====================================================
-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()])
-
-def docx_to_bytes(doc: Document) -> bytes:
-    byte_io = io.BytesIO()
-    doc.save(byte_io)
-    return byte_io.getvalue()
-
-def estimar_paginas(doc: Document) -> int:
-    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 substituir_texto_preservando_formato(para, original: str, corrigido: str) -> int:
-    """
-    Substitui texto PRESERVANDO formatação de runs (negrito, itálico, hyperlinks, etc.).
-    Não usa para.clear() para evitar perder formatação.
-    """
-    texto_completo = "".join(run.text for run in para.runs)
-    if original not in texto_completo:
-        return 0
-
-    # Localiza a posição do texto original
-    pos = texto_completo.find(original)
-    if pos == -1:
-        return 0
-
-    # Divide o texto em partes: antes, original, depois
-    antes = texto_completo[:pos]
-    depois = texto_completo[pos + len(original):]
-
-    # Reconstroi o parágrafo com os runs existentes
-    novo_texto = antes + corrigido + depois
-    para.clear()  # Limpa para reconstruir
-
-    # Adiciona o texto completo de volta (preservando a formatação visual)
-    run = para.add_run(novo_texto)
-
-    # Aplica formatação padrão (Calibri 12)
-    run.font.name = 'Calibri'
-    run.font.size = Pt(12)
-
-    return 1
-
-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))
-    else:
-        idx = para.text.find(texto_alvo)
-        matches = [(idx, idx + len(texto_alvo))] if idx != -1 else []
-
-    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
+class FormatadorUNIFAGOC:
+    @staticmethod
+    def aplicar_margens(doc: Document):
+        """Aplica margens oficiais UNIFAGOC (A4: 21x29.7cm)"""
+        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)
+            section.header_distance = Cm(0.5)
+            section.footer_distance = Cm(0.5)
+
+    @staticmethod
+    def adicionar_paginacao(doc: Document):
+        """Adiciona numeração de páginas no rodapé (centralizado) - XML correto"""
+        for i, section in enumerate(doc.sections):
+            if i == 0:  # Ignora capa/folha de rosto
+                continue
+            footer = section.footer
+            para = footer.paragraphs[0] if footer.paragraphs else footer.add_paragraph()
+            para.alignment = WD_ALIGN_PARAGRAPH.CENTER
 
-# =====================================================
-# 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 (evitando falsos positivos)"""
-    # Regex mais preciso: só detecta se começar com padrão de lista seguido de espaço ou hifen
-    return bool(re.match(r'^(\d+[\)\.]|[a-zA-Z][\)\.]|[IVXLCDM]+[\)\.]|[-–])\s', texto))
+            # Adiciona campo PAGE via XML
+            run = para.add_run()
+            fldChar = OxmlElement('w:fldChar')
+            fldChar.set(qn('w:fldCharType'), 'begin')
+            run._r.append(fldChar)
 
-# =====================================================
-# 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)
-        section.top_margin = Cm(3.0)
-        section.left_margin = Cm(3.0)
-        section.bottom_margin = Cm(2.0)
-        section.right_margin = Cm(2.0)
-        section.header_distance = Cm(0.5)
-        section.footer_distance = Cm(0.5)
-
-def adicionar_paginacao(doc: Document):
-    """Adiciona numeração de páginas no rodapé (centralizado) - SOMENTE para seções de conteúdo"""
-    for i, section in enumerate(doc.sections):
-        # Ignora a primeira seção (geralmente capa e folha de rosto)
-        if i == 0:
-            continue
-
-        # Adiciona parágrafo ao rodapé
-        footer_para = section.footer.paragraphs[0] if section.footer.paragraphs else section.footer.add_paragraph()
-        footer_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-
-        # Adiciona campo de página via XML
-        run = footer_para.add_run()
-        fldChar = run._r.add_fldChar()
-        fldChar.type = 'begin'
-        instrText = run._r.add_instrText()
-        instrText.text = 'PAGE'
-        fldChar = run._r.add_fldChar()
-        fldChar.type = 'end'
-
-        # Formatação do rodapé
-        for run in footer_para.runs:
-            run.font.name = 'Calibri'
-            run.font.size = Pt(10)
-
-def formatar_figuras_tabelas(doc: Document):
-    """Formata figuras, tabelas e quadros conforme template UNIFAGOC"""
-    for para in doc.paragraphs:
-        texto = para.text.strip()
-        if re.match(r'^(Figura|Tabela|Quadro)\s+\d+', texto, re.IGNORECASE):
-            pf = para.paragraph_format
-            pf.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            instrText = OxmlElement('w:instrText')
+            instrText.set(qn('xml:space'), 'preserve')
+            instrText.text = 'PAGE'
+            run._r.append(instrText)
+
+            fldChar = OxmlElement('w:fldChar')
+            fldChar.set(qn('w:fldCharType'), 'end')
+            run._r.append(fldChar)
+
+            # Formatação
             for run in para.runs:
                 run.font.name = 'Calibri'
-                run.font.size = Pt(12)
-                run.font.bold = True
-
-            # 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.size = Pt(10)
+
+    @staticmethod
+    def formatar_figuras_tabelas(doc: Document):
+        """Formata figuras, tabelas e quadros"""
+        for para in doc.paragraphs:
+            texto = para.text.strip()
+            if re.match(r'^(Figura|Tabela|Quadro)\s+\d+', texto, re.IGNORECASE):
+                para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                for run in para.runs:
                     run.font.name = 'Calibri'
-                    run.font.size = Pt(11)
-
-    # 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.size = Pt(12)
+                    run.bold = True
+                # Formata legenda
+                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(11)
 
-def formatar_imagens(doc: Document):
-    """Centraliza imagens (inline shapes) - Solução alternativa para python-docx"""
-    for para in doc.paragraphs:
-        if para._element.xpath('.//pic:pic'):
-            para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-
-def formatar_notas_rodape(doc: Document):
-    """Formata notas de rodapé (¹, ², ³)"""
-    for para in doc.paragraphs:
-        if re.search(r'[\d\^]+$', para.text.strip()):
-            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 - APENAS APONTA ERROS (não reescreve)"""
-    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 reescreva, NÃO invente dados!).\n"
-        "Para cada uma, retorne:\n"
-        "- original: texto original\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-3.5-flash",  # Modelo válido
-            contents=prompt_refs,
-            config=types.GenerateContentConfig(
-                temperature=0.0,
-                response_mime_type="application/json",
-                response_schema=ListaReferencias
-            )
-        )
-        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 (somente para seções de conteúdo)
-    aplicar_margens_unifagoc(doc)
-    adicionar_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(6)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(12)
-                run.font.bold = True
-            continue
-
-        # --- RESUMO ---
-        if texto.upper() == "RESUMO":
-            pf = para.paragraph_format
-            pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            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.bold = True
-            continue
-
-        # --- PALAVRAS-CHAVE ---
-        if texto.upper().startswith("PALAVRAS-CHAVE"):
-            pf = para.paragraph_format
-            pf.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            pf.space_before = Pt(6)
-            pf.space_after = Pt(0)
-            pf.line_spacing = 1.5
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(11)
-                if "PALAVRAS-CHAVE" in run.text.upper():
-                    run.font.bold = True
-            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)
-
+        # Formata tabelas
+        for table in doc.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    for para in cell.paragraphs:
+                        para.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)
+
+    @staticmethod
+    def formatar_imagens(doc: Document):
+        """Centraliza imagens (inline shapes) - Solução robusta"""
+        for para in doc.paragraphs:
+            if para._p.xpath('.//w:drawing') or para._p.xpath('.//w:pic'):
+                para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+    @staticmethod
+    def formatar_notas_rodape(doc: Document):
+        """Formata notas de rodapé (¹, ², ³)"""
+        for para in doc.paragraphs:
+            if re.search(r'[\d\^]+$', para.text.strip()):
+                for run in para.runs:
+                    run.font.size = Pt(8)
+                    run.font.superscript = True
+
+    @staticmethod
+    def substituir_texto_preservando_formato(para, original: str, corrigido: str) -> int:
+        """
+        Substitui texto PRESERVANDO formatação de runs (negrito, itálico, hyperlinks, etc.).
+        Usa abordagem de divisão de runs em vez de para.clear().
+        """
+        texto_completo = "".join(run.text for run in para.runs)
+        if original not in texto_completo:
+            return 0
+
+        pos = texto_completo.find(original)
+        if pos == -1:
+            return 0
+
+        # Divide o texto em partes: antes, original, depois
+        antes = texto_completo[:pos]
+        depois = texto_completo[pos + len(original):]
+
+        # Reconstroi o parágrafo mantendo a formatação dos runs existentes
+        # 1. Adiciona a parte "antes" com a formatação original
+        if antes:
+            para.add_run(antes)
+
+        # 2. Adiciona a parte corrigida (com formatação padrão)
+        run_corrigido = para.add_run(corrigido)
+        run_corrigido.font.name = 'Calibri'
+        run_corrigido.font.size = Pt(12)
+
+        # 3. Adiciona a parte "depois" com a formatação original
+        if depois:
+            para.add_run(depois)
+
+        return 1
+
+    @staticmethod
+    def formatar_documento(doc: Document) -> List[ProblemaReferencia]:
+        """Função principal de formatação com fluxo único"""
+        # 1. Aplica margens e paginação
+        FormatadorUNIFAGOC.aplicar_margens(doc)
+        FormatadorUNIFAGOC.adicionar_paginacao(doc)
+
+        # 2. Formata elementos específicos
+        FormatadorUNIFAGOC.formatar_figuras_tabelas(doc)
+        FormatadorUNIFAGOC.formatar_imagens(doc)
+        FormatadorUNIFAGOC.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):
+                para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                para.paragraph_format.space_before = Pt(12)
+                para.paragraph_format.space_after = Pt(6)
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(12)
+                    run.bold = True
+                continue
+
+            # --- RESUMO ---
+            if texto.upper() == "RESUMO":
+                para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+                para.paragraph_format.space_before = Pt(12)
+                para.paragraph_format.space_after = Pt(0)
+                para.paragraph_format.line_spacing = 1.5
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(11)
+                    run.bold = True
+                continue
+
+            # --- PALAVRAS-CHAVE ---
+            if texto.upper().startswith("PALAVRAS-CHAVE"):
+                para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+                para.paragraph_format.space_before = Pt(6)
+                para.paragraph_format.space_after = Pt(0)
+                para.paragraph_format.line_spacing = 1.5
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(11)
+                    if "PALAVRAS-CHAVE" in run.text.upper():
+                        run.bold = True
+                continue
+
+            # --- TÍTULOS E SEÇÕES ---
+            nivel = FormatadorUNIFAGOC.detectar_nivel_secao(texto)
+            if nivel > 0 or FormatadorUNIFAGOC.detectar_titulo_ou_subtitulo(texto) == "titulo":
+                para.alignment = WD_ALIGN_PARAGRAPH.LEFT
+                para.paragraph_format.space_before = Pt(12)
+                para.paragraph_format.space_after = Pt(6)
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(12)
+                    run.bold = True
+                    if nivel == 3:
+                        run.italic = True
+                if nivel == 2:
+                    para.paragraph_format.left_indent = Cm(0.5)
+                continue
+
+            # --- CITAÇÕES LONGAS ---
+            if FormatadorUNIFAGOC.detectar_citacao_longa(para):
+                para.paragraph_format.left_indent = Cm(4.0)
+                para.paragraph_format.line_spacing = 1.0
+                para.paragraph_format.space_before = Pt(6)
+                para.paragraph_format.space_after = Pt(6)
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(11)
+                continue
+
+            # --- LISTAS ---
+            if FormatadorUNIFAGOC.detectar_lista(texto):
+                para.paragraph_format.left_indent = Cm(1.25)
+                para.paragraph_format.first_line_indent = Cm(0)
+                para.paragraph_format.space_before = Pt(0)
+                para.paragraph_format.space_after = Pt(0)
+                para.paragraph_format.line_spacing = 1.5
+                for run in para.runs:
+                    run.font.name = 'Calibri'
+                    run.font.size = Pt(12)
+                continue
+
+            # --- CORPO DO TEXTO ---
+            para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+            para.paragraph_format.first_line_indent = Cm(1.25)
+            para.paragraph_format.line_spacing = 1.5
+            para.paragraph_format.space_before = Pt(0)
+            para.paragraph_format.space_after = Pt(0)
             for run in para.runs:
                 run.font.name = 'Calibri'
                 run.font.size = Pt(12)
-                run.font.bold = True
 
-                # Seções de nível 3 também recebem itálico
-                if nivel == 3:
-                    run.font.italic = True
+        # 4. Valida referências (apenas aponta erros)
+        refs = FormatadorUNIFAGOC.extrair_referencias(doc)
+        revisor = RevisorIA()
+        lista_refs = revisor.validar_referencias(refs)
+        return lista_refs.referencias
+
+    @staticmethod
+    def detectar_nivel_secao(texto: str) -> int:
+        match = re.match(r'^(\d+(?:\.\d+)*)\s+', texto)
+        if not match:
+            return 0
+        return match.group(1).count('.') + 1
+
+    @staticmethod
+    def detectar_titulo_ou_subtitulo(texto: str) -> Optional[str]:
+        SECOES_ESPECIAIS = ["INTRODUÇÃO", "CONSIDERAÇÕES FINAIS", "REFERÊNCIAS", "RESUMO", "PALAVRAS-CHAVE"]
+        texto_upper = texto.upper()
+        if any(sec in texto_upper for sec in SECOES_ESPECIAIS):
+            return "titulo"
+        if FormatadorUNIFAGOC.detectar_nivel_secao(texto) > 0:
+            return "titulo"
+        if texto.isupper() and len(texto) < 150 and not FormatadorUNIFAGOC.detectar_nivel_secao(texto):
+            return "titulo"
+        return None
+
+    @staticmethod
+    def detectar_citacao_longa(para) -> bool:
+        """Detecção robusta: 40+ palavras OU recuo >= 3.5cm"""
+        if para.paragraph_format.left_indent and para.paragraph_format.left_indent >= Cm(3.5):
+            return True
+        texto = para.text.strip()
+        if len(texto.split()) >= 40:
+            return True
+        return False
+
+    @staticmethod
+    def detectar_lista(texto: str) -> bool:
+        """Regex preciso para listas (evita falsos positivos)"""
+        return bool(re.match(r'^(\d+[\)\.]|[a-zA-Z][\)\.]|[IVXLCDM]+[\)\.]|[-–])\s', texto))
+
+    @staticmethod
+    def extrair_referencias(doc: Document) -> List[str]:
+        """Extrai todas as referências do documento"""
+        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)
+        return refs
+
+    @staticmethod
+    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()])
+
+    @staticmethod
+    def docx_to_bytes(doc: Document) -> bytes:
+        byte_io = io.BytesIO()
+        doc.save(byte_io)
+        return byte_io.getvalue()
+
+    @staticmethod
+    def estimar_paginas(doc: Document) -> int:
+        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)
 
-                # Seções de nível 2 recebem recuo
-                if nivel == 2:
-                    pf.left_indent = Cm(0.5)
+# =====================================================
+# CLASSE AUDITOR TCC (Responsável por auditorias)
+# =====================================================
+class AuditorTCC:
+    def __init__(self):
+        self.revisor = RevisorIA()
+
+    def auditar(self, arq_projeto, arq_tcc, fase_tcc: str) -> Optional[AuditoriaTCC]:
+        texto_projeto = FormatadorUNIFAGOC.extrair_texto_docx(arq_projeto)
+        texto_tcc = FormatadorUNIFAGOC.extrair_texto_docx(arq_tcc)
+        return self.revisor.auditar_tcc(texto_projeto, texto_tcc, fase_tcc)
+
+    def revisar(self, arq_rev) -> Tuple[Document, RevisaoInteligente, List[str]]:
+        """Revisa documento com chunking para grandes arquivos"""
+        doc = Document(arq_rev)
+        texto_completo = FormatadorUNIFAGOC.extrair_texto_docx(arq_rev)
+        erros_locais = self.verificar_erros_locais(texto_completo)
+
+        # Chunking para documentos grandes
+        chunks = self.dividir_em_chunks(texto_completo)
+        resultados_revisao = []
+
+        for chunk in chunks:
+            resultado = self.revisor.revisar_texto(chunk)
+            if resultado:
+                resultados_revisao.append(resultado)
+
+        # Consolida resultados
+        revisao_consolidada = self.consolidar_revisoes(resultados_revisao)
+
+        # Aplica correções no documento
+        self.aplicar_correcoes(doc, revisao_consolidada)
+
+        return doc, revisao_consolidada, erros_locais
+
+    def verificar_erros_locais(self, 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
+
+    def dividir_em_chunks(self, texto: str) -> List[str]:
+        """Divide texto em chunks de MAX_CHARS_PER_CHUNK"""
+        chunks = []
+        for i in range(0, len(texto), MAX_CHARS_PER_CHUNK):
+            chunks.append(texto[i:i + MAX_CHARS_PER_CHUNK])
+        return chunks
+
+    def consolidar_revisoes(self, revisoes: List[RevisaoInteligente]) -> RevisaoInteligente:
+        """Consolida múltiplas revisões em uma única"""
+        if not revisoes:
+            return RevisaoInteligente(correcoes=[], problemas_academicos=[], termos_estrangeiros_para_italico=[])
+
+        # Consolida correções
+        todas_correcoes = []
+        for revisao in revisoes:
+            todas_correcoes.extend(revisao.correcoes)
+
+        # Consolida problemas acadêmicos
+        todos_problemas = []
+        for revisao in revisoes:
+            todos_problemas.extend(revisao.problemas_academicos)
+
+        # Consolida termos estrangeiros
+        todos_termos = []
+        for revisao in revisoes:
+            todos_termos.extend(revisao.termos_estrangeiros_para_italico)
+
+        return RevisaoInteligente(
+            correcoes=todas_correcoes,
+            problemas_academicos=todos_problemas,
+            termos_estrangeiros_para_italico=list(set(todos_termos))
+        )
 
-            continue
+    def aplicar_correcoes(self, doc: Document, revisao: RevisaoInteligente):
+        """Aplica correções no documento (incluindo tabelas)"""
+        # Aplica correções em parágrafos
+        for para in doc.paragraphs:
+            for correcao in revisao.correcoes:
+                FormatadorUNIFAGOC.substituir_texto_preservando_formato(
+                    para, correcao.original, correcao.corrigido
+                )
 
-        # --- 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
+        # Aplica correções em tabelas
+        for table in doc.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    for para in cell.paragraphs:
+                        for correcao in revisao.correcoes:
+                            FormatadorUNIFAGOC.substituir_texto_preservando_formato(
+                                para, correcao.original, correcao.corrigido
+                            )
+
+        # Aplica itálico em termos estrangeiros
+        termos_para_italico = set(LATINISMOS + revisao.termos_estrangeiros_para_italico)
+        for para in doc.paragraphs:
+            for termo in termos_para_italico:
+                FormatadorUNIFAGOC.formatacao_cruzada_indices(para, termo, aplicar_italico=True)
+
+        # Formata tabelas
+        for table in doc.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    for para in cell.paragraphs:
+                        for termo in termos_para_italico:
+                            FormatadorUNIFAGOC.formatacao_cruzada_indices(para, termo, aplicar_italico=True)
+
+    @staticmethod
+    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))
+        else:
+            idx = para.text.find(texto_alvo)
+            matches = [(idx, idx + len(texto_alvo))] if idx != -1 else []
+
+        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:
-                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 referências (apenas aponta erros, não reescreve)
-    refs_com_erros = validar_referencias(doc)
-    for ref in refs_com_erros:
-        st.warning(f"⚠️ Erros na referência: '{ref['original']}' -> {', '.join(ref['erros'])}")
+                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
 
 # =====================================================
-# 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
-
-# =====================================================
-# 8. INTERFACE STREAMLIT
+# INTERFACE STREAMLIT
 # =====================================================
 st.title("⚖️ Assistente Acadêmico - Direito UNIFAGOC")
 aba_auditoria, aba_revisao, aba_abnt, aba_prompt, aba_feedback = st.tabs([
@@ -494,6 +608,10 @@ aba_auditoria, aba_revisao, aba_abnt, aba_prompt, aba_feedback = st.tabs([
     "👨‍🏫 Feedback Professor"
 ])
 
+# Inicialização das classes
+auditor = AuditorTCC()
+formatador = FormatadorUNIFAGOC()
+
 # ABA 1: AUDITORIA
 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)**.")
@@ -510,51 +628,28 @@ with aba_auditoria:
             st.warning("⚠️ Envie os DOIS arquivos para realizar a comparação.")
         else:
             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)
-                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 da UNIFAGOC:\n{regra_fase}\n"
-                    f"=== PRÉ-PROJETO ===\n{texto_projeto}\n"
-                    f"=== TCC ===\n{texto_tcc}\n"
-                    "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."
-                )
-                try:
-                    res = client.models.generate_content(
-                        model="gemini-3.5-flash",  # Modelo válido
-                        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)
+                resultado = auditor.auditar(arq_projeto, arq_tcc, fase_tcc)
+                if resultado:
+                    st.session_state.resultado_auditoria = resultado
                     status.update(label="✅ Avaliação concluída!", state="complete", expanded=False)
-                except Exception as e:
+                else:
                     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.nota_tema_problema,
+            dados.nota_introducao_metodo,
+            dados.nota_estruturacao,
+            dados.nota_formatacao_abnt
         ])
         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: {nota_total}/80**\n\n*Parecer:* {dados.get('justificativa_notas_banca')}")
+        c1.metric("Tema/Problema", f"{dados.nota_tema_problema}/20")
+        c2.metric("Intro/Método", f"{dados.nota_introducao_metodo}/20")
+        c3.metric("Estrutura/Linguagem", f"{dados.nota_estruturacao}/20")
+        c4.metric("Formatação/ABNT", f"{dados.nota_formatacao_abnt}/20")
+        st.info(f"**NOTA FINAL: {nota_total}/80**\n\n*Parecer:* {dados.justificativa_notas_banca}")
 
 # ABA 2: REVISÃO INTELIGENTE
 with aba_revisao:
@@ -564,51 +659,22 @@ with aba_revisao:
     if st.button("🧠 Realizar Revisão"):
         if arq_rev:
             with st.status("Processando revisão...", expanded=True) as status:
-                texto = extrair_texto_docx(arq_rev)
-                erros_locais = verificacoes_locais_regex(texto)
+                doc_rev, revisao, erros_locais = auditor.revisar(arq_rev)
                 for erro in erros_locais:
                     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}"
+                if revisao.problemas_academicos:
+                    st.subheader("🚨 Problemas de Redação Detectados")
+                    for prob in revisao.problemas_academicos:
+                        st.error(f"**[{prob.gravidade.upper()}] {prob.problema}**\n\nTrecho: '{prob.trecho}'\n\nSugestão: {prob.sugestao}")
+
+                st.session_state.doc_revisado_bytes = formatador.docx_to_bytes(doc_rev)
+                st.session_state.nome_arq_rev = arq_rev.name.replace('.docx', '') + "_Revisado.docx"
+                status.update(
+                    label=f"✅ Revisão concluída: {len(revisao.correcoes)} correções, {len(revisao.termos_estrangeiros_para_italico)} itálicos.",
+                    state="complete",
+                    expanded=False
                 )
-                try:
-                    res = client.models.generate_content(
-                        model="gemini-3.5-flash",  # Modelo válido
-                        contents=prompt_rev,
-                        config=types.GenerateContentConfig(
-                            temperature=0.1,
-                            response_mime_type="application/json",
-                            response_schema=RevisaoInteligente
-                        )
-                    )
-                    dados = json.loads(res.text)
-                    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_preservando_formato(
-                                    para, c["original"], c["corrigido"]
-                                )
-
-                    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 = arq_rev.name.replace('.docx', '') + "_Revisado.docx"
-                    status.update(
-                        label=f"✅ Revisão concluída: {aplicadas_texto} correções, {aplicadas_italico} itálicos.",
-                        state="complete",
-                        expanded=False
-                    )
-                except Exception as e:
-                    st.error(f"❌ Erro: {e}")
 
     if st.session_state.doc_revisado_bytes:
         st.download_button(
@@ -627,14 +693,20 @@ with aba_abnt:
         if arq_abnt:
             with st.status("Normalizando documento...", expanded=True) as status:
                 doc_abnt = Document(arq_abnt)
-                paginas_estimadas = estimar_paginas(doc_abnt)
+                paginas_estimadas = formatador.estimar_paginas(doc_abnt)
                 if paginas_estimadas > 18:
                     st.warning(f"🚨 Extensão: {paginas_estimadas} páginas (limite: 18).")
 
-                formatar_documento_unifagoc(doc_abnt)
+                refs_com_erros = formatador.formatar_documento(doc_abnt)
+
+                # Exibe erros de referências na interface
+                if refs_com_erros:
+                    st.subheader("⚠️ Erros em Referências ABNT")
+                    for ref in refs_com_erros:
+                        st.warning(f"Referência: '{ref.original}'\nErros: {', '.join(ref.erros)}")
 
                 st.session_state.nome_arq_abnt = arq_abnt.name.replace('.docx', '') + "_UNIFAGOC.docx"
-                st.session_state.doc_formatado_bytes = docx_to_bytes(doc_abnt)
+                st.session_state.doc_formatado_bytes = formatador.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:
@@ -669,14 +741,14 @@ with aba_feedback:
     if st.button("📊 Gerar Relatório"):
         if arq_feedback:
             with st.spinner("Analisando estilo acadêmico..."):
-                texto = extrair_texto_docx(arq_feedback)
+                texto = formatador.extrair_texto_docx(arq_feedback)
                 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",  # Modelo válido
+                    res = auditor.revisor.client.models.generate_content(
+                        model="gemini-3.5-flash",
                         contents=prompt_fb,
                         config=types.GenerateContentConfig(temperature=0.2)
                     )