app.py

import gradio as gr
import pandas as pd
import numpy as np
import re
import os
import matplotlib.pyplot as plt
from datetime import timedelta
from fpdf import FPDF
from typing import Tuple, Dict, List
import logging
import warnings

warnings.filterwarnings('ignore')

# Configuração de logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

class DataProcessor:
    @staticmethod
    def parse_duration(duration_str: str) -> timedelta:
        try:
            h, m, s = map(int, duration_str.split(':'))
            return timedelta(hours=h, minutes=m, seconds=s)
        except:
            return timedelta(0)

    @staticmethod
    def format_timedelta(td: timedelta) -> str:
        total_seconds = int(td.total_seconds())
        hours, remainder = divmod(total_seconds, 3600)
        minutes, seconds = divmod(remainder, 60)
        if hours > 0:
            return f"{hours}h {minutes}min {seconds}s"
        elif minutes > 0:
            return f"{minutes}min {seconds}s"
        return f"{seconds}s"

    @staticmethod
    def normalize_html_to_csv(input_html_path: str, output_csv_path: str) -> None:
        try:
            html_data = pd.read_html(input_html_path)
            data = html_data[0]
            data.to_csv(output_csv_path, index=False, encoding='utf-8-sig')
            logging.info(f"HTML normalizado com sucesso: {output_csv_path}")
        except Exception as e:
            logging.error(f"Erro ao normalizar HTML: {str(e)}")
            raise

    @staticmethod
    def normalize_excel_to_csv(input_excel_path: str, output_csv_path: str) -> None:
        try:
            excel_data = pd.read_excel(input_excel_path)
            unnecessary_columns = [col for col in excel_data.columns if 'Unnamed' in str(col)]
            if unnecessary_columns:
                excel_data = excel_data.drop(columns=unnecessary_columns)
            excel_data.to_csv(output_csv_path, index=False, encoding='utf-8-sig')
            logging.info(f"Excel normalizado com sucesso: {output_csv_path}")
        except Exception as e:
            logging.error(f"Erro ao normalizar Excel: {str(e)}")
            raise

class StudentAnalyzer:
    def __init__(self, tarefas_df: pd.DataFrame, alunos_df: pd.DataFrame):
        self.tarefas_df = tarefas_df
        self.alunos_df = alunos_df
        self.processor = DataProcessor()

    def prepare_data(self) -> pd.DataFrame:
        self.tarefas_df.columns = self.tarefas_df.columns.str.strip()
        self.alunos_df.columns = self.alunos_df.columns.str.strip()

        required_columns = ['Aluno', 'Nota', 'Duração']
        if not all(col in self.tarefas_df.columns for col in required_columns):
            raise ValueError("Colunas obrigatórias não encontradas no arquivo de tarefas")

        self.tarefas_df['Duração'] = self.tarefas_df['Duração'].apply(self.processor.parse_duration)
        return self.match_students()

    def match_students(self) -> pd.DataFrame:
        def generate_aluno_pattern(ra, dig_ra):
            ra_str = str(ra).zfill(9)
            return f"{ra_str[1]}{ra_str[2:]}{dig_ra}-sp".lower()

        self.alunos_df['Aluno_Pattern'] = self.alunos_df.apply(
            lambda row: generate_aluno_pattern(row['RA'], row['Dig. RA']), axis=1
        )

        def extract_pattern(nome):
            if isinstance(nome, str):
                match = re.search(r'\d+.*', nome.lower())
                return match.group(0) if match else None
            return None

        self.tarefas_df['Aluno_Pattern'] = self.tarefas_df['Aluno'].apply(extract_pattern)
        return self.calculate_metrics()

    def calculate_metrics(self) -> pd.DataFrame:
        metrics_df = pd.DataFrame()
        
        for _, aluno in self.alunos_df.iterrows():
            aluno_pattern = aluno['Aluno_Pattern']
            aluno_tarefas = self.tarefas_df[self.tarefas_df['Aluno_Pattern'] == aluno_pattern]
            
            if not aluno_tarefas.empty:
                duracao_total = aluno_tarefas['Duração'].sum()
                acertos_total = aluno_tarefas['Nota'].sum()
                
                metrics = {
                    'Nome do Aluno': aluno['Nome do Aluno'],
                    'Tarefas Completadas': len(aluno_tarefas),
                    'Acertos Absolutos': acertos_total,
                    'Total Tempo': str(duracao_total),
                    'Tempo Médio por Tarefa': str(duracao_total / len(aluno_tarefas)),
                    'Eficiência': (acertos_total / duracao_total.total_seconds() * 3600)
                }
                metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)

        return metrics_df.sort_values('Acertos Absolutos', ascending=False)

class ReportGenerator:
    def __init__(self, data: pd.DataFrame):
        self.data = data
        self.stats = self.calculate_statistics()
        self.data['Nível'] = self.data['Acertos Absolutos'].apply(self.classify_performance)

    def classify_performance(self, acertos):
        if acertos >= 10:
            return 'Avançado'
        elif acertos >= 5:
            return 'Intermediário'
        else:
            return 'Necessita Atenção'

    def calculate_statistics(self) -> Dict:
        basic_stats = {
            'media_acertos': float(self.data['Acertos Absolutos'].mean()),
            'desvio_padrao': float(self.data['Acertos Absolutos'].std()),
            'mediana_acertos': float(self.data['Acertos Absolutos'].median()),
            'total_alunos': len(self.data),
            'media_tarefas': float(self.data['Tarefas Completadas'].mean()),
            'media_tempo': str(pd.to_timedelta(self.data['Total Tempo']).mean())
        }

        top_students = self.data.nlargest(3, 'Acertos Absolutos')[
            ['Nome do Aluno', 'Acertos Absolutos']
        ].values.tolist()
        basic_stats['top_performers'] = top_students

        efficient_students = self.data.nlargest(3, 'Eficiência')[
            ['Nome do Aluno', 'Eficiência', 'Acertos Absolutos']
        ].values.tolist()
        basic_stats['most_efficient'] = efficient_students

        return basic_stats

    def generate_graphs(self) -> List[plt.Figure]:
        plt.style.use('seaborn')
        graphs = []
        
        # 1. Distribuição por nível
        plt.figure(figsize=(12, 6))
        nivel_counts = self.data['Nível'].value_counts()
        colors = {'Avançado': '#2ecc71', 'Intermediário': '#f1c40f', 'Necessita Atenção': '#e74c3c'}
        
        bars = plt.bar(nivel_counts.index, nivel_counts.values)
        for i, bar in enumerate(bars):
            bar.set_color(colors[nivel_counts.index[i]])
            plt.text(bar.get_x() + bar.get_width()/2, bar.get_height(), 
                    str(nivel_counts.values[i]), 
                    ha='center', va='bottom')
        
        plt.title('Distribuição dos Alunos por Nível de Desempenho', pad=20, fontsize=12)
        plt.ylabel('Número de Alunos', labelpad=10)
        plt.grid(True, alpha=0.3)
        graphs.append(plt.gcf())
        plt.close()

        # 2. Top 10 alunos
        plt.figure(figsize=(12, 6))
        top_10 = self.data.head(10)
        bars = plt.barh(top_10['Nome do Aluno'], top_10['Acertos Absolutos'], 
                       color='#3498db')
        
        plt.title('Top 10 Alunos - Acertos Absolutos', pad=20, fontsize=12)
        plt.xlabel('Número de Acertos', labelpad=10)
        
        for i, bar in enumerate(bars):
            plt.text(bar.get_width(), bar.get_y() + bar.get_height()/2,
                    f' {bar.get_width():.0f}', 
                    va='center')
        
        plt.grid(True, alpha=0.3)
        plt.tight_layout()
        graphs.append(plt.gcf())
        plt.close()

        # 3. Relação tempo x acertos
        plt.figure(figsize=(12, 6))
        for nivel in colors:
            mask = self.data['Nível'] == nivel
            tempo = pd.to_timedelta(self.data[mask]['Total Tempo']).dt.total_seconds() / 60
            plt.scatter(tempo, self.data[mask]['Acertos Absolutos'],
                       c=colors[nivel], label=nivel, alpha=0.6, s=100)
        
        plt.title('Relação entre Tempo e Acertos por Nível', pad=20, fontsize=12)
        plt.xlabel('Tempo Total (minutos)', labelpad=10)
        plt.ylabel('Número de Acertos', labelpad=10)
        plt.legend()
        plt.grid(True, alpha=0.3)
        graphs.append(plt.gcf())
        plt.close()

        # 4. Relação Tarefas x Acertos com linha de tendência
        plt.figure(figsize=(12, 6))
        plt.scatter(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'],
                   color='#3498db', alpha=0.6, s=100)
        
        z = np.polyfit(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'], 1)
        p = np.poly1d(z)
        x_range = np.linspace(self.data['Tarefas Completadas'].min(), 
                            self.data['Tarefas Completadas'].max(), 100)
        plt.plot(x_range, p(x_range), "r--", alpha=0.8, label='Tendência')
        
        plt.title('Relação entre Tarefas Completadas e Acertos', pad=20, fontsize=12)
        plt.xlabel('Número de Tarefas Completadas', labelpad=10)
        plt.ylabel('Número de Acertos', labelpad=10)
        plt.legend()
        plt.grid(True, alpha=0.3)
        graphs.append(plt.gcf())
        plt.close()

        return graphs

    def generate_pdf(self, output_path: str, graphs: List[plt.Figure]) -> None:
        """Gera relatório em PDF com análise detalhada."""
        class PDF(FPDF):
            def header(self):
                self.set_font('Arial', 'B', 15)
                self.set_fill_color(240, 240, 240)
                self.cell(0, 15, 'Relatório de Desempenho - Análise Detalhada', 0, 1, 'C', True)
                self.ln(10)

        pdf = PDF('L', 'mm', 'A4')

        # Introdução
        pdf.add_page()
        pdf.set_font('Arial', 'B', 14)
        pdf.set_fill_color(240, 240, 240)
        pdf.cell(0, 10, 'Introdução', 0, 1, 'L', True)
        pdf.ln(5)
        pdf.set_font('Arial', '', 11)
        intro_text = """
        Este relatório apresenta uma análise abrangente do desempenho dos alunos nas atividades realizadas.
        Os dados são analisados considerando três aspectos principais:

        • Acertos: Total de questões respondidas corretamente
        • Engajamento: Número de tarefas completadas
        • Dedicação: Tempo investido nas atividades

        Os alunos são classificados em três níveis de acordo com seu desempenho:
        • Avançado: 10 ou mais acertos - Excelente domínio do conteúdo
        • Intermediário: 5 a 9 acertos - Bom entendimento, com espaço para melhorias
        • Necessita Atenção: Menos de 5 acertos - Requer suporte adicional

        A eficiência é medida em acertos por hora, permitindo identificar alunos que
        conseguem bons resultados com uso eficiente do tempo.
        """
        pdf.multi_cell(0, 7, intro_text)
        
        # Visão Geral
        pdf.add_page()
        pdf.set_font('Arial', 'B', 14)
        pdf.cell(0, 10, 'Visão Geral da Turma', 0, 1, 'L', True)
        pdf.ln(5)

        tempo_medio = pd.to_timedelta(self.stats['media_tempo'])
        minutos = int(tempo_medio.total_seconds() // 60)
        segundos = int(tempo_medio.total_seconds() % 60)
        
        pdf.set_font('Arial', '', 11)
        stats_text = f"""
        Participação e Resultados:
        • Total de Alunos Participantes: {self.stats['total_alunos']}
        • Média de Tarefas por Aluno: {self.stats['media_tarefas']:.1f}
        • Média de Acertos: {self.stats['media_acertos']:.1f}
        • Tempo Médio de Dedicação: {minutos} minutos e {segundos} segundos

        Distribuição de Desempenho:
        • Desvio Padrão: {self.stats['desvio_padrao']:.1f} acertos
        • Mediana: {self.stats['mediana_acertos']:.1f} acertos
        """
        pdf.multi_cell(0, 7, stats_text)

        # Destaques
        pdf.ln(5)
        pdf.set_font('Arial', 'B', 12)
        pdf.cell(0, 10, 'Destaques de Desempenho', 0, 1)
        pdf.set_font('Arial', '', 11)
        
        pdf.ln(3)
        pdf.cell(0, 7, "🏆 Melhores Desempenhos:", 0, 1)
        for aluno, acertos in self.stats['top_performers']:
            pdf.cell(0, 7, f"• {aluno}: {acertos:.0f} acertos", 0, 1)

        pdf.ln(3)
        pdf.cell(0, 7, "⚡ Maior Eficiência:", 0, 1)
        for aluno, eficiencia, acertos in self.stats['most_efficient']:
            pdf.cell(0, 7, f"• {aluno}: {eficiencia:.1f} acertos/hora ({acertos:.0f} acertos totais)", 0, 1)

        # Gráficos e Análises
        for i, graph in enumerate(graphs):
            pdf.add_page()
            graph_path = f'temp_graph_{i}.png'
            graph.savefig(graph_path, dpi=300, bbox_inches='tight')
            pdf.image(graph_path, x=10, y=30, w=270)
            os.remove(graph_path)
            
            # Título e explicação para cada gráfico
            pdf.ln(150)  # Espaço após o gráfico
            pdf.set_font('Arial', 'B', 12)
            
            if i == 0:
                pdf.cell(0, 10, 'Análise da Distribuição por Nível', 0, 1, 'L', True)
                pdf.set_font('Arial', '', 11)
                pdf.multi_cell(0, 6, """
                Este gráfico ilustra como os alunos estão distribuídos entre os três níveis de desempenho.
                • Verde: Alunos no nível Avançado - demonstram excelente compreensão
                • Amarelo: Alunos no nível Intermediário - bom progresso com espaço para melhorias
                • Vermelho: Alunos que Necessitam Atenção - requerem suporte adicional
                """)
                
            elif i == 1:
                pdf.cell(0, 10, 'Top 10 Alunos por Acertos', 0, 1, 'L', True)
                pdf.set_font('Arial', '', 11)
                pdf.multi_cell(0, 6, """
                Destaca os dez alunos com maior número de acertos absolutos.
                Este ranking permite:
                • Identificar exemplos de sucesso na turma
                • Reconhecer diferentes níveis de excelência
                • Estabelecer metas realistas para os demais alunos
                """)
                
            elif i == 2:
                pdf.cell(0, 10, 'Relação Tempo x Desempenho', 0, 1, 'L', True)
                pdf.set_font('Arial', '', 11)
                pdf.multi_cell(0, 6, """
                Mostra a relação entre tempo dedicado e número de acertos.
                Pontos importantes:
                • Cores indicam o nível de cada aluno
                • Posição vertical mostra o número de acertos
                • Posição horizontal indica o tempo total dedicado
                • Dispersão dos pontos revela diferentes padrões de estudo
                """)
                
            elif i == 3:
                pdf.cell(0, 10, 'Progresso por Número de Tarefas', 0, 1, 'L', True)
                pdf.set_font('Arial', '', 11)
                pdf.multi_cell(0, 6, """
                Analisa se mais tarefas realizadas resultam em melhor desempenho.
                A linha de tendência (tracejada) indica:
                • Correlação entre quantidade de tarefas e acertos
                • Expectativa média de progresso
                • Alunos acima da linha superam a expectativa da turma
                """)

        # Detalhamento por Nível
        for nivel in ['Avançado', 'Intermediário', 'Necessita Atenção']:
            alunos_nivel = self.data[self.data['Nível'] == nivel]
            if not alunos_nivel.empty:
                pdf.add_page()
                pdf.set_font('Arial', 'B', 14)
                pdf.cell(0, 10, f'Detalhamento - Nível {nivel}', 0, 1, 'L', True)
                pdf.ln(5)

                # Tabela
                colunas = [
                    ('Nome do Aluno', 80),
                    ('Acertos', 25),
                    ('Tarefas', 25),
                    ('Tempo Total', 35),
                    ('Eficiência', 25)
                ]
                
                # Cabeçalho da tabela
                pdf.set_font('Arial', 'B', 10)
                pdf.set_fill_color(230, 230, 230)
                for titulo, largura in colunas:
                    pdf.cell(largura, 8, titulo, 1, 0, 'C', True)
                pdf.ln()

                # Dados
                pdf.set_font('Arial', '', 10)
                for _, row in alunos_nivel.iterrows():
                    tempo = pd.to_timedelta(row['Total Tempo'])
                    tempo_str = f"{int(tempo.total_seconds() // 60)}min {int(tempo.total_seconds() % 60)}s"
                    
                    pdf.cell(80, 7, str(row['Nome do Aluno'])[:40], 1)
                    pdf.cell(25, 7, f"{row['Acertos Absolutos']:.0f}", 1, 0, 'C')
                    pdf.cell(25, 7, str(row['Tarefas Completadas']), 1, 0, 'C')
                    pdf.cell(35, 7, tempo_str, 1, 0, 'C')
                    pdf.cell(25, 7, f"{float(row['Eficiência']):.1f}", 1, 0, 'C')
                    pdf.ln()

        # Recomendações Finais
        pdf.add_page()
        pdf.set_font('Arial', 'B', 14)
        pdf.cell(0, 10, 'Recomendações e Próximos Passos', 0, 1, 'L', True)
        pdf.ln(5)
        
        pdf.set_font('Arial', '', 11)
        percent_necessita_atencao = len(self.data[self.data['Nível'] == 'Necessita Atenção']) / len(self.data) * 100
        
        recom_text = f"""
        Com base na análise dos dados, recomenda-se:

        1. Ações Imediatas:
           • Implementar monitoria com alunos do nível Avançado
           • Realizar reforço focado nos {percent_necessita_atencao:.1f}% que necessitam atenção
           • Desenvolver planos de estudo personalizados

        2. Melhorias no Processo:
           • Acompanhamento individualizado dos alunos com baixo desempenho
           • Feedback regular sobre o progresso
           • Atividades extras para alunos com alta eficiência

        3. Próximos Passos:
           • Compartilhar resultados individuais
           • Agendar sessões de reforço
           • Reconhecer publicamente bons desempenhos
           • Estabelecer metas claras de melhoria
        """
        pdf.multi_cell(0, 7, recom_text)

        pdf.output(output_path)

def process_files(html_file, excel_files) -> Tuple[str, str, str]:
    """Processa arquivos e gera relatório."""
    try:
        temp_dir = "temp_files"
        os.makedirs(temp_dir, exist_ok=True)

        # Limpar diretório temporário
        for file in os.listdir(temp_dir):
            os.remove(os.path.join(temp_dir, file))

        # Salvar arquivos
        html_path = os.path.join(temp_dir, "alunos.htm")
        with open(html_path, "wb") as f:
            f.write(html_file)

        excel_paths = []
        for i, excel_file in enumerate(excel_files):
            excel_path = os.path.join(temp_dir, f"tarefa_{i}.xlsx")
            with open(excel_path, "wb") as f:
                f.write(excel_file)
            excel_paths.append(excel_path)

        # Processar arquivos
        processor = DataProcessor()
        alunos_csv_path = os.path.join(temp_dir, "alunos.csv")
        processor.normalize_html_to_csv(html_path, alunos_csv_path)

        tarefas_df = pd.DataFrame()
        for excel_path in excel_paths:
            csv_path = excel_path.replace('.xlsx', '.csv')
            processor.normalize_excel_to_csv(excel_path, csv_path)
            df = pd.read_csv(csv_path)
            tarefas_df = pd.concat([tarefas_df, df], ignore_index=True)

        # Análise
        alunos_df = pd.read_csv(alunos_csv_path)
        analyzer = StudentAnalyzer(tarefas_df, alunos_df)
        results_df = analyzer.prepare_data()

        # Gerar relatório
        report_generator = ReportGenerator(results_df)
        graphs = report_generator.generate_graphs()
        
        # Salvar outputs
        output_html = os.path.join(temp_dir, "relatorio.html")
        output_pdf = os.path.join(temp_dir, "relatorio.pdf")
        results_df.to_html(output_html, index=False)
        report_generator.generate_pdf(output_pdf, graphs)

        return results_df.to_html(index=False), output_html, output_pdf

    except Exception as e:
        logging.error(f"Erro no processamento: {str(e)}")
        raise

# Interface Gradio
theme = gr.themes.Default(
    primary_hue="blue",
    secondary_hue="gray",
    font=["Arial", "sans-serif"],
    font_mono=["Courier New", "monospace"],
)

with gr.Blocks(theme=theme) as interface:
    gr.Markdown("""
    # Sistema de Análise de Desempenho Acadêmico
    
    Este sistema analisa o desempenho dos alunos e gera um relatório detalhado com:
    - Análise estatística completa
    - Visualizações gráficas
    - Recomendações personalizadas
    """)
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("## Lista de Alunos")
            html_file = gr.File(
                label="Arquivo HTML com lista de alunos (.htm)",
                type="binary",
                file_types=[".htm", ".html"]
            )
        
        with gr.Column():
            gr.Markdown("## Relatórios de Tarefas")
            excel_files = gr.Files(
                label="Arquivos Excel com dados das tarefas (.xlsx)",
                type="binary",
                file_count="multiple",
                file_types=[".xlsx"]
            )

    with gr.Row():
        generate_btn = gr.Button("Gerar Relatório", variant="primary", size="lg")
        
    with gr.Row():
        output_html = gr.HTML()
        
    with gr.Row():
        with gr.Column():
            download_html_btn = gr.File(
                label="Download Relatório HTML",
                type="filepath",
                interactive=False
            )
        with gr.Column():
            download_pdf_btn = gr.File(
                label="Download Relatório PDF",
                type="filepath",
                interactive=False
            )

    generate_btn.click(
        fn=process_files,
        inputs=[html_file, excel_files],
        outputs=[output_html, download_html_btn, download_pdf_btn]
    )

if __name__ == "__main__":
    interface.launch(
        share=False,
        server_name="0.0.0.0",
        server_port=7860,
        show_error=True
    )