/*------------------------------------------------------------------------------
TIA 3. 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.

TIA 4. gyakorlat
ovábbfejlesztés: Határidős munkák utemezése a legnagyobb késés minimalizálása érdekében.
Egygépes termelésiütemezési feladat.
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.

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

#include<stdio.h>
#include<stdlib.h>

typedef struct{
               int id;   //azonosito: 0,1, ...
               long ProcT; //muveleti ido
               long StartT; //kezdeti ido
               long EndT;   //befejezesi ido
               long d;      //hatarido
               long L;      //keses
               } T_JOB; //munka

void Simulation( T_JOB* job, int NJ, int* s, long t0);
void Evaluate( T_JOB* job, int NJ, double* obj_val);
void print_obj_val( double* obj_val);
void print_job_Gantt(T_JOB* job, int NJ, int* s);
void SPT_rule(T_JOB* job, int NJ, int* s);
void EDD_rule(T_JOB* job, int NJ, int* s);


int main(int argc, char* argv[])
{
  T_JOB* job;   //munkak strukturavektora
  int NJ;       //munkak szama
  int i;        //munka indexe
  int* s;        //utemterv
  double obj_val[4];  //celfuggvenyek

  printf("\n Egygepes gyartorendszer iranyitasa");
  printf("\n Munkak szama=");
  scanf("%d", &NJ);  //betolti az erteket

                    //ellenorzes nincs
   job = (T_JOB*) calloc(NJ, sizeof(T_JOB) ); //vektor
   s = (int*) calloc(NJ, sizeof(int) );       //vektor

   //input adatok generalasa
   //valos kornyezetben ezek a term.info. rsz-bol jonnek
   for ( i=0; i<NJ; i++)
     {
       job[i].id = i;
       job[i].ProcT = 1 + rand() % 50; //veletlen szam
       job[i].d = job[i].ProcT + rand() % 200;
       s[i] = i;    //ad-hoc sorrend
     }

   //Ad_hoc
   printf("\n Ad-hoc sorrend:");
   Simulation( job, NJ, s, 0); //t0 = 0
   Evaluate( job, NJ, obj_val);
   print_job_Gantt(job, NJ, s);
   print_obj_val( obj_val);

   //SPT
   printf("\n SPT sorrend:");
   SPT_rule(job, NJ, s);
   Simulation( job, NJ, s, 0); //t0 = 0
   Evaluate( job, NJ, obj_val);
   print_job_Gantt(job, NJ, s);
   print_obj_val( obj_val);

   //EDD
   printf("\n EDD sorrend:");
   EDD_rule(job, NJ, s);
   Simulation( job, NJ, s, 0); //t0 = 0
   Evaluate( job, NJ, obj_val);
   print_job_Gantt(job, NJ, s);
   print_obj_val( obj_val);

   free( job );
   free( s );

   getch();

   return 0;
}
//---------------------------------------------------------------------------
void Simulation( T_JOB* job, int NJ, int* s, long t0)
{  //egyidoben csak egy munka vegezheto
   //a gep folyamatosan rendelkezesre all
   //a muveleti ido magaban foglalja az atallasi idot is

   int i;

   for( i=0; i<NJ; i++ )
     {
       if ( i == 0 )
           job[ s[0] ].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 Evaluate( T_JOB* job, int NJ, double* obj_val)
{
  double WIP;  //atlagos keszletszint
  double Csum;  //befejezesi idopontok osszege
  double Cmax;  //utolso munka befejezesi idopontja
  double Lmax;  //legnagyobb keses

  int i;

  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;

      //keses  = befejezes   - hatarido
      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;

   }

  WIP = Csum/Cmax;

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

}

void print_obj_val( double* obj_val)
{
  printf("\n Csum = %lf", obj_val[0]);
  printf("\n Cmax = %lf", obj_val[1]);
  printf("\n WIP = %lf", obj_val[2]);
  printf("\n Lmax = %lf", obj_val[3]);
}

void print_job_Gantt(T_JOB* job, int NJ, int* s)
{
   int i;
   printf("\n\t sor \t job \t start \t proc \t end \t d \t L");
   for ( i=0; i<NJ; i++ )
        printf("\n\t %d \t %d \t %ld \t %ld \t %ld \t %ld \t %ld"
                , i
                , 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 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;
     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;
     for( j=i+1; j<NJ; j++)
        if ( job[ s[index] ].d > job[ s[j] ].d ) //Earliest Due Date
            index = j;

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