go

app.py

@@ -1,28 +1,80 @@
-
-import gradio as gr
 import javalang
 from typing import Dict, List, Tuple
+from dataclasses import dataclass
 import re
 
-class JavaStructuralEvaluator:
+@dataclass
+class RubricCriterion:
+    name: str
+    description: str
+    weight: int
+    is_essential: bool
+    levels: Dict[str, Dict[str, float]]
+
+class EnhancedJavaStructuralEvaluator:
     """Avaliador baseado em estruturas usadas"""
     def __init__(self):
         self.rubric = {
-            "declaracoes": 25,  # Declarações e tipos
-            "estruturas_controle": 25,  # if, switch, loops
-            "operadores": 25,  # Operadores e expressões
-            "io_strings": 25  # System.out, concatenação, etc
+            "declarations": RubricCriterion(
+                name="Declarações",
+                description="Uso de tipos e declarações",
+                weight=25,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Uso mínimo/incorreto"},
+                    "Regular": {"threshold": 10, "description": "1-2 tipos primitivos, 1-2 variáveis"},
+                    "Bom": {"threshold": 15, "description": "3 tipos primitivos, 3-4 variáveis"},
+                    "Excelente": {"threshold": 20, "description": "≥4 tipos primitivos, ≥5 variáveis"}
+                }
+            ),
+            "control_structures": RubricCriterion(
+                name="Estruturas de Controle",
+                description="Controle de fluxo do programa",
+                weight=25,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Uso mínimo/incorreto"},
+                    "Regular": {"threshold": 10, "description": "1 tipo, uso básico"},
+                    "Bom": {"threshold": 15, "description": "2 tipos diferentes, uso correto"},
+                    "Excelente": {"threshold": 20, "description": "≥3 tipos diferentes, uso apropriado"}
+                }
+            ),
+            "operators": RubricCriterion(
+                name="Operadores",
+                description="Operações e expressões",
+                weight=25,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Uso mínimo/incorreto"},
+                    "Regular": {"threshold": 10, "description": "1-2 operadores"},
+                    "Bom": {"threshold": 15, "description": "3-4 operadores"},
+                    "Excelente": {"threshold": 20, "description": "≥5 operadores diferentes"}
+                }
+            ),
+            "io_strings": RubricCriterion(
+                name="I/O e Strings",
+                description="Entrada/saída e manipulação de texto",
+                weight=25,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Uso mínimo/incorreto"},
+                    "Regular": {"threshold": 10, "description": "E/S simples"},
+                    "Bom": {"threshold": 15, "description": "E/S moderada, manipulação básica"},
+                    "Excelente": {"threshold": 20, "description": "E/S complexa, manipulação avançada"}
+                }
+            )
         }
-    
-    def analyze_declarations(self, code: str) -> Tuple[float, List[str]]:
-        """Analisa declarações e tipos"""
+
+    def evaluate_declarations(self, code: str) -> Tuple[float, str, List[str]]:
+        """Avalia declarações e tipos"""
         score = 0
+        level = "Fraco"
         feedback = []
-        
+
         try:
             tree = javalang.parse.parse(code)
             
-            # Verificar tipos primitivos
+            # Análise de tipos primitivos
             primitives = {
                 'int': 'números inteiros',
                 'double': 'números decimais',
@@ -33,474 +85,471 @@ class JavaStructuralEvaluator:
                 'byte': 'valores byte',
                 'short': 'números curtos'
             }
-            
+
             used_types = set()
-            for _, node in tree.filter(javalang.tree.LocalVariableDeclaration):
-                type_name = node.type.name
+            declarations = [node for _, node in tree.filter(javalang.tree.LocalVariableDeclaration)]
+            for decl in declarations:
+                type_name = decl.type.name
                 used_types.add(type_name)
-                
-            for type_name, description in primitives.items():
-                if type_name in used_types:
-                    score += 3
-                    feedback.append(f"✓ Uso correto de {type_name} para {description}")
-            
-            # Verificar declarações de variáveis
-            total_vars = len(list(tree.filter(javalang.tree.LocalVariableDeclaration)))
-            if total_vars > 0:
-                score += 5
-                feedback.append(f"✓ {total_vars} variáveis declaradas corretamente")
-            
-            # Verificar constantes
-            constants = list(tree.filter(javalang.tree.FieldDeclaration))
-            if any('final' in node.modifiers for _, node in tree.filter(javalang.tree.FieldDeclaration)):
-                score += 4
+
+            num_types = len(used_types)
+            num_vars = len(declarations)
+            has_constants = any('final' in node.modifiers for _, node in tree.filter(javalang.tree.FieldDeclaration))
+
+            # Determinar nível
+            if num_types >= 4 and num_vars >= 5 and has_constants:
+                score = 25
+                level = "Excelente"
+            elif num_types >= 3 and num_vars >= 3:
+                score = 15
+                level = "Bom"
+            elif num_types >= 1 or num_vars >= 1:
+                score = 10
+                level = "Regular"
+
+            feedback.append(f"✓ {num_types} tipos primitivos diferentes utilizados")
+            feedback.append(f"✓ {num_vars} variáveis declaradas")
+            if has_constants:
                 feedback.append("✓ Uso adequado de constantes (final)")
-            
+
         except Exception as e:
             feedback.append("⚠ Erro na análise de declarações")
-            
-        return score, feedback
 
-    def analyze_control_structures(self, code: str) -> Tuple[float, List[str]]:
-        """Analisa estruturas de controle"""
+        return score, level, feedback
+
+    def evaluate_control_structures(self, code: str) -> Tuple[float, str, List[str]]:
+        """Avalia estruturas de controle"""
         score = 0
+        level = "Fraco"
         feedback = []
-        
+
         try:
             tree = javalang.parse.parse(code)
             
-            # If/Else
-            if_count = len(list(tree.filter(javalang.tree.IfStatement)))
-            if if_count > 0:
-                score += 5
-                feedback.append(f"✓ Uso correto de {if_count} estrutura(s) if/else")
-            
-            # Switch
-            switch_count = len(list(tree.filter(javalang.tree.SwitchStatement)))
-            if switch_count > 0:
-                score += 5
-                feedback.append(f"✓ Uso correto de {switch_count} switch/case")
-            
-            # For loops
-            for_count = len(list(tree.filter(javalang.tree.ForStatement)))
-            if for_count > 0:
-                score += 5
-                feedback.append(f"✓ Uso correto de {for_count} loop(s) for")
-            
-            # While loops
-            while_count = len(list(tree.filter(javalang.tree.WhileStatement)))
-            if while_count > 0:
-                score += 5
-                feedback.append(f"✓ Uso correto de {while_count} loop(s) while")
-            
-            # Do-While loops
-            do_while_count = len(list(tree.filter(javalang.tree.DoStatement)))
-            if do_while_count > 0:
-                score += 5
-                feedback.append(f"✓ Uso correto de {do_while_count} loop(s) do-while")
-            
+            structures = {
+                'if': len(list(tree.filter(javalang.tree.IfStatement))),
+                'switch': len(list(tree.filter(javalang.tree.SwitchStatement))),
+                'for': len(list(tree.filter(javalang.tree.ForStatement))),
+                'while': len(list(tree.filter(javalang.tree.WhileStatement))),
+                'do_while': len(list(tree.filter(javalang.tree.DoStatement)))
+            }
+
+            num_different_structures = sum(1 for count in structures.values() if count > 0)
+            total_structures = sum(structures.values())
+
+            # Determinar nível
+            if num_different_structures >= 3 and total_structures >= 4:
+                score = 25
+                level = "Excelente"
+            elif num_different_structures >= 2 and total_structures >= 2:
+                score = 15
+                level = "Bom"
+            elif num_different_structures >= 1:
+                score = 10
+                level = "Regular"
+
+            for struct, count in structures.items():
+                if count > 0:
+                    feedback.append(f"✓ {count} estrutura(s) {struct}")
+
         except Exception as e:
             feedback.append("⚠ Erro na análise de estruturas de controle")
-            
-        return score, feedback
 
-    def analyze_operators(self, code: str) -> Tuple[float, List[str]]:
-        """Analisa operadores e expressões"""
+        return score, level, feedback
+
+    def evaluate_operators(self, code: str) -> Tuple[float, str, List[str]]:
+        """Avalia operadores"""
         score = 0
+        level = "Fraco"
         feedback = []
-        
+
         try:
-            # Operadores aritméticos
-            arithmetic = ['+', '-', '*', '/', '%']
-            for op in arithmetic:
-                if op in code:
-                    score += 2
-                    feedback.append(f"✓ Uso do operador aritmético {op}")
-            
-            # Operadores de comparação
-            comparison = ['==', '!=', '>', '<', '>=', '<=']
-            for op in comparison:
-                if op in code:
-                    score += 2
-                    feedback.append(f"✓ Uso do operador de comparação {op}")
-            
-            # Operadores lógicos
-            logical = ['&&', '||', '!']
-            for op in logical:
-                if op in code:
-                    score += 2
-                    feedback.append(f"✓ Uso do operador lógico {op}")
-            
-            # Operadores de atribuição
-            assignment = ['+=', '-=', '*=', '/=']
-            for op in assignment:
-                if op in code:
-                    score += 2
-                    feedback.append(f"✓ Uso do operador de atribuição {op}")
-            
+            operators = {
+                'arithmetic': ['+', '-', '*', '/', '%'],
+                'comparison': ['==', '!=', '>', '<', '>=', '<='],
+                'logical': ['&&', '||', '!'],
+                'assignment': ['+=', '-=', '*=', '/=']
+            }
+
+            used_operators = set()
+            for category, ops in operators.items():
+                for op in ops:
+                    if op in code:
+                        used_operators.add(op)
+                        feedback.append(f"✓ Uso do operador {op}")
+
+            num_operators = len(used_operators)
+
+            # Determinar nível
+            if num_operators >= 5:
+                score = 25
+                level = "Excelente"
+            elif num_operators >= 3:
+                score = 15
+                level = "Bom"
+            elif num_operators >= 1:
+                score = 10
+                level = "Regular"
+
         except Exception as e:
             feedback.append("⚠ Erro na análise de operadores")
-            
-        return score, feedback
 
-    def analyze_io_strings(self, code: str) -> Tuple[float, List[str]]:
-        """Analisa entrada/saída e manipulação de strings"""
+        return score, level, feedback
+
+    def evaluate_io_strings(self, code: str) -> Tuple[float, str, List[str]]:
+        """Avalia entrada/saída e strings"""
         score = 0
+        level = "Fraco"
         feedback = []
-        
+
         try:
-            # System.out
-            if 'System.out.print' in code:
-                score += 5
-                feedback.append("✓ Uso correto de System.out.print")
-            
-            # Scanner
-            if 'Scanner' in code:
-                score += 5
-                feedback.append("✓ Uso correto da classe Scanner para entrada")
-            
-            # Concatenação de strings
-            if '+' in code and '"' in code:
-                score += 5
-                feedback.append("✓ Concatenação de strings com operador +")
-            
-            # Métodos de String
+            features = {
+                'output': 'System.out.print' in code,
+                'input': 'Scanner' in code,
+                'concatenation': '+' in code and '"' in code,
+                'string_methods': False
+            }
+
+            # Verificar métodos de String
             string_methods = ['concat', 'substring', 'length', 'equals', 'compareTo']
-            for method in string_methods:
-                if f'.{method}(' in code:
-                    score += 2
-                    feedback.append(f"✓ Uso do método String.{method}")
-            
+            methods_used = [method for method in string_methods if f'.{method}(' in code]
+            features['string_methods'] = len(methods_used) > 0
+
+            # Contar recursos utilizados
+            num_features = sum(1 for used in features.values() if used)
+
+            # Determinar nível
+            if num_features >= 3 and features['string_methods']:
+                score = 25
+                level = "Excelente"
+            elif num_features >= 2:
+                score = 15
+                level = "Bom"
+            elif num_features >= 1:
+                score = 10
+                level = "Regular"
+
+            if features['output']:
+                feedback.append("✓ Uso de saída (System.out)")
+            if features['input']:
+                feedback.append("✓ Uso de entrada (Scanner)")
+            if features['concatenation']:
+                feedback.append("✓ Concatenação de strings")
+            if methods_used:
+                feedback.append(f"✓ Uso de {len(methods_used)} métodos de String")
+
         except Exception as e:
             feedback.append("⚠ Erro na análise de I/O e strings")
-            
-        return score, feedback
+
+        return score, level, feedback
 
     def evaluate_code(self, code: str) -> Dict:
-        """Avalia o código Java"""
-        # Análises individuais
-        decl_score, decl_feedback = self.analyze_declarations(code)
-        ctrl_score, ctrl_feedback = self.analyze_control_structures(code)
-        op_score, op_feedback = self.analyze_operators(code)
-        io_score, io_feedback = self.analyze_io_strings(code)
-        
-        # Calcular pontuação total
-        total_score = sum([
-            decl_score,
-            ctrl_score,
-            op_score,
-            io_score
-        ])
-        
-        # Normalizar para 100
-        total_score = min(100, total_score)
-        
-        # Determinar nível
-        proficiency = "Necessita Melhorias"
+        """Avalia o código Java usando todos os critérios"""
+        evaluation = {
+            "scores": {},
+            "levels": {},
+            "feedback": {},
+            "summary": {
+                "total_score": 0,
+                "proficiency": ""
+            }
+        }
+
+        # Avaliar cada critério
+        criteria_evaluations = {
+            "declarations": self.evaluate_declarations(code),
+            "control_structures": self.evaluate_control_structures(code),
+            "operators": self.evaluate_operators(code),
+            "io_strings": self.evaluate_io_strings(code)
+        }
+
+        # Compilar resultados
+        for criterion, (score, level, feedback) in criteria_evaluations.items():
+            evaluation["scores"][criterion] = score
+            evaluation["levels"][criterion] = level
+            evaluation["feedback"][criterion] = feedback
+            evaluation["summary"]["total_score"] += score
+
+        # Determinar proficiência geral
+        total_score = evaluation["summary"]["total_score"]
         if total_score >= 90:
-            proficiency = "Excelente"
+            evaluation["summary"]["proficiency"] = "Excelente"
         elif total_score >= 75:
-            proficiency = "Bom"
+            evaluation["summary"]["proficiency"] = "Bom"
         elif total_score >= 60:
-            proficiency = "Satisfatório"
-            
-        return {
-            "total_score": total_score,
-            "proficiency": proficiency,
-            "feedback": {
-                "declaracoes": decl_feedback,
-                "estruturas_controle": ctrl_feedback,
-                "operadores": op_feedback,
-                "io_strings": io_feedback
-            }
-        }
+            evaluation["summary"]["proficiency"] = "Satisfatório"
+        else:
+            evaluation["summary"]["proficiency"] = "Necessita Melhorias"
+
+        return evaluation
 
-class CompetencyEvaluator:
+class EnhancedCompetencyEvaluator:
+    """Avaliador baseado em competências"""
     def __init__(self):
         self.rubric = {
-            "syntax_correctness": 50,
-            "competencies": 50
+            "syntax": RubricCriterion(
+                name="Corretude Sintática",
+                description="Correção técnica do código",
+                weight=50,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Muitos erros"},
+                    "Regular": {"threshold": 20, "description": "Código funcional, alguns erros"},
+                    "Bom": {"threshold": 30, "description": "Código correto, erros menores"},
+                    "Excelente": {"threshold": 40, "description": "Código exemplar, sem erros"}
+                }
+            ),
+            "competencies": RubricCriterion(
+                name="Competências Práticas",
+                description="Qualidade da implementação",
+                weight=50,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Implementação pobre"},
+                    "Regular": {"threshold": 20, "description": "Implementação básica"},
+                    "Bom": {"threshold": 30, "description": "Boa implementação"},
+                    "Excelente": {"threshold": 40, "description": "Implementação sofisticada"}
+                }
+            )
         }
-    
-    def analyze_syntax_correctness(self, code: str) -> Tuple[float, List[str]]:
+
+    def evaluate_syntax(self, code: str) -> Tuple[float, str, List[str]]:
+        """Avalia corretude sintática"""
         score = 0
+        level = "Fraco"
         feedback = []
-        
+
         try:
             tree = javalang.parse.parse(code)
             
-            # 1. Estrutura básica do programa (10 pontos)
-            if 'class' in code:
-                score += 5
-                feedback.append("✓ Estrutura de classe correta")
-            if 'public static void main' in code:
-                score += 5
-                feedback.append("✓ Método main corretamente declarado")
-
-            # 2. Declarações e Tipos (10 pontos)
+            # 1. Estrutura básica (10 pts)
+            has_class = 'class' in code
+            has_main = 'public static void main' in code
+            if has_class and has_main:
+                score += 10
+                feedback.append("✓ Estrutura básica correta (classe e main)")
+
+            # 2. Declarações (10 pts)
             declarations = list(tree.filter(javalang.tree.LocalVariableDeclaration))
             if declarations:
-                score += 5
-                feedback.append("✓ Declarações de variáveis sintáticamente corretas")
-                if any(hasattr(d, 'type') and d.type.name in ['int', 'double', 'String', 'boolean'] for d in declarations):
-                    score += 5
-                    feedback.append("✓ Tipos de dados usados corretamente")
-
-            # 3. Expressões e Operadores (10 pontos)
-            binary_operations = []
-            for path, node in tree.filter(javalang.tree.BinaryOperation):
-                if hasattr(node, 'operator'):
-                    binary_operations.append(node)
-            
-            if binary_operations:
                 score += 10
-                feedback.append("✓ Expressões e operadores usados corretamente")
+                feedback.append(f"✓ {len(declarations)} declarações sintáticamente corretas")
 
-            # 4. Blocos e Estruturas (10 pontos)
-            open_braces = code.count('{')
-            close_braces = code.count('}')
-            if open_braces == close_braces and open_braces > 0:
-                score += 5
+            # 3. Blocos e estruturas (10 pts)
+            if code.count('{') == code.count('}') and code.count('{') > 0:
+                score += 10
                 feedback.append("✓ Blocos corretamente delimitados")
-            
-            semicolons = len(re.findall(';[^;]*$', code, re.MULTILINE))
-            if semicolons > 0:
-                score += 5
-                feedback.append("✓ Instruções corretamente terminadas")
-
-            # 5. Entrada/Saída (10 pontos)
-            if 'System.out' in code:
-                score += 5
-                feedback.append("✓ Sintaxe de saída correta")
-            if 'Scanner' in code:
-                score += 5
-                feedback.append("✓ Sintaxe de entrada correta")
+
+            # 4. Expressões (10 pts)
+            expressions = list(tree.filter(javalang.tree.BinaryOperation))
+            if expressions:
+                score += 10
+                feedback.append("✓ Expressões bem formadas")
+
+            # 5. Pontuação e formatação (10 pts)
+            lines = code.split('\n')
+            well_formatted = all(line.strip().endswith(';') or 
+                               line.strip().endswith('{') or 
+                               line.strip().endswith('}') or 
+                               line.strip() == "" or 
+                               line.strip().startswith('//') 
+                               for line in lines if line.strip())
+            if well_formatted:
+                score += 10
+                feedback.append("✓ Código bem formatado e pontuado")
+
+            # Determinar nível
+            if score >= 40:
+                level = "Excelente"
+            elif score >= 30:
+                level = "Bom"
+            elif score >= 20:
+                level = "Regular"
 
         except Exception as e:
             feedback.append(f"⚠ Erro de sintaxe: {str(e)}")
-            
-        return score, feedback
 
-    def analyze_competencies(self, code: str) -> Tuple[float, List[str]]:
+        return score, level, feedback
+
+    def evaluate_competencies(self, code: str) -> Tuple[float, str, List[str]]:
+        """Avalia competências práticas"""
         score = 0
+        level = "Fraco"
         feedback = []
-        
+
         try:
             tree = javalang.parse.parse(code)
-            
-            # 1. Seleção de Estruturas (15 pontos)
+
+            # 1. Seleção de estruturas (15 pts)
             structures = {
                 'if': list(tree.filter(javalang.tree.IfStatement)),
                 'for': list(tree.filter(javalang.tree.ForStatement)),
                 'while': list(tree.filter(javalang.tree.WhileStatement))
             }
             
+            struct_score = 0
             for struct_type, instances in structures.items():
                 if instances:
-                    if struct_type == 'for':
-                        for path, node in tree.filter(javalang.tree.ForStatement):
-                            if any('length' in str(getattr(node, attr, '')) for attr in dir(node)):
-                                score += 5
-                                feedback.append("✓ Uso adequado de for para iteração em arrays")
-                                break
-                    elif struct_type == 'while':
-                        for path, node in tree.filter(javalang.tree.WhileStatement):
-                            if any('hasNext' in str(getattr(node, attr, '')) for attr in dir(node)):
-                                score += 5
-                                feedback.append("✓ Uso adequado de while para leitura de dados")
-                                break
-                    else:
-                        score += 5
-                        feedback.append(f"✓ Uso apropriado de {struct_type}")
-
-            # 2. Manipulação de Dados (15 pontos)
-            binary_operations = []
-            for path, node in tree.filter(javalang.tree.BinaryOperation):
-                if hasattr(node, 'operator'):
-                    binary_operations.append(node)
-            
-            if binary_operations:
-                arithmetic_ops = [op for op in binary_operations if hasattr(op, 'operator') and op.operator in ['*', '/', '+', '-']]
-                comparison_ops = [op for op in binary_operations if hasattr(op, 'operator') and op.operator in ['>', '<', '>=', '<=', '==']]
-                assignment_ops = [op for op in binary_operations if hasattr(op, 'operator') and '=' in op.operator]
-                
-                if arithmetic_ops:
-                    score += 5
-                    feedback.append("✓ Cálculos implementados corretamente")
-                if comparison_ops:
-                    score += 5
-                    feedback.append("✓ Comparações implementadas corretamente")
-                if assignment_ops:
-                    score += 5
-                    feedback.append("✓ Atribuições implementadas corretamente")
-
-            # 3. Clareza e Organização (10 pontos)
-            # Verificar nomes significativos
-            has_meaningful_names = True
-            for path, node in tree.filter(javalang.tree.LocalVariableDeclaration):
-                if hasattr(node, 'declarators') and node.declarators:
-                    for declarator in node.declarators:
-                        if hasattr(declarator, 'name') and len(declarator.name) <= 1:
-                            has_meaningful_names = False
-                            break
-            
-            if has_meaningful_names:
-                score += 5
-                feedback.append("✓ Nomes de variáveis significativos")
+                    struct_score += 5
+                    if struct_type == 'for' and any('length' in str(inst) for inst in instances):
+                        struct_score += 2
+                    elif struct_type == 'while' and any('hasNext' in str(inst) for inst in instances):
+                        struct_score += 2
+            
+            score += min(15, struct_score)
+            if struct_score > 0:
+                feedback.append(f"✓ Uso apropriado de estruturas de controle")
+
+            # 2. Manipulação de dados (15 pts)
+            data_score = 0
+            operations = list(tree.filter(javalang.tree.BinaryOperation))
+            if operations:
+                if any(op.operator in ['*', '/', '+', '-'] for op in operations):
+                    data_score += 5
+                if any(op.operator in ['>', '<', '>=', '<=', '=='] for op in operations):
+                    data_score += 5
+                if any('=' in str(op) for op in operations):
+                    data_score += 5
+
+            score += min(15, data_score)
+            if data_score > 0:
+                feedback.append("✓ Manipulação de dados adequada")
+
+            # 3. Clareza e organização (10 pts)
+            org_score = 0
+            if all(len(decl.declarators[0].name) > 1 for _, decl in tree.filter(javalang.tree.LocalVariableDeclaration)):
+                org_score += 5
             
-            # Verificar indentação e comentários
             lines = code.split('\n')
             if any('//' in line or '/*' in line for line in lines):
-                score += 5
-                feedback.append("✓ Código bem documentado")
+                org_score += 5
 
-            # 4. Resolução do Problema (10 pontos)
-            has_input = 'Scanner' in code
-            has_processing = bool(binary_operations)
-            has_output = 'System.out' in code
-            
-            if has_input and has_output:
-                score += 5
-                feedback.append("✓ Programa com entrada e saída")
-            if has_processing:
-                score += 5
-                feedback.append("✓ Lógica de processamento implementada")
+            score += min(10, org_score)
+            if org_score > 0:
+                feedback.append("✓ Código bem organizado e documentado")
+
+            # 4. Resolução do problema (10 pts)
+            if 'Scanner' in code and 'System.out' in code and operations:
+                score += 10
+                feedback.append("✓ Solução completa com entrada, processamento e saída")
+
+            # Determinar nível
+            if score >= 40:
+                level = "Excelente"
+            elif score >= 30:
+                level = "Bom"
+            elif score >= 20:
+                level = "Regular"
 
         except Exception as e:
             feedback.append(f"⚠ Erro na análise de competências: {str(e)}")
-            
-        return score, feedback
+
+        return score, level, feedback
 
     def evaluate_code(self, code: str) -> Dict:
-        # Análises individuais
-        syntax_score, syntax_feedback = self.analyze_syntax_correctness(code)
-        comp_score, comp_feedback = self.analyze_competencies(code)
-        
-        # Calcular pontuação total
-        total_score = syntax_score + comp_score
-        
-        # Determinar nível
-        proficiency = "Necessita Melhorias"
+        """Avalia o código Java usando todos os critérios"""
+        evaluation = {
+            "scores": {},
+            "levels": {},
+            "feedback": {},
+            "summary": {
+                "total_score": 0,
+                "proficiency": ""
+            }
+        }
+
+        # Avaliar cada critério
+        criteria_evaluations = {
+            "syntax": self.evaluate_syntax(code),
+            "competencies": self.evaluate_competencies(code)
+        }
+
+        # Compilar resultados
+        for criterion, (score, level, feedback) in criteria_evaluations.items():
+            evaluation["scores"][criterion] = score
+            evaluation["levels"][criterion] = level
+            evaluation["feedback"][criterion] = feedback
+            evaluation["summary"]["total_score"] += score
+
+        # Determinar proficiência geral
+        total_score = evaluation["summary"]["total_score"]
         if total_score >= 90:
-            proficiency = "Excelente"
+            evaluation["summary"]["proficiency"] = "Excelente"
         elif total_score >= 75:
-            proficiency = "Bom"
+            evaluation["summary"]["proficiency"] = "Bom"
         elif total_score >= 60:
-            proficiency = "Satisfatório"
-            
-        return {
-            "total_score": total_score,
-            "proficiency": proficiency,
-            "feedback": {
-                "corretude_sintatica": syntax_feedback,
-                "competencias": comp_feedback
-            }
-        }
+            evaluation["summary"]["proficiency"] = "Satisfatório"
+        else:
+            evaluation["summary"]["proficiency"] = "Necessita Melhorias"
 
-def process_java_files(files) -> str:
-    """Avalia código usando a rubrica estrutural"""
-    evaluator = JavaStructuralEvaluator()
-    return evaluate_files(files, evaluator, "Estrutural")
+        return evaluation
 
-def evaluate_competency(files) -> str:
-    """Avalia código usando a rubrica de competências"""
-    evaluator = CompetencyEvaluator()
-    return evaluate_files(files, evaluator, "Competências")
+# Interface Gradio
+import gradio as gr
 
-def evaluate_files(files, evaluator, evaluation_type: str) -> str:
-    """Função auxiliar para avaliar arquivos com qualquer avaliador"""
+def process_java_files(files, evaluation_type: str) -> str:
+    """Avalia arquivos Java usando o avaliador especificado"""
     results = []
-    project_files = {}
-    
+
     try:
-        if not isinstance(files, list):
-            files = [files]
-        
-        # Primeiro, vamos ler todos os arquivos
+        # Criar avaliador apropriado
+        if evaluation_type == "structural":
+            evaluator = EnhancedJavaStructuralEvaluator()
+        else:
+            evaluator = EnhancedCompetencyEvaluator()
+
+        # Processar cada arquivo
         for file in files:
             with open(file.name, 'r', encoding='utf-8') as f:
-                content = f.read()
-                project_files[file.name] = content
-        
-        # Identificar arquivo principal
-        main_file = None
-        other_files = {}
-        for filename, content in project_files.items():
-            if "public static void main" in content:
-                main_file = (filename, content)
-            else:
-                other_files[filename] = content
-        
-        # Resumo do projeto
-        results.append(f"""
-{'='*50}
-AVALIAÇÃO {evaluation_type.upper()}
-{'='*50}
-Total de arquivos: {len(project_files)}
-Arquivo principal: {main_file[0] if main_file else 'Não encontrado'}
-Arquivos complementares: {len(other_files)}
-{'='*50}
-""")
-        
-        # Avaliar arquivo principal
-        if main_file:
-            result = f"\nARQUIVO PRINCIPAL: {main_file[0]}\n{'-'*30}\n"
-            evaluation = evaluator.evaluate_code(main_file[1])
-            
-            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():
-                if comments:
-                    result += f"\n{category.title()}:\n"
-                    for comment in comments:
-                        result += f"  {comment}\n"
-            
+                code = f.read()
+
+            # Avaliar código
+            evaluation = evaluator.evaluate_code(code)
+
+            # Formatar resultado
+            result = f"\n{'='*50}\n"
+            result += f"Avaliação do arquivo: {file.name}\n"
+            result += f"{'='*50}\n\n"
+
+            # Pontuação e nível
+            result += f"Pontuação Total: {evaluation['summary']['total_score']:.1f}/100\n"
+            result += f"Nível de Proficiência: {evaluation['summary']['proficiency']}\n\n"
+
+            # Detalhamento por critério
+            result += "Avaliação Detalhada por Critério:\n"
+            result += "-" * 30 + "\n\n"
+
+            for criterion in evaluation["scores"].keys():
+                result += f"• {criterion.title()}:\n"
+                result += f"  Nível: {evaluation['levels'][criterion]}\n"
+                result += f"  Pontuação: {evaluation['scores'][criterion]:.1f}\n"
+                result += "  Feedback:\n"
+                for fb in evaluation['feedback'][criterion]:
+                    result += f"    - {fb}\n"
+                result += "\n"
+
             results.append(result)
-        
-        # Avaliar outros arquivos
-        if other_files:
-            results.append(f"\nARQUIVOS COMPLEMENTARES\n{'-'*30}")
-            
-            for filename, content in other_files.items():
-                result = f"\nAvaliando: {filename}\n"
-                evaluation = evaluator.evaluate_code(content)
-                
-                result += f"Pontuação: {evaluation['total_score']:.1f}/100\n"
-                result += f"Nível: {evaluation['proficiency']}\n\n"
-                
-                result += "Feedback:\n"
-                for category, comments in evaluation['feedback'].items():
-                    if comments:
-                        result += f"\n{category.title()}:\n"
-                        for comment in comments:
-                            result += f"  {comment}\n"
-                
-                results.append(result)
-        
+
         return "\n".join(results)
-        
     except Exception as e:
-        return f"Erro ao processar arquivos: {str(e)}\nTipo do erro: {type(e)}"
+        return f"Erro ao processar arquivos: {str(e)}"
 
 # Interface Gradio com abas
-with gr.Blocks(title="Java-Judge-Syntax-Competencies") as demo:
+with gr.Blocks(title="Avaliador de Código Java") as demo:
     gr.Markdown("""
-    # Java-Judge-Syntax-Competencies
+    # Avaliador de Código Java
     
-    ### [Visualizar Rubrica em PDF](rubric.pdf)
-    ### [Visualizar Rubrica em PNG](rubric_table.png)
-    Este avaliador analisa código Java usando duas rubricas diferentes:
-    1. **Avaliação Estrutural**: Foca no uso correto de elementos da linguagem
-    2. **Avaliação por Competências**: Analisa qualidade e eficiência do código
+    Este avaliador analisa código Java usando duas perspectivas diferentes:
+    1. **Avaliação Estrutural**: Foca nos elementos fundamentais da linguagem
+    2. **Avaliação por Competências**: Analisa a qualidade técnica e boas práticas
     """)
-    
+
     with gr.Tabs():
         with gr.Tab("Avaliação Estrutural"):
             upload_structural = gr.File(
                 file_count="multiple",
-                label="Upload dos arquivos Java"
+                label="Upload dos arquivos Java",
+                file_types=[".java"]
             )
             evaluate_btn_structural = gr.Button("Avaliar Estruturas")
             output_structural = gr.Textbox(
@@ -508,15 +557,16 @@ with gr.Blocks(title="Java-Judge-Syntax-Competencies") as demo:
                 lines=25
             )
             evaluate_btn_structural.click(
-                fn=process_java_files,
+                fn=lambda x: process_java_files(x, "structural"),
                 inputs=upload_structural,
                 outputs=output_structural
             )
-            
+
         with gr.Tab("Avaliação por Competências"):
             upload_competency = gr.File(
                 file_count="multiple",
-                label="Upload dos arquivos Java"
+                label="Upload dos arquivos Java",
+                file_types=[".java"]
             )
             evaluate_btn_competency = gr.Button("Avaliar Competências")
             output_competency = gr.Textbox(
@@ -524,10 +574,10 @@ with gr.Blocks(title="Java-Judge-Syntax-Competencies") as demo:
                 lines=25
             )
             evaluate_btn_competency.click(
-                fn=evaluate_competency,
+                fn=lambda x: process_java_files(x, "competency"),
                 inputs=upload_competency,
                 outputs=output_competency
             )
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(debug=True)