/*------------------------------------------------------------------------------
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 idopont
                long EndT; //befejezesi idopont
                } T_JOB;

void Simulation( T_JOB* job, int NJ, int* s, long ref_time);
void Evalute( T_JOB* job, int NJ, double* objf);
void Print_objf( double* objf);
void SPT_rule( T_JOB* job, int NJ, int* s);

int main ( )
{
  int NJ; //number of jobs
  int i;  //job index
  int* s;  //utemterv
  double objf[3]; //statikus

  T_JOB* job;

  printf("\n Demo utemeyes egy eroforrasra Csum celfv-vel");
  printf("\n Kerem a munkak szamat:");
  scanf("%d", &NJ); //nincs ellenorzes

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

  //input generalasa
  for ( i=0; i<NJ; i++)
   {
     job[i].id = i;
     job[i].ProcT = rand() % 20;
     s[i] = i; //as-hoc sorrend
   }

   //ad-hoc
   Simulation( job, NJ, s, 0);
   Evalute( job, NJ, objf);
   printf("\n Ad-hoc sorrend eseten:");
   Print_objf( objf);

     //SPT-rule
   SPT_rule( job, NJ, s);
   Simulation( job, NJ, s, 0);
   Evalute( job, NJ, objf);
   printf("\n SPT sorrend eseten:");
   Print_objf( objf);

  free( job );
  free( s );

  getch();

  return 1;
}

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

  job[ s[0] ].StartT = ref_time;
  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 Evalute( T_JOB* job, int NJ, double* objf)
{
 int i;
 double Cmax;
 double Csum;
 double WIP;
 Csum = 0;
 Cmax = job[0].EndT;

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

    Csum += job[i].EndT;
  }

  WIP = Csum / Cmax;

  objf[0] = Cmax;
  objf[1] = Csum;
  objf[2] = WIP;
}

void Print_objf( double* objf)
{
  printf("\n Cmax=%lf", objf[0]);
  printf("\n Csum=%lf", objf[1]);
  printf("\n WIP=%lf", objf[2]);

}

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

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

  for ( i=0; i<NJ-1; i++)
   {
    index = i;
     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;
       }
    }
}