#include <iostream.h>
#include <fstream.h>
#include <cstdlib>
#include <math.h>


#define NUM_PKTS	10000
#define lambda		0.95
#define mu			0.98
#define DEBUG		0
#define NUM_SIMS	10


struct Packet_node {
	int pktnumber;
	double pktarrivaltime;
	double pktserviceduration;
	double pktstartservicetime;
	double pktdeparturetime;
};

Packet_node PacketArray[NUM_PKTS+1];
int QLengthArray[NUM_PKTS+1];


void initPacketArray() {

	double urv1 = 0.0;				// uniform random variate for inter-arrival times
	double urv2 = 0.0;				// uniform random variate for service times
	double iat = 0.0;				// inter-arrival time
	double st = 0.0;				// service time
	srand(162);						// seed for random number generator
	
	PacketArray[1].pktnumber = 1;
	urv1 = (double)rand()/RAND_MAX;
	iat = -log(urv1)/lambda;
	urv2 = (double)rand()/RAND_MAX;
	PacketArray[1].pktarrivaltime = iat;
	PacketArray[1].pktserviceduration = -log(urv2)/mu;

	for (int i = 2; i <= NUM_PKTS; i++) {

		PacketArray[i].pktnumber = i;
		
		// set arrival time
		urv1 = (double)rand()/RAND_MAX;
		iat = -log(urv1)/lambda;
		PacketArray[i].pktarrivaltime = PacketArray[i-1].pktarrivaltime + iat;

		// set service time
		urv2 = (double)rand()/RAND_MAX;
		PacketArray[i].pktserviceduration = -log(urv2)/mu;

	}


}


void showPacketArray() {

	ofstream fout;
	fout.open("output.txt");
	
	if (DEBUG) {
		for (int i = 1; i <= NUM_PKTS; i++) {
			cout << "\n\nPacket node " << i << "\n---------------\n";
			fout << "\n\nPacket node " << i << "\n---------------\n";
			cout << "Packet Number: " << PacketArray[i].pktnumber << "\n";
			fout << "Packet Number: " << PacketArray[i].pktnumber << "\n";
			cout << "Arrival Time : " << PacketArray[i].pktarrivaltime << "\n";
			fout << "Arrival Time : " << PacketArray[i].pktarrivaltime << "\n";
			cout << "Svc Duration : " << PacketArray[i].pktserviceduration << "\n";
			fout << "Svc Duration : " << PacketArray[i].pktserviceduration << "\n";
			cout << "Svc Start Tm : " << PacketArray[i].pktstartservicetime << "\n";
			fout << "Svc Start Tm : " << PacketArray[i].pktstartservicetime << "\n";
			cout << "Departure Tm : " << PacketArray[i].pktdeparturetime << "\n";
			fout << "Departure Tm : " << PacketArray[i].pktdeparturetime << "\n";
			cout << "Queue Length : " << QLengthArray[i] << "\n\n";
			fout << "Queue Length : " << QLengthArray[i] << "\n\n";
		}
	}

	fout.flush();
	fout.close();

}



void runSimulation() {

	ofstream fout2;
	fout2.open("debug.txt");
	
	int arrivalpktnumber = 1;
	int inservicepktnumber = 1;
	PacketArray[1].pktstartservicetime = PacketArray[1].pktarrivaltime;
	PacketArray[1].pktdeparturetime = PacketArray[1].pktstartservicetime + PacketArray[1].pktserviceduration;
	
	for (arrivalpktnumber = 2; arrivalpktnumber <= NUM_PKTS; arrivalpktnumber++) {

		QLengthArray[arrivalpktnumber] = QLengthArray[arrivalpktnumber - 1] + 1;
		
		if (DEBUG) {
			cout << "\n---------------------------------------------------------\n";
			cout << "Arrival packet number is             : " << arrivalpktnumber << "\n";
			cout << "Packet being serviced is             : " << inservicepktnumber << "\n";
			cout << "Queuelength at arrival of this pkt is: " << QLengthArray[arrivalpktnumber] << "\n";
			fout2 << "\n---------------------------------------------------------\n";
			fout2 << "Arrival packet number is             : " << arrivalpktnumber << "\n";
			fout2 << "Packet being serviced is             : " << inservicepktnumber << "\n";
			fout2 << "Queuelength at arrival of this pkt is: " << QLengthArray[arrivalpktnumber] << "\n";
		}
		
		
		/* 
		if arriving packet arrives before departure time of packet being serviced, 
			put it in queue
		else if arriving packet arrives after current packet being serviced departs,
			
			1) start servicing the next packet
			
			2) if there was a queue, 
				 decrease its length
				 set the start service time of new pkt being serviced to departure time of the previous pkt
					that was serviced, unless that was before arrival time, in which case, it is served 
					when it arrives.			
			   else if no queue
				 set the start service time of new pkt being serviced to its arrival time
				
			3) set departure time for new pkt = startsvctime + svcduration

		*/

		if (PacketArray[arrivalpktnumber].pktarrivaltime < PacketArray[inservicepktnumber].pktdeparturetime) {
		
//			QLengthArray[arrivalpktnumber]++;
			if (DEBUG) {
				cout << "arrival time of pkt " << arrivalpktnumber << " less than dep tiem of pkt " << inservicepktnumber << "\n";
				cout << "queue length is now " << QLengthArray[arrivalpktnumber] << "\n";
				fout2 << "arrival time of pkt " << arrivalpktnumber << " less than dep tiem of pkt " << inservicepktnumber << "\n";
				fout2 << "queue length is now " << QLengthArray[arrivalpktnumber] << "\n";
				}


		} else {
			
			if (DEBUG) {
				cout << "arrival time of pkt " << arrivalpktnumber << " NOT less than dep tiem of pkt " << inservicepktnumber << "\n";
				fout2 << "arrival time of pkt " << arrivalpktnumber << " NOT less than dep tiem of pkt " << inservicepktnumber << "\n";
			}

			inservicepktnumber++;

			if (DEBUG) {
				cout << "pkt being serviced is now: " << inservicepktnumber << "\n";
				fout2 << "pkt being serviced is now: " << inservicepktnumber << "\n";
			}


			if (--QLengthArray[arrivalpktnumber] > 0) {
				//QLengthArray[arrivalpktnumber]--;
				PacketArray[inservicepktnumber].pktstartservicetime = PacketArray[inservicepktnumber - 1].pktdeparturetime;
				if (PacketArray[inservicepktnumber].pktstartservicetime < PacketArray[inservicepktnumber].pktarrivaltime) {
					PacketArray[inservicepktnumber].pktstartservicetime = PacketArray[inservicepktnumber].pktarrivaltime;
				} 
			} else {
				PacketArray[inservicepktnumber].pktstartservicetime = PacketArray[inservicepktnumber].pktarrivaltime;
			}

			PacketArray[inservicepktnumber].pktdeparturetime = PacketArray[inservicepktnumber].pktstartservicetime \
															   +  PacketArray[inservicepktnumber].pktserviceduration;

			if (DEBUG) {
				cout << "queue length is now " << QLengthArray[arrivalpktnumber] << "\n";
				fout2 << "queue length is now " << QLengthArray[arrivalpktnumber] << "\n";
			}

		}

	}

	// now that the packets are all arrived, run through and finish the processing
	//  for the remaining packets in queue

	for (int i = inservicepktnumber; i <= NUM_PKTS; i++) {
		QLengthArray[inservicepktnumber] = QLengthArray[inservicepktnumber] + 1;
		inservicepktnumber++;
		PacketArray[inservicepktnumber].pktstartservicetime = PacketArray[inservicepktnumber - 1].pktdeparturetime;
		PacketArray[inservicepktnumber].pktdeparturetime = PacketArray[inservicepktnumber].pktstartservicetime \
														   + PacketArray[inservicepktnumber].pktserviceduration;
	}

	
	fout2.flush();
	fout2.close();


}


void doAnalysis() {
	
	ofstream fout3;
	fout3.open("results.txt");
//	fout3.open("results.xls");
	
	double utilization;
	double meantimeinqueue;
	double totaltimeinqueue;
	double meantimeinsystem;
	double totaltimeinsystem;
	double meannumberinqueue;

	utilization = 0;
	meantimeinqueue = 0;
	totaltimeinqueue = 0;
	meantimeinsystem = 0;
	totaltimeinsystem = 0;
	meannumberinqueue = 0;


	utilization = lambda/mu;

	for (int i = 1; i <= NUM_PKTS; i++) {
		totaltimeinqueue += (PacketArray[i].pktstartservicetime - PacketArray[i].pktarrivaltime);
		totaltimeinsystem += (PacketArray[i].pktdeparturetime - PacketArray[i].pktarrivaltime);
		fout3 << QLengthArray[i] << "\n";
	}
	meantimeinqueue = totaltimeinqueue / NUM_PKTS;
	meantimeinsystem = totaltimeinsystem / NUM_PKTS;

	
	
	cout << "Actual mean time in queue    : " << meantimeinqueue << "\n";
	cout << "Expected mean time in que    : " << utilization/(mu - lambda) << "\n\n";
	
	cout << "Actual mean time in system   : " << meantimeinsystem << "\n";
	cout << "Expected mean time in system : " << (1/(mu - lambda)) << "\n\n";

	fout3.flush();
	fout3.close();

}




void main() {
	
	initPacketArray();
	runSimulation();
	doAnalysis();
	showPacketArray();
	
}