#include <iostream>
#include <iomanip>
#include <fstream>
#include <cctype>
#include <cstdlib>
#include <string>
#define MAXJOBS 50

using namespace std;

//help message
static char *help = "jseq stages rule inputfile \n\
	stages = 1 or 2, the number of work centers or process stages\n\
	rule   = job sequencing rule:\n\
		F (first-come, first served, 1-stage)\n\
		S (shortest processing time first, 1-stage)\n\
		E (earliest due date, 1-stage)\n\
		C (critical ratio, 1-stage)\n\
		R (slack time remaining, 1-stage)\n\
		A all rules for 1-stage problem\n\
		J (Johnson's rule, 2-stage)\n\
		X (Johnson's rule with due dates, 2-stage)\n\
		P (Palmer's method, multi-stage)\n\
	file   = name of text input file, one job per line, in form:\n\
		jobname processTime dueDate    (1-stage problems)\n\
		jobname stage1time stage2time  (2-stage problems)\n\
	jobnames are 1-8 characters (no blanks), times and due dates are integers.";

//structures
	struct onestage
	{
		string name;
		float time;
		float due;
	};

	struct twostage
	{
		string name;
		float s1;
		float s2;
	};

	struct johnson2
	{
		string name;
		float s1;
		float s2;
		float due;
	};

//functions
int inputA(onestage [], int, char * []);
void outputA(onestage [], int, char);
void first(onestage [], int &, float &, float &, float &, float &, float &);
void shortest(onestage [], int &, float &, float &, float &, float &, float &);
void earliest(onestage [], int &, float &, float &, float &, float &, float &);
void critical(onestage [], int &, float &, float &, float &, float &, float &);
void slack(onestage [], int &, float &, float &, float &, float &, float &);
void all(onestage [], int);
void header(char);
void PrintTitle(float, char, int);
int inputJ(twostage [], char * []);
int inputJ2(johnson2 [], char * []);
void calculationJ(twostage [], int, int []);
void calculationJ2(johnson2 [], int, int []);
void displayJ(twostage [], int [], int);
void displayJ2(johnson2 [], int [], int);


int main(int argc, char * argv[])
{
	onestage job1[MAXJOBS];
	twostage job2[MAXJOBS];
	johnson2 jobs[MAXJOBS];
	int n=0;
	char choice;
	int stages;

	//Check to see if there are four arguments
	if(argc != 4)
		{cout<<help<<endl;
		exit(1);
		}

	//Get stages, rule, and number of jobs
	stages= atoi(argv[1]);
	choice= *argv[2];

	if(stages==1)
		{n=inputA(job1, n, argv);

		//Call title function
		PrintTitle(n, choice, stages);

		//Call output function
		outputA(job1, n, choice);
		}
	else if(stages==2)
		{
		if(toupper(choice)=='J')
			{n=inputJ(job2, argv);
			
			PrintTitle(n, choice, stages);

			int arr[n];
			
			calculationJ(job2, n, arr);

			displayJ(job2, arr, n);
			}
		else if(toupper(choice)=='X')
			{n=inputJ2(jobs, argv);

			PrintTitle(n, choice, stages);

			int arr[n];

			calculationJ2(jobs, n, arr);

			displayJ2(jobs, arr, n);
			}
		}

return 0;
}

//Print Title Function
void PrintTitle(float n, char choice, int stages)
{
	//Print stages, jobs, and rule
	cout<<endl<<"==================="<<endl;
	cout<<"JOB SHOP Scheduling"<<endl;
	cout<<"==================="<<endl;
	cout<<"Stages:"<<setw(5)<<stages<<endl;
	cout<<"Jobs:"<<setw(7)<<n<<endl;
	cout<<"Rule:      ";
	if(toupper(choice)=='F')
		cout<<"First Come, First Served"<<endl<<endl;
	else if(toupper(choice)=='S')
		cout<<"Shortest Processing Time"<<endl<<endl;
	else if(toupper(choice)=='E')
		cout<<"Earliest Due Date"<<endl<<endl;
	else if(toupper(choice)=='C')
		cout<<"Critical Ratio Rule"<<endl<<endl;
	else if(toupper(choice)=='R')
		cout<<"Slack Time Remaining"<<endl<<endl;
	else if(toupper(choice)=='A')
		cout<<"All Rules"<<endl<<endl;
	else if(toupper(choice)=='J')
		cout<<"Johnson's Rule"<<endl<<endl;
	else if(toupper(choice)=='X')
		cout<<"Johnson's Rule with Due Dates"<<endl<<endl;
	else if(toupper(choice)=='P')
		cout<<"Palmer's Method"<<endl<<endl;
	else
		{cout<<endl<<"ERROR: The rule should be one of the following:"<<endl;
		cout<<"F= First Come, First Served"<<endl;
		cout<<"S= Shortest Processing Time"<<endl;
		cout<<"E= Earliest Due Date"<<endl;
		cout<<"C= Critical Ratio Rule"<<endl;
		cout<<"R= Slack Time Remaining"<<endl;
		cout<<"A= All One Stage Rules"<<endl;
		cout<<"J= Johnson's Rule"<<endl;
		cout<<"X= Johnson's Rule with Due Dates"<<endl;
		exit(1);
		}
}




//One Stage Input Function
int inputA(onestage job1[], int count, char *argv[])
{
	//Declare count
	count=0;

	//Declare infile as an ifstream and open it
	ifstream infile;
	infile.open(argv[3]);

	//Check to see if infile exists
	if(infile.fail())
		{cout<<"Error opening file!"<<endl;
		exit(1);
		}

	//Get initial data from file
	char input[81];
	infile.getline(input, 81, '\n');

	const char delimiters[]=" ";
	char *token;
	char jobID[8];

	//Get rest of data
	while(!infile.eof())
		{
		int length=strlen(input);

		if(token= strtok(input, delimiters))
			{for(int x=0; x<8; x++)
				{jobID[x]=*token;
				token++;
				}
			string temp(jobID, 0, 8);
			job1[count].name=temp;
			}
		else
			{cout<<help<<endl;
			exit(1);
			}
		
		if(token=strtok(NULL, delimiters))
			{job1[count].time=atof(token);
				if(job1[count].time<1)
					{cout<<help<<endl;
					exit(1);
					}						
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		if(token=strtok(NULL, delimiters))
			{job1[count].due=atof(token);
				if(job1[count].due<1)
					{cout<<help<<endl;
					exit(1);
					}
			}
		else
			{cout<<help<<endl;
			exit(1);
			}
		

		infile.getline(input, 81, '\n');
		count++;
		}
	return count;
}

//One Stage Output Function
void outputA(onestage job1[], int n, char choice)
{
	float flow=0;
	float tardy=0;
	float totalflow=0;
	float totaltardy=0;
	float numtardy=0;

	//Call job function according to choice
	if(toupper(choice)=='F')
		first(job1, n, flow, tardy, totalflow, totaltardy, numtardy);
	else if(toupper(choice)=='S')
		shortest(job1, n, flow, tardy, totalflow, totaltardy, numtardy);
	else if(toupper(choice)=='E')
		earliest(job1, n, flow, tardy, totalflow, totaltardy, numtardy);
	else if(toupper(choice)=='C')
		critical(job1, n, flow, tardy, totalflow, totaltardy, numtardy);
	else if(toupper(choice)=='R')
		slack(job1, n, flow, tardy, totalflow, totaltardy, numtardy);
	else if(toupper(choice)=='A')
		all(job1, n);

	if(toupper(choice)!='A')
		{
		cout<<"     ---    ----    ----    ----    ---------";
	
		if(toupper(choice)=='C')
			cout<<"    -----";
		else if(toupper(choice)=='R')
			cout<<"    ---------";
		cout<<endl;

		//Display the sum of the flow time and sum of the tardy jobs
		cout<<setw(24)<<totalflow<<setw(21)<<totaltardy<<endl<<endl<<endl;
	
		//Calculate the percentage of jobs that are tardy
		float percenttardy=(numtardy/n)*100;
	
		//Display totals
		cout<<"Number of Jobs:"<<setprecision(2)<<fixed<<showpoint<<setw(16)<<n<<endl;
		cout<<"Total Flow Time:"<<setw(15)<<totalflow<<endl;
		cout<<"Average Flow Time:"<<setw(13)<<(totalflow/n)<<endl;
		cout<<"Makespan:"<<setw(22)<<flow<<endl;
		cout<<"Average Jobs in System:"<<setw(8)<<(totalflow/flow)<<endl;
		cout<<"Number of Tardy Jobs:"<<setw(10)<<numtardy<<setw(5)<<"("<<percenttardy<<"%)"<<endl;
		cout<<"Average Lateness:"<<setw(14)<<(totaltardy/n)<<endl;
		}
}


//First Come, First Served Function
void first(onestage job1[], int &count, float &flow, float &tardy, float &totalflow, float &totaltardy, float &numtardy)
{
	header('F');
	
	for(int x=0; x<count; x++)
	{
		//Display information for each job
		cout<<setw(8)<<setprecision(0)<<fixed<<noshowpoint<<job1[x].name;
		cout<<setw(8)<<job1[x].time;
		cout<<setw(8)<<(flow+=job1[x].time);
		cout<<setw(8)<<job1[x].due;
		cout<<setw(13);

		//Calculate the number of tardy jobs
		tardy=flow-job1[x].due;
		if(tardy>0)
			{cout<<tardy<<endl;
			numtardy++;
			}
		else
			{tardy=0;
			cout<<tardy<<endl;
			}

		//Calculate the sum of the flow time and the sum of the tardy jobs
		totalflow+=flow;
		totaltardy+=tardy;
	}
}

//Shortest Processing Time Function
void shortest(onestage job1[], int &count, float &flow, float &tardy, float &totalflow, float &totaltardy, float &numtardy)
{
	header('S');
	bool swap;
	float tempTime;
	string tempName;
	float tempDue;

	//Bubble Sort data to arrange information from shortest processing time to longest
	do{
		swap=false;
		for(int c=0; c<(count-1); c++)
			{
			if(job1[c].time > job1[c+1].time)
				{
				tempTime=job1[c].time;
				job1[c].time=job1[c+1].time;
				job1[c+1].time=tempTime;

				tempName=job1[c].name;
				job1[c].name=job1[c+1].name;
				job1[c+1].name=tempName;

				tempDue=job1[c].due;
				job1[c].due=job1[c+1].due;
				job1[c+1].due=tempDue;

				swap=true;
				}
			}
	}while(swap);

	//Display information for each job
	for(int x=0; x<count; x++)
		{
		cout<<setw(8)<<setprecision(0)<<fixed<<noshowpoint<<job1[x].name;
		cout<<setw(8)<<job1[x].time;
		cout<<setw(8)<<(flow+=job1[x].time);
		cout<<setw(8)<<job1[x].due;
		cout<<setw(13);
		tardy=flow-job1[x].due;
		if(tardy>0)
			{cout<<tardy<<endl;
			numtardy++;
			}
		else
			{tardy=0;
			cout<<tardy<<endl;
			}
		totalflow+=flow;
		totaltardy+=tardy;
		}
}


//Earliest Due Date function
void earliest(onestage job1[], int &count, float &flow, float &tardy, float &totalflow, float &totaltardy, float &numtardy)
{
	header('E');
	bool swap;
	float tempTime;
	string tempName;
	float tempDue;

	//Bubble Sort data: earliest to latest due date
	do{
		swap=false;
		for(int a=0; a<(count-1); a++)
			{
			if(job1[a].due > job1[a+1].due)
				{
				tempTime=job1[a].time;
				job1[a].time=job1[a+1].time;
				job1[a+1].time=tempTime;

				tempName=job1[a].name;
				job1[a].name=job1[a+1].name;
				job1[a+1].name=tempName;

				tempDue=job1[a].due;
				job1[a].due=job1[a+1].due;
				job1[a+1].due=tempDue;

				swap=true;
				}
			}
	}while(swap);

	//Display information for each job
	for(int b=0; b<count; b++)
		{
		cout<<setw(8)<<setprecision(0)<<fixed<<noshowpoint<<job1[b].name;
		cout<<setw(8)<<job1[b].time;
		cout<<setw(8)<<(flow+=job1[b].time);
		cout<<setw(8)<<job1[b].due;
		cout<<setw(13);
		tardy=flow-job1[b].due;
		if(tardy>0)
			{cout<<tardy<<endl;
			numtardy++;
			}
		else
			{tardy=0;
			cout<<tardy<<endl;
			}
		totalflow+=flow;
		totaltardy+=tardy;
		}
}


//Critical Ratio Rule Function
void critical(onestage job1[],int &count, float &flow, float &tardy, float &totalflow, float &totaltardy, float &numtardy)
{
	header('C');
	bool swap;
	float tempTime;
	string tempName;
	float tempDue;
	float cRatio[count];
	float tempRatio;

	//Calculate CR for each job and store in cRatio
	for(int x=0; x<count; x++)
		{
		cRatio[x]=(job1[x].due/job1[x].time);
		}

	//Bubble Sort data: smallest to largest Critical Ratio
	do{
		swap=false;
		for(int m=0; m<(count-1); m++)
			{
			if(cRatio[m] > cRatio[m+1])
				{
				tempRatio=cRatio[m];
				cRatio[m]=cRatio[m+1];
				cRatio[m+1]=tempRatio;

				tempTime=job1[m].time;
				job1[m].time=job1[m+1].time;
				job1[m+1].time=tempTime;

				tempName=job1[m].name;
				job1[m].name=job1[m+1].name;
				job1[m+1].name=tempName;

				tempDue=job1[m].due;
				job1[m].due=job1[m+1].due;
				job1[m+1].due=tempDue;

				swap=true;
				}
			}
	}while(swap);


	//Display information for each job
	for(int b=0; b<count; b++)
		{
		cout<<setw(8)<<setprecision(0)<<fixed<<noshowpoint<<job1[b].name;
		cout<<setw(8)<<job1[b].time;
		cout<<setw(8)<<(flow+=job1[b].time);
		cout<<setw(8)<<job1[b].due;
		cout<<setw(13);
		tardy=flow-job1[b].due;
		if(tardy>0)
			{cout<<tardy;
			numtardy++;
			}
		else
			{tardy=0;
			cout<<tardy;
			}
		cout<<setw(9)<<setprecision(1)<<fixed<<showpoint<<cRatio[b];
		cout<<endl;
		totalflow+=flow;
		totaltardy+=tardy;
		}
}


//Slack Time Remaining Function
void slack(onestage job1[], int &count, float &flow, float &tardy, float &totalflow, float &totaltardy, float &numtardy)
{
	header('R');
	bool swap;
	float tempTime;
	string tempName;
	float tempDue;
	float slack[count];
	float tempSlack;

	//Calculate the slack time remaining for each job
	for(int n=0; n<count; n++)
		{
		slack[n]=(job1[n].due-job1[n].time);
		}

	//Bubble Sort data: least to most slack time remaining
	do{
		swap=false;
		for(int a=0; a<(count-1); a++)
			{
			if(slack[a] > slack[a+1])
				{
				tempSlack=slack[a];
				slack[a]=slack[a+1];
				slack[a+1]=tempSlack;

				tempTime=job1[a].time;
				job1[a].time=job1[a+1].time;
				job1[a+1].time=tempTime;

				tempName=job1[a].name;
				job1[a].name=job1[a+1].name;
				job1[a+1].name=tempName;

				tempDue=job1[a].due;
				job1[a].due=job1[a+1].due;
				job1[a+1].due=tempDue;

				swap=true;
				}
			}
	}while(swap);

	//Display information for each job
	for(int z=0; z<count; z++)
		{
		cout<<setw(8)<<setprecision(0)<<fixed<<noshowpoint<<job1[z].name;
		cout<<setw(8)<<job1[z].time;
		cout<<setw(8)<<(flow+=job1[z].time);
		cout<<setw(8)<<job1[z].due;
		cout<<setw(13);
		tardy=flow-job1[z].due;
		if(tardy>0)
			{cout<<tardy;
			numtardy++;
			}
		else
			{tardy=0;
			cout<<tardy;
			}
		cout<<setw(13)<<slack[z];
		cout<<endl;
		totalflow+=flow;
		totaltardy+=tardy;
		}
}


//All Rules Function
void all(onestage job1[], int n)
{
	cout<<endl<<endl<<"FIRST COME, FIRST SERVED"<<endl;
	outputA(job1, n, 'F');

	cout<<endl<<endl<<"SHORTEST PROCESSING TIME"<<endl;
	outputA(job1, n, 'S');
	
	cout<<endl<<endl<<"EARLIEST DUE DATE"<<endl;
	outputA(job1, n, 'E');

	cout<<endl<<endl<<"CRITICAL RATIO RULE"<<endl;
	outputA(job1, n, 'C');

	cout<<endl<<endl<<"SLACK TIME REMAINING"<<endl;
	outputA(job1, n, 'R');

}




//One Stage Header Function
void header(char choice)
{
	//Display header information
	cout<<"            Proc    Flow    Due";
	if(toupper(choice)=='C')
		cout<<"                  Critical";
	else if(toupper(choice)=='R')
		cout<<"                  Slack Time";

	cout<<endl<<"     Job    Time    Time    Date    Tardiness";
	if(toupper(choice)=='C')
		cout<<"    Ratio";
	else if(toupper(choice)=='R')
		cout<<"    Remaining";

	cout<<endl<<"     ---    ----    ----    ----    ---------";
	if(toupper(choice)=='C')
		cout<<"    -----";
	else if(toupper(choice)=='R')
		cout<<"    ---------";

	cout<<endl;
}


//Two Stage (Johnson) Input Function
int inputJ(twostage job2[], char *argv[])
{
	//Declare inputfile as an ifstream
	ifstream inputfile;

	//Open inputfile
	inputfile.open(argv[3]);

	//Check to see if inputfile opened
	if(inputfile.fail())
		{cout<<"Error opening file!"<<endl;
		exit(1);
		}

	//Priming read of data from inputfile
	int count=0;
	char input[81];
	inputfile.getline(input, 81, '\n');
	
	const char delimiters[]=" ";
	char *token;
	char jobID[9];

	//Get rest of data
	while(!inputfile.eof())
		{
		int length=strlen(input);

		if(token= strtok(input, delimiters))
			{for(int x=0; x<8; x++)
				{jobID[x]=*token;
				token++;
			}
			string temp(jobID, 0, 8);
			job2[count].name=temp;
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		if(token=strtok(NULL, delimiters))
			{job2[count].s1=atof(token);
				if(job2[count].s1<1)
					{cout<<help<<endl;
					exit(1);
					}
			}
		else
			{cout<<help<<endl;
			exit(1);
			}			
			
		if(token=strtok(NULL, delimiters))
			{job2[count].s2=atof(token);
				if(job2[count].s2<1)
					{cout<<help<<endl;
					exit(1);
					}
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		
		
		inputfile.getline(input, 81, '\n');
		count++;
		}
	return count;
}


//Calculation Function for Johnson's Rule
void calculationJ(twostage job2[], int count, int arr[])
{
	//Declare variables
	float smallest1, smallest2, highest, stage1[count], stage2[count];
	int location1, location2, total=0;
	string name[count];

	//Initialize the arrays of name, stage1, and stage2	
	for(int a=0; a<count; a++)
		{name[a]=job2[a].name;
		stage1[a]=job2[a].s1;
		stage2[a]=job2[a].s2;
		}

	//Initialize all emements in array to -1
	for(int a=0; a<count; a++)
		arr[a]=-1;

	//Initialize highest to the first element in stage1
	highest=job2[0].s1;

	//Find highest number out of both stages
	for(int h=0; h<count; h++)
		{if(stage1[h]>highest)
			highest=stage1[h];
		if(stage2[h]>highest)
			highest=stage2[h];
		}

	do{
		//Initialize smallest number in both stages to the first element
		smallest1=stage1[0];
		smallest2=stage2[0];

		//Find smallest in stage1
		for(int x=0; x<count; x++)
			{if(stage1[x]<=smallest1)
				{smallest1=stage1[x];
				location1=x;
				}
			}
		
		//Find smallest in stage2
		for(int y=0; y<count; y++)
			{if(stage2[y]<=smallest2)
				{smallest2=stage2[y];
				location2=y;
				}
			}


		//Smallest is in stage1
		if(smallest1<smallest2 || smallest1==smallest2)
			{for(int x=0; x<count; x++)
				{if(arr[x]==-1)
					{arr[x]=location1;
					stage1[location1]= highest + 1;
					stage2[location1]= highest + 1;
					total++;
					break;
					}
				}
			}

		//Smallest is in stage2
		if(smallest1>smallest2)
			{for(int y=count-1; y>-1; y--)
				{if(arr[y]==-1)
					{arr[y]=location2;
					stage1[location2]=highest + 1;
					stage2[location2]=highest + 1;
					total++;
					break;
					}
				}
			}

		}while(total<count);
	cout<<endl<<endl;
}


//Display Function for Johnson's Rule
void displayJ(twostage job2[], int arr[], int count)
{
	//Declare variables
	float end1[count], end2[count], begin1[count], begin2[count], totalflow=0;

	//Initialize ending of 1st stage to processing time of the stage
	end1[0]=job2[arr[0]].s1;

	//Calculate end of stage1
	for(int a=1; a<count; a++)
		{end1[a]=end1[a-1]+job2[arr[a]].s1;
		}

	//Calculate beginning of stage1
	begin1[0]=0;
	for(int b=1; b<count; b++)
		{begin1[b]=end1[b-1];
		}

	//Calculate beginning of stage2
	begin2[0]=end1[0];
	for(int c=1; c<count; c++)
		{
		if((begin2[c-1]+job2[arr[c-1]].s2)>end1[c])
			begin2[c]=job2[arr[c-1]].s2+begin2[c-1];
		else if((begin2[c-1]+job2[arr[c-1]].s2)<end1[c] || (begin2[c-1]+job2[arr[c-1]].s2)==end1[c])
			begin2[c]=end1[c];
		}

	//Calculate end of stage2
	for(int d=0; d<count; d++)
		{end2[d]=begin2[d]+job2[arr[d]].s2;
		totalflow+=end2[d];
		}



	//Display data
	cout<<"             Processing Time        Stage 1         Stage 2   "<<endl;
	cout<<"     ---    ------------------    ------------    ------------"<<endl;
	cout<<"     Job    Stage 1    Stage 2    Begin    End    Begin    End"<<endl;
	cout<<"     ---    ------------------    ------------    ------------"<<endl;

	for(int x=0; x<count; x++)
	{
	cout<<setw(8)<<job2[arr[x]].name<<setw(11)<<job2[arr[x]].s1<<setw(11)<<job2[arr[x]].s2<<setw(9)<<begin1[x]<<setw(7)<<end1[x]<<setw(9)<<begin2[x]<<setw(7)<<end2[x]<<endl;
	}

	cout<<endl<<endl;
	cout<<"Number of Jobs:"<<setprecision(2)<<fixed<<setw(16)<<count<<endl;
	cout<<"Total Flow Time:"<<setw(15)<<totalflow<<endl;
	cout<<"Average Flow Time:"<<setw(13)<<(totalflow/count)<<endl;
	cout<<"Makespan:"<<setw(22)<<end2[count-1]<<endl;
	cout<<"Average Jobs in System:"<<setw(8)<<(totalflow/(end2[count-1]))<<endl<<endl;
}


//Two Stage (Johnson) Function with Due Dates
int inputJ2(johnson2 jobs[], char *argv[])
{
	//Declare inputfile as an ifstream
	ifstream inputfile;

	//Open inputfile
	inputfile.open(argv[3]);

	//Check to see if inputfile opened
	if(inputfile.fail())
		{cout<<"Error opening file!"<<endl;
		exit(1);
		}

	//Priming read of data from inputfile
	int count=0;
	char input[81];
	inputfile.getline(input, 81, '\n');

	const char delimiters[]=" ";
	char *token;
	char jobID[9];

	//Get rest of data
	while(!inputfile.eof())
		{
		int length=strlen(input);

		if(token= strtok(input, delimiters))
			{for(int x=0; x<8; x++)
				{jobID[x]=*token;
				token++;
				}
			string temp(jobID, 0, 8);
			jobs[count].name=temp;
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		if(token= strtok(NULL, delimiters))
			{jobs[count].s1=atof(token);
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		if(token= strtok(NULL, delimiters))
			{jobs[count].s2=atof(token);
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		if(token= strtok(NULL, delimiters))
			{jobs[count].due=atof(token);
			}
		else
			{cout<<help<<endl;
			exit(1);
			}

		inputfile.getline(input, 81, '\n');
		count++;
		}
	return count;
}


//Calculation Function for Johnson's Rule with Due Dates
void calculationJ2(johnson2 jobs[], int count, int arr[])
{
	//Declare variables
	float smallest1, smallest2, highest, stage1[count], stage2[count];
	int location1, location2, total=0;
	string name[count];

	//Initialize the arrays of name, stage1, and stage2
	for(int a=0; a<count; a++)
		{name[a]=jobs[a].name;
		stage1[a]=jobs[a].s1;
		stage2[a]=jobs[a].s2;
		}

	//Initialize all elements in array to -1
	for (int a=0; a<count; a++)
		arr[a]=-1;
	
	//Initialize highest to the first element in stage1
	highest=jobs[0].s1;

	//Find highest number out of both stages
	for(int h=0; h<count; h++)
		{if(stage1[h]>highest)
			highest=stage1[h];
		if(stage2[h]>highest)
			highest=stage2[h];
		}

	do{
		//Initialize smallest number in both stages to the first element
		smallest1=stage1[0];
		smallest2=stage2[0];

		//Find smallest in stage1
		for(int x=0; x<count; x++)
			{if(stage1[x]<=smallest1)
				{smallest1=stage1[x];
				location1=x;
				}
			}

		//Find smallest in stage2
		for(int y=0; y<count; y++)
			{if(stage2[y]<=smallest2)
				{smallest2=stage2[y];
				location2=y;
				}
			}

		//Smallest is in stage1
		if(smallest1<smallest2 || smallest1==smallest2)
			{for(int x=0; x<count; x++)
				{if(arr[x]==-1)
					{arr[x]=location1;
					stage1[location1]= highest + 1;
					stage2[location1]= highest + 1;
					total++;
					break;
					}
				}
			}

		//Smallest is in stage2
		if(smallest1>smallest2)
			{for(int y=count-1; y>-1; y--)
				{if(arr[y]==-1)
					{arr[y]=location2;
					stage1[location2]= highest + 1;
					stage2[location2]= highest + 1;
					total++;
					break;
					}
				}
			}
		
		}while(total<count);
	cout<<endl<<endl;
}


//Display Function for Johnson's Rule with Due Dates
void displayJ2(johnson2 jobs[], int arr[], int count)
{
	//Declare variables
	float end1[count], end2[count], begin1[count], begin2[count], totalflow=0;

	//Initialize ending of 1st stage to processing time of the stage
	end1[0]=jobs[arr[0]].s1;

	//Calculate end of stage1
	for(int a=1; a<count; a++)
		{end1[a]=end1[a-1]+jobs[arr[a]].s1;
		}

	//Calculate beginning of stage1
	begin1[0]=0;
	for(int b=1; b<count; b++)
		{begin1[b]=end1[b-1];
		}

	//Calculate beginning of stage2
	begin2[0]=end1[0];
	for(int c=1; c<count; c++)
		{
		if((begin2[c-1]+jobs[arr[c-1]].s2)>end1[c])
			begin2[c]=jobs[arr[c-1]].s2+begin2[c-1];
		else if((begin2[c-1]+jobs[arr[c-1]].s2)<end1[c] || (begin2[c-1]+jobs[arr[c-1]].s2)==end1[c])
			begin2[c]=end1[c];
		}

	//Calculate end of stage2
	for(int d=0; d<count; d++)
		{end2[d]=begin2[d]+jobs[arr[d]].s2;
		totalflow+=end2[d];
		}

	float tardy=0;
	float totaltardy=0;
	float numtardy=0;

	//Display data
	cout<<"             Processing Time        Stage 1         Stage 2"<<endl;
	cout<<"     ---    ------------------    ------------    ------------    --------    ---------"<<endl;
	cout<<"     Job    Stage 1    Stage 2    Begin    End    Begin    End    Due Date    Tardiness"<<endl;
	cout<<"     ---    ------------------    ------------    ------------    --------    ---------"<<endl;

	for(int x=0; x<count; x++)
	{
	cout<<setw(8)<<jobs[arr[x]].name<<setw(11)<<jobs[arr[x]].s1;
	cout<<setw(11)<<jobs[arr[x]].s2<<setw(9)<<begin1[x];
	cout<<setw(7)<<end1[x]<<setw(9)<<begin2[x]<<setw(7)<<end2[x];
	cout<<setw(12)<<jobs[arr[x]].due;
	tardy= end2[x]-jobs[arr[x]].due;
	if(tardy>0)
		{cout<<setw(13)<<tardy<<endl;
		totaltardy+=tardy;
		numtardy++;
		}
	else
		cout<<setw(13)<<'0'<<endl;
	}

	cout<<"     ---    ------------------    ------------    ------------    --------    ---------"<<endl;
	cout<<setw(87)<<totaltardy<<endl;

	float percenttardy= (numtardy/count)*100;	

	cout<<endl<<endl;
	cout<<"Number of Jobs:"<<setprecision(2)<<fixed<<setw(16)<<count<<endl;
	cout<<"Total Flow Time:"<<setw(15)<<totalflow<<endl;
	cout<<"Average Flow Time:"<<setw(13)<<(totalflow/count)<<endl;
	cout<<"Makespan:"<<setw(22)<<end2[count-1]<<endl;
	cout<<"Average Jobs in System:"<<setw(8)<< (totalflow/ (end2[count-1]))<<endl;
	cout<<"Number of Tardy Jobs:"<<setw(10)<< numtardy<<" ( "<<percenttardy<<"% )"<<endl;
	cout<<"Average Lateness:"<<setw(14)<< (totaltardy/count)<<endl<<endl;
}