/*
Napisati konkurentni program koji simulira prioritetni rasporedjivac
u jednoprocesorskom sistemu. Procesi su predstavljeni nitima. Da bi se izvrsili pozivaju
metodu izvrsi deljene promenljive tipa Rasporedjivac.
Svaki proces sadrzi odredjeni broj naredbi.
Naredbe se izvrsavaju jedna po jedna. Za svaku naredbu, proces mora da saceka da procesor bude slobodan.
Izvrsavanje jedne naredbe traje 300 ms. Nakon izvrsavanja naredbe,
proces odlazi u stanje spreman, a drugi spreman proces dobija procesor.
Procesi su klasifikovani prema prioritetu.
Za svaki prioritet, postoji odvojen red cekanja na procesor.
Prednost u koriscenju procesora imaju procesi sa visim prioritetom.
Medju procesima istog prioriteta, rasporedjivanje se obavlja po FIFO principu.

Prioritet procesa je odredjen staticki u trenutku kreiranja procesa.

Na kraju izvrsavanja svake naredbe proces treba da ispise:
Proces X izvrsio naredbu broj Y.

Napomena: Za uspostavljanje reda cekanja po FIFO principu koristiti datu klasu cv_hrono
*/

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <deque>
#include <vector>
using namespace std;
using namespace chrono;




/*
#####################################################################################################################
#####################################################################################################################
#####################################################################################################################
*/



class cv_chrono {
	struct cv_pair {
		condition_variable cv;
		bool fulfilled;
		cv_pair() : fulfilled(false) {}
	};
	deque<cv_pair*> ccv;

public:

	void wait(unique_lock<mutex>& lock)
	{
		cv_pair* pair = new cv_pair;
		ccv.push_back(pair);
		while (!pair->fulfilled)
			pair->cv.wait(lock);
		while (ccv.front() != pair)
		{
			lock.unlock();
			this_thread::yield();
			lock.lock();
		}
		ccv.pop_front();
		delete pair;
	}

	cv_status wait_for(unique_lock<mutex>& lock, int sekundi)
	{
		cv_pair* pair = new cv_pair;
		ccv.push_back(pair);
		cv_status status;
		while (!pair->fulfilled) {
			status = pair->cv.wait_for(lock, seconds(sekundi));
			if (status == cv_status::timeout) {
				break;
			}
		}
		ccv.pop_front();
		delete pair;
		return status;
	}

	bool notify_one()
	{
		if (ccv.empty())
			return false;
		ccv.front()->fulfilled = true;
		ccv.front()->cv.notify_one();
		return true;
	}

	void notify_all()
	{
		for (auto i = ccv.begin(); i != ccv.end(); ++i) {
			(*i)->fulfilled = true;
			(*i)->cv.notify_one();
		}
	}
};



/*
#####################################################################################################################
#####################################################################################################################
#####################################################################################################################
*/


mutex term_m;
mutex m;
class Rasporedjivac {
public:
	int brPr;
	vector<cv_chrono> cv;
	bool zauzet = false;
	vector<int> cek;
	condition_variable triger;

	Rasporedjivac(int broj_nivoa_prioriteta) : brPr(broj_nivoa_prioriteta) { cv = vector<cv_chrono>(broj_nivoa_prioriteta); cek = vector<int>(broj_nivoa_prioriteta); }
	void izvrsi(int id_procesa, int broj_naredbi, int prioritet)
	{
		for (int i = 0; i < broj_naredbi; ++i)
		{
			unique_lock<mutex> l(m);
			if (zauzet)
			{
				cek[prioritet]++;
				cv[prioritet].wait(l);
				cek[prioritet]--;
			}
			zauzet = true;
			l.unlock();
			this_thread::sleep_for(seconds(1));
			l.lock();
			{
				cout << "proces " << id_procesa << " prioriteta " << prioritet << " svrsi ti u usta naredbo " << i + 1 << endl;
				unique_lock<mutex> l(term_m);
			}
			triger.notify_one();
			zauzet = false;
			cek[prioritet]++;
			cv[prioritet].wait(l);
		}
	}
};


const int BROJ_PROCESA = 5;
const int BROJ_PRIORITETA = 3;

void proces(Rasporedjivac& r, int id_procesa, int broj_naredbi) {
	int prioritet = rand() % BROJ_PRIORITETA;
	{
		unique_lock<mutex> l(term_m);
		cout << "Kreira se proces " << id_procesa << " prioriteta " <<
			prioritet << " sa brojem naredbi " << broj_naredbi << endl;
	}
	r.izvrsi(id_procesa, broj_naredbi, prioritet);
	unique_lock<mutex> l(term_m);
	cout << "Proces " << id_procesa << " sa prioritetom " <<
		prioritet << " se zavrsio." << endl;
}

void t(Rasporedjivac& r)
{
	while (true)
	{
		unique_lock<mutex> l(m);
		r.triger.wait(l);
		for (int i = 0; i < r.brPr; i++) {
			if (r.cek[i] > 0) {
				r.cv[i].notify_one();
				break;
			}
		}
	}
}
int main() {
	srand(time(NULL));

	Rasporedjivac r(BROJ_PRIORITETA);
	thread procesi[BROJ_PROCESA];
	thread tr = thread(t, ref(r));
	for (int i = 0; i < BROJ_PROCESA; i++)
		procesi[i] = thread(proces, ref(r), i + 1, rand() % 10 + 1);

	for (int i = 0; i < BROJ_PROCESA; i++)
		procesi[i].join();

	tr.detach();
}