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 weasyprint import HTML
import seaborn as sns
from typing import Tuple, Dict, List
import logging
import warnings
warnings.filterwarnings('ignore')

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)
        return f"{hours:02}:{minutes:02}:{seconds:02}"

    @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()
            
                # Calcula eficiência como float diretamente
                eficiencia = (acertos_total / duracao_total.total_seconds() * 3600)
            
                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': eficiencia  # Armazena como float, não como string
                }
                metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)
            
        # Converte explicitamente a coluna Eficiência para float
        metrics_df['Eficiência'] = metrics_df['Eficiência'].astype(float)
        return metrics_df

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)
        self.data = self.data.sort_values('Acertos Absolutos', ascending=False)

    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')
        basic_stats['top_performers'] = top_students[['Nome do Aluno', 'Acertos Absolutos']].values.tolist()

        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]:
        graphs = []
        plt.style.use('seaborn')
        
        # 1. Distribuição por nível
        plt.figure(figsize=(12, 6))
        nivel_counts = self.data['Nível'].value_counts()
        colors = {'Avançado': 'green', 'Intermediário': 'yellow', 'Necessita Atenção': 'red'}
        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')
        plt.ylabel('Número de Alunos')
        graphs.append(plt.gcf())
        plt.close()

        # 2. Top 10 alunos
        plt.figure(figsize=(12, 6))
        top_10 = self.data.head(10)
        plt.barh(top_10['Nome do Aluno'], top_10['Acertos Absolutos'])
        plt.title('Top 10 Alunos - Acertos Absolutos')
        plt.xlabel('Número de Acertos')
        for i, v in enumerate(top_10['Acertos Absolutos']):
            plt.text(v, i, f'{v:.0f}', va='center')
        plt.tight_layout()
        graphs.append(plt.gcf())
        plt.close()

        # 3. Relação tempo x acertos
        plt.figure(figsize=(10, 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)
        plt.title('Relação Tempo x Acertos por Nível')
        plt.xlabel('Tempo Total (minutos)')
        plt.ylabel('Número de Acertos')
        plt.legend()
        plt.grid(True, alpha=0.3)
        graphs.append(plt.gcf())
        plt.close()

        # 4. Relação Tarefas x Acertos
        plt.figure(figsize=(10, 6))
        plt.scatter(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'])
        plt.title('Relação entre Tarefas Completadas e Acertos')
        plt.xlabel('Número de Tarefas Completadas')
        plt.ylabel('Número de Acertos')
        plt.grid(True, alpha=0.3)
        z = np.polyfit(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'], 1)
        p = np.poly1d(z)
        plt.plot(self.data['Tarefas Completadas'], p(self.data['Tarefas Completadas']), 
                "r--", alpha=0.8, label='Tendência')
        plt.legend()
        graphs.append(plt.gcf())
        plt.close()

        return graphs

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

        pdf = PDF('L', 'mm', 'A4')
        
        # Sumário executivo
        pdf.add_page()
        pdf.set_font('Arial', 'B', 12)
        pdf.cell(0, 10, 'Sumário Executivo', 0, 1)
        pdf.set_font('Arial', '', 10)
        
        summary_text = f"""
        Visão Geral da Turma:
        - Média de Acertos: {self.stats['media_acertos']:.1f}
        - Desvio Padrão: {self.stats['desvio_padrao']:.1f}
        - Mediana: {self.stats['mediana_acertos']:.1f}
        - Total de Alunos: {self.stats['total_alunos']}
        - Média de Tarefas por Aluno: {self.stats['media_tarefas']:.1f}
        - Tempo Médio Total: {self.stats['media_tempo']}
        """
        pdf.multi_cell(0, 10, summary_text)

        pdf.ln()
        pdf.cell(0, 10, "Top 3 - Maiores Números de Acertos:", 0, 1)
        for aluno, acertos in self.stats['top_performers']:
            pdf.cell(0, 10, f"- {aluno}: {acertos:.0f} acertos", 0, 1)

        pdf.ln()
        pdf.cell(0, 10, "Alunos Mais Eficientes:", 0, 1)
        for aluno, eficiencia, acertos in self.stats['most_efficient']:
            # Formata a eficiência com 2 casas decimais ao exibir
            pdf.cell(0, 10, f"- {aluno}: Eficiência {eficiencia:.2f} (Acertos: {acertos:.0f})", 0, 1)

        for i, graph in enumerate(graphs):
            pdf.add_page()
            graph_path = f'temp_graph_{i}.png'
            graph.savefig(graph_path)
            pdf.image(graph_path, x=10, y=30, w=270)
            os.remove(graph_path)

        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', 12)
                pdf.cell(0, 10, f'Alunos - Nível {nivel}', 0, 1)
                
                columns = ['Nome do Aluno', 'Acertos Absolutos', 'Tarefas', 'Tempo Total', 'Eficiência']
                widths = [80, 30, 30, 30, 30]
                pdf.set_font('Arial', 'B', 8)
                for i, col in enumerate(columns):
                    pdf.cell(widths[i], 7, col, 1)
                pdf.ln()

                pdf.set_font('Arial', '', 8)
                for _, row in alunos_nivel.iterrows():
                    pdf.cell(widths[0], 6, str(row['Nome do Aluno'])[:40], 1)
                    pdf.cell(widths[1], 6, str(row['Acertos Absolutos']), 1)
                    pdf.cell(widths[2], 6, str(row['Tarefas Completadas']), 1)
                    pdf.cell(widths[3], 6, str(row['Total Tempo']), 1)
                    pdf.cell(widths[4], 6, str(row['Eficiência']), 1)
                    pdf.ln()

        pdf.output(output_path)

def process_files(html_file, excel_files) -> Tuple[str, str, str]:
    try:
        temp_dir = "temp_files"
        os.makedirs(temp_dir, exist_ok=True)

        for file in os.listdir(temp_dir):
            os.remove(os.path.join(temp_dir, file))

        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)

        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)

        alunos_df = pd.read_csv(alunos_csv_path)
        analyzer = StudentAnalyzer(tarefas_df, alunos_df)
        results_df = analyzer.prepare_data()

        report_generator = ReportGenerator(results_df)
        graphs = report_generator.generate_graphs()
        
        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")
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("## Lista de Alunos (arquivo .htm)")
            html_file = gr.File(label="Upload do arquivo HTML", type="binary")
        
        with gr.Column():
            gr.Markdown("## Relatórios de Tarefas (arquivos .xlsx)")
            excel_files = gr.Files(label="Upload dos arquivos Excel", type="binary", file_count="multiple")

    generate_btn = gr.Button("Gerar Relatório", variant="primary")
    output_html = gr.HTML()
    download_html_btn = gr.File(label="Download HTML Report")
    download_pdf_btn = gr.File(label="Download PDF Report")

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

# Iniciar a aplicação
if __name__ == "__main__":
    interface.launch()