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

Tová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>
#include<time.h>

#define N_OBJF 4

typedef struct {
                int id;
                long ProcT; //muveleti ido
                long StartT;  //inditasi idopont
                long EndT;    //befejezesi idopont
                long d;        //hatarido
                long L;        //keses
               } T_JOB;

void Simulate( T_JOB* job, int NJ, int* s, long t_ref);
void Evalute( T_JOB* job, int NJ, double* objf);
void Print_objf(double* objf);
void SPT_rule( T_JOB* job, int NJ, int* s);
void EDD_rule( T_JOB* job, int NJ, int* s);

int main()
{
 int NJ; //munkak szama
 T_JOB* job; //munkak adatait
 int i;
 int* s;  //utemterv
 double objf[N_OBJF];
 time_t t;

 srand( time(&t) ); //veletlenszam generator inic.

 printf("\n Kerem a munkak szamat:");
 scanf("%d", &NJ); //vedelem nincs

 job = (T_JOB*) calloc(NJ, sizeof(T_JOB) ); //strukturavektor
 s = (int*) calloc(NJ, sizeof(int));
 //input adatok generalasa
 //valos rendszbol ezek lekerdezhetok
 for ( i=0; i<NJ; i++)
  {
   job[i].id = i;
   job[i].ProcT = 1 + rand()%20;
   job[i].d = job[i].ProcT + (NJ-i)*rand()%100;

   s[i] = i; //inic. utemterv AD-HOC sorrend
  }

 //Ad-hoc sorrendet
  printf("\n Ad-hoc sorrend szerinti vegrehajtas:");
  Simulate( job, NJ, s, 0); //referencia ido 0
  Evalute( job, NJ, objf);
  Print_objf(objf);

 //SPT sorrendet
  printf("\n SPT sorrend szerinti vegrehajtas:");
  SPT_rule( job, NJ, s);
  Simulate( job, NJ, s, 0); //referencia ido 0
  Evalute( job, NJ, objf);
  Print_objf(objf);

 //EDD sorrendet
  printf("\n EDD sorrend szerinti vegrehajtas:");
  EDD_rule( job, NJ, s);
  Simulate( job, NJ, s, 0); //referencia ido 0
  Evalute( job, NJ, objf);
  Print_objf(objf);

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

 getch();
 return 1;
}

void Simulate( T_JOB* job, int NJ, int* s, long t_ref)
{
  int i;

  job[ s[0] ].StartT = t_ref;
  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;  //Work in process, atlagos keszletszint
 double Lmax;

 Csum = 0;
 Cmax = job[0]. EndT;
 job[0].L = job[0].EndT - job[0].d;
 Lmax = job[0].L;

 for (i=0; i<NJ; i++)
  {
   job[i].L = job[i].EndT - job[i].d;
   if ( job[i].L > Lmax )
        Lmax = job[i].L;

   Csum += job[i].EndT;
   if ( Cmax < job[i].EndT )
        Cmax = job[i].EndT;
  }

  WIP = Csum / Cmax;

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

}

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

}

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

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

  for ( i=0; i<NJ-1; i++)
   {
     index = i;
     for (j=i+1; j<NJ; j++)
        if ( job[ s[j] ].ProcT < job[ s[index] ].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, temp, index;

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

  for ( i=0; i<NJ-1; i++)
   {
     index = i;
     for (j=i+1; j<NJ; j++)
        if ( job[ s[j] ].d < job[ s[index] ].d )
             index = j;

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

}