#include "Evaluator.h"
#include "Genetic.h"
#include <math.h>
#include <vector>
#include <omp.h>

#define DEBUG 0

using namespace std;

/**
* the default constructor
*/
TaskInfo::TaskInfo(){
	start = 0;
	end = 0;
	proc_index = -1;
}

/**
* the default constructor
*/
Evaluator::Evaluator(){}

/**
* the constructor
*
* @param TG the input graph of tasks
* @param PG the input graph of processors
*/
Evaluator::Evaluator(TaskGraf &TG, ProcesorGraf &PG){
	tasks = TG;
	procs = PG;
	
	proc_time = (int*)calloc(procs.nr_noduri , sizeof(int));
	task_info = (TaskInfo*)calloc(tasks.nr_noduri , sizeof(TaskInfo));;
	
}

/**
* Method that evaluates one chromosome, computing its makespan, fitness, etc
*
* @param ch the chromosome we want to evaluate
*/
void Evaluator::evaluateIndividual(Chromosome &ch){
	int i,j;	
	Gene g;
	int time,start,end; 	
	int cost_com, id_proc, id_task;
	tasks.init();
	procs.init();
	
	if (DEBUG == 1) 
		ch.print();
	

	//initializes the task information
	for (i=0;i<tasks.nr_noduri;i++){
		task_info[i].start = 0;
		task_info[i].end = 0;
		task_info[i].proc_index = -1;		
	}
	//initializes procesor times 
	for (i=0;i<procs.nr_noduri;i++)
		proc_time[i]=0;


	for (i=0;i<tasks.nr_noduri;i++){
		g = ch[i];
		time = proc_time[g.proc_index]; 
	
		if (DEBUG == 1) printf("P%d : time = %d\n",g.proc_index, time);
	
		if (DEBUG == 1) printf("Predecesori:\n");
	
		for (j=0;j<tasks.noduri[g.task_index].nr_pred;j++){
			cost_com = ((Muchie *)(tasks.noduri[g.task_index].predecesori[j]))->cost;
			id_task = ((Muchie *)(tasks.noduri[g.task_index].predecesori[j]))->predecesor->id;
			id_proc = task_info[id_task].proc_index; 
					
			if (DEBUG == 1) printf("T%d pe P%d - cost=%d\n",id_task,id_proc,cost_com);
		
			if (id_proc == g.proc_index)
				cost_com = 0;
			else cost_com *= procs.noduri[g.proc_index].cost_comm[id_proc];

			if (DEBUG == 1) printf("Cost comm : %d\n",cost_com);

			if (time < cost_com + task_info[id_task].end)
				time = cost_com + task_info[id_task].end;

			if (DEBUG == 1) printf("Time : %d\n",time);
	
		}
		start = time; 		
		time += tasks.noduri[g.task_index].cost * procs.noduri[g.proc_index].cost;
		end = time; 
		
		//tasks.noduri[g.task_index].setProcesor(g.proc_index,start,end);
		//procs.noduri[g.proc_index].time = time;
		//procs.noduri[g.proc_index].addTask(g.task_index);
			
		task_info[g.task_index].start = start;
		task_info[g.task_index].end = end;
		task_info[g.task_index].proc_index = g.proc_index;
		proc_time[g.proc_index]  = time;
		if (DEBUG == 1) printf("Time update on P%d : %d\n\n",g.proc_index,time);	
	}

	int makespan = proc_time[0];
	for (i=1;i<procs.nr_noduri;i++)
		if (proc_time[i] > makespan)
			makespan = proc_time[i];

	if (DEBUG == 2) printf("makespan = %d\n",makespan);
	
	ch.makespan = makespan; 

	double av = 0; 
	double min = 30000; 

	for (i=0;i<procs.nr_noduri;i++){
		av+=proc_time[i]; 
		if (proc_time[i] < min )
			min = proc_time[i];
	}

	av = av / procs.nr_noduri;
	
	ch.evalT1 = min / makespan;
	ch.evalT2 = av / makespan ;

	double delta = 0;
	for (i=0;i<procs.nr_noduri;i++){
		delta+= (av - proc_time[i])*(av - proc_time[i]);
	}
	delta = delta / procs.nr_noduri;
	ch.loadBalance = 1 - 1/av * sqrt(delta);

	if (DEBUG == 2) printf("T1 = %f  T2 = %f  LB = %f\n",ch.evalT1, ch.evalT2, ch.loadBalance);	
}

/**
* Method that evaluates one population's performance
*
* @param ch the list of chromosomes 
*/
void Evaluator::evaluatePopulation(vector<Chromosome> &chs){
	int i;
	for (i=0;i<(int)chs.size();i++){
		if (chs[i].fitness == 0) 
			evaluateIndividual(chs[i]);
	}
	
	double best = chs[0].makespan;

	for (i=0;i<(int)chs.size();i++){
		if (chs[i].makespan < best)
			best = chs[i].makespan;
	}

	for (i=0;i<(int)chs.size();i++){
		chs[i].evalT3 = best / chs[i].makespan;
		chs[i].fitness = chs[i].evalT1 * chs[i].evalT2 * chs[i].evalT3 * chs[i].evalT3 * chs[i].evalT3 ;		
		if (DEBUG == 1) printf("Fit = %f\n",chs[i].fitness);
	}
	

}