Workshop Prático: Sistema de Geração Automática de Dados de Teste com Algoritmo Genético

# Instalar dependências necessárias
!pip install matplotlib numpy typing -q

# Configuração do ambiente - silenciar warnings e forçar CPU
import warnings
warnings.filterwarnings('ignore')

# Imports principais
import random
import numpy as np
import matplotlib.pyplot as plt
from typing import List, Tuple, Dict, Set
from dataclasses import dataclass
import copy

# Configurar seed para reprodutibilidade
random.seed(42)
np.random.seed(42)

print("✅ Ambiente configurado com sucesso!")

class TriangleClassifier:
    """Classificador de triângulos que serve como função-alvo para geração de testes.
    
    Esta classe implementa a lógica de classificação de triângulos baseada nos 
    comprimentos dos lados, seguindo diferentes caminhos de execução.
    """
    
    @staticmethod
    def classify(a: int, b: int, c: int) -> str:
        """Classifica um triângulo baseado nos comprimentos dos lados.
        
        Parameters:
            a (int): Comprimento do primeiro lado
            b (int): Comprimento do segundo lado  
            c (int): Comprimento do terceiro lado
            
        Returns:
            str: Classificação do triângulo ('Invalid', 'Not a triangle', 
                 'Equilateral', 'Isosceles', 'Scalene')
        """
        # Caminho 1: Verificação de valores inválidos
        if a <= 0 or b <= 0 or c <= 0:
            return "Invalid"
        
        # Caminho 2: Verificação da desigualdade triangular
        if a + b <= c or a + c <= b or b + c <= a:
            return "Not a triangle"
        
        # Caminho 3: Triângulo equilátero (todos os lados iguais)
        if a == b and b == c:
            return "Equilateral"
        
        # Caminho 4: Triângulo isósceles (dois lados iguais)
        if a == b or b == c or a == c:
            return "Isosceles"
        
        # Caminho 5: Triângulo escaleno (todos os lados diferentes)
        return "Scalene"

# Teste manual dos caminhos de execução
print("🔍 Análise Manual dos Caminhos de Execução:")
print("="*50)

test_cases = [
    (0, 5, 5, "Invalid"),
    (1, 1, 5, "Not a triangle"), 
    (3, 3, 3, "Equilateral"),
    (3, 3, 4, "Isosceles"),
    (3, 4, 5, "Scalene")
]

for i, (a, b, c, expected) in enumerate(test_cases, 1):
    result = TriangleClassifier.classify(a, b, c)
    status = "✅" if result == expected else "❌"
    print(f"Caminho {i}: ({a}, {b}, {c}) → '{result}' {status}")

print(f"\n📊 Total de caminhos identificados: {len(test_cases)}")

@dataclass
class Individual:
    """Representa um indivíduo na população do algoritmo genético.
    
    Cada indivíduo é uma solução candidata representada por um trio de inteiros
    que correspondem aos lados de um triângulo.
    """
    a: int
    b: int 
    c: int
    fitness: float = 0.0
    
    def get_genes(self) -> Tuple[int, int, int]:
        """Retorna os genes (lados do triângulo) como tupla.
        
        Returns:
            Tuple[int, int, int]: Trio de valores representando os lados
        """
        return (self.a, self.b, self.c)
    
    def __str__(self) -> str:
        return f"Individual({self.a}, {self.b}, {self.c}) [fitness: {self.fitness:.2f}]"


class GeneticTestGenerator:
    """Implementa um algoritmo genético para geração automática de dados de teste.
    
    O objetivo é encontrar um conjunto de dados de teste que maximize a cobertura
    de caminhos de execução da função TriangleClassifier.classify().
    """
    
    def __init__(self, population_size: int = 50, mutation_rate: float = 0.1, 
                 max_generations: int = 100, gene_range: Tuple[int, int] = (-5, 20)):
        """Inicializa o gerador de testes genético.
        
        Parameters:
            population_size (int): Tamanho da população
            mutation_rate (float): Taxa de mutação (0.0 a 1.0)
            max_generations (int): Número máximo de gerações
            gene_range (Tuple[int, int]): Range dos valores dos genes
        """
        self.population_size = population_size
        self.mutation_rate = mutation_rate
        self.max_generations = max_generations
        self.gene_min, self.gene_max = gene_range
        
        # Tracking para análise de resultados
        self.fitness_history: List[float] = []
        self.coverage_history: List[int] = []
        self.known_paths: Set[str] = set()
        
    def create_random_individual(self) -> Individual:
        """Cria um indivíduo com genes aleatórios.
        
        Returns:
            Individual: Novo indivíduo com valores aleatórios
        """
        a = random.randint(self.gene_min, self.gene_max)
        b = random.randint(self.gene_min, self.gene_max)
        c = random.randint(self.gene_min, self.gene_max)
        return Individual(a, b, c)
    
    def initialize_population(self) -> List[Individual]:
        """Cria a população inicial com indivíduos aleatórios.
        
        Returns:
            List[Individual]: Lista com a população inicial
        """
        return [self.create_random_individual() for _ in range(self.population_size)]

# Demonstração da criação de população inicial
print("🧬 Demonstração da Criação de População Inicial:")
print("="*50)

generator = GeneticTestGenerator(population_size=10)
initial_pop = generator.initialize_population()

print("Primeiros 5 indivíduos da população inicial:")
for i, individual in enumerate(initial_pop[:5]):
    print(f"  {i+1}. {individual}")

print(f"\n📈 População criada com {len(initial_pop)} indivíduos")

class GeneticTestGenerator(GeneticTestGenerator):  # Extensão da classe anterior
    """Continuação da implementação do algoritmo genético - Função de Fitness."""
    
    def evaluate_fitness(self, individual: Individual) -> float:
        """Avalia a fitness de um indivíduo baseada na cobertura de caminhos.
        
        A fitness é calculada como o número de caminhos únicos descobertos
        por este indivíduo. Quanto mais caminhos únicos, maior a fitness.
        
        Parameters:
            individual (Individual): Indivíduo a ser avaliado
            
        Returns:
            float: Valor de fitness (número de caminhos cobertos)
        """
        a, b, c = individual.get_genes()
        
        # Executa a função-alvo e obtém o resultado
        result = TriangleClassifier.classify(a, b, c)
        
        # Adiciona o caminho descoberto ao conjunto de caminhos conhecidos
        self.known_paths.add(result)
        
        # A fitness é o número total de caminhos únicos descobertos até agora
        # (Este é um exemplo simplificado - em cenários reais, seria mais sofisticado)
        fitness = len(self.known_paths)
        
        return float(fitness)
    
    def evaluate_population(self, population: List[Individual]) -> None:
        """Avalia a fitness de todos os indivíduos na população.
        
        Parameters:
            population (List[Individual]): População a ser avaliada
        """
        # Reset dos caminhos conhecidos para esta avaliação
        self.known_paths.clear()
        
        # Primeira passada: executa todos os indivíduos para descobrir caminhos
        for individual in population:
            a, b, c = individual.get_genes()
            result = TriangleClassifier.classify(a, b, c)
            self.known_paths.add(result)
        
        # Segunda passada: atribui fitness baseada no número total de caminhos
        total_paths = len(self.known_paths)
        for individual in population:
            individual.fitness = float(total_paths)
    
    def tournament_selection(self, population: List[Individual], 
                           tournament_size: int = 3) -> Individual:
        """Seleciona um indivíduo usando seleção por torneio.
        
        Parameters:
            population (List[Individual]): População para seleção
            tournament_size (int): Tamanho do torneio
            
        Returns:
            Individual: Indivíduo vencedor do torneio
        """
        # Seleciona indivíduos aleatórios para o torneio
        tournament = random.sample(population, min(tournament_size, len(population)))
        
        # Retorna o indivíduo com maior fitness
        return max(tournament, key=lambda ind: ind.fitness)

# Demonstração da avaliação de fitness
print("📊 Demonstração da Função de Fitness:")
print("="*50)

# Criar alguns indivíduos de teste
test_individuals = [
    Individual(0, 5, 5),    # Invalid
    Individual(1, 1, 5),    # Not a triangle
    Individual(3, 3, 3),    # Equilateral
    Individual(3, 3, 4),    # Isosceles
    Individual(3, 4, 5),    # Scalene
]

generator = GeneticTestGenerator()
generator.evaluate_population(test_individuals)

print("Avaliação de fitness dos indivíduos de teste:")
for individual in test_individuals:
    a, b, c = individual.get_genes()
    result = TriangleClassifier.classify(a, b, c)
    print(f"  {individual} → '{result}'")

print(f"\n🎯 Caminhos únicos descobertos: {len(generator.known_paths)}")
print(f"📍 Caminhos: {sorted(generator.known_paths)}")

class GeneticTestGenerator(GeneticTestGenerator):  # Continuação - Operadores Genéticos
    """Continuação da implementação - Operadores de Crossover e Mutação."""
    
    def crossover(self, parent1: Individual, parent2: Individual) -> Individual:
        """Realiza crossover de um ponto entre dois pais.
        
        Parameters:
            parent1 (Individual): Primeiro pai
            parent2 (Individual): Segundo pai
            
        Returns:
            Individual: Filho resultante do crossover
        """
        # Crossover de um ponto: escolhe aleatoriamente de qual pai vem cada gene
        genes1 = parent1.get_genes()
        genes2 = parent2.get_genes()
        
        # Cada gene tem 50% de chance de vir de cada pai
        child_genes = []
        for i in range(3):
            if random.random() < 0.5:
                child_genes.append(genes1[i])
            else:
                child_genes.append(genes2[i])
        
        return Individual(child_genes[0], child_genes[1], child_genes[2])
    
    def mutate(self, individual: Individual) -> Individual:
        """Aplica mutação a um indivíduo.
        
        Parameters:
            individual (Individual): Indivíduo a ser mutado
            
        Returns:
            Individual: Indivíduo mutado
        """
        mutated = copy.deepcopy(individual)
        
        # Cada gene tem chance de sofrer mutação
        if random.random() < self.mutation_rate:
            mutated.a = random.randint(self.gene_min, self.gene_max)
        
        if random.random() < self.mutation_rate:
            mutated.b = random.randint(self.gene_min, self.gene_max)
            
        if random.random() < self.mutation_rate:
            mutated.c = random.randint(self.gene_min, self.gene_max)
        
        return mutated
    
    def create_next_generation(self, population: List[Individual]) -> List[Individual]:
        """Cria a próxima geração usando seleção, crossover e mutação.
        
        Parameters:
            population (List[Individual]): População atual
            
        Returns:
            List[Individual]: Nova geração
        """
        new_population = []
        
        # Elitismo: mantém o melhor indivíduo
        best_individual = max(population, key=lambda ind: ind.fitness)
        new_population.append(copy.deepcopy(best_individual))
        
        # Gera o resto da população
        while len(new_population) < self.population_size:
            # Seleção dos pais
            parent1 = self.tournament_selection(population)
            parent2 = self.tournament_selection(population)
            
            # Crossover
            child = self.crossover(parent1, parent2)
            
            # Mutação
            child = self.mutate(child)
            
            new_population.append(child)
        
        return new_population

# Demonstração dos operadores genéticos
print("🧬 Demonstração dos Operadores Genéticos:")
print("="*50)

# Criar dois pais para teste
parent1 = Individual(3, 3, 3)
parent2 = Individual(5, 4, 6)

print(f"Pai 1: {parent1}")
print(f"Pai 2: {parent2}")

generator = GeneticTestGenerator(mutation_rate=0.3)

# Demonstrar crossover
print("\n🔀 Crossover:")
for i in range(3):
    child = generator.crossover(parent1, parent2)
    print(f"  Filho {i+1}: {child}")

# Demonstrar mutação
print("\n🎲 Mutação:")
original = Individual(3, 3, 3)
for i in range(3):
    mutated = generator.mutate(original)
    print(f"  Original: {original} → Mutado: {mutated}")

class GeneticTestGenerator(GeneticTestGenerator):  # Implementação completa
    """Implementação completa do algoritmo genético para geração de testes."""
    
    def run_evolution(self, verbose: bool = True) -> Dict:
        """Executa o algoritmo genético completo.
        
        Parameters:
            verbose (bool): Se deve imprimir progresso durante a execução
            
        Returns:
            Dict: Resultados da evolução incluindo melhor solução e histórico
        """
        # Inicialização
        population = self.initialize_population()
        self.fitness_history = []
        self.coverage_history = []
        
        if verbose:
            print(f"🚀 Iniciando evolução com {self.population_size} indivíduos por {self.max_generations} gerações")
            print(f"⚙️  Parâmetros: Taxa de mutação = {self.mutation_rate}")
            print("="*70)
        
        best_coverage = 0
        generations_without_improvement = 0
        
        for generation in range(self.max_generations):
            # Avaliação da população
            self.evaluate_population(population)
            
            # Estatísticas da geração
            current_coverage = len(self.known_paths)
            best_fitness = max(ind.fitness for ind in population)
            avg_fitness = sum(ind.fitness for ind in population) / len(population)
            
            # Armazenar histórico
            self.fitness_history.append(best_fitness)
            self.coverage_history.append(current_coverage)
            
            # Verificar melhoria
            if current_coverage > best_coverage:
                best_coverage = current_coverage
                generations_without_improvement = 0
            else:
                generations_without_improvement += 1
            
            # Log do progresso
            if verbose and (generation % 10 == 0 or generation == self.max_generations - 1):
                print(f"Geração {generation:3d}: Cobertura = {current_coverage}/5, "
                      f"Fitness = {best_fitness:.1f}, Avg = {avg_fitness:.1f}")
            
            # Critério de parada: encontrou todos os caminhos
            if current_coverage >= 5:
                if verbose:
                    print(f"\n🎯 Todos os caminhos encontrados na geração {generation}!")
                break
            
            # Critério de parada: sem melhoria por muitas gerações
            if generations_without_improvement >= 20:
                if verbose:
                    print(f"\n⏹️  Parada por convergência na geração {generation}")
                break
            
            # Criar próxima geração
            population = self.create_next_generation(population)
        
        # Encontrar conjunto final de teste
        final_test_suite = self._extract_test_suite(population)
        
        return {
            'final_population': population,
            'test_suite': final_test_suite,
            'paths_covered': sorted(self.known_paths),
            'coverage_count': len(self.known_paths),
            'fitness_history': self.fitness_history,
            'coverage_history': self.coverage_history,
            'generations_run': len(self.fitness_history)
        }
    
    def _extract_test_suite(self, population: List[Individual]) -> List[Tuple[int, int, int, str]]:
        """Extrai um conjunto mínimo de casos de teste que cobrem todos os caminhos.
        
        Parameters:
            population (List[Individual]): População final
            
        Returns:
            List[Tuple[int, int, int, str]]: Lista de casos de teste únicos
        """
        test_suite = {}
        
        for individual in population:
            a, b, c = individual.get_genes()
            result = TriangleClassifier.classify(a, b, c)
            
            # Manter apenas um exemplo por caminho (o primeiro encontrado)
            if result not in test_suite:
                test_suite[result] = (a, b, c, result)
        
        return list(test_suite.values())

# Executar o algoritmo genético completo
print("🧪 Execução Completa do Algoritmo Genético:")
print("="*70)

# Configuração padrão
generator = GeneticTestGenerator(
    population_size=30,
    mutation_rate=0.15,
    max_generations=50
)

results = generator.run_evolution(verbose=True)

print("\n📋 Conjunto Final de Casos de Teste:")
print("="*50)
for i, (a, b, c, classification) in enumerate(results['test_suite'], 1):
    print(f"{i}. ({a:2d}, {b:2d}, {c:2d}) → '{classification}'")

print(f"\n📊 Estatísticas Finais:")
print(f"   • Caminhos cobertos: {results['coverage_count']}/5 ({results['coverage_count']/5*100:.0f}%)")
print(f"   • Gerações executadas: {results['generations_run']}")
print(f"   • Caminhos encontrados: {results['paths_covered']}")

def random_search_baseline(num_evaluations: int = 1500, 
                          gene_range: Tuple[int, int] = (-5, 20)) -> Dict:
    """Implementa busca aleatória pura como baseline de comparação.
    
    Parameters:
        num_evaluations (int): Número de avaliações aleatórias
        gene_range (Tuple[int, int]): Range dos valores dos genes
        
    Returns:
        Dict: Resultados da busca aleatória
    """
    gene_min, gene_max = gene_range
    found_paths = set()
    coverage_history = []
    test_suite = {}
    
    print(f"🎲 Executando busca aleatória com {num_evaluations} avaliações...")
    
    for evaluation in range(num_evaluations):
        # Gerar trio aleatório
        a = random.randint(gene_min, gene_max)
        b = random.randint(gene_min, gene_max)
        c = random.randint(gene_min, gene_max)
        
        # Avaliar
        result = TriangleClassifier.classify(a, b, c)
        found_paths.add(result)
        
        # Manter primeiro exemplo de cada caminho
        if result not in test_suite:
            test_suite[result] = (a, b, c, result)
        
        # Registrar progresso a cada 50 avaliações
        if evaluation % 50 == 0:
            coverage_history.append(len(found_paths))
        
        # Parar se encontrar todos os caminhos
        if len(found_paths) >= 5:
            print(f"   ✅ Todos os caminhos encontrados após {evaluation + 1} avaliações")
            break
    
    return {
        'test_suite': list(test_suite.values()),
        'paths_covered': sorted(found_paths),
        'coverage_count': len(found_paths),
        'evaluations_used': evaluation + 1 if len(found_paths) >= 5 else num_evaluations,
        'coverage_history': coverage_history
    }

# Comparação experimental
print("⚖️  Comparação Experimental: Busca Aleatória vs. Algoritmo Genético")
print("="*70)

# Executar busca aleatória
random.seed(42)  # Mesma seed para comparação justa
random_results = random_search_baseline(num_evaluations=1500)

print("\n🎲 Resultados da Busca Aleatória:")
print(f"   • Caminhos cobertos: {random_results['coverage_count']}/5")
print(f"   • Avaliações utilizadas: {random_results['evaluations_used']}")
print(f"   • Caminhos: {random_results['paths_covered']}")

# Executar algoritmo genético novamente para comparação justa
print("\n🧬 Executando Algoritmo Genético para comparação...")
random.seed(42)  # Mesma seed
np.random.seed(42)

ga_generator = GeneticTestGenerator(
    population_size=30,
    mutation_rate=0.15, 
    max_generations=50
)
ga_results = ga_generator.run_evolution(verbose=False)

# Estimar número de avaliações do AG (população * gerações)
ga_evaluations = 30 * ga_results['generations_run']

print(f"\n🧬 Resultados do Algoritmo Genético:")
print(f"   • Caminhos cobertos: {ga_results['coverage_count']}/5")
print(f"   • Estimativa de avaliações: {ga_evaluations}")
print(f"   • Gerações: {ga_results['generations_run']}")
print(f"   • Caminhos: {ga_results['paths_covered']}")

# Análise comparativa
print("\n📊 Análise Comparativa:")
print("="*50)

if ga_results['coverage_count'] > random_results['coverage_count']:
    print("🏆 Vencedor: Algoritmo Genético (melhor cobertura)")
elif ga_results['coverage_count'] < random_results['coverage_count']:
    print("🏆 Vencedor: Busca Aleatória (melhor cobertura)")
else:
    if ga_evaluations < random_results['evaluations_used']:
        print("🏆 Vencedor: Algoritmo Genético (mesma cobertura, menos avaliações)")
    else:
        print("🏆 Empate ou Busca Aleatória mais eficiente")

efficiency_ga = ga_results['coverage_count'] / ga_evaluations if ga_evaluations > 0 else 0
efficiency_random = random_results['coverage_count'] / random_results['evaluations_used']

print(f"\nEficiência (caminhos/avaliação):")
print(f"   • Algoritmo Genético: {efficiency_ga:.6f}")
print(f"   • Busca Aleatória: {efficiency_random:.6f}")

def plot_evolution_analysis(ga_results: Dict, random_results: Dict) -> None:
    """Cria visualizações comparativas da evolução dos algoritmos.
    
    Parameters:
        ga_results (Dict): Resultados do algoritmo genético
        random_results (Dict): Resultados da busca aleatória
    """
    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
    fig.suptitle('Análise Comparativa: Algoritmo Genético vs. Busca Aleatória', fontsize=16)
    
    # Gráfico 1: Evolução da Fitness (AG)
    ax1.plot(ga_results['fitness_history'], 'b-', linewidth=2, label='Melhor Fitness')
    ax1.set_title('Evolução da Fitness - Algoritmo Genético')
    ax1.set_xlabel('Geração')
    ax1.set_ylabel('Fitness')
    ax1.grid(True, alpha=0.3)
    ax1.legend()
    
    # Gráfico 2: Evolução da Cobertura (AG)
    ax2.plot(ga_results['coverage_history'], 'g-', linewidth=2, marker='o', markersize=4)
    ax2.set_title('Evolução da Cobertura - Algoritmo Genético')
    ax2.set_xlabel('Geração')
    ax2.set_ylabel('Caminhos Cobertos')
    ax2.set_ylim(0, 5.5)
    ax2.grid(True, alpha=0.3)
    
    # Adicionar linha objetivo
    ax2.axhline(y=5, color='r', linestyle='--', alpha=0.7, label='Objetivo (5 caminhos)')
    ax2.legend()
    
    # Gráfico 3: Comparação de Eficiência
    methods = ['Algoritmo\nGenético', 'Busca\nAleatória']
    coverage_counts = [ga_results['coverage_count'], random_results['coverage_count']]
    colors = ['skyblue', 'lightcoral']
    
    bars = ax3.bar(methods, coverage_counts, color=colors, alpha=0.7, edgecolor='black')
    ax3.set_title('Comparação de Cobertura Final')
    ax3.set_ylabel('Caminhos Cobertos')
    ax3.set_ylim(0, 6)
    
    # Adicionar valores nas barras
    for bar, count in zip(bars, coverage_counts):
        height = bar.get_height()
        ax3.text(bar.get_x() + bar.get_width()/2., height + 0.1,
                f'{count}/5', ha='center', va='bottom', fontweight='bold')
    
    # Linha objetivo
    ax3.axhline(y=5, color='red', linestyle='--', alpha=0.7, label='Objetivo')
    ax3.legend()
    
    # Gráfico 4: Convergência da Busca Aleatória (simulada)
    # Simular progresso da busca aleatória baseado nos resultados
    random_steps = list(range(0, len(random_results['coverage_history']) * 50, 50))
    ax4.plot(random_steps, random_results['coverage_history'], 'r-', 
             linewidth=2, marker='s', markersize=4, label='Busca Aleatória')
    
    # Comparar com progresso do AG (em termos de avaliações)
    ga_steps = [i * 30 for i in range(len(ga_results['coverage_history']))]
    ax4.plot(ga_steps, ga_results['coverage_history'], 'b-', 
             linewidth=2, marker='o', markersize=4, label='Algoritmo Genético')
    
    ax4.set_title('Convergência por Número de Avaliações')
    ax4.set_xlabel('Avaliações Estimadas')
    ax4.set_ylabel('Caminhos Cobertos')
    ax4.set_ylim(0, 5.5)
    ax4.grid(True, alpha=0.3)
    ax4.legend()
    
    plt.tight_layout()
    plt.show()

# Executar experimento completo com múltiplas configurações
print("📈 Análise Detalhada com Diferentes Configurações:")
print("="*70)

configurations = [
    {'pop_size': 20, 'mutation_rate': 0.1, 'name': 'Conservador'},
    {'pop_size': 30, 'mutation_rate': 0.15, 'name': 'Balanceado'}, 
    {'pop_size': 40, 'mutation_rate': 0.2, 'name': 'Agressivo'}
]

config_results = []

for config in configurations:
    print(f"\n🧪 Testando configuração {config['name']}...")
    
    # Reset das seeds para comparação justa
    random.seed(42)
    np.random.seed(42)
    
    generator = GeneticTestGenerator(
        population_size=config['pop_size'],
        mutation_rate=config['mutation_rate'],
        max_generations=30
    )
    
    results = generator.run_evolution(verbose=False)
    config_results.append({
        'name': config['name'],
        'coverage': results['coverage_count'],
        'generations': results['generations_run'],
        'evaluations': config['pop_size'] * results['generations_run']
    })
    
    print(f"   Resultado: {results['coverage_count']}/5 caminhos em {results['generations_run']} gerações")

# Visualizar comparação
print("\n📊 Criando visualizações comparativas...")
plot_evolution_analysis(ga_results, random_results)

# Resumo das configurações testadas
print("\n📋 Resumo das Configurações Testadas:")
print("="*60)
print(f"{'Configuração':<12} {'Cobertura':<10} {'Gerações':<10} {'Avaliações':<12}")
print("-" * 60)
for result in config_results:
    print(f"{result['name']:<12} {result['coverage']}/5{'':<6} "
          f"{result['generations']:<10} {result['evaluations']:<12}")

print("\n🏆 Melhor configuração: ", end="")
best_config = max(config_results, key=lambda x: (x['coverage'], -x['evaluations']))
print(f"{best_config['name']} (cobertura: {best_config['coverage']}/5, "
      f"avaliações: {best_config['evaluations']})")

def generate_final_analysis() -> None:
    """Gera análise final dos resultados e lições aprendidas."""
    
    print("🎯 ANÁLISE CRÍTICA DOS RESULTADOS")
    print("="*70)
    
    print("\n1. 📊 EFICÁCIA DO ALGORITMO GENÉTICO:")
    print("""
   ✅ PONTOS FORTES:
   • Converge rapidamente para soluções de alta qualidade
   • Explora o espaço de busca de forma sistemática
   • Elitismo garante que boas soluções não sejam perdidas
   • Operadores genéticos facilitam descoberta de novos caminhos
   
   ⚠️  LIMITAÇÕES OBSERVADAS:
   • Para problemas simples, pode ser "overkill" comparado à busca aleatória
   • Requer ajuste de parâmetros (população, mutação, etc.)
   • Overhead computacional dos operadores genéticos
    """)
    
    print("\n2. 🔍 INSIGHTS SOBRE SBSE:")
    print("""
   • REPRESENTAÇÃO: Trios de inteiros são adequados para este problema
   • FITNESS FUNCTION: Número de caminhos cobertos é uma métrica simples mas eficaz
   • ESCALABILIDADE: Para funções com mais caminhos, a vantagem do AG seria maior
   • AUTOMATIZAÇÃO: O processo elimina completamente a necessidade de criação manual
    """)
    
    print("\n3. 🏭 APLICAÇÃO INDUSTRIAL:")
    print("""
   CENÁRIOS ONDE SBSE SERIA VANTAJOSA:
   • Funções com centenas de caminhos de execução
   • Sistemas com interações complexas entre parâmetros
   • Necessidade de otimizar múltiplos objetivos (cobertura + tempo + recursos)
   • Integração com ferramentas de CI/CD para teste contínuo
    """)
    
    print("\n4. 🎓 LIÇÕES APRENDIDAS:")
    print("""
   📚 CONCEITUAIS:
   • SBSE transforma problemas de ES em problemas de otimização
   • A qualidade da função de fitness é crucial para o sucesso
   • Parâmetros bem ajustados fazem diferença significativa
   
   💻 TÉCNICAS:
   • Type hints e docstrings melhoram drasticamente a legibilidade
   • Visualizações são essenciais para entender o comportamento do algoritmo
   • Comparação com baselines simples valida a eficácia da abordagem
    """)
    
    print("\n5. 🚀 PRÓXIMOS PASSOS:")
    print("""
   EXTENSÕES POSSÍVEIS:
   • Implementar outros algoritmos (Simulated Annealing, PSO)
   • Adicionar objetivos múltiplos (cobertura + tempo de execução)
   • Testar em funções mais complexas com estruturas de dados
   • Integrar com ferramentas reais de teste (JUnit, pytest)
   • Implementar técnicas híbridas (AG + busca local)
    """)

# Gerar análise final
generate_final_analysis()

# Demonstração final: aplicar em uma nova função
print("\n🎯 DEMONSTRAÇÃO FINAL: Aplicação em Nova Função")
print("="*70)

def complex_function(x: int, y: int) -> str:
    """Função mais complexa para demonstrar extensibilidade."""
    if x < 0 or y < 0:
        return "negative"
    elif x == 0 and y == 0:
        return "origin"
    elif x > y:
        return "x_greater"
    elif y > x:
        return "y_greater"
    else:
        return "equal"

print("Nova função para teste:")
print("• complex_function(x, y) com 5 caminhos possíveis")
print("• Demonstra como SBSE pode ser aplicada a qualquer função")

# Teste rápido da nova função
test_cases_new = [(-1, 5), (0, 0), (5, 3), (3, 5), (4, 4)]
print("\nCaminhos encontrados manualmente:")
for x, y in test_cases_new:
    result = complex_function(x, y)
    print(f"  complex_function({x}, {y}) → '{result}'")

print("\n✨ O mesmo framework de AG poderia ser facilmente")
print("   adaptado para esta nova função mudando apenas:")
print("   • Representação: Individual(x, y) ao invés de (a, b, c)")
print("   • Função de avaliação: chamar complex_function ao invés de TriangleClassifier")
print("   • Range dos genes conforme necessário")

print("\n🎉 LABORATÓRIO CONCLUÍDO COM SUCESSO!")
print("\nVocê implementou um sistema completo de SBSE e viu na prática como:")
print("• Algoritmos de busca podem automatizar tarefas de engenharia de software")
print("• A representação adequada e função de fitness são cruciais")
print("• Visualização e análise comparativa validam os resultados")
print("• O framework é extensível para outros problemas de ES")