/*------------------------------------------------------------------------------
TIA 6. gyakorlat
F|perm|Cmax
Egyutas előzésnélküli többoperációs ütemezési feladat.
Cél: A befejezési időpont minimalizálása.
1. rész:
Modellépítés és szimuláció.
A Simulation_F 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;       //azonosito
                long* ProcT;  //muveleti idok, vector of processing times
                long* StartT; //keydesi idok, vector of starting times
                long* EndT;   //befejezesi idok, vector of finishing (end) times
               } T_JOB;
 /*CodeBlocks
 long max( long a, long b)
   {
     return a > b ? a : b; //felteteles operator
     //if (a > b) return a;
     //else return b;
   }
 */
void Simulation_F( T_JOB* job, int NJ, int NM, int* s, long t_ref);

int main(int argc, char* argv[])
{
  int i; //munka indexe, job
  int NJ; //munkak szama, number of jobs
  int m; //gep indexe, muvelet sorszama
  int NM; //gepek szam, number of machines
  int* s; //utemterv, schedule
  T_JOB* job;   //jobok listaja, vector of jobs

  printf("\n Flow Shop utemezesi feladat demo.");
  printf("\n Munkak szama:");
  scanf("%d", &NJ);
  printf("\n Gepek szama:");
  scanf("%d", &NM);

  //Modellepites, Model Building
  srand( 0 ); //inicializalja a veletlenszam generatort
  job = (T_JOB*) calloc( NJ, sizeof(T_JOB) ); //mem. foglalas
  for (i=0; i<NJ; i++)
   {
      job[i].id = i;
      job[i].ProcT  = (long*) calloc( NM, sizeof(long) );
      job[i].StartT = (long*) calloc( NM, sizeof(long) );
      job[i].EndT   = (long*) calloc( NM, sizeof(long) );

      //a technologiai terv definialja a muveleti idoket
      for (m=0; m<NM; m++)
          job[i].ProcT[m] = 1 + rand()%20;  //kvazi-veletlenszam
   }

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

  //Szimulacio
  Simulation_F( job, NJ, NM, s, 0); //0 idopontban indul a folyamat

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

  getch();
  return 0;
}

 void Simulation_F( T_JOB* job, int NJ, int NM, int* s, long t_ref)
 {
   //a tablara felirt logikai kovetkeztetes eredmenye alapjan
   //a szimulacio elvegezheto "executiin-driven" elv hasznalataval
   int i;  //munka index
   int m;  //gep index

   for (i=0; i<NJ; i++)  //i az inditas szerinti sorszam
    {  //a munka azonositoja s[i]
      for(m=0; m<NM; m++)
       {
          if ( i==0 )
          {  //kezdo munka
             if ( m==0 )
               { //kezdo gep
                 job[ s[i] ].StartT[ m ] = t_ref;
                 //nincs elotte mas munka
               }
             else
               { //kozbenso gep
                 job[ s[i] ].StartT[ m ] = job[ s[i] ].EndT[ m-1 ];
                 //a gep biztosan szabad
               }

          }
          else
          {  //kozbenso munka
             if ( m==0 )
               { //kezdo gep
                 job[ s[i] ].StartT[ m ] = job[ s[i-1] ].StartT[ m ];
                 //az elozo munka befejezodott a gepen
               }
             else
               { //kozbenso gep
                 job[ s[i] ].StartT[ m ] = max( job[ s[i-1] ].StartT[ m ]
                                               ,job[ s[i] ].EndT[ m-1 ] );
                                         // elozo munka az adott genen mikor fejezodik be
                                          // a munka elozo operacioja mikor fejezodik be
               }
          }

          job[ s[i] ].EndT[ m ] = job[ s[i] ].StartT[ m ] +
                                  job[ s[i] ].ProcT[ m ];
          //bef. idoponto = kezdesi idopont + muveleti ido

       }
    }

 }