/*------------------------------------------------------------------------------
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:
1|di|Lmax
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
                long ProcT;  //muveleti ido
                long StartT; //inditasi ido
                long EndT;   //befejezesi ido
                long d;      //hatarido
                long L;      //keses
               } T_JOB;      //munka

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

 void SPT_rule( T_JOB* job, int NJ, int* s);
 void EDD_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);
 void Print_SCH(T_JOB* job, int NJ, int* s);



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
    job[i].d = 10 + (NJ-i)*rand()%100;
    //tovabbi hatarido finomitas lehetseges
    //job[i].d = job[i].ProcT * (1+rand()%5) * i * (1+rand()%10);
    //job[i].d = job[i].ProcT * (1+rand()%5) * (1 + rand()%(NJ-i) ); //hatarido generalas finomitasa

    s[i] = i;  //inic.
   }

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

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

  //eredmeny
  Print_SCH(job, NJ, s);

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

  //eredmenyek megjelenitese
  Print_Objf( &objf);

  //Utemezes EDD szabaly alkalmazasaval
  //Earliest Due Date
  EDD_rule( job, NJ, s);

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

  //eredmeny
  Print_SCH(job, NJ, s);

  //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 EDD_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++)
      if ( job[ s[index] ].d > job[ s[j] ].d )
         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;
   job[ s[0] ].L = job[ s[0] ].EndT - job[ s[0] ].d; //Li = Ci - di


   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;
       job[ s[i] ].L = job[ s[i] ].EndT - job[ s[i] ].d; //Li = Ci - di

     }
 }

 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;

        if ( i == 0 )
              objf->Lmax = job[i].L;
        else  if ( objf->Lmax < job[i].L )
                   objf->Lmax = job[i].L;
     }

     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);
   printf("\n Lmax = %ld", objf->Lmax);
 }

 void Print_SCH(T_JOB* job, int NJ, int* s)
 {
  int i;
  printf("\n Sorsz.\t Munka \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,
             s[i],
             job[ s[i] ].StartT,
             job[ s[i] ].ProcT,
             job[ s[i] ].EndT,
             job[ s[i] ].d,
             job[ s[i] ].L );

 }