app.py

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

class JavaPOOEvaluator:
    """Java-Judge: OO Paradigm"""
    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("⚠ Erro ao analisar classes e objetos.")

        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_encapsulation(self, code: str) -> Tuple[float, List[str]]:
        """Avalia encapsulamento e uso de modificadores"""
        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'.")

            getters_setters = [method for _, method in tree.filter(javalang.tree.MethodDeclaration) if method.name.startswith('get') or method.name.startswith('set')]
            if getters_setters:
                score += 5
                feedback.append(f"✓ {len(getters_setters)} getter(s) ou setter(s) implementado(s).")
            else:
                feedback.append("⚠ Nenhum getter ou setter encontrado.")
        except Exception as e:
            feedback.append("⚠ Erro ao analisar encapsulamento.")

        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("⚠ Erro ao analisar herança.")

        return score, feedback

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

        try:
            tree = javalang.parse.parse(code)
            overridden_methods = [node for _, node in tree.filter(javalang.tree.MethodDeclaration) if 'Override' in (node.annotations or [])]
            
            if overridden_methods:
                score += 10
                feedback.append(f"✓ {len(overridden_methods)} método(s) sobrescrito(s) corretamente.")
            else:
                feedback.append("⚠ Nenhum uso de polimorfismo encontrado.")
        except Exception as e:
            feedback.append("⚠ Erro ao analisar polimorfismo.")

        return score, feedback

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

        try:
            tree = javalang.parse.parse(code)
            abstract_classes = [node for _, node in tree.filter(javalang.tree.ClassDeclaration) if 'abstract' in node.modifiers]
            interfaces = list(tree.filter(javalang.tree.InterfaceDeclaration))

            if abstract_classes:
                score += 5
                feedback.append(f"✓ {len(abstract_classes)} classe(s) abstrata(s) declarada(s).")
            else:
                feedback.append("⚠ Nenhuma classe abstrata encontrada.")

            if interfaces:
                score += 5
                feedback.append(f"✓ {len(interfaces)} interface(s) declarada(s).")
            else:
                feedback.append("⚠ Nenhuma interface encontrada.")
        except Exception as e:
            feedback.append("⚠ Erro ao analisar abstração.")

        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)
        poly_score, poly_feedback = self.analyze_polymorphism(code)
        abs_score, abs_feedback = self.analyze_abstraction(code)

        essential_score = cls_score + meth_score
        bonus_score = enc_score + inh_score + poly_score + abs_score
        total_score = essential_score + bonus_score
        total_score = min(100, total_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,
            "essential_score": essential_score,
            "bonus_score": bonus_score,
            "proficiency": proficiency,
            "feedback": {
                "classes_objetos": cls_feedback,
                "metodos": meth_feedback,
                "encapsulamento": enc_feedback,
                "heranca": inh_feedback,
                "polimorfismo": poly_feedback,
                "abstracao": abs_feedback,
            }
        }

# Interface Gradio
with gr.Blocks(title="Java-Judge: OO Paradigm", 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.Markdown("#### Avalie seu código Java com base em critérios de POO")
    
    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)
    
    gr.Markdown("### Rubrica de Avaliação")
    rubric_image = gr.Image("rubric_table.png", label="Tabela Resumida da Rubrica", elem_id="rubric_image")

    def evaluate_code_files(files) -> str:
        evaluator = JavaPOOEvaluator()
        results = []

        for file in files:
            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)

        return "\n".join(results)

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

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