#include <iostream>
#include <sstream>
#include <string>
#include <fstream>
#include <vector>
#include <cstdlib>
#include "../include/Individual.h"
#include "../include/FitnessFunctions.h"
#include "../include/Population.h"

using namespace std;
/**Declaration for non-member functions*/
bool cmpA(Individual* one, Individual* two);
bool cmpD(Individual* one, Individual* two);

/**Constructor and Destructor*/
Population::Population(){
	Individuals = new vector<Individual*>();
}

Population::~Population(){
	while(!Individuals->empty()){
		delete Individuals->back();
		Individuals->pop_back();
	}
	delete Individuals;
}

/**Begin the fun!*/
void Population::Sort(bool Ascending){
	if(Ascending){
		std::sort(Individuals->begin(),Individuals->end(), cmpA);
	}else
	if(!Ascending){
		std::sort(Individuals->begin(),Individuals->end(), cmpD);
	}
}

int Population::PickRandomIndividual(){
	srand((unsigned) time(0));
	int rand_int;
	rand_int = (rand()%(Individuals->size())) + 1;
	return rand_int;
}

Individual* Population::SelectIndividual(int TournamentSize, bool Maximising){
	Individual* most;
	Individual* least;
	Individual* tmp;
	int i;
	for(i=0;i<TournamentSize;i++){
		if(i == 0){
			most = Individuals->at(PickRandomIndividual());
			least = most;
			continue;
		}else{
			tmp = Individuals->at(PickRandomIndividual());
			if(!tmp->HasBeenEvaluated()){
				i--;
				continue;
			}
			if(tmp->GetFitness() > most->GetFitness()){
				most = tmp;
			}else if(tmp->GetFitness() < least->GetFitness()){
				least = tmp;
			}
		}
	}
	

	if(Maximising)
		return most;
	return least;
}

void Population::AddIndividual(Individual* Ind){
	Individuals->push_back(Ind);
}

void Population::CreateNextPopulation(bool Maximising){
	vector<Individual*>* tmpInd;
	tmpInd = new vector<Individual*>();

	Population::Sort(false);

	int i;
	for(i=0;i<ELITESIZE;i++){
		tmpInd->push_back(Individuals->at(i)->Clone());
	}

	/**Declare and allocate new children ...*/
	Individual* Child1;
	Individual* Child2;
	Child1 = new BinaryStringIndividual();
	Child2 = new BinaryStringIndividual();

	// "Tournament Slection" for binary tournament selection.
	tmpInd->at(0)->CrossOver(tmpInd->at(1), Child1, Child2);

	/**Mutate and store children*/
	Child1->Mutate(MUTATIONRATE);
	Child2->Mutate(MUTATIONRATE);
	tmpInd->push_back(Child1);
	tmpInd->push_back(Child2);

	Individuals->clear(); //This is the trouble code ...
}

void Population::Evaluate(FitnessFunction* FitFunc){
	vector<Individual*>::iterator iter;
	iter = Individuals->begin();
	while(iter!=Individuals->end()){
		FitFunc->Evaluate(*iter);
		iter++;
	}
}

void Population::DisplayAll(){
	vector<Individual*>::iterator iter;
	iter = Individuals->begin();
	string* tmp;
	while(iter != Individuals->end()){
		tmp = (string*) (*iter)->GetGenotype();
		(*iter)->Display();
		cout<<endl;
		iter++;
	}
}

void Population::GetStatistics(float* MaxFitness, float* MinFitness, float* AvgFitness){
	vector<Individual*>::iterator iter;
	float tot = 0.0f;
	int count = 1;
	iter = Individuals->begin();
	*MaxFitness = (*iter)->GetFitness();
	*MinFitness = *MaxFitness;
	while(iter != Individuals->end()){
		if((*iter)->GetFitness() > *MaxFitness){*MaxFitness = (*iter)->GetFitness();}else
		if((*iter)->GetFitness() < *MinFitness){*MinFitness = (*iter)->GetFitness();}
		tot += (*iter)->GetFitness();
		count++;
		iter++;
	}
	*AvgFitness = (tot/(float)count);
}


/**Compare functions for use in Population::sort() ... cmpA is for an ascending order.
and cmpD is for a descending order.
Note: non-member functions*/
bool cmpA(Individual* one, Individual* two){
	return one->GetFitness() < two->GetFitness();
}

bool cmpD(Individual* one, Individual* two){
	return one->GetFitness() > two->GetFitness();
}


output:
0       66      38      45.9091
1       66      66      0
terminate called after throwing an instance of 'std::out_of_range'
  what():  vector::_M_range_check
/bin/sh: line 1: 21977 Aborted                 ./geneticalgorithm