#include <map>
#include <queue>
#include "sched_rr.h"
#include "basesched.h"
#include <iostream>

using namespace std;

SchedRR::SchedRR(vector<int> argn) {
	// Round robin recibe la cantidad de cores y sus cpu_quantum por parámetro
	cur_pid = IDLE_TASK;
	nucleos = argn[1];
	quantums = new uint[nucleos];

	for (int i = 0; i < nucleos; i++) {
		quantums[i] = argn[i+2];
	}
}

SchedRR::~SchedRR() {
	p_map.clear();
	delete [] quantums;
}

void SchedRR::load(int pid) {
	p_map[pid].state=READY;
}

void SchedRR::unblock(int pid) {
	p_map[pid].state=READY;
}

int SchedRR::next_pid() {
	// Hasta el fin de la 'lista', hay alguno listo?
	for(it_type it = ++p_map.find(cur_pid); it != p_map.end(); it++) {
		if (it->first == IDLE_TASK)
			continue;

		if (it->second.state == READY)
			return it->first;
	}

	// Desde el inicio hasta donde estaba, hay alguno listo?
	for(it_type it = p_map.begin(); it != p_map.find(cur_pid); it++) {
		if (it->first == IDLE_TASK)
			continue;

		if (it->second.state == READY)
			return it->first;
	}

	if (p_map[cur_pid].state == READY)
		return cur_pid;

	return IDLE_TASK;
}

int SchedRR::tick(int cpu, const enum Motivo m) {
	uint switch_process=0;

	for (int i == 0; i<nucleos; i++) {
		uint current = current_pid(
	}

	switch(m) {
		case TICK:
			p_map[cur_pid].quantum_count++;
			break;
		case BLOCK:
			switch_process=1;
			p_map[cur_pid].state=BLOCKED;
			break;
		case EXIT:
			switch_process=1;
			p_map.erase(cur_pid);
			cur_pid=IDLE_TASK;
			break;
	}

	if (cur_pid==IDLE_TASK)
		switch_process=1;

	if (p_map[cur_pid].quantum_count>=quantums[cpu]) {
		switch_process=1;
		p_map[cur_pid].state=READY;
		p_map[cur_pid].quantum_count=0;
	}

	if (switch_process) {
		cur_pid=next_pid();
		p_map[cur_pid].state=RUNNING;
	}
	
	return cur_pid;
}