/*------------------------------------------------------------------------------
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; //azonosito
                long ProcT; //muveleti ido
                long StartT; //inditasi idopont
                long EndT; //befejezesi idopont
                long d;    //hatarido
                long L;    //keses
                } 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);
void EDD_rule( T_JOB* job, int NJ, int* s);
void Print_Sch( T_JOB* job, int NJ);


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

  T_JOB* job;

  srand( (unsigned) time(&t) );
  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++)
   { //Termelesinformatikai rendszerbol lekerdezheto a valosagban
     job[i].id = i;
     job[i].ProcT = 1 + rand() % 20;
     job[i].d = job[i].ProcT + (NJ - i)*rand()%100; //tesztelheto mas semaval
     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);

   EDD_rule( job, NJ, s);
   Simulation( job, NJ, s, 0);
   Evalute( job, NJ, objf);
   printf("\n EDD sorrend eseten:");
   Print_Sch( job, NJ);
   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;
 double Lmax;

 Csum = 0;
 Cmax = job[0].EndT;

 job[0].L = job[0].EndT - job[0].d; //keses
 Lmax = job[0].L;

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

    Csum += job[i].EndT;

    job[i].L = job[i].EndT - job[i].d; //keses
    if ( Lmax < job[i].L )
         Lmax = job[i].L;
  }

  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, 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;
       }
    }
}

void EDD_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] ].d > job[ s[j] ].d )
         index = j;

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

void Print_Sch( T_JOB* job, int NJ)
{
  int i;
  printf("\n id \t Start \t ProcT \t End \t d \t L");
  for ( i=0; i<NJ; i++)
     printf("\n %d \t %ld \t %ld \t %ld \t %ld \t %ld",
                i,
                job[i].StartT,
                job[i].ProcT,
                job[i].EndT,
                job[i].d,
                job[i].L );

}