/*------------------------------------------------------------------------------
TIA 2. gyakorlat
Egygépes termelésütemezési feladat modellezése és megoldása.
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<stdlib.h>

typedef struct {
                int id;      //azonosito
                long ProcT;  //muveleti ido
                long StartT; //inditasi ido
                long EndT;   //befejezesi ido
               } T_JOB;      //munka

typedef struct {
                long Cmax;   //utolso munka bef. idopontja
                long Csum;   //befejezesi idopontok osszege
                double ASL;  //atlagos keszletszint
               } T_OBJF;     //celfuggveny

 void SPT_rule( T_JOB* job, int NJ, int* s);
 void Simulation( T_JOB* job, int NJ, int* s, long t0);
 void Evaluate( T_JOB* job, int NJ, T_OBJF* objf);
 void Print_Objf( T_OBJF* objf);


int main(int argc, char* argv[])
{
  T_JOB* job;   //munkak vektorara mutato pointer
  T_OBJF objf;  //celfuggveny
  int NJ;       //munkak szama
  int i;        //job id futoindexe
  int* s;       //utemtervre mutato pointer


  printf("\n Munkak szama:");
  scanf("%d", &NJ); //ellenorzes nincs

  job = (T_JOB*) calloc( NJ, sizeof(T_JOB) ); //strukturavektor
   s = (int*) calloc(NJ, sizeof(int) );       //egeszvektor

  //term.info.rendszerbol lekerdezes helyett random adatok
  for (i=0; i<NJ; i++)
   {
    job[i].id = i;
    job[i].ProcT = 1 + rand()%20;  //1 es 20 kozotti veletlenszam
    s[i] = i;  //inic.
   }

  //Utemezes SPT szabaly alkalmazasaval
  //Shortest Processing Time
  SPT_rule( job, NJ, s);

  //szimulacio
  Simulation( job, NJ, s, 0);

  //celfuggveny szamitasa
  Evaluate( job, NJ, &objf);

  //eredmenyek megjelenitese
  Print_Objf( &objf);


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

  printf("\n Demo vege.");
  getch();

  return 1;
}
//---------------------------------------------------------------------------

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

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

  //rendezes
  for(i=0; i<NJ-1; i++)
  {
   index = i;
   for (j=i+1; j<NJ; j++)
      //javitott BUG
      //if ( job[ s[i] ].ProcT < job[ s[j] ].ProcT )
      if ( job[ s[index] ].ProcT > job[ s[j] ].ProcT )
         index = j;

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

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

   job[ s[0] ].StartT = t0; //referencia idopont
   job[ s[0] ].EndT = job[ s[0] ].StartT
                      + job[ s[0] ].ProcT;

   for( i=1; i<NJ; i++)
     {
       job[ s[i] ].StartT = job[ s[i-1] ].EndT;
       job[ s[i] ].EndT = job[ s[i] ].StartT
                          + job[ s[i] ].ProcT;
     }
 }

 void Evaluate( T_JOB* job, int NJ, T_OBJF* objf)
 {
    int i;

    objf->Csum = 0;
    objf->Cmax = job[0].EndT;

    for(i=0; i<NJ; i++)
     {
        objf->Csum += job[i].EndT;      //soronkent szamoljuk a lepcsos fv alatti teruletet
        if ( job[i].EndT > objf->Cmax ) //legkesobbi befejezesi idopont
             objf->Cmax = job[i].EndT;
     }

     objf->ASL = (double) objf->Csum / objf->Cmax;  //atlagos keszletszint

 }

 void Print_Objf( T_OBJF* objf)
 {
   printf("\n Csum = %ld", objf->Csum);
   printf("\n Cmax = %ld", objf->Cmax);
   printf("\n ASL = %lf", objf->ASL);
 }