#include <windows.h>
#include <stdio.h>
#include <stdlib.h>  
#include <time.h>
#include "Ulti.h"
#include "pcb.h"
#include "Equeue.h"
#define DEBUG 1
#define STA_READY 0
#define STA_RUN   1
#define STA_END   2
struct PCBNode
 {
       char processName[20];
       int  processID;
       int  remainSecs;
       int  status, priorityNum;
       struct PCBNode* next;
 };
typedef struct PCBNode* PCBList;
typedef struct PCBNode* ptrPCBNode;
struct Process
{
       char processName[20];
       int processID;
       int status;
       int priorityNum;
       int remainSecs;
       struct Process* next;
};
 typedef struct Process* ptrProcess;

char *inFileName="inputData.txt";
char *outFileName="outputData.txt";
int main(int argc,char* argv[])
{
   /*--------Open file--------*/
   FILE* inputFile;
   FILE* outputFile;
   int bDelay;
   /*=--------creation part-------*/
   char mode;
   int numOfThread; 
   PCBList pcbList,p;
   ptrPCBNode tmpNode;
   /*--------main process-------*/
   pQueue readyQueue,endQueue;
   ptrProcess runProcess,tmpProcess;
   int count;
   if((inputFile=fopen(inFileName,"rb"))==NULL)
   {   
       printf("open inputFile error\n");
       return -1;
   }
   if((outputFile=fopen(outFileName,"wb"))==NULL)
   {
       printf("open outputFile error\n");
       return -1;
   }
       printf("oepn files success \n");
   /*Create the PCB Table*/
   /*create a pcbList with a null head.*/  
   pcbList=(ptrPCBNode)malloc(sizeof(struct PCBNode));
   p=pcbList;
   fscanf(inputFile,"mode=%c\r\n",&mode);
   fscanf(inputFile,"numOfThread=%d\r\n",&numOfThread);
   fscanf(inputFile,"delay=%d\r\n",&bDelay);
   printf("------------program init starts------------\n");
   fprintf(outputFile,"------------program init starts------------\r\n");
   if(mode=='0')/*Read process definition from the file*/
       {
                   /*Creation with input list*/
                   int i;
                   for(i=0;i<numOfThread;i++)
                  {
                           tmpNode=(ptrPCBNode)malloc(sizeof(struct PCBNode));
                          fscanf(inputFile,"%d,%d,%s\r\n",&tmpNode->priorityNum,&tmpNode->remainSecs,tmpNode->processName);   
                           tmpNode->processName[strlen(tmpNode->processName)]='\0';
                           tmpNode->processID=i;
                           tmpNode->staturs=STA_READY;
      
                           if(tmpNode->remainSecs>0)

                           {

                                   p->next=tmpNode;

                                   p=p->next;

           

           printf("ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Ready\n",tmpNode->processID,tmpNode->processName,tmpNode->priorityNum,tmpNode->remainSecs);

           fprintf(outputFile,"ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Ready\r\n",tmpNode->processID,tmpNode->processName,tmpNode->priorityNum,tmpNode->remainSecs);

 

                           }   

                   }

       p->next=NULL;//Correction: add this to has effects in sort algorithm

           }

   else if(mode=='1')

       {

                   int i;

                   srand((unsigned int)time (NULL));

                   

                   for(i=0;i<numOfThread;i++)

                   {

                       tmpNode=(ptrPCBNode)malloc(sizeof(struct PCBNode));                        tmpNode->priorityNum=(int)eRandom(10);  

                       tmpNode->remainSecs=(int)eRandom(10);   

                       tmpNode->processID=i;   

                           strcpy(tmpNode->processName,"Process");

                           tmpNode->processName[7]=48+i;

                           tmpNode->processName[8]='\0';

                           

                           tmpNode->staturs=STA_READY;

                           

                           if(tmpNode->remainSecs>0)

                           {

                                   p->next=tmpNode;

                                   p=p->next;

           printf("ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Ready\n",tmpNode->processID,tmpNode->processName,tmpNode->priorityNum,tmpNode->remainSecs);

           fprintf(outputFile,"ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Ready\r\n",tmpNode->processID,tmpNode->processName,tmpNode->priorityNum,tmpNode->remainSecs);

                           }   

                   }

                   p->next=NULL;//Correction: add this to has effects in sort algorithm

       }   

   else

       {

           printf("mode is illegal!\n");

           return -1;

       }

   printf("------------program init ends------------\n");

   fprintf(outputFile,"------------program init ends------------\r\n");

   /*Sort the pcb table*/      

   sortPCB(pcbList);                           //8:56 test ok

   if(DEBUG)printf("sortPCB successfully\n");  

   

   /*init queue*/

   endQueue=createNullQueueWithHead();

   readyQueue=createNullQueueWithHead();

       

   tmpNode=pcbList;

   tmpNode=tmpNode->next;

   

   while(tmpNode!=NULL)                        //9:38 test ok

   {

       tmpProcess=(ptrProcess)malloc(sizeof(struct Process));

       tmpProcess->processID=tmpNode->processID;

       tmpProcess->staturs=tmpNode->staturs;

       tmpProcess->priorityNum=tmpNode->priorityNum;

       tmpProcess->remainSecs=tmpNode->remainSecs;

       strcpy(tmpProcess->processName,tmpNode->processName);

       enQueue(readyQueue,tmpProcess);

       tmpNode=tmpNode->next;

   }

   

   if(DEBUG)printf("create readyQueue successfully\n");

   runProcess=NULL;

   /*The core of process management*/

   printf("------------start of main simulation program------------\n");

   fprintf(outputFile,"------------start of main simulation program------------\r\n");

   count=0;

   while(!isEmpty(readyQueue)||runProcess!=NULL)

   {

       if(bDelay)

           eDelay(1000);/*DELAY 1 SECS*/

       

       if(runProcess!=NULL)

           {

           count++;

   printf("Line:%d ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Running\n",count,runProcess->processID,runProcess->processName,runProcess->priorityNum,runProcess->remainSecs);

   fprintf(outputFile,"Line:%d ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Running\r\n",count,runProcess->processID,runProcess->processName,runProcess->priorityNum,runProcess->remainSecs);

                   runProcess->priorityNum++;

                   runProcess->remainSecs--;

                   

                   if(runProcess->remainSecs==0)/*if time use out,end the process*/

                       {

                           runProcess->staturs=STA_END;

                           enQueue(endQueue,runProcess);

                           updatePCBList(pcbList,runProcess);

                           count++;

   printf("Line:%d ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Ends\n",count,runProcess->processID,runProcess->processName,runProcess->priorityNum,runProcess->remainSecs);

   fprintf(outputFile,"Line:%d ProcessID:%d,Name:%s,Priority:%d,RemainSecs:%d Staturs: Ends\r\n",count,runProcess->processID,runProcess->processName,runProcess->priorityNum,runProcess->remainSecs);

                       }

                   else if(!isEmpty(readyQueue))

                       {

                           runProcess->staturs=STA_READY;

                           insert(readyQueue,runProcess);

                           updatePCBList(pcbList,runProcess);  

                       }

           }

       

       /*apply new mem for the new node*/

       //Correction:runProcess!=NULL should be placed at front

       if(runProcess!=NULL&&runProcess->remainSecs==0)//for the last thread consult.&& runProcess!=firstNode(NULL)

           runProcess=NULL;

       

       if(!isEmpty(readyQueue))

       {

           runProcess=(ptrProcess)malloc(sizeof(struct Process));  

           /*wake up a new thread*/    

           runProcess=deQueue(readyQueue);

           runProcess->staturs=STA_RUN;

           updatePCBList(pcbList,runProcess);

       }

   }//10:03 test ok

   printf("------------end of main simulation program------------\n");

   fprintf(outputFile,"------------end of main simulation program------------\r\n");

 

   fclose(inputFile);

   fclose(outputFile);

 

   printf("program ends successfully\n");

   getchar();

   return 0;

}


#define STA_READY 0
#define STA_RUN   1
#define STA_END   2
struct PCBNode
 {
       char processName[20];
       int  processID;
       int  remainSecs;
       int  status, priorityNum;
       struct PCBNode* next;
 };
typedef struct PCBNode* PCBList;
typedef struct PCBNode* ptrPCBNode;
struct Process
{
       char processName[20];
       int processID;
       int status;
       int priorityNum;
       int remainSecs;
       struct Process* next;
};
 typedef struct Process* ptrProcess;

 typedef  ptrProcess PtrQueueType;