/*******************************************************
   Proj2.cpp
   CMSC-341  Spring 2004 Project 2 
   Spencer Shimko, Section 001, sshimko1 
   Created:  29 February 2004
   Current:  29 February 2004

   ServiceQueue main{} 
   	main for priority based service queue
*********************************************************/
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <stdlib.h>
#include <vector>
#include "ServiceQueue.h"
#include "Server.h"
#include "Job.h"

using namespace std;

/* main
 * driver for priority queue project
 * should be more divided 
 */
int main(int argc, const char* argv[]){
	
	const char* USAGE = "Usage: ./Proj2 simfile";

	struct {
		unsigned seed;
		int serverNo;
		double p1;
		double p2;
		int smallService;
		int largeService;
		int switchPoint;
		int simuTime;
	} lineIn;
			
	// per simulation stats
	struct {
		int totalSmall;
		int totalLarge;
		double avgSmall;
		double avgLarge;
		int longWait;
		int maxQueue;
		double avgIdle;
	} stats;

	// verify command line arguments
	if (argc == 2){

		// open/test file 
		ifstream sFile(argv[1],ios::in);			

		// if file did not open properly display error and die
		if ( !sFile ){
			cout << "INVALID FILENAME!" << endl;
			cout << USAGE << endl;
			return 1;
		}else{// else file opened ok so continue processing

			ServiceQueue < Job > serQ; // construct queue structure		
			vector < Server > serVAct; // construct vector for active servers
			vector < Server > serVIdl; // construct vector for idle servers
			double rn; // random number for job creation
			int simcnt = 0; // number of sims ran
			int cnt = 0; // runtime per sim

			// read input into lineIn struct
			// loop while we have input
			while (
			sFile >> lineIn.seed >> lineIn.serverNo >> lineIn.p1
				>> lineIn.p2 >> lineIn.smallService >> lineIn.largeService
				>> lineIn.switchPoint >> lineIn.simuTime
			){
				// per simulation stats
				stats.totalSmall = 0;
				stats.totalLarge = 0;
				stats.avgSmall = 0.0;
				stats.avgLarge = 0.0;
				stats.longWait = 0;
				stats.maxQueue = 0;
				stats.avgIdle = 0.0;

				simcnt++; // inc simulation count

				// seed rand # generator
				srand(lineIn.seed);

				// fill idle server vector
				for (int x = 1; x <= lineIn.serverNo; x++)
				{
					Server s;
					serVIdl.push_back ( s );
				}

				for ( int x = 1 ; x <= lineIn.simuTime ; x++ )
				{
					rn = rand ( )/ (double) RAND_MAX;	
					if ( lineIn.p1 <= rn )
					{
						// create new small job that runs for 
						// smallService time and was created 
						// at time x in simulation
						Job *j = new Job( SMALL_J, lineIn.smallService, x ); 
						serQ.enqueue ( *j );
					} else if ( rn < ( lineIn.p2 + lineIn.p1 ) )
					{


						// create new large job that runs for 
						// largeService time and was created 
						// at time x in simulation
						Job* j = new Job( LARGE_J, lineIn.largeService, x ); 
						serQ.enqueue ( *j );
					}

					int y = 0; // index
					// iterate through idle servers and increment idle time
					for ( vector < Server >::iterator i = serVIdl.begin ( );
i!= serVIdl.end ( ); i++ )
                                        {
							serVIdl.at(y).incSIdle ( );
							y++;
					}	 					

					y = 0; // reset int index
					// iterate through busy servers and handle tasks
					for ( vector < Server >::iterator i = serVAct.begin ( ); i != serVAct.end ( ); i++)
					{
						// decrement job time remaining
						serVAct.at(y).getJob ( ).decJTime ( );
					
						// find complete jobs and swap b/twn vectors 
						if ( serVAct.at(y).getJob ( ).getJTime ( ) == 0 )
						{		
							serVIdl.push_back(serVAct.at (y) );
							serVAct.erase(i);
						}		
						y++; //inc index
					}	 					

					// while there are jobs to serve and idle servers
					if ( (!serQ.isEmpty ( )) && (!serVIdl.empty ( ) ) )
					{
						// move server from idle to active vector
						serVAct.push_back(serVIdl.back ( ) );
						serVIdl.pop_back ( );
						
						int temp =  serQ.getSize ( );
						
						// check queue size against max in stats
						if (temp > stats.maxQueue)
							stats.maxQueue = temp;
						// if the switch point is past prioritize
						if ( (lineIn.switchPoint >= temp) )
						{
							serVAct.back ( ).setJob ( serQ.dequeuePr ( ));
							// check wait time against stats
							if ( (cnt - (serVAct.back ( ).getJob ( ).getCTime ( )) > stats.longWait ))
								stats.longWait = (cnt - (serVAct.back ( ).getJob ( ).getCTime ( )));
						} else // normal dequeue
						{
							serVAct.back ( ).setJob ( serQ.dequeue ( ));
							// check wait time against stats
                                                        if ( (cnt - (serVAct.back ( ).getJob ( ).getCTime ( )) > stats.longWait ))

                                                                stats.longWait = (cnt - (serVAct.back( ).getJob ( ).getCTime ( )));
 

						}
						// increment stats counts
						if (serVAct.back ( ).getJob (
).getJType ( ) == SMALL_J)
						{
							stats.totalSmall++;
						}
						else
							stats.totalLarge++;
				
					}
					cnt = x;
				}

				// finish waiting jobs
				// 
				while ( (!serQ.isEmpty ( )) || (!serVAct.empty ( )) )
				{
					int y=0 ; //reset int index
                                        // iterate through idle servers and increment idle time
                                        for ( vector < Server >::iterator i = serVIdl.begin ( ); i!= serVIdl.end ( ); i++)
                                        {
                                                        serVIdl.at(y).incSIdle ( );
						y++; //inc int index
                                        }

					y=0; //reset int index
                                        // iterate through busy servers and handle tasks
                                        for ( vector < Server >::iterator i = serVAct.begin ( ); i
!= serVAct.end ( ); i++)
                                        {
                                              // decrement job time remaining
                                                serVAct.at(y).getJob ( ).decJTime ( );

                                                // find complete jobs and swap b/twn vectors
                                                if ( serVAct.at(y).getJob ( ).getJTime ( ) == 0 )
                                                {
                                                        serVIdl.push_back(serVAct.at (y) );
                                                        serVAct.erase(i);
                                                }
						y++; //inc int index
                                        }
                                        // while there are jobs to serve and idle servers
                                        if ( (!serQ.isEmpty ( )) && (!serVIdl.empty ( ) ) )
                                        {
                                                // move server from idle to active vector
                                                serVAct.push_back(serVIdl.back ( ) );
						serVIdl.pop_back ( );

                                                // if the switch point is past prioritize
                                                if ( (lineIn.switchPoint >= serQ.getSize ( )) )
                                                {
                                                        serVAct.back ( ).setJob ( serQ.dequeuePr ());
                                                       // check wait time against stats
                                                        if ( (cnt - (serVAct.back ( ).getJob ( ).getCTime ( )) > stats.longWait ))
                                                                stats.longWait = (cnt - (serVAct.back( ).getJob ( ).getCTime ( )));
 

                                                } else // normal dequeue
                                                        serVAct.back ( ).setJob ( serQ.dequeue ( ));

                                                       // check wait time against stats
                                                        if ( (cnt - (serVAct.back ( ).getJob ( ).getCTime ( )) > stats.longWait ))
                                                                stats.longWait = (cnt - (serVAct.back ( ).getJob ( ).getCTime ( )));



                                        }
					cnt ++;
				}
			
				int y=0 ;//reset int index
				for ( vector < Server >::iterator i = serVIdl.begin ( ); i!= serVIdl.end ( ); i++)
				{
					stats.avgIdle += serVIdl.at(y).getSIdle
( );	
					y++; //inc int index
				}
				stats.avgIdle = stats.avgIdle/(stats.totalSmall+stats.totalLarge);
				
				// display stats
				cout << "=================================" << endl;
				cout << "Simulation #: " << simcnt << endl << endl;
				cout << "Seed: " << lineIn.seed << endl;
				cout << "Sim. Time: " << lineIn.simuTime << endl;
				cout << "Switch Point: " << lineIn.switchPoint <<endl;
				cout << "P1: " << lineIn.p1 << endl;
				cout << "P2: " << lineIn.p2 << endl;
				cout << "Small Service Time: " << lineIn.smallService << endl;
				cout << "Large Service Time: " << lineIn.largeService << endl;
				cout << "---------------------------------"<< endl;		
				cout << "Total Small Jobs: " << stats.totalSmall << endl;
				cout << "Total Large Jobs: " << stats.totalLarge << endl;
				cout << "Average Small Wait: " << stats.avgSmall/stats.totalSmall << endl;
				cout << "Average Large Wait: " << stats.avgLarge/stats.totalLarge << endl;
				cout << "Longest wait: " << stats.longWait << endl;
				cout << "Average Server Idle: " << stats.avgIdle << endl;
	
			}
			// destroy and free server vector
			serVIdl.~vector < Server > ( );
			// destroy and free servicequeue
			serQ.~ServiceQueue < Job > ( );

			// close simulation file
			sFile.close ( );
		}		
	
	// else incorrect number of command line arguments
	} else{
		//print error/usage and exit
		cout << USAGE << endl;
		return 1;
	} 
	
	// run successful
	return 0;
}