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
matplotlib.use('Agg')

# Configurações globais
ESCALA_MAXIMA_NOTAS = 12  # Aumentado para melhor visualização
LIMITE_APROVACAO_NOTA = 5
LIMITE_APROVACAO_FREQ = 75
BIMESTRES = ['1º Bimestre', '2º Bimestre', '3º Bimestre', '4º Bimestre']
CONCEITOS_VALIDOS = ['ES', 'EP', 'ET']  # Conceitos não numéricos válidos

def converter_nota(valor):
    """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
    
    # Se for string, limpar e verificar se é conceito
    if isinstance(valor, str):
        valor_limpo = valor.strip().upper()
        if valor_limpo in CONCEITOS_VALIDOS:
            # Converter conceitos para valores numéricos
            conceitos_map = {'ET': 10, 'ES': 8, 'EP': 6}
            return conceitos_map.get(valor_limpo)
        
        # Tentar converter para número
        try:
            return float(valor_limpo.replace(',', '.'))
        except:
            return None
    
    # Se for número, retornar diretamente
    if isinstance(valor, (int, float)):
        return float(valor)
    
    return None

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

def calcular_frequencia_media(frequencias):
    """Calcula média de frequência considerando apenas bimestres cursados."""
    freq_validas = []
    for freq in frequencias:
        try:
            # Limpar string e converter para número
            if isinstance(freq, str):
                freq = freq.strip().replace('%', '').replace(',', '.')
            if freq and freq != '-':
                valor = float(freq)
                if valor > 0:  # Considerar apenas frequências positivas
                    freq_validas.append(valor)
        except:
            continue
    
    if not freq_validas:
        return 0
    return sum(freq_validas) / len(freq_validas)

def extrair_tabelas_pdf(pdf_path):
    """Extrai tabelas do PDF e retorna um DataFrame processado."""
    try:
        tables = camelot.read_pdf(pdf_path, pages='all', flavor='lattice')
        print(f"Tabelas extraídas: {len(tables)}")
        
        if len(tables) == 0:
            raise ValueError("Nenhuma tabela foi extraída do PDF.")
        
        # Processar a primeira tabela
        df = tables[0].df
        
        # Extrair nome do aluno e outras informações se disponível
        info_aluno = {}
        for i, row in df.iterrows():
            if 'Nome do Aluno' in str(row[0]):
                info_aluno['nome'] = row[1].strip() if len(row) > 1 else ''
            elif 'RA' in str(row[0]):
                info_aluno['ra'] = row[1].strip() if len(row) > 1 else ''
            elif 'Escola' in str(row[0]):
                info_aluno['escola'] = row[1].strip() if len(row) > 1 else ''
            elif 'Turma' in str(row[0]):
                info_aluno['turma'] = row[1].strip() if len(row) > 1 else ''
        
        # Encontrar a tabela de notas
        for i, table in enumerate(tables):
            df_temp = table.df
            # Verificar se é a tabela de notas
            if any('Disciplina' in str(col) for col in df_temp.iloc[0]) or \
               any('Bimestre' in str(col) for col in df_temp.iloc[0]):
                df = df_temp
                # Renomear as colunas corretamente
                df = df.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'
                })
                break
        
        if df.empty:
            raise ValueError("A tabela extraída está vazia.")
        
        # Adicionar informações do aluno ao DataFrame
        for key, value in info_aluno.items():
            df.attrs[key] = value
        
        return df
        
    except Exception as e:
        print(f"Erro na extração das tabelas: {str(e)}")
        raise
        
        # Adicionar informações do aluno ao DataFrame
        for key, value in info_aluno.items():
            df.attrs[key] = value
        
        return df
        
    except Exception as e:
        print(f"Erro na extração das tabelas: {str(e)}")
        raise

def obter_disciplinas_validas(df):
    """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
        
        # Coletar notas e frequências
        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)
        
        # Calcular médias apenas se houver dados válidos
        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 gerar_paleta_cores(n_cores):
    """Gera uma paleta de cores distintas para o número de disciplinas."""
    cores_base = [
        '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd',
        '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf',
        '#393b79', '#637939', '#8c6d31', '#843c39', '#7b4173'
    ]
    
    if n_cores > len(cores_base):
        HSV_tuples = [(x/n_cores, 0.7, 0.85) for x in range(n_cores)]
        cores_extras = ['#%02x%02x%02x' % tuple(int(x*255) for x in colorsys.hsv_to_rgb(*hsv)) 
                       for hsv in HSV_tuples]
        return cores_extras
    
    return cores_base[:n_cores]

def plotar_evolucao_bimestres(disciplinas_dados, temp_dir):
    """Plota gráfico de evolução das notas por bimestre."""
    n_disciplinas = len(disciplinas_dados)
    
    if n_disciplinas == 0:
        raise ValueError("Nenhuma disciplina válida encontrada para plotar.")
    
    # Calcular tamanho da figura para A4 (proporção 1:√2)
    plt.figure(figsize=(11.69, 8.27))  # Tamanho A4 em polegadas
    
    cores = gerar_paleta_cores(n_disciplinas)
    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p', 'h', '*']
    estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--']
    
    plt.grid(True, linestyle='--', alpha=0.3, zorder=0)
    
    for idx, disc_data in enumerate(disciplinas_dados):
        notas = pd.Series(disc_data['notas'])
        bimestres_cursados = disc_data['bimestres_cursados']
        
        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]
            
            if notas_validas:
                plt.plot(bimestres, notas_validas,
                        color=cores[idx % len(cores)],
                        marker=marcadores[idx % len(marcadores)],
                        markersize=8,
                        linewidth=2,
                        label=disc_data['disciplina'],
                        linestyle=estilos_linha[idx % len(estilos_linha)],
                        alpha=0.8)
                
                for x, y in zip(bimestres, notas_validas):
                    if y is not None:
                        plt.annotate(f"{y:.1f}", (x, y),
                                   textcoords="offset points",
                                   xytext=(0, 5),
                                   ha='center',
                                   fontsize=8)
    
    plt.title('Evolução das Médias por Disciplina ao Longo dos Bimestres',
             pad=20, fontsize=12, fontweight='bold')
    plt.xlabel('Bimestres', fontsize=10)
    plt.ylabel('Notas', fontsize=10)
    plt.xticks([1, 2, 3, 4], ['1º Bim', '2º Bim', '3º Bim', '4º Bim'])
    plt.ylim(0, ESCALA_MAXIMA_NOTAS)
    
    # Adicionar linha de aprovação
    plt.axhline(y=LIMITE_APROVACAO_NOTA, color='r', linestyle='--', alpha=0.3)
    plt.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima para aprovação',
             transform=plt.gca().get_yaxis_transform(), color='r', alpha=0.5)
    
    # Ajustar legenda baseado no número de disciplinas
    if n_disciplinas > 8:
        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=8,
                  ncol=max(1, n_disciplinas // 12))
    else:
        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=1)
    
    plt.tight_layout()
    
    plot_path = os.path.join(temp_dir, 'evolucao_notas.png')
    plt.savefig(plot_path, bbox_inches='tight', dpi=300)
    plt.close()
    return plot_path

def plotar_graficos_destacados(disciplinas_dados, temp_dir):
    """Plota gráficos de médias e frequências com destaques."""
    n_disciplinas = len(disciplinas_dados)
    
    if not n_disciplinas:
        raise ValueError("Nenhuma disciplina válida encontrada no boletim.")
    
    # Calcular tamanho da figura para A4 (proporção 1:√2)
    plt.figure(figsize=(11.69, 8.27))  # Tamanho A4 em polegadas
    
    disciplinas = [d['disciplina'] for d in disciplinas_dados]
    medias_notas = [d['media_notas'] for d in disciplinas_dados]
    medias_freq = [d['media_freq'] for d in disciplinas_dados]
    
    cores_notas = ['red' if media < LIMITE_APROVACAO_NOTA else 'green' 
                   for media in medias_notas]
    cores_freq = ['red' if media < LIMITE_APROVACAO_FREQ else 'green' 
                  for media in medias_freq]
    
    media_global = np.mean(medias_notas)
    freq_global = np.mean(medias_freq)
    
    # Gráfico de notas
    plt.subplot(2, 1, 1)
    barras_notas = plt.bar(disciplinas, medias_notas, color=cores_notas)
    plt.title('Média de Notas por Disciplina', pad=20, fontsize=12, fontweight='bold')
    plt.xticks(rotation=45, ha='right', fontsize=8)
    plt.ylim(0, ESCALA_MAXIMA_NOTAS)
    
    # Adicionar linha de média mínima
    plt.axhline(y=LIMITE_APROVACAO_NOTA, color='r', linestyle='--', alpha=0.3)
    plt.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima',
             transform=plt.gca().get_yaxis_transform(), color='r', alpha=0.5)
    
    # Valores nas barras
    for barra in barras_notas:
        altura = barra.get_height()
        plt.text(barra.get_x() + barra.get_width()/2., altura,
                f'{altura:.1f}',
                ha='center', va='bottom', fontsize=8)
    
    # Gráfico de frequências
    plt.subplot(2, 1, 2)
    barras_freq = plt.bar(disciplinas, medias_freq, color=cores_freq)
    plt.title('Frequência Média por Disciplina', pad=20, fontsize=12, fontweight='bold')
    plt.xticks(rotation=45, ha='right', fontsize=8)
    plt.ylim(0, 110)  # Deixar espaço para os valores acima das barras
    
    # Adicionar linha de frequência mínima
    plt.axhline(y=LIMITE_APROVACAO_FREQ, color='r', linestyle='--', alpha=0.3)
    plt.text(0.02, LIMITE_APROVACAO_FREQ + 1, 'Frequência mínima',
             transform=plt.gca().get_yaxis_transform(), color='r', alpha=0.5)
    
    # Valores nas barras
    for barra in barras_freq:
        altura = barra.get_height()
        plt.text(barra.get_x() + barra.get_width()/2., altura,
                f'{altura:.1f}%',
                ha='center', va='bottom', fontsize=8)
    
    plt.suptitle(
        f'Média Global: {media_global:.1f} | Frequência Global: {freq_global:.1f}%',
        y=0.95, fontsize=12, fontweight='bold'
    )
    
    if freq_global < LIMITE_APROVACAO_FREQ:
        plt.figtext(0.5, 0.02,
                   "Atenção: Risco de Reprovação por Baixa Frequência",
                   ha="center", fontsize=10, color="red")
    
    plt.tight_layout()
    
    plot_path = os.path.join(temp_dir, 'medias_frequencias.png')
    plt.savefig(plot_path, bbox_inches='tight', dpi=300)
    plt.close()
    return plot_path

def gerar_relatorio_pdf(df, disciplinas_dados, grafico1_path, grafico2_path):
    """Gera relatório PDF com os gráficos e análises."""
    pdf = FPDF()
    pdf.set_auto_page_break(auto=True, margin=15)
    pdf.add_page()
    
    # Cabeçalho
    pdf.set_font('Helvetica', 'B', 16)
    pdf.cell(0, 10, 'Relatório de Desempenho Escolar', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
    pdf.ln(5)
    
    # Informações do aluno
    pdf.set_font('Helvetica', '', 11)
    if hasattr(df, 'attrs'):
        if 'nome' in df.attrs:
            pdf.cell(0, 7, f'Aluno: {df.attrs["nome"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
        if 'ra' in df.attrs:
            pdf.cell(0, 7, f'RA: {df.attrs["ra"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
        if 'escola' in df.attrs:
            pdf.cell(0, 7, f'Escola: {df.attrs["escola"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
        if 'turma' in df.attrs:
            pdf.cell(0, 7, f'Turma: {df.attrs["turma"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    
    pdf.ln(5)
    
    # Data do relatório
    data_atual = datetime.now().strftime('%d/%m/%Y')
    pdf.set_font('Helvetica', 'I', 10)
    pdf.cell(0, 5, f'Relatório gerado em: {data_atual}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    pdf.ln(10)
    
    # Gráficos
    pdf.image(grafico1_path, x=10, w=190)
    pdf.ln(10)
    pdf.image(grafico2_path, x=10, w=190)
    pdf.ln(10)
    
    # Seção de Análise
    pdf.set_font('Helvetica', 'B', 14)
    pdf.cell(0, 10, 'Análise de Desempenho', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.ln(5)
    
    # Calcular médias globais
    medias_notas = [d['media_notas'] for d in disciplinas_dados]
    medias_freq = [d['media_freq'] for d in disciplinas_dados]
    media_global = np.mean(medias_notas)
    freq_global = np.mean(medias_freq)
    
    # Resumo geral
    pdf.set_font('Helvetica', '', 11)
    pdf.cell(0, 7, f'Média Global: {media_global:.1f}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.cell(0, 7, f'Frequência Global: {freq_global:.1f}%', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.ln(5)
    
    # Avisos Importantes
    pdf.set_font('Helvetica', 'B', 12)
    pdf.cell(0, 10, 'Avisos Importantes:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.ln(2)
    
    pdf.set_font('Helvetica', '', 10)
    
    # Disciplinas com baixo desempenho
    disciplinas_risco = []
    for disc_data in disciplinas_dados:
        avisos = []
        if disc_data['media_notas'] < LIMITE_APROVACAO_NOTA:
            avisos.append(f"Média de notas abaixo de {LIMITE_APROVACAO_NOTA} ({disc_data['media_notas']:.1f})")
        if disc_data['media_freq'] < LIMITE_APROVACAO_FREQ:
            avisos.append(f"Frequência abaixo de {LIMITE_APROVACAO_FREQ}% ({disc_data['media_freq']:.1f}%)")
        
        if avisos:
            disciplinas_risco.append((disc_data['disciplina'], avisos))
    
    if disciplinas_risco:
        for disc, avisos in disciplinas_risco:
            for aviso in avisos:
                pdf.cell(0, 7, f'- {disc}: {aviso}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    else:
        pdf.cell(0, 7, 'Nenhum problema identificado.', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    
    pdf.ln(5)
    
    # Rodapé
    pdf.set_y(-30)
    pdf.set_font('Helvetica', 'I', 8)
    pdf.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')
    
    # Salvar PDF
    temp_pdf = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
    pdf_path = temp_pdf.name
    pdf.output(pdf_path)
    return pdf_path

def processar_boletim(file):
    """Função principal que processa o boletim e gera o relatório."""
    temp_dir = None
    try:
        if file is None:
            return None, "Nenhum arquivo foi fornecido."
        
        temp_dir = tempfile.mkdtemp()
        print(f"Diretório temporário criado: {temp_dir}")
        
        if not hasattr(file, 'name') or not os.path.exists(file.name):
            return None, "Arquivo inválido ou corrompido."
            
        if os.path.getsize(file.name) == 0:
            return None, "O arquivo está vazio."
        
        temp_pdf = os.path.join(temp_dir, 'boletim.pdf')
        shutil.copy2(file.name, temp_pdf)
        print(f"PDF copiado para: {temp_pdf}")
        
        if not os.path.exists(temp_pdf) or os.path.getsize(temp_pdf) == 0:
            return None, "Erro ao copiar o arquivo."
        
        print("Iniciando extração das tabelas...")
        df = extrair_tabelas_pdf(temp_pdf)
        print("Tabelas extraídas com sucesso")
        
        if df is None or df.empty:
            return None, "Não foi possível extrair dados do PDF."
        
        try:
            # Processar disciplinas
            disciplinas_dados = obter_disciplinas_validas(df)
            if not disciplinas_dados:
                return None, "Nenhuma disciplina válida encontrada no boletim."
            
            # Gerar gráficos
            print("Gerando gráficos...")
            grafico1_path = plotar_evolucao_bimestres(disciplinas_dados, temp_dir)
            grafico2_path = plotar_graficos_destacados(disciplinas_dados, temp_dir)
            print("Gráficos gerados")
            
            # Gerar PDF
            print("Gerando relatório PDF...")
            pdf_path = gerar_relatorio_pdf(df, disciplinas_dados, grafico1_path, grafico2_path)
            print("Relatório PDF gerado")
            
            # Criar arquivo de retorno
            output_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
            output_path = output_file.name
            shutil.copy2(pdf_path, output_path)
                
            return output_path, "Relatório gerado com sucesso!"
            
        except Exception as e:
            return None, f"Erro ao processar os dados: {str(e)}"
        
    except Exception as e:
        print(f"Erro durante o processamento: {str(e)}")
        return None, f"Erro ao processar o boletim: {str(e)}"
        
    finally:
        if temp_dir and os.path.exists(temp_dir):
            try:
                shutil.rmtree(temp_dir)
                print("Arquivos temporários limpos")
            except Exception as e:
                print(f"Erro ao limpar arquivos temporários: {str(e)}")

# Interface Gradio
iface = gr.Interface(
    fn=processar_boletim,
    inputs=gr.File(label="Upload do Boletim (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"
)

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