/*------------------------------------------------------------------------------
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>
#include<time.h>

typedef struct{
               int id;        //azonosito
               long* ProcT;   //muveleti idok vektora
               long* StartT;  //inditasi idopontok vektora
               long* EndT;    //befejezesi idopontok vektora
               } T_JOB;       //munka

/*CodeBlocks eseten definialjuk a max fuggvenyt
long max(long a, long b)
{
 return a>=b ? a : b;
}
*/

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

int main()
{
  time_t t;
  int NJ; //number of jobs
  int i;  //index of jobs
  int NR; //number of resources
  int r;  //index of resources

  T_JOB* job;  //jobs
  int* s;      //schedule

  //A termelesinformatikai integralt rendszerbol lekerdezheto
  printf("\n Flow Shop demo.");
  printf("\n Kerem a munkak szamat:");
  scanf("%d", &NJ);  //ellenorzes nincs
  printf("\n Kerem a gepek szamat:");
  scanf("%d", &NR);  //ellenorzes nincs

  srand( time(&t) ); //inic.
  s = (int*) calloc(NJ, sizeof(int)); //utemterv
  job = (T_JOB*) calloc(NJ, sizeof(T_JOB)); //strukturavektor
  for (i=0; i<NJ; i++)
    {
      job[i].id = i;
      job[i].ProcT  = (long*) calloc(NR, sizeof(long)); //helyfoglalas
      job[i].StartT = (long*) calloc(NR, sizeof(long)); //helyfoglalas
      job[i].EndT   = (long*) calloc(NR, sizeof(long)); //helyfoglalas

      for (r=0; r<NR; r++)
        job[i].ProcT[r] = 1 + rand()%20;

      s[i]=i;  //Ad-hoc sorrend
    }

   //Ad-hoc sorrend
   Simulation_F(job, NJ, NR, s, 0);
   Print_Res_Gantt(job, NJ, NR, s);





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

  getch();
  return 1;
}

void Simulation_F(T_JOB* job, int NJ, int NR, int* s, long t0)
{
  int i; //job index
  int r; //resource index

  for ( i=0; i<NJ; i++)
   for ( r=0; r<NR; r++)
    {
      if ( i==0 )
        { //kezdo munka
          if ( r==0 )
            { //kezdo gep
              job[ s[i] ].StartT[ r ] = t0; //ref. idoben indul
            }
          else
            { //nem kezdo gep
              job[ s[i] ].StartT[ r ] = job[ s[i] ].EndT[ r-1 ]; //elozo gepen a befejezes idopontja hatarozza meg
            }
        }
      else
        { //nem kezdo munka
          if ( r==0 )
            { //kezdo gep
              job[ s[i] ].StartT[ r ] = job[ s[i-1] ].EndT[ r ];  //elozo munka befejezese hatarozza meg az inditast
            }
          else
            { //nem kezdo gep
              //max azt mutatja, hogy melyik eset a dominans
              job[ s[i] ].StartT[ r ] = max(  job[ s[i] ].EndT[ r-1 ],
                                               job[ s[i-1] ].EndT[ r ] );
            }

        }

      //kesz = indit + dolgozik
     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, r;

  printf("\n\n Eroforras orientalt Gantt diagram:");
  for ( r=0; r<NR; r++)
  {
    printf("\n R_%d", r);
    printf("\n sor \t job \t indul \t muv \t kesz");
    for (i=0; i<NJ; i++)
         printf("\n %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] );

  }
}