/*-------------------------------------------------------------------------------

A termelésinformatikai alapjai c. tantrárgy GEIAK150-B
Miskolci Egyetem, Alkalmazott Informatikai Intézeti Tanszék
Dr. Kulcsár Gyula, egyetemi docens

TIA gyakorlat 01
Egy eroforrást tartalmazó gyártócella működésének szimulációja.

TIA gyakorlat 02
Egy eroforrást tartalmazó gyártócella ütemezése.
Az ütemezés célja a befejezési idők összegének minimalizálása,
ezáltal az átlagos készletszint minimalizálása.
Az SPT (Shortest Processing Time) műveleti idő szerint nemcsökkenő munkasorrend
optimális ütemtervet eredményez.
-------------------------------------------------------------------------------
*/


#include<stdio.h>
#include<conio.h>

typedef struct {
                 int id;
                 long ProcT;
                 long StartT;
                 long EndT;
               } T_JOB;

void generate_data( T_JOB* job, int NJ );
void create_schedule(int* s, int NJ);
void simulation( T_JOB* job, int NJ, int* s, long t0);
void print_execution_data( T_JOB* job, int NJ, int* s);
void Evaluate( T_JOB* job, int NJ, double* obj_f );
void print_obj_f( double* obj_f );
void SPT_rule( T_JOB* job, int NJ, int* s);







int main(int argc, char* argv[])
{
  //int NM; //number of machines
  //egyetlen gep dolgoyik
  int NJ; //number of jobs
  T_JOB* job;   //strukturara mutato pointer
  int i;
  int* s; //utemtervre mutato pointer

  double obj_f[3]; //celfuggvenyek tombje


  printf("\n Demo program egygepes gyartocella szimulaciojara");
  printf("\n Munkak szama = ");
  scanf("%d", &NJ);

  //mem. foglalas
  job = (T_JOB*) calloc(NJ, sizeof(T_JOB) );  //dinamikus tomb
  s = (int*) calloc(NJ, sizeof(int) );  //dinamikus tomb

  //adatok generalasa
  generate_data( job, NJ );

  //utemezes
   create_schedule(s, NJ);

  //simulacio
  simulation( job, NJ, s, 0); //nulla ref. ido

  //vegrehajtasi eredmeny
  print_execution_data( job, NJ, s);


  //evaluate();
  Evaluate( job, NJ, obj_f );

  //celfuggvenyek megjelenitese
   print_obj_f( obj_f );

   //SPT optimalis eredmenyt ad
  SPT_rule( job, NJ, s);
  simulation( job, NJ, s, 0); //nulla ref. ido
  print_execution_data( job, NJ, s);
  Evaluate( job, NJ, obj_f );
  print_obj_f( obj_f );



  free( job ); //mem. felszabaditas
  free( s );

  printf("\n Kesz! Bill. lenyomasra kilep");
  getch();

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

void generate_data( T_JOB* job, int NJ )
{
   //Valos kornyezetben adatbazisbol lekerdezheto
   int i;

   for ( i=0; i<NJ; i++)
     {
       job[i].id = i;
       job[i].ProcT = 1 + rand() % 100; //1 es 100 kozotti veletlenszam
     }

}

void create_schedule(int* s, int NJ)
{  //dontesi valtozo
   //utemterv: munkak inditasi sorrendje
   int i;

   for ( i=0; i<NJ; i++ )
     s[i] = i;
}

void simulation( T_JOB* job, int NJ, int* s, long t0)
{
   int i;

   for ( i=0; i<NJ; i++)
   {
     if ( i==0 )
        job[ s[i] ].StartT = t0;
     else
        job[ s[i] ].StartT = job[ s[i-1] ].EndT;

     job[ s[i] ].EndT = job[ s[i] ].StartT
                        + job[ s[i] ].ProcT;

   }
}

void print_execution_data( T_JOB* job, int NJ, int* s)
{
  int i;
  printf("\n Az eroforrason a munkak vegrehajtasi adatai:");
  printf("\n # \t id \t indul \t muv. \t bef.");

  for ( i=0; i<NJ; i++ )
    {
      printf("\n %d \t %d \t %ld \t %ld \t %ld",
             i+1,
             job[ s[i] ].id,
             job[ s[i] ].StartT,
             job[ s[i] ].ProcT,
             job[ s[i] ].EndT
             );

    }
}

void Evaluate( T_JOB* job, int NJ, double* obj_f )
{
  int i;

  double Cmax;   //utolso munka befejezesi idopontja
  double Csum;   //befejezesi idopontok osszege
  double WIP;    //Work in Process, atlagos keszletszint

  Csum = 0;
  for( i=0; i<NJ; i++ )
   {
     Csum += job[i].EndT;

     if ( i==0 )
        Cmax = job[i].EndT;
     else
        if ( Cmax < job[i].EndT )
             Cmax = job[i].EndT;
   }

  if ( Cmax != 0 )
     WIP = Csum / Cmax;
  else
     WIP = 0;

   obj_f[0] = Cmax;
   obj_f[1] = Csum;
   obj_f[2] = WIP;

}

void print_obj_f( double* obj_f )
{
   printf("\n Celfuggvenyek:");
   printf("\n \t Cmax = %lf", obj_f[0]);
   printf("\n \t Csum = %lf", obj_f[1]);
   printf("\n \t WIP = %lf", obj_f[2]);
}

void SPT_rule( T_JOB* job, int NJ, int* s)
{
  int i, j, index, temp;

  for ( i=0; i<NJ; i++)
     s[i]=i;

  for ( i=0; i<NJ-1; i++ )
   {
     index = i;  //jelolt pozicioja

     for( j=i+1; j<NJ; j++ )
       if ( job[ s[index] ].ProcT > job[ s[j] ].ProcT )
           index = j;

     if ( index != i )
      { //csere
        temp = s[index];
        s[index] = s[i];
        s[i] = temp;

      }


   }
}