/*------------------------------------------------------------------------------
TIA 8. gyakorlat
F|perm|Cmax ütemezési feladat modellezése.
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;
                long* ProcT;  //pointer: muveleti idok vektorara mutat
                long* StartT; //pointer: inditasi idopontok vektorara mutat
                long* EndT; //pointer: befejezesi idopontok vektorara mutat
               }T_JOB; //munka

long max_l( long a, long b) { return a>b ? a : b; }

void Simulation_F( T_JOB* job, int NJ, int NR, int* s, long t_ref);
void Print_Res_Gantt( T_JOB* job, int NJ, int NR, int* s);



int main(int argc, char* argv[])
{
  int NJ;   //munkak szama
  int i;    //munka indexe
  int NR;   //eroforrasok (munkahelyek) szama
  int r;    //eroforras indexe
  T_JOB* job; //job-tablara mutat
  //perm: a munkak nem elozheti meg egymast
  int* s;     //utemezes vektorara mutat

  printf("\n Flow Shop utemezesi feladat szimulacioja.");
  printf("\n Munkak szama:");
  scanf("%d", &NJ);
  printf("\n Eroforrasok szama:");
  scanf("%d", &NR);

  //mem. fogalalas
  job = (T_JOB*) calloc(NJ, sizeof(T_JOB));
  s = (int*) calloc(NJ, sizeof(int));    //utemterv

  for ( i=0; i<NJ; i++ )
    {
      job[i].id = i;
      job[i].ProcT = (long*) calloc(NR, sizeof(long));
      //alapadat generalasa
      for ( r=0; r<NR; r++ )
         job[i].ProcT[r] = 1+rand()%100;  //muveleti ido

      job[i].StartT = (long*) calloc(NR, sizeof(long));
      job[i].EndT = (long*) calloc(NR, sizeof(long));

      //AD-HOC: erkezesi sorrend
      s[i]=NJ-1-i;
      //LIFO
      //s[i]=NJ-1-i;
    }

  //teszt
  Simulation_F( job, NJ, NR, s, 0);
  Print_Res_Gantt( job, NJ, NR, s);



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

  getch();
  return 1;
}

void Simulation_F( T_JOB* job, int NJ, int NR, int* s, long t_ref)
{
  int i; //vegrehajtasi sorrend indexe
  int r; //eroforras indexe

  for ( i=0; i<NJ; i++ ) //vegrehajtasi sorrend
   for ( r=0; r<NR; r++ )
   {
     if ( i==0 ) //kezdo munka
       {
          if ( r==0 ) //kezdo munkahely
             //az inditas idopontja a mervado
             job[ s[i] ].StartT[r] = t_ref;  //referencia ido
          else  //nem kezdo munkahely
             //elozo geprol mikor erkezik
             job[ s[i] ].StartT[r] = job[ s[i] ].EndT[r-1];
       }
     else  //nem kezdo munka
       {
          if ( r==0 ) //kezdo munkahely
             //elozo munka mikor fejezodik be
             job[ s[i] ].StartT[r] = job[ s[i-1] ].EndT[r];
          else  //nem kezdo munkahely
             job[ s[i] ].StartT[r] = max_l( job[ s[i] ].EndT[r-1], //elozo geprol mikor erkezik
                                            job[ s[i-1] ].EndT[r] ); //a gep mikor szabadul fel az elozo munka terhelese alol
       }

       //bef. ido = kezdet + muv. ido;
       job[ s[i] ].EndT[r] = job[ s[i] ].StartT[r]
                           + job[ s[i] ].ProcT[r];
   }
}

void Print_Res_Gantt( T_JOB* job, int NJ, int NR, int* s)
{
  int i;
  int r;

  printf("\n Resource Gantt Chart \n");
  for (r=0; r<NR; r++)
   {
     printf("\n R_%d", r);
     printf("\n\t sor\tmunka\tindul\tmuv.\tvegez");
     for (i=0; i<NJ; i++)
      printf("\n\t %d\t%d\t%ld\t%ld\t%ld",
             i,
             s[i],
             job[s[i]].StartT[r],
             job[s[i]].ProcT[r],
             job[s[i]].EndT[r]);

   }
}