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.")
    
    plt.figure(figsize=(11.69, 8.27))
    
    cores = gerar_paleta_cores(n_disciplinas)
    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p', 'h', '*']
    estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--']
    
    plt.grid(True, linestyle='--', alpha=0.3, zorder=0)
    
    # Deslocamento menor para manter as linhas mais próximas mas ainda distinguíveis
    deslocamentos = np.linspace(-0.05, 0.05, n_disciplinas)
    
    # Dicionário para armazenar valores por posição
    notas_por_posicao = {}
    
    # Primeira passagem: coletar todos os valores
    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 + desloc for bim in bimestres_cursados if notas[bim-1] is not None]
            
            for bim, nota in zip(bimestres, notas_validas):
                if nota is not None:
                    # Usar valor exato para agrupar apenas notas idênticas
                    if bim not in notas_por_posicao:
                        notas_por_posicao[bim] = {}
                    if nota not in notas_por_posicao[bim]:
                        notas_por_posicao[bim][nota] = []
                    notas_por_posicao[bim][nota].append((idx, nota))

    # Segunda passagem: plotar e adicionar anotações
    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:
                # Plotar linha e pontos
                plt.plot(bimestres_deslocados, 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)
                
                # Adicionar anotações com posicionamento inteligente
                for bim_orig, bim_desloc, nota in zip(bimestres, bimestres_deslocados, notas_validas):
                    if nota is not None:
                        # Verificar quantas notas iguais existem nesta posição
                        notas_iguais = notas_por_posicao[bim_desloc].get(nota, [])
                        idx_atual = notas_iguais.index((idx, nota))
                        
                        if idx_atual == 0:  # Apenas anotar a primeira ocorrência
                            # Calcular deslocamento vertical baseado no número de notas próximas
                            y_offset = 5 + (len(notas_iguais) * 2)
                            
                            plt.annotate(f"{nota:.1f}",
                                       (bim_desloc, nota),
                                       textcoords="offset points",
                                       xytext=(0, y_offset),
                                       ha='center',
                                       va='bottom',
                                       fontsize=8,
                                       bbox=dict(facecolor='white', 
                                               edgecolor='none',
                                               alpha=0.7,
                                               pad=0.5))
    
    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
    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.")
    
    # Aumentar a figura para melhor visualização
    plt.figure(figsize=(12, 10))
    
    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]
    
    # Criar subplot com mais espaço entre os gráficos
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10), height_ratios=[1, 1])
    plt.subplots_adjust(hspace=0.5)  # Aumentar espaço entre os gráficos
    
    cores_notas = ['red' if media < LIMITE_APROVACAO_NOTA else '#2ecc71' for media in medias_notas]
    cores_freq = ['red' if media < LIMITE_APROVACAO_FREQ else '#2ecc71' for media in medias_freq]
    
    media_global = np.mean(medias_notas)
    freq_global = np.mean(medias_freq)
    
    # Gráfico de notas
    barras_notas = ax1.bar(disciplinas, medias_notas, color=cores_notas)
    ax1.set_title('Média de Notas por Disciplina', pad=20, fontsize=12, fontweight='bold')
    ax1.set_ylim(0, ESCALA_MAXIMA_NOTAS)
    ax1.grid(True, axis='y', alpha=0.3, linestyle='--')
    
    # Melhorar a apresentação dos rótulos
    ax1.set_xticklabels(disciplinas, rotation=45, ha='right', va='top')
    ax1.set_ylabel('Notas', fontsize=10, labelpad=10)
    
    # Adicionar linha de média mínima
    ax1.axhline(y=LIMITE_APROVACAO_NOTA, color='r', linestyle='--', alpha=0.3)
    ax1.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima (5,0)',
             transform=ax1.get_yaxis_transform(), color='r', alpha=0.7)
    
    # Valores nas barras
    for barra in barras_notas:
        altura = barra.get_height()
        ax1.text(barra.get_x() + barra.get_width()/2., altura,
                f'{altura:.1f}',
                ha='center', va='bottom', fontsize=8)
    
    # Gráfico de frequências
    barras_freq = ax2.bar(disciplinas, medias_freq, color=cores_freq)
    ax2.set_title('Frequência Média por Disciplina', pad=20, fontsize=12, fontweight='bold')
    ax2.set_ylim(0, 110)
    ax2.grid(True, axis='y', alpha=0.3, linestyle='--')
    
    # Melhorar a apresentação dos rótulos
    ax2.set_xticklabels(disciplinas, rotation=45, ha='right', va='top')
    ax2.set_ylabel('Frequência (%)', fontsize=10, labelpad=10)
    
    # Adicionar linha de frequência mínima
    ax2.axhline(y=LIMITE_APROVACAO_FREQ, color='r', linestyle='--', alpha=0.3)
    ax2.text(0.02, LIMITE_APROVACAO_FREQ + 1, 'Frequência mínima (75%)',
             transform=ax2.get_yaxis_transform(), color='r', alpha=0.7)
    
    # Valores nas barras
    for barra in barras_freq:
        altura = barra.get_height()
        ax2.text(barra.get_x() + barra.get_width()/2., altura,
                f'{altura:.1f}%',
                ha='center', va='bottom', fontsize=8)
    
    # Título global com informações de média
    plt.suptitle(
        f'Desempenho Geral\nMédia Global: {media_global:.1f} | Frequência Global: {freq_global:.1f}%',
        y=0.98, fontsize=14, 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=11, color="red", weight='bold')
    
    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', 18)
    pdf.cell(0, 10, 'Relatório de Desempenho Escolar', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
    pdf.ln(15)  # Aumentar espaço após título
    
    # Informações do aluno
    pdf.set_font('Helvetica', 'B', 12)
    pdf.cell(0, 10, 'Informações do Aluno', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.line(10, pdf.get_y(), 200, pdf.get_y())  # Adicionar linha divisória
    pdf.ln(5)
    
    pdf.set_font('Helvetica', '', 11)
    if hasattr(df, 'attrs'):
        if 'nome' in df.attrs:
            pdf.cell(0, 7, f'Nome: {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(10)
    
    # Data do relatório
    data_atual = datetime.now().strftime('%d/%m/%Y')
    pdf.set_font('Helvetica', 'I', 10)
    pdf.cell(0, 5, f'Data de geração: {data_atual}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
    pdf.ln(15)
    
    # Seção de gráficos
    pdf.set_font('Helvetica', 'B', 14)
    pdf.cell(0, 10, 'Análise Gráfica', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
    pdf.ln(10)
    
    pdf.image(grafico1_path, x=10, w=190)
    pdf.ln(15)
    pdf.image(grafico2_path, x=10, w=190)
    pdf.ln(15)
    
    # Seção de Análise
    pdf.set_font('Helvetica', 'B', 14)
    pdf.cell(0, 10, 'Análise Detalhada', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
    pdf.ln(10)
    
    # 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', 'B', 12)
    pdf.cell(0, 7, 'Resumo Geral:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.ln(5)
    
    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(10)
    
    # Avisos Importantes
    pdf.set_font('Helvetica', 'B', 12)
    pdf.cell(0, 10, 'Pontos de Atenção:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
    pdf.ln(5)
    
    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:
            pdf.set_font('Helvetica', 'B', 10)
            pdf.cell(0, 7, f'- {disc}:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
            pdf.set_font('Helvetica', '', 10)
            for aviso in avisos:
                pdf.cell(10)  # Indentação
                pdf.cell(0, 7, f'- {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')
    
    # Rodapé
    pdf.set_y(-30)
    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
    pdf.ln(5)
    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")