/*-------------------------------------------------------------------------------
F|perm|max(Ci)  Ütemezési fedadat szimulációja.
Egyutas előzésnélküli többoperációs termelésütemezési feladat.
A Simulation_FS adott műveleti idők és adott indítási sorrend esetében kiszámítja 
az operációk indítási és befejezési időpontjait.
-------------------------------------------------------------------------------*/


#include<stdio.h>
#include<stdlib.h>

typedef struct{
                int id;      //identifier of the job
                long* ProcT; //processing time of the operations
                long* StartT;
                long* EndT;
              } T_JOB;

void Simulation_FS( T_JOB* job, int NJ, int NM,
                 int* s, long t_ref);
void Print_Job_Gantt( T_JOB* job, int NJ, int NM, int* s);
long Evaluation_FS( T_JOB* job, int NJ, int NM, int* s);





int main(int argc, char* argv[])
{
  int NJ; //number of jobs in the system
  int NM; //number of machines (people)
  int i;  //index of job
  int m;  //index of machine
  T_JOB* job;  //list of jobs
  int* s;      //schedule
  long Cmax;   //completion time


  //adatok betoltese
  printf("\n Egyutas, elozes nelkuli utemezesi feladat.");
  printf("\n Munkak szama:");
  scanf("%d", &NJ);
  printf("\n Gepek szama:");
  scanf("%d", &NM);

  //memoriamodell
  job = (T_JOB*) calloc(NJ, sizeof(T_JOB) ); //strukturavektor
  for( i=0; i<NJ; i++)
    {
      job[i].id = i; //identifier
      job[i].ProcT  = (long*) calloc(NM, sizeof(long) ); //vector
      job[i].StartT = (long*) calloc(NM, sizeof(long) ); //vector
      job[i].EndT   = (long*) calloc(NM, sizeof(long) ); //vector

      //folyamattervezo adatai adottak a valosagban
      for ( m=0; m<NM; m++ )
        job[i].ProcT[m] = 1 + rand()%20;
    }

  //utemterv
  s = (int*) calloc(NJ, sizeof(int) );
  //ad-hoc sorrend
  for( i=0; i<NJ; i++)
      s[i] = i;

  //szimulacio
  Simulation_FS( job, NJ, NM, s, 0);
  printf("\n Ad-hoc sorrend");
  Print_Job_Gantt( job, NJ, NM, s);
  Cmax = Evaluation_FS( job, NJ, NM, s);
  printf("\n Cmax = %ld", Cmax );

  getch();

  //felszabaditas
  for( i=0; i<NJ; i++)
    {
      free( job[i].ProcT );
      free( job[i].StartT );
      free( job[i].EndT );
    }
  free( job );

  free( s );

  return 0;
}
//---------------------------------------------------------------------------

void Simulation_FS( T_JOB* job, int NJ, int NM,
                 int* s, long t_ref)
{ //egyutas, elozes nelkuli (Flow Shop) feladat szimulacioja
  int i, m; //futoindex
            //i jelenti az inditas sorszamat
            //m elvegzendo operacio sorszama
            //s[i] az i-edik munka azonositoja

  for( i=0; i<NJ; i++ )
    {
      for( m=0; m<NM; m++ )
        {
           if ( i==0 ) //kezdo munka
             {
              if ( m==0 ) //kezdo operacio
                 //mikor inditjuk
                 job[ s[i] ].StartT[m] = t_ref;
              else //nem kezdo operacio
                 //az elozo operacioja mikor fejezodik be
                 job[ s[i] ].StartT[m] = job[ s[i] ].EndT[m-1];
             }
           else  //nem kezdo munka
             {
              if ( m==0 ) //kezdo operacio
                 //az elotte elvegzett operacio mikor fejezodik be
                 job[ s[i] ].StartT[m] = job[ s[i-1] ].EndT[m];
              else
                 //a munka mikor erkezik
                 //a gep mikor szabadul fel
                 job[ s[i] ].StartT[m] = max ( job[ s[i] ].EndT[m-1],
                                               job[ s[i-1] ].EndT[m] );
             }
           //befejezes = inditas + muveleti ido
           job[ s[i] ].EndT[m] =   job[ s[i] ].StartT[m]
                                 + job[ s[i] ].ProcT[m];
        }
    }

}

void Print_Job_Gantt( T_JOB* job, int NJ, int NM, int* s)
{
   int i, m;
   printf("\n Munka orientalt Gantt diagram");
   for( i=0; i<NJ; i++ )
     {
       printf("\n\t %d. munka \t gep \t indul \t muv. \t kesz", s[i]);
       for( m=0; m<NM; m++)
         printf("\n\t \t \t %d \t %ld \t %ld \t %ld",
                 m,
                 job[s[i]].StartT[m],
                 job[s[i]].ProcT[m],
                 job[s[i]].EndT[m] );

     }

}

long Evaluation_FS( T_JOB* job, int NJ, int NM, int* s)
{
   //utolsokent inditott munka utolso operacioja
   return job[ s[NJ-1] ].EndT[ NM-1];
}