import math
import numpy as np

def apply_function(individual):
    x = individual["x"]
    y = individual["y"]
    result = -(20 + np.e - 20 * np.exp(-0.2 * np.sqrt(0.5*(x**2 + y**2))) \
    - np.exp(0.5*(np.cos(2*3.14*x)+np.cos(2*3.14*y))))
    return result


def GA_Plus(lambda_,mu,generations):
        import random

    def generate_population(size, x_boundaries, y_boundaries):
        lower_x_boundary, upper_x_boundary = x_boundaries
        lower_y_boundary, upper_y_boundary = y_boundaries

        population = []
        for i in range(size):
            individual = {
                "x": random.uniform(lower_x_boundary, upper_x_boundary),
                "y": random.uniform(lower_y_boundary, upper_y_boundary),
            }
            population.append(individual)

        return population
    
    def choice_by_roulette(sorted_population, fitness_sum):
        offset = 0
        normalized_fitness_sum = fitness_sum

        lowest_fitness = apply_function(sorted_population[0])
        if lowest_fitness < 0:
            offset = -lowest_fitness
            normalized_fitness_sum += offset * len(sorted_population)

        draw = random.uniform(0, 1)

        accumulated = 0
        for individual in sorted_population:
            fitness = apply_function(individual) + offset
            probability = fitness / normalized_fitness_sum
            accumulated += probability

            if draw <= accumulated:
                return individual
    def sort_population_by_fitness(population):
        return sorted(population, key=apply_function)


    def crossover(individual_a, individual_b):
        xa = individual_a["x"]
        ya = individual_a["y"]

        xb = individual_b["x"]
        yb = individual_b["y"]

        return {"x": (xa + xb) / 2, "y": (ya + yb) / 2}


    def mutate(individual):
        next_x = individual["x"] + random.uniform(-0.01, 0.01)
        next_y = individual["y"] + random.uniform(-0.01, 0.01)

        lower_boundary, upper_boundary = (-10, 10)

        # Guarantee we keep inside boundaries
        next_x = min(max(next_x, lower_boundary), upper_boundary)
        next_y = min(max(next_y, lower_boundary), upper_boundary)

        return {"x": next_x, "y": next_y}

    def make_next_generation(previous_population,population_size):
        next_generation = []
        sorted_by_fitness_population = sort_population_by_fitness(previous_population)
        fitness_sum = sum(apply_function(individual) for individual in population)
        for i in range(population_size):
            first_choice = choice_by_roulette(sorted_by_fitness_population, fitness_sum)
            second_choice = choice_by_roulette(sorted_by_fitness_population, fitness_sum)

            individual = crossover(first_choice, second_choice)
            individual = mutate(individual)
            next_generation.append(individual)

            return next_generation
    
    population = generate_population(size=lambda_, x_boundaries=(-20, 20), y_boundaries=(-20, 20))

    i = 1
while True:
#         print(f"