#include "sched_rr.h"
#include "basesched.h"

using namespace std;

SchedRR::SchedRR(vector<int> argn) {
	// Round robin recibe la cantidad de cores y sus cpu_quantum por parámetro
	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(uint cur_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;
	uint cur_pid = current_pid(cpu);

	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:
		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) {
		// Implementación simple, se puede usar current_remaining(cpu) para ver
		// si conviene cambiar de nucleo, y/o ver cuanto es el precio de migrar
		cur_pid = next_pid(cur_pid);
		p_map[cur_pid].state = RUNNING;
	}

	return cur_pid;
}