#include <cstdlib>
#include <iostream>
#include <math.h>
#include <time.h>
#include <memory>
#include <array>
#include <vector>
#include <fstream>
#include <string>

#include <ga/ga.h>
#include <ga/GARealGenome.C>
#include <ga/GARealGenome.h>
#include <StaticLib/StaticLib.h>

enum SelectionMethod {
    SELECTION_RANK,
    //SELECTION_ROULETTE_WHEEL,
    SELECTION_TOURNAMENT,
    SELECTION_UNIFORM,
    //SELECTION_SRS,
    //SELECTION_DS
};

enum ReproductionMethod {
    REPRODUCTION_SIMPLE,
    REPRODUCTION_STEADY_STATE,
    //REPRODUCTION_INCREMETAL,
    //REPRODUCTION_DEME
};

enum CrossoverMethod {
    CROSSOVER_UNIFORM,
    //CROSSOVER_EVEN_ODD,
    //CROSSOVER_ONE_POINT,
    //CROSSOVER_TWO_POINT,
    //CROSSOVER_PARTIAL_MATCH,
    //CROSSOVER_ORDER,
    //CROSSOVER_CYCLE,
    CROSSOVER_REAL_BLEND,
    CROSSOVER_REAL_ARITHMETIC
};

enum MutationMethod {
    MUTATION_FLIP,
    //MUTATION_SWAP,
    MUTATION_REAL_GAUSSIAN
};

enum Dimension {
    DIM_SELECTION,
    DIM_REPRODUCTION,
    DIM_CROSSOVER,
    DIM_MUTATION
};

constexpr std::array<int, 4> METHOD_SIZES = {{ 3, 2, 3, 2 }};

const int FUNCTION_NR = 6;

const int POPULATION_SIZE = 50;
const int N_GENERATIONS = 200;
const float P_MUTATION = 0.001f;
const float P_CROSSOVER = 0.5f;

const int TOTAL_METHODS = METHOD_SIZES[DIM_SELECTION] * METHOD_SIZES[DIM_REPRODUCTION] * METHOD_SIZES[DIM_CROSSOVER] * METHOD_SIZES[DIM_MUTATION];

const int MAX_ITERATIONS = 10;

typedef std::array<std::array<std::array<std::array<std::array<float, MAX_ITERATIONS>, METHOD_SIZES[DIM_MUTATION]>, METHOD_SIZES[DIM_CROSSOVER]>, METHOD_SIZES[DIM_REPRODUCTION]>, METHOD_SIZES[DIM_SELECTION]> ScoresArr;

float Objective(GAGenome& g) {
    GARealGenome& genome = (GARealGenome&)g;
    return GA_TestFunction(FUNCTION_NR, genome.gene(0), genome.gene(1));
}

std::unique_ptr<GAGeneticAlgorithm> getGeneticAlghoritm(ReproductionMethod reproductionMethod, const GAPopulation& population) {
    switch (reproductionMethod) {
        case REPRODUCTION_SIMPLE:
            return std::unique_ptr<GAGeneticAlgorithm>(new GASimpleGA(population));
        case REPRODUCTION_STEADY_STATE:
            return std::unique_ptr<GAGeneticAlgorithm>(new GASteadyStateGA(population));
        //case REPRODUCTION_INCREMETAL:
            //return std::unique_ptr<GAGeneticAlgorithm>(new GAIncrementalGA(population));
        //case REPRODUCTION_DEME:
            //return std::unique_ptr<GAGeneticAlgorithm>(new GADemeGA(population));
        default:
            return nullptr;
    }
}

std::unique_ptr<GASelectionScheme> getSelectionScheme(SelectionMethod selectionMethod) {
    switch (selectionMethod) {
        case SELECTION_RANK:
            return std::unique_ptr<GASelectionScheme>(new GARankSelector());
        //case SELECTION_ROULETTE_WHEEL:
            //return std::unique_ptr<GASelectionScheme>(new GARouletteWheelSelector());
        case SELECTION_TOURNAMENT:
            return std::unique_ptr<GASelectionScheme>(new GATournamentSelector());
        case SELECTION_UNIFORM:
            return std::unique_ptr<GASelectionScheme>(new GAUniformSelector());
        //case SELECTION_SRS:
            //return std::unique_ptr<GASelectionScheme>(new GASRSSelector());
        //case SELECTION_DS:
            //return std::unique_ptr<GASelectionScheme>(new GADSSelector());
        default:
            return nullptr;
    }
}

int (*getMutator(MutationMethod mutationMethod))(GAGenome &, float) {
    switch (mutationMethod) {
        case MUTATION_FLIP:
            return GARealGenome::FlipMutator;
        //case MUTATION_SWAP:
            //return GARealGenome::SwapMutator;
        case MUTATION_REAL_GAUSSIAN:
            return GARealGaussianMutator;
        default:
            return NULL;
    }
}

int (*getSexualCrossover(CrossoverMethod crossoverMethod))(const GAGenome&, const GAGenome&, GAGenome*, GAGenome*) {
    switch (crossoverMethod) {
        case CROSSOVER_UNIFORM:
            return GARealGenome::UniformCrossover;
        //case CROSSOVER_EVEN_ODD:
            //return GARealGenome::EvenOddCrossover;
        //case CROSSOVER_ONE_POINT:
            //return GARealGenome::OnePointCrossover;
        //case CROSSOVER_TWO_POINT:
            //return GARealGenome::TwoPointCrossover;
        //case CROSSOVER_PARTIAL_MATCH:
            //return GARealGenome::PartialMatchCrossover;
        //case CROSSOVER_ORDER:
            //return GARealGenome::OrderCrossover;
        //case CROSSOVER_CYCLE:
            //return GARealGenome::CycleCrossover;
        case CROSSOVER_REAL_BLEND:
            return GARealBlendCrossover;
        case CROSSOVER_REAL_ARITHMETIC:
            return GARealArithmeticCrossover;
        default:
            return NULL;
    }
}

void generateStats(const ScoresArr &scores, Dimension dim, const std::string &filename, const std::vector<std::string> &categories) {
    std::vector<float> means(METHOD_SIZES[dim], 0.0f);
    std::vector<float> stds(METHOD_SIZES[dim], 0.0f);
    int pointsToIter = TOTAL_METHODS * MAX_ITERATIONS / METHOD_SIZES[dim];
    for (int i = 0; i < METHOD_SIZES[dim]; ++i) {
        double sum = 0.0;
        for (int selI = (dim == DIM_SELECTION ? i : 0); selI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_SELECTION]); ++selI) {
            for (int repI = (dim == DIM_REPRODUCTION ? i : 0); repI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_REPRODUCTION]); ++repI) {
                for (int crossI = (dim == DIM_CROSSOVER ? i : 0); crossI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_CROSSOVER]); ++crossI) {
                    for (int mutI = (dim == DIM_MUTATION ? i : 0); mutI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_MUTATION]); ++mutI) {
                        for (int n = 0; n < MAX_ITERATIONS; ++n) {
                            sum += scores[selI][repI][crossI][mutI][n];
                        }
                    }
                }
            }
        }
        double avg = sum / pointsToIter;
        double diffSqSum = 0.0;
        for (int selI = (dim == DIM_SELECTION ? i : 0); selI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_SELECTION]); ++selI) {
            for (int repI = (dim == DIM_REPRODUCTION ? i : 0); repI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_REPRODUCTION]); ++repI) {
                for (int crossI = (dim == DIM_CROSSOVER ? i : 0); crossI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_CROSSOVER]); ++crossI) {
                    for (int mutI = (dim == DIM_MUTATION ? i : 0); mutI < (dim == DIM_MUTATION ? i + 1 : METHOD_SIZES[DIM_MUTATION]); ++mutI) {
                        for (int n = 0; n < MAX_ITERATIONS; ++n) {
                            double diff = scores[selI][repI][crossI][mutI][n] - avg;
                            diffSqSum += diff * diff;
                        }
                    }
                }
            }
        }
        means[i] = avg;
        stds[i] = sqrt(diffSqSum / (pointsToIter - 1));
    }
    std::ofstream file(filename);
    for (int i = 0; i < METHOD_SIZES[dim]; ++i) {
        file << categories[i] << "\t" << means[i] << "\t" << stds[i] << std::endl;
    }
    file.close();
}

int main(int argc, char **argv) {

    ScoresArr scores;

    GARealAlleleSetArray alleles;
    alleles.add(GA_Get_Min_x(FUNCTION_NR), GA_Get_Max_x(FUNCTION_NR));
    alleles.add(GA_Get_Min_y(FUNCTION_NR), GA_Get_Max_y(FUNCTION_NR));

    GARealGenome basicGenome(alleles, Objective);

    GASigmaTruncationScaling sigmaTruncationScaling;

    int count = 0;

    for (int selI = 0; selI < METHOD_SIZES[DIM_SELECTION]; ++selI) {
        for (int repI = 0; repI < METHOD_SIZES[DIM_REPRODUCTION]; ++repI) {
            for (int crossI = 0; crossI < METHOD_SIZES[DIM_CROSSOVER]; ++crossI) {
                for (int mutI = 0; mutI < METHOD_SIZES[DIM_MUTATION]; ++mutI) {

                    std::cout << "\rGenerating stats... " << (count * 100 / TOTAL_METHODS) << "%" << std::flush;
                    ++count;

                    for (int i = 0; i < MAX_ITERATIONS; ++i) {

                        auto genome = std::unique_ptr<GAGenome>(basicGenome.clone());

                        auto mutator = getMutator(static_cast<MutationMethod>(mutI));
                        genome->mutator(mutator);

                        auto crossover = getSexualCrossover(static_cast<CrossoverMethod>(crossI));
                        genome->crossover(crossover);

                        auto selScheme = getSelectionScheme(static_cast<SelectionMethod>(selI));
                        GAPopulation population(*genome);
                        population.selector(*selScheme);

                        auto ga = getGeneticAlghoritm(static_cast<ReproductionMethod>(repI), population);
                        ga->scaling(sigmaTruncationScaling);
                        ga->minimize();
                        ga->populationSize(POPULATION_SIZE);
                        ga->nGenerations(N_GENERATIONS);
                        ga->pMutation(P_MUTATION);
                        ga->pCrossover(P_CROSSOVER);

                        ga->initialize();
                        ga->evolve();

                        scores[selI][repI][crossI][mutI][i] = ga->statistics().bestIndividual().score();
                        // std::cout << ga->statistics().bestIndividual() << std::endl;

                    }

                }
            }
        }
    }

    std::cout << "\rStats generated!        " <<std::endl;

    generateStats(scores, DIM_CROSSOVER, "part1_crossover.dat", { "Uniform", "One Point", "Two Point", "Partial Match", /*"Order", */"Blend (Real)", "Arithmetic (Real)" });

}