#include "adevs.h"
#include <list>
#include <iostream>
#include <cstdlib>
#include <sys/time.h>
using namespace std;
using namespace adevs;

/* A queuing problem. The generator creates jobs for the server + queue.
   The transducer counts finished jobs and reports throughput and
   turn around time. The input/output time is the Time at which
   the job was created. */

class Transducer;
class Processor;
class Generator;

Transducer* transducer;
Processor* processor;
Generator* generator;

class Transducer:
	public Model<Time>
{
	public:
		Transducer():
			Model<Time>(),job_count(0),turn_around_sum(0){}
		Time init(SimEnv<Time>* env)
		{
			/* We don't do anything on our own */
			return adevs_inf<Time>();
		}
		/* This method will never be called */
		Time update(SimEnv<Time>*){ return adevs_inf<Time>(); }
		/* Act on messages from the server */
		Time update(SimEnv<Time>* env, vector<Time>& x)
		{
			/* Add the incoming jobs to our job count */
			job_count += x.size();
			/* Add up the real turn around time */
			for (unsigned i = 0; i < x.size(); i++)
				turn_around_sum += (env->now()-x[i]).real;
			/* Wait for more input */
			return adevs_inf<Time>();
		}
		/* This won't be used */
		void fini(Time){}
		/* Print final statistics */
		void print_stats(Time now)
		{
			/* Output header */
			cout << "time,jobs,throughput,turn around" << endl;
			/* Report statistics */
			cout << now.real << " " << now.logical << "," << job_count <<
				"," << (double(job_count)/double(now.real)) <<
				"," << (double(turn_around_sum)/double(job_count)) <<
				endl;
		}
		/* Get the number of completed jobs */
		int get_job_count() const { return job_count; }
	private:
		int job_count, turn_around_sum;
};

class Processor:
	public Model<Time>
{
	public:
		Processor(int period):
			Model<Time>(),period(period),tN(adevs_inf<Time>()){}
		/* Wait for the first job */
		Time init(SimEnv<Time>*) { return adevs_inf<Time>(); }
		Time update(SimEnv<Time>* env)
		{
			/* Send the completed job to the transducer */
			env->send(this,transducer,q.front());
			/* Remove the finished job from the queue */
			q.pop_front();
			/* If we have more jobs, then schedule the next one and
			   remember when it will be finished. */
			if (!q.empty())
				return (tN = env->now()+Time(rand()%period+1,0));
			/* Otherwise wait for the next job */
			return (tN = adevs_inf<Time>());
		}
		Time update(SimEnv<Time>* env, vector<Time>& x)
		{
			/* Put new jobs into the queue */
			for (unsigned i = 0; i < x.size(); i++)
				q.push_back(x[i]);
			/* If we just finished a job, send it along */
			if (env->now() == tN)
				return update(env);
			/* Otherwise if we are busy then just keep working */
			else if (tN < adevs_inf<Time>())
				return tN;
			/* Schedule the next job */
			return env->now()+Time(rand()%period+1,0);
		}
		void fini(Time){}
	private:
		const int period;
		Time tN;
		list<Time> q;
};

class Generator:
	public Model<Time>
{
	public:
		Generator(int period):
			Model<Time>(),period(period){}
		Time init(SimEnv<Time>* env)
		{
			/* Schedule the first job. */
			return env->now()+Time(rand()%period+1,0);
		}
		Time update(SimEnv<Time>* env)
		{
			/* Send the job and schedule another one */
			env->send(this,processor,env->now());
			return env->now()+Time(rand()%period+1,0);
		}
		Time update(SimEnv<Time>*,vector<Time>&) { return adevs_inf<Time>(); }
		void fini(Time){}
	private:
		const int period;
};

int main()
{
	srand(time(NULL));
	/* Create the models */
	generator = new Generator(5);
	processor = new Processor(4);
	transducer = new Transducer();
	/* Create a simulator */
	Simulator<Time> sim;
	/* Add the models to the simulator */
	sim.add(generator);
	sim.add(processor);
	sim.add(transducer);
	/* Run the simulation until we've seen enough jobs */
	while (transducer->get_job_count() < 100000)
		sim.exec_next_event();
	/* Report the results */
	transducer->print_stats(sim.now());
	/* Cleanup */
	delete generator;
	delete processor;
	delete transducer;
	return 0;
}