app.py

import gradio as gr
import camelot
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from fpdf import FPDF
from fpdf.enums import XPos, YPos
import tempfile
import os
import matplotlib
import shutil
import colorsys
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor
from typing import Dict, List, Tuple, Optional
from io import BytesIO
import logging
from contextlib import contextmanager

# Configurar matplotlib
matplotlib.use('Agg')

# Configurar logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Configurações globais
ESCALA_MAXIMA_NOTAS = 12
LIMITE_APROVACAO_NOTA = 5
LIMITE_APROVACAO_FREQ = 75
BIMESTRES = ['1º Bimestre', '2º Bimestre', '3º Bimestre', '4º Bimestre']
CONCEITOS_VALIDOS = ['ES', 'EP', 'ET']

# Cores para os gráficos
COR_APROVADO = '#2ECC71'  # Verde suave
COR_REPROVADO = '#E74C3C'  # Vermelho suave

# Definição das disciplinas de formação básica
FORMACAO_BASICA = {
    'fundamental': {
        'LINGUA PORTUGUESA',
        'MATEMATICA',
        'HISTORIA',
        'GEOGRAFIA',
        'CIENCIAS',
        'LINGUA ESTRANGEIRA INGLES',
        'ARTE',
        'EDUCACAO FISICA'
    },
    'medio': {
        'LINGUA PORTUGUESA',
        'MATEMATICA',
        'HISTORIA',
        'GEOGRAFIA',
        'BIOLOGIA',
        'FISICA',
        'QUIMICA',
        'INGLES',
        'FILOSOFIA',
        'SOCIOLOGIA',
        'ARTE',
        'EDUCACAO FISICA'
    }
}

# Context managers
@contextmanager
def temp_directory():
    temp_dir = tempfile.mkdtemp()
    try:
        yield temp_dir
    finally:
        if os.path.exists(temp_dir):
            shutil.rmtree(temp_dir)

@contextmanager
def temp_file(suffix=None):
    temp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
    try:
        yield temp.name
    finally:
        if os.path.exists(temp.name):
            os.unlink(temp.name)

class PDFReport(FPDF):
    """Classe personalizada para geração do relatório PDF."""
    def __init__(self):
        super().__init__()
        self.set_auto_page_break(auto=True, margin=15)
        
    def header_footer(self):
        """Adiciona header e footer padrãoo nas páginas."""
        self.set_y(-30)
        self.line(10, self.get_y(), 200, self.get_y())
        self.ln(5)
        self.set_font('Helvetica', 'I', 8)
        self.cell(0, 10, 
                 'Este relatório é uma análise automática e deve ser validado junto à secretaria da escola.',
                 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')

def converter_nota(valor) -> Optional[float]:
    """Converte valor de nota para float, tratando casos especiais e conceitos."""
    if pd.isna(valor) or valor == '-' or valor == 'N' or valor == '' or valor == 'None':
        return None
    
    if isinstance(valor, str):
        valor_limpo = valor.strip().upper()
        if valor_limpo in CONCEITOS_VALIDOS:
            conceitos_map = {'ET': 10, 'ES': 8, 'EP': 6}
            return conceitos_map.get(valor_limpo)
        
        try:
            return float(valor_limpo.replace(',', '.'))
        except:
            return None
    
    if isinstance(valor, (int, float)):
        return float(valor)
    
    return None

def calcular_media_bimestres(notas: List[float]) -> float:
    """Calcula média considerando apenas bimestres com notas válidas."""
    notas_validas = [nota for nota in notas if nota is not None]
    return sum(notas_validas) / len(notas_validas) if notas_validas else 0

def calcular_frequencia_media(frequencias: List[str]) -> float:
    """Calcula média de frequência considerando apenas bimestres cursados."""
    freq_validas = []
    for freq in frequencias:
        try:
            if isinstance(freq, str):
                freq = freq.strip().replace('%', '').replace(',', '.')
            if freq and freq != '-':
                valor = float(freq)
                if valor > 0:
                    freq_validas.append(valor)
        except:
            continue
    
    return sum(freq_validas) / len(freq_validas) if freq_validas else 0
    
def extrair_tabelas_pdf(pdf_path: str) -> pd.DataFrame:
    """Extrai tabelas do PDF usando stream para o nome e lattice para notas."""
    try:
        # Extrair nome do aluno usando stream
        tables_header = camelot.read_pdf(
            pdf_path,
            pages='1',
            flavor='stream',
            edge_tol=500
        )
        
        info_aluno = {}
        
        # Procurar nome do aluno
        for table in tables_header:
            df = table.df
            for i in range(len(df)):
                for j in range(len(df.columns)):
                    texto = str(df.iloc[i,j]).strip()
                    if 'Nome do Aluno' in texto:
                        try:
                            if j + 1 < len(df.columns):
                                nome = str(df.iloc[i,j+1]).strip()
                            elif i + 1 < len(df):
                                nome = str(df.iloc[i+1,j]).strip()
                            if nome and nome != 'Nome do Aluno:':
                                info_aluno['nome'] = nome
                                break
                        except:
                            continue
        
        # Extrair tabela de notas usando lattice
        tables_notas = camelot.read_pdf(
            pdf_path,
            pages='all',
            flavor='lattice'
        )
        
        # Encontrar tabela de notas
        df_notas = None
        max_rows = 0
        
        for table in tables_notas:
            df_temp = table.df
            if len(df_temp) > max_rows and 'Disciplina' in str(df_temp.iloc[0,0]):
                max_rows = len(df_temp)
                df_notas = df_temp.copy()
                df_notas = df_notas.rename(columns={
                    0: 'Disciplina',
                    1: 'Nota B1', 2: 'Freq B1', 3: '%Freq B1', 4: 'AC B1',
                    5: 'Nota B2', 6: 'Freq B2', 7: '%Freq B2', 8: 'AC B2',
                    9: 'Nota B3', 10: 'Freq B3', 11: '%Freq B3', 12: 'AC B3',
                    13: 'Nota B4', 14: 'Freq B4', 15: '%Freq B4', 16: 'AC B4',
                    17: 'CF', 18: 'Nota Final', 19: 'Freq Final', 20: 'AC Final'
                })
        
        if df_notas is None:
            raise ValueError("Tabela de notas não encontrada")
        
        # Adicionar informações do aluno ao DataFrame
        df_notas.attrs['nome'] = info_aluno.get('nome', 'Nome não encontrado')
        
        return df_notas
        
    except Exception as e:
        logger.error(f"Erro na extração das tabelas: {str(e)}")
        raise

def detectar_nivel_ensino(disciplinas: List[str]) -> str:
    """Detecta se são ensino fundamental ou médio baseado nas disciplinas."""
    disciplinas_set = set(disciplinas)
    disciplinas_exclusivas_medio = {'BIOLOGIA', 'FISICA', 'QUIMICA', 'FILOSOFIA', 'SOCIOLOGIA'}
    return 'medio' if any(d in disciplinas_set for d in disciplinas_exclusivas_medio) else 'fundamental'

def obter_disciplinas_validas(df: pd.DataFrame) -> List[Dict]:
    """Identifica disciplinas válidas no boletim com seus dados."""
    colunas_notas = ['Nota B1', 'Nota B2', 'Nota B3', 'Nota B4']
    colunas_freq = ['%Freq B1', '%Freq B2', '%Freq B3', '%Freq B4']
    
    disciplinas_dados = []
    
    for _, row in df.iterrows():
        disciplina = row['Disciplina']
        if pd.isna(disciplina) or disciplina == '':
            continue
        
        notas = []
        freqs = []
        bimestres_cursados = []
        
        for i, (col_nota, col_freq) in enumerate(zip(colunas_notas, colunas_freq), 1):
            nota = converter_nota(row[col_nota])
            freq = row[col_freq] if col_freq in row else None
            
            if nota is not None or (freq and freq != '-'):
                bimestres_cursados.append(i)
                notas.append(nota if nota is not None else 0)
                freqs.append(freq)
            else:
                notas.append(None)
                freqs.append(None)
        
        if bimestres_cursados:
            media_notas = calcular_media_bimestres(notas)
            media_freq = calcular_frequencia_media(freqs)
            
            disciplinas_dados.append({
                'disciplina': disciplina,
                'notas': notas,
                'frequencias': freqs,
                'media_notas': media_notas,
                'media_freq': media_freq,
                'bimestres_cursados': bimestres_cursados
            })
    
    return disciplinas_dados

    
def separar_disciplinas_por_categoria(disciplinas_dados: List[Dict]) -> Dict:
    """Separa as disciplinas em formação básica e diversificada."""
    disciplinas = [d['disciplina'] for d in disciplinas_dados]
    nivel = detectar_nivel_ensino(disciplinas)
    
    formacao_basica = []
    diversificada = []
    
    for disc_data in disciplinas_dados:
        if disc_data['disciplina'] in FORMACAO_BASICA[nivel]:
            formacao_basica.append(disc_data)
        else:
            diversificada.append(disc_data)
    
    return {
        'nivel': nivel,
        'formacao_basica': formacao_basica,
        'diversificada': diversificada
    }
# Funções de plotagem
def gerar_paleta_cores(n_cores: int) -> List[str]:
    """Gera uma paleta de cores harmoniosa."""
    cores_formacao_basica = [
        '#2E86C1',  # Azul royal
        '#2ECC71',  # Verde esmeralda
        '#E74C3C',  # Vermelho coral
        '#F1C40F',  # Amarelo ouro
        '#8E44AD',  # Roxo médio
        '#E67E22',  # Laranja escuro
        '#16A085',  # Verde-água
        '#D35400'   # Laranja queimado
    ]
    
    if n_cores <= len(cores_formacao_basica):
        return cores_formacao_basica[:n_cores]
    
    # Gerar cores adicionais se necessário
    HSV_tuples = [(x/n_cores, 0.8, 0.9) for x in range(n_cores)]
    return ['#%02x%02x%02x' % tuple(int(x*255) for x in colorsys.hsv_to_rgb(*hsv)) 
            for hsv in HSV_tuples]

def plotar_evolucao_bimestres(disciplinas_dados: List[Dict], temp_dir: str, 
                             titulo: Optional[str] = None, 
                             nome_arquivo: Optional[str] = None) -> str:
    """Plota gráfico de evolução das notas com visual aprimorado."""
    n_disciplinas = len(disciplinas_dados)
    
    if n_disciplinas == 0:
        raise ValueError("Nenhuma disciplina válida encontrada para plotar.")
    
    # Configuração do estilo
    plt.style.use('seaborn-v0_8-darkgrid')
    fig, ax = plt.subplots(figsize=(11.69, 8.27))
    
    # Configurar grid mais suave
    ax.grid(True, linestyle='--', alpha=0.2, color='gray')
    ax.set_axisbelow(True)
    
    cores = gerar_paleta_cores(n_disciplinas)
    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p']
    estilos_linha = ['-', '--', '-.', ':']
    
    deslocamentos = np.linspace(-0.02, 0.02, n_disciplinas)
    anotacoes_usadas = {}
    
    for idx, disc_data in enumerate(disciplinas_dados):
        notas = pd.Series(disc_data['notas'])
        bimestres_cursados = disc_data['bimestres_cursados']
        desloc = deslocamentos[idx]
        
        if bimestres_cursados:
            notas_validas = [nota for i, nota in enumerate(notas, 1) if i in bimestres_cursados and nota is not None]
            bimestres = [bim for bim in bimestres_cursados if notas[bim-1] is not None]
            bimestres_deslocados = [bim + desloc for bim in bimestres]
            
            if notas_validas:
                ax.plot(bimestres_deslocados, notas_validas,
                        color=cores[idx % len(cores)],
                        marker=marcadores[idx % len(marcadores)],
                        markersize=8,
                        linewidth=2.5,
                        label=disc_data['disciplina'],
                        linestyle=estilos_linha[idx % len(estilos_linha)],
                        alpha=0.8,
                        zorder=3)
                
                ax.fill_between(bimestres_deslocados, 0, notas_validas,
                                color=cores[idx % len(cores)], alpha=0.1)
                
                for bim, nota in zip(bimestres_deslocados, notas_validas):
                    if nota is not None:
                        y_offset = 10
                        while any(abs(y - (nota + y_offset/20)) < 0.4 for y, _ in anotacoes_usadas.get(bim, [])):
                            y_offset += 5
                        
                        ax.annotate(f"{nota:.1f}",
                                    (bim, nota),
                                    xytext=(0, y_offset),
                                    textcoords="offset points",
                                    ha='center',
                                    va='bottom',
                                    fontsize=9,
                                    bbox=dict(facecolor='white',
                                              edgecolor=cores[idx % len(cores)],
                                              alpha=0.8,
                                              pad=2,
                                              boxstyle='round,pad=0.5'))
                        
                        if bim not in anotacoes_usadas:
                            anotacoes_usadas[bim] = []
                        anotacoes_usadas[bim].append((nota + y_offset/20, nota))
    
    titulo_grafico = titulo or 'Evolução das Médias por Disciplina'
    ax.set_title(titulo_grafico, pad=20, fontsize=14, fontweight='bold')
    ax.set_xlabel('Bimestres', fontsize=12, labelpad=10)
    ax.set_ylabel('Notas', fontsize=12, labelpad=10)
    
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    
    ax.set_xticks([1, 2, 3, 4])
    ax.set_xticklabels(['1º Bim', '2º Bim', '3º Bim', '4º Bim'], fontsize=10)
    ax.set_ylim(0, ESCALA_MAXIMA_NOTAS)
    
    ax.axhline(y=LIMITE_APROVACAO_NOTA, color=COR_REPROVADO, linestyle='--', alpha=0.3, linewidth=2)
    ax.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima para aprovação',
            transform=ax.get_yaxis_transform(), color=COR_REPROVADO, alpha=0.7)
    
    if n_disciplinas > 8:
        ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=9, framealpha=0.8, fancybox=True, shadow=True,
                  ncol=max(1, n_disciplinas // 12))
    else:
        ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10, framealpha=0.8, fancybox=True, shadow=True)
    
    plt.tight_layout()

    # Força a renderização para evitar o erro de renderizador
    fig.canvas.draw()
    
    # Salvar com alta qualidade
    nome_arquivo = nome_arquivo or 'evolucao_notas.png'
    plot_path = os.path.join(temp_dir, nome_arquivo)
    fig.savefig(plot_path, bbox_inches='tight', dpi=300, facecolor='white', edgecolor='none')
    plt.close(fig)
    
    return plot_path

    
# Interface Gradio
iface = gr.Interface(
    fn=processar_boletim,
    inputs=gr.File(
        label="Upload do Boletim (PDF)",
        type="binary",
        file_types=[".pdf"]
    ),
    outputs=[
        gr.File(label="Relatório (PDF)"),
        gr.Textbox(label="Status")
    ],
    title="Análise de Boletim Escolar",
    description="Faça upload do boletim em PDF para gerar um relatório com análises e visualizações.",
    allow_flagging="never",
    theme=gr.themes.Default()
)

if __name__ == "__main__":
    iface.launch(
        server_name="0.0.0.0",
        share=True
    )