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

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.

TIA gyakorlat 03
Egygépes utemezési feladat modellezése,
határidős munkák figyelembe vételével.
Minden munkának saját határideje van.
Az ütemezés célja a legnagyobb késés minimalizálása.
EDD Earliest Due Date (határidő szerint nemcsökkenő munkasorrend)
A megoldás optimális ütemtervet eredményez.

TIA gyakorlat 04
Továbbfejlesztés:
Párhuzamos gépes termelésütemezési feladat: P||Csum ütemezési feladat.
Megoldás: MSPT algoritmus.
Az ütemezés célja a munkák befejezési időpontjai összegének minimalizálása.
MSPT Modified Shortest Processing Time
módosított legrövidebb műveleti idejű munka előre:
Alkalmazzuk az SPT szabályt a munkák sorbarendezésére (műveleti idők alapján nemcsökkenő sorrendbe),
ezután képezzünk a gépek számának megfelelő hosszú csoportokat.
Az első csoport munkái az elsők rendre az egyes gépeken,
a második csoport munkái a másodikok rendre az egyes gépeken stb.
A megoldás optimális ütemtervet eredményez.

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


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

typedef struct {
                 int id;
                 long ProcT;
                 long StartT;
                 long EndT;
                 long d;      //hatarido
                 long L;      //keses

               } T_JOB;

typedef struct {
                int id;
                int l;   //load, terheles: elvegzendo munkak szama
                } T_RES;  //


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);
void EDD_rule( T_JOB* job, int NJ, int* s);
void MSPT( T_JOB* job, int NJ, T_RES* res, int NR, int** sch);
void simulation_P( T_JOB* job, int NJ, T_RES* res, int NR,  int** sch, long t0);
void print_Res_Gantt_table( T_JOB* job, int NJ, T_RES* res, int NR, int** sch);












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

  double obj_f[4]; //celfuggvenyek tombje
  int NR; //number of resources
  T_RES* res;  //pointer
  int r;       //gep futoindexe
  int* sch; //utemterv minden gepre kulon-kulon

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

  printf("\n Gepek (eroforrasok) szama = ");
  scanf("%d", &NR);

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

  sch = (int**) calloc(NR, sizeof(int*));
  for ( r=0; r<NR; r++)
     sch[r] = (int*) calloc(NJ, sizeof(int));

  //adatok generalasa
  generate_data( job, NJ );

  //utemezes
  printf("\n Ad-hoc rendezes:");
   create_schedule(s, NJ);

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

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

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

  //celfuggvenyek megjelenitese
   print_obj_f( obj_f );

   //SPT optimalis eredmenyt ad
  printf("\n SPT rendezes:");
  SPT_rule( job, NJ, s);
  simulation( job, NJ, s, 0); //nulla ref. ido
  Evaluate( job, NJ, obj_f );
  print_execution_data( job, NJ, s);
  print_obj_f( obj_f );

   //EDD optimalis eredmenyt ad a hatarido tullepes minimalizalasakor
  printf("\n EDD rendezes:");
  EDD_rule( job, NJ, s);
  simulation( job, NJ, s, 0); //nulla ref. ido
  Evaluate( job, NJ, obj_f );
  print_execution_data( job, NJ, s);
  print_obj_f( obj_f );

  //MSPT tobb gepre
  MSPT( job, NJ, res, NR, sch);
  simulation_P( job, NJ, res, NR, sch, 0);
  Evaluate( job, NJ, obj_f );
  print_Res_Gantt_table( job, NJ, res, NR, sch);
  print_obj_f( obj_f );




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

  for ( r=0; r<NR; r++)
    free( sch[r] );
  free( sch );  


  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
       job[i].d = 1 + (NJ-i) * rand()%10 + rand() % 100;   //gyartasi hatarido
     }

}

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. \t hat. \t keses");

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

    }
}

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
  double Lmax;   //legnagyobb keses

  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;

     job[i].L = job[i].EndT - job[i].d;
     if ( i==0 )
        Lmax = job[i].L;
     else
        if ( Lmax < job[i].L )
           Lmax = job[i].L;

   }

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

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

}

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]);
   printf("\n \t Lmax = %lf", obj_f[3]);
}

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;

      }


   }
}

void EDD_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] ].d > job[ s[j] ].d )  //hatarido szerint nemcsokkeno sorrend
           index = j;

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

      }


   }
}

void MSPT( T_JOB* job, int NJ, T_RES* res, int NR, int** sch)
{
  //1. fazis: elokeszites
  int* v;
  int i;
  int r;

  v = (int*) calloc(NJ, sizeof(int) );

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

  //renzes
  SPT_rule( job, NJ, v);

  //2. fazis: munkak szetosztasa a gepek kozott
  for ( r=0; r<NR; r++)
    res[r].l = 0; //terheles kezdetben nulla

  for ( i=0; i<NJ; i++)
   {
    //v[i] munka melyik gepre kerul?
    r = i % NR;  //osztasi maradek

    //a kivalsztott munka melyik pozicioba kerul?
    sch[r][ res[r].l ] = v[i];
    res[r].l++; 
   }


  free(v);
}


void simulation_P( T_JOB* job, int NJ, T_RES* res, int NR,  int** sch, long t0)
{
  //A gepek szimulacioja egymastol fuggetlenul elvegezheto, mert a vizsgalt rendszer lehetove teszi.
  int r;

  for ( r=0; r<NR; r++)
    simulation( job, res[r].l, sch[r], t0);

}


void print_Res_Gantt_table( T_JOB* job, int NJ, T_RES* res, int NR, int** sch)
{
  int r;

  for ( r=0; r<NR; r++)
  {
    printf("\n\n %d. gep/munkahely tehelese (%d feladat):", r, res[r].l);
    print_execution_data( job, res[r].l, sch[r]);


  }

}