#include "Population.hpp"
#include "Individual.hpp"

#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <algorithm>
#include <random>

using namespace std;

Population::Population(int nobj){
    _nobj = nobj;
}

Population::~Population(){
    // No need to delete much, at least as of now..
}

void Population::fromStream(istream & ist, const IndividualReader * rdr){
    while (!ist.eof()){
        _individuals.push_back(unique_ptr<Individual>(rdr->fromStream(ist)));
        while (!ist.eof() && isspace(ist.peek())){ist.get();} // skip whitespace.
    }
}

void Population::toStream(ostream & ost) const {
    for (size_t i = 0; i<_individuals.size(); ++i){
        _individuals[i]->toStream(ost); ost << endl;
    }
}

double Population::getObjectiveValue (int individualIndex, int objectiveIndex) const
{
    if (individualIndex >= (int)_individuals.size()) {
        cerr << "They want obj " << individualIndex << " " << objectiveIndex << " " << endl;
        cerr << "We have only " << _individuals.size() << " individuals." << endl;
    }
    return _individuals[individualIndex]->getObjective(objectiveIndex);
}

vector<double>
Population::getTrace (int individualIndex) const{
    return _individuals[individualIndex]->getTrace();
}


size_t Population::size() const {return _individuals.size();}

int Population::getIndividualID (int individualIndex) const{
    return _individuals[individualIndex]->getId();
}

void Population::setIndividualID (int individualIndex, int newID){
    _individuals[individualIndex]->setId(newID);
}

void Population::evaluate(){
    for (auto& indiv : _individuals) indiv->evaluate();
}

void Population::mutate(){
    for (auto& indiv : _individuals) indiv->mutate();
}

void Population::improve(mt19937 * mt){
    for (auto& indiv : _individuals){
        indiv->improve(mt);
    }
}

int Population::binaryTournament(int ii1, int ii2, mt19937 * mt){
    return _individuals[ii1]->
        winsTournamentAgainst(*_individuals[ii2], mt)?ii1:ii2;
}

void Population::adopt(unique_ptr<Individual> indiv){
    _individuals.push_back(move(indiv));
}

void Population::adoptFrom(Population & p1)
{
    for (auto& indiv : p1._individuals) {
        _individuals.push_back(move(indiv));
    }
}

void Population::adoptFromTwo(Population &p1, Population &p2){
    adoptFrom(p1);
    adoptFrom(p2);
}

void Population::deepCopyFrom(Population & p1)
{
    for (auto& indiv : p1._individuals) {
        _individuals.push_back(unique_ptr<Individual>(indiv->clone()));
    }
}

void Population::clear()
{
    _individuals.clear();
}