#include "chess.hpp"
#include <cstdlib>
#include <iostream>
#include <random>

std::default_random_engine generator;

void InitializeGenerator(void) {
    generator.seed(std::random_device{}());
}

int GenerateRandomNumber(int generationLimit) {
    int generatedNumber;
    std::uniform_int_distribution<> distribution(0, generationLimit - 1);
    generatedNumber = distribution(generator);
    return generatedNumber;
}

GeneticRules::GeneticRules(void) {
    boardSize = 4;
    populationSize = 1;
}

GeneticRules::GeneticRules(unsigned int boardSize, unsigned int populationSize) {
    this->boardSize = boardSize;
    this->populationSize = populationSize;
}

Individual::Individual(const unsigned int boardSize) {
    generationCount = 0;
    InitializeGenerator();
    // population init part of vector resize
    board.resize(boardSize, 0);
    for (int i = 0; i < board.size(); ++i) { 
        board.at(i) = GenerateRandomNumber(boardSize);
    }
}


void Individual::Print(void) {
    std::cout << generationCount << ':' << std::endl;
    for (int i : board) {
        std::cout << '[';
        for (int j = 0; j < board.size(); ++j) {
            if (j == i) { std::cout << "Q"; }
            else { std::cout << ' '; }
        }
        std::cout << ']';
        std::cout << std::endl;
    }
}

// Gets the fitness of the population
unsigned int Individual::GetFitness(void) {
    unsigned int fitness = 0;
    for (unsigned int i : board) { 
        if (!IsQueenThreatened(i)) { fitness++; }
    }
    std::cout << fitness << std::endl;
    return fitness;
}

//
void Individual::Selection(void) {
    /* TODO: Finish selection
    int fitness[N] = {0};
    int fitness_sum = 0;
    int i, j;
    // get fitness for all members of population
    for ( i=0; i<N; i++ ){
        fitness[i] = get_fitness(population[i]);
        fitness_sum += fitness[i];
    }


    // this is simple fitness proportional selection
    // (roulette wheel sampling)
    int roll;
    int temp_sum = 0;
    int selection;
    for ( i=0; i<N; i++ ){
        temp_sum = 0;
        roll = rand()%fitness_sum;
        for ( j=0; j<N; j++ ){
            temp_sum += fitness[j];
            if ( roll < temp_sum ){
                selection = j;
                break;
            }
        }
        selected[i] = selection;
    }
    */
}

// Crossover on the population
void Individual::Crossover(void) {
    /* TODO: Finish Crossover 
    double crossover_roll;
    int crossover_locus;
    int i;
    unsigned char temp1;
    unsigned char temp2;
    unsigned char mask;
    unsigned char temp_population[N];

    for ( i=0; i<N; i+=2){ 
        crossover_roll = ((double)rand())/((double)RAND_MAX);
        temp1 = 0;
        temp2 = 0;
        if(crossover_roll <= P_c){  //crossover
            crossover_locus = rand()%L;
            mask = get_mask(crossover_locus);
            temp1 = population[selected[i]] & mask;
            temp1 ^= population[selected[i+1]] & ~mask;
            temp2 = population[selected[i+1]] & mask;
            temp2 ^= population[selected[i]] & ~mask;
            temp_population[i] = temp1;
            temp_population[i+1] = temp2;
        }
        else{  //clone
            temp_population[i] = population[selected[i]];
            temp_population[i+1] = population[selected[i+1]];
        }
    }

    //copy back to population
    for ( i=0; i<N; i++ ){
        population[i] = temp_population[i];
    }
    */
}

// Mutates the population
void Individual::Mutation(void) {
    /* TODO: Finish Mutation
    double mutation_roll;
    int i, j;
    for ( i=0; i<N; i++){
        for ( j=0; j<L; j++ ){
            mutation_roll = ((double)rand())/((double)RAND_MAX);
            if ( mutation_roll <= P_m ){
                population[i] ^= (1<<j);   //toggle bit
            }
        }
    }
    */
}

// Checks if the passed in queen is threatened on the board
// Impossible for queens to be threatened by same row
bool Individual::IsQueenThreatened(const int queenRow) {
    int queenCol = board.at(queenRow);
    int diffRow, diffCol;
    for (int row = 0; row < board.size(); ++row) {
        if (row == queenRow) { continue; }
        diffCol = abs(queenCol - (int)board.at(row));
        diffRow = abs(queenRow - row);
        if (diffCol == 0) { return true; } // Column threat
        if (diffCol == diffRow) { return true; }
    }
    return false;
}