import numpy

import ga_methods

# Genetic Algorithm
if __name__ == "__main__":

    """
    The y=target is to maximize this equation ASAP:
        y = w1x1+w2x2+w3x3+w4x4+w5x5+6wx6
        where (x1,x2,x3,x4,x5,x6)=(4,-2,3.5,5,-11,-4.7)
        What are the best values for the 6 weights w1 to w6?
        We are going to use the genetic algorithm for the best possible values after a number of generations.
    """

    # Inputs of the equation.
    equation_inputs = [4, -2, 3.5, 5, -11, -4.7]

    # Number of the weights we are looking to optimize.
    num_weights = len(equation_inputs)

    """
    Genetic algorithm parameters:
        Mating pool size
        Population size
    """
    sol_per_pop = 8
    num_parents_mating = 4

    # Defining the population size.
    pop_size = (sol_per_pop,
                num_weights)  # The population will have sol_per_pop chromosome where each chromosome has num_weights genes.
    # Creating the initial population.
    new_population = numpy.random.uniform(low=-4.0, high=4.0, size=pop_size)
    print(new_population)

    """
    new_population[0, :] = [2.4,  0.7, 8, -2,   5,   1.1]
    new_population[1, :] = [-0.4, 2.7, 5, -1,   7,   0.1]
    new_population[2, :] = [-1,   2,   2, -3,   2,   0.9]
    new_population[3, :] = [4,    7,   12, 6.1, 1.4, -4]
    new_population[4, :] = [3.1,  4,   0,  2.4, 4.8,  0]
    new_population[5, :] = [-2,   3,   -7, 6,   3,    3]
    """

    best_outputs = []
    num_generations = 1000
    for generation in range(num_generations):
        print("Generation : ", generation)
        # Measuring the fitness of each chromosome in the population.
        fitness = ga_methods.cal_pop_fitness(equation_inputs, new_population)
        print("Fitness")
        print(fitness)

        best_outputs.append(numpy.max(numpy.sum(new_population * equation_inputs, axis=1)))
        # The best result in the current iteration.
        print("Best result : ", numpy.max(numpy.sum(new_population * equation_inputs, axis=1)))

        # Selecting the best parents in the population for mating.
        parents = ga_methods.select_mating_pool(new_population, fitness,
                                                num_parents_mating)
        print("Parents")
        print(parents)

        # Generating next generation using crossover.
        offspring_crossover = ga_methods.crossover(parents,
                                                   offspring_size=(pop_size[0] - parents.shape[0], num_weights))
        print("Crossover")
        print(offspring_crossover)

        # Adding some variations to the offspring using mutation.
        offspring_mutation = ga_methods.mutation(offspring_crossover, num_mutations=2)
        print("Mutation")
        print(offspring_mutation)

        # Creating the new population based on the parents and offspring.
        new_population[0:parents.shape[0], :] = parents
        new_population[parents.shape[0]:, :] = offspring_mutation

    # Getting the best solution after iterating finishing all generations.
    # At first, the fitness is calculated for each solution in the final generation.
    fitness = ga_methods.cal_pop_fitness(equation_inputs, new_population)
    # Then return the index of that solution corresponding to the best fitness.
    best_match_idx = numpy.where(fitness == numpy.max(fitness))

    print("Best solution : ", new_population[best_match_idx, :])
    print("Best solution fitness : ", fitness[best_match_idx])

    import matplotlib.pyplot

    matplotlib.pyplot.plot(best_outputs)
    matplotlib.pyplot.xlabel("Iteration")
    matplotlib.pyplot.ylabel("Fitness")
    matplotlib.pyplot.show()