import gradio as gr
import javalang
from typing import Dict, List, Tuple

class JavaPOOEvaluator:
    """Avaliador para Programação Orientada a Objetos"""
    def __init__(self):
        self.rubric = {
            "classes": 20,
            "objetos": 20,
            "metodos": 20,
            "atributos": 20,
            "encapsulamento": 10,
            "heranca": 10,
            "polimorfismo": 10,
            "abstracao": 10,
        }

    def analyze_classes_and_objects(self, code: str) -> Tuple[float, List[str]]:
        """Avalia a definição e o uso de classes e objetos"""
        score = 0
        feedback = []

        try:
            tree = javalang.parse.parse(code)
            classes = list(tree.filter(javalang.tree.ClassDeclaration))
            
            if classes:
                score += 15
                feedback.append(f"✓ {len(classes)} classe(s) declarada(s) corretamente.")
            else:
                feedback.append("⚠ Nenhuma classe declarada encontrada.")

            objects = [node for _, node in tree.filter(javalang.tree.VariableDeclarator) if 'new' in str(node.initializer)]
            if objects:
                score += 5
                feedback.append(f"✓ {len(objects)} objeto(s) criado(s) corretamente.")
            else:
                feedback.append("⚠ Nenhuma instância de objeto criada.")
        except Exception as e:
            feedback.append(f"⚠ Erro ao analisar classes e objetos: {e}")

        return score, feedback

    def analyze_methods(self, code: str) -> Tuple[float, List[str]]:
        """Avalia a definição e organização de métodos"""
        score = 0
        feedback = []

        try:
            tree = javalang.parse.parse(code)
            methods = list(tree.filter(javalang.tree.MethodDeclaration))
            
            if methods:
                score += 15
                feedback.append(f"✓ {len(methods)} método(s) declarado(s) corretamente.")
            else:
                feedback.append("⚠ Nenhum método declarado encontrado.")
        except Exception as e:
            feedback.append(f"⚠ Erro ao analisar métodos: {e}")

        return score, feedback

    def analyze_inheritance(self, code: str) -> Tuple[float, List[str]]:
        """Avalia o uso de herança"""
        score = 0
        feedback = []

        try:
            tree = javalang.parse.parse(code)
            subclasses = [node for _, node in tree.filter(javalang.tree.ClassDeclaration) if node.extends]
            
            if subclasses:
                score += 10
                feedback.append(f"✓ {len(subclasses)} classe(s) estendendo outra(s).")
            else:
                feedback.append("⚠ Nenhum uso de herança encontrado.")
        except Exception as e:
            feedback.append(f"⚠ Erro ao analisar herança: {e}")

        return score, feedback

    def analyze_encapsulation(self, code: str) -> Tuple[float, List[str]]:
        """Avalia o encapsulamento"""
        score = 0
        feedback = []

        try:
            tree = javalang.parse.parse(code)
            fields = list(tree.filter(javalang.tree.FieldDeclaration))
            private_count = sum(1 for _, node in fields if 'private' in node.modifiers)

            if private_count:
                score += 5
                feedback.append(f"✓ {private_count} atributo(s) encapsulado(s) com 'private'.")
            else:
                feedback.append("⚠ Nenhum atributo privado encontrado.")
        except Exception as e:
            feedback.append(f"⚠ Erro ao analisar encapsulamento: {e}")

        return score, feedback

    def evaluate_code(self, code: str) -> Dict:
        """Avalia o código Java"""
        cls_score, cls_feedback = self.analyze_classes_and_objects(code)
        meth_score, meth_feedback = self.analyze_methods(code)
        enc_score, enc_feedback = self.analyze_encapsulation(code)
        inh_score, inh_feedback = self.analyze_inheritance(code)

        total_score = cls_score + meth_score + enc_score + inh_score
        proficiency = "Necessita Melhorias"
        if total_score >= 90:
            proficiency = "Excelente"
        elif total_score >= 75:
            proficiency = "Bom"
        elif total_score >= 60:
            proficiency = "Satisfatório"

        return {
            "total_score": total_score,
            "proficiency": proficiency,
            "feedback": {
                "classes_objetos": cls_feedback,
                "metodos": meth_feedback,
                "encapsulamento": enc_feedback,
                "heranca": inh_feedback,
            }
        }

# Interface Gradio
with gr.Blocks(title="Avaliador de POO em Java", css="#rubric_image img {max-width: 50%; height: auto; margin: 0 auto;}") as demo:
    gr.Markdown("# Avaliador de POO em Java")
    gr.Markdown("### [Visualizar a Rubrica em PDF](rubric.pdf)")
    gr.Image("rubric_table.png", label="Tabela Resumida da Rubrica", elem_id="rubric_image")

    upload = gr.File(label="Carregue arquivos Java para avaliação", file_types=[".java"], file_count="multiple")
    evaluate_button = gr.Button("Avaliar Código")
    output = gr.Textbox(label="Resultado da Avaliação", lines=25)

    def evaluate_code_files(files) -> str:
        """Função para avaliar múltiplos arquivos Java"""
        evaluator = JavaPOOEvaluator()
        results = []

        for file in files:
            try:
                with open(file.name, 'r', encoding='utf-8') as f:
                    code = f.read()
                evaluation = evaluator.evaluate_code(code)

                result = f"\nArquivo: {file.name}\n"
                result += f"Pontuação Total: {evaluation['total_score']:.1f}/100\n"
                result += f"Nível: {evaluation['proficiency']}\n\n"
                result += "Feedback Detalhado:\n"
                for category, comments in evaluation['feedback'].items():
                    result += f"\n{category.replace('_', ' ').title()}:\n"
                    for comment in comments:
                        result += f"  {comment}\n"
                results.append(result)
            except Exception as e:
                results.append(f"Erro ao processar o arquivo {file.name}: {e}")
        
        return "\n".join(results)

    evaluate_button.click(fn=evaluate_code_files, inputs=upload, outputs=output)

if __name__ == "__main__":
    demo.launch(share=True)