/*-------------------------------------------------------------------------------
P||Szum(Ci)  Utemezesi fedadat megoldasa MSPT ütemezési szabály alkalmazásával.
Párhuzamos gépes termelésütemezési feladat.
Az ütemezés célja a munkák befejezési időpontjai összegének minimalizálása, 
ezáltal az átlagos készletszint minimalizálása.
MSPT Modified Shortest Processing Time 
módosított legrövidebb műveleti idejű munka előre:
Alkalmazzuk az SPT szabályt a munkák sorbarendezésére (műveleti idők alapján nemcsökkenő sorrendbe),
ezután képezzünk a gépek számának (m) megfelelő hosszú csoportokat. 
Az első csoport munkái az elsők rendre az egyes gépeken, 
a második csoport munkái a másodikok rendre az egyes gépeken stb.
Feltétel, hogy a munkák és a gépek számának hányadosa (n/m) egész legyen, 
ezt teljesíthetjük, ha bizonyos számú 0 műveleti idejű fiktív munkát hozzáadunk a rendeléscsoporthoz.
A megoldás optimális ütemtervet eredményez. 
-------------------------------------------------------------------------------*/

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

typedef struct {
                int id;
                long int SetT,
                         ProcT,
                         OpT,
                         StartT,
                         EndT,
                         D,
                         L;
                }T_JOB;

typedef struct {
                int id;
                int l; /*load*/
                long int C; /*completion time*/
               }T_MACHINE;

typedef struct {
               long Cmax,  /*utolso job bef. idopontja*/
                    Csum; /* bef. idok osszege*/
               }T_OBJF;    /*celfuggvenyek*/

void simulation(T_JOB* job, int** sch, int NJ, T_MACHINE* machine, int NM, long t);
void evaluation(T_JOB* job, int NJ, T_OBJF* objf);
void print_objf(T_OBJF* objf);
void print_Gantt(T_JOB* job, int** sch, int NJ, T_MACHINE* machine, int NM);
void SPT_rule(T_JOB* job, int* r, int NJ);
void EDD_rule(T_JOB* job, int* r, int NJ);

int main(int argc, char* argv[])
{
  int NJ; /* munkak szama*/
  int NM; /* gepek szama*/

  int i, j;
  T_JOB* job; /* munkak strvektre mutato*/
  int** sch; /* utemterv */
  T_OBJF objf;
  /* modellepites, utemezes, szimulacio, ertekeles*/

  /*modellepites*/
  printf("\n Kerem a munkak aktualis szamat:");
  scanf("%d", &NJ);

  job = calloc(sizeof(T_JOB), NJ);
  randomize();
  for (i=0; i<NJ; i++)
   {
    job[i].id = i;
    job[i].SetT = 1 + random(10);
    job[i].ProcT = 1 + random(100);
    job[i].OpT = job[i].SetT + job[i].ProcT;
    job[i].D = 1 + random(50) + job[i].OpT*random(5);
   }

  /*utemezes*/
  sch = calloc(sizeof(int*), NM);
  for (i=0; i<NM; i++)
     sch[i] = calloc(sizeof(int), NJ);



  /*Ad-hoc*/
  printf("\n AD-HOC sorrend: \n");
  /*szimulacio*/
 // simulation(job, sch, NJ, 0);
  /*ertekeles*/
  evaluation(job, NJ, &objf);
  //print_Gantt(job, sch, NJ);
  print_objf(&objf);




  getch();

  for(i=0; i<NM; i++)
     free(sch[i]);
  free(sch);
  free(job);
 return 0;
}
//---------------------------------------------------------------------------

void simulation(T_JOB* job, int** sch, int NJ, T_MACHINE* machine, int NM, long t)
{
  int i;
  int m;
  for (m=0; m<NM; m++)
  {
  i=0;
  job[ sch[m][i] ].StartT = t;
  job[ sch[m][i] ].EndT = job[ sch[m][i] ].StartT + job[ sch[m][i] ].OpT;

  for (i=1; i<machine[m].l; i++)
  {
    job[ sch[m][i] ].StartT = job[ sch[m][i-1] ].EndT;
    job[ sch[m][i] ].EndT = job[ sch[m][i] ].StartT + job[ sch[m][i] ].OpT;
  }

  }
}

void evaluation(T_JOB* job, int NJ, T_OBJF* objf)
{
 int i;
 objf->Csum = 0;
 objf->Cmax = 0;

 for (i=0; i<NJ; i++ )
 {
  objf->Csum += job[i].EndT;

  job[i].L = job[i].EndT - job[i].D; /*keses*/

  if (i==0) objf->Cmax = job[i].EndT;
  else if ( objf->Cmax < job[i].EndT ) objf->Cmax = job[i].EndT;

 }
}

void print_objf(T_OBJF* objf)
{
 printf("\n Csum= %ld", objf->Csum);
 printf("\n Cmax= %ld", objf->Cmax);
}

void print_Gantt(T_JOB* job, int** sch, int NJ, T_MACHINE* machine, int NM)
{
 int i;
 int m;
 for (m=0; m<NM; m++)
 {

 printf("\n machine_%d \n", m);
 printf("\n n: job_id \t StarT \t OpT \t EndT \t D \t L");

 for ( i=0; i<machine[m].l; i++)
 {
  printf("\n %d: job_%d \t %ld \t %ld \t %ld \t %ld \t %ld",
  i,
  sch[m][i],
  job[ sch[m][i]].StartT,
  job[ sch[m][i]].OpT,
  job[ sch[m][i]].EndT,
  job[ sch[m][i]].D,
  job[ sch[m][i]].L);

 }

 }//m
}

void SPT_rule(T_JOB* job, int* r, int NJ)
{
 int i, j, temp;
 for (i=0; i<NJ-1; i++)
  for (j=i+1; j<NJ; j++)
   {
     if ( job[ r[i] ].OpT > job[ r[j] ].OpT )
       {
        temp = r[j];
        r[j] = r[i];
        r[i] = temp;
       }
   }

}


void EDD_rule(T_JOB* job, int* r, int NJ)
{
 int i, j, temp;
 for (i=0; i<NJ-1; i++)
  for (j=i+1; j<NJ; j++)
   {
     if ( job[ r[i] ].D > job[ r[j] ].D )
       {
        temp = r[j];
        r[j] = r[i];
        r[i] = temp;
       }
   }

}