/*------------------------------------------------------------------------------
1||Szum(Ci)  Utemezesi fedadat megoldasa SPT ütemezési szabály alkalmazásával.
Egygépes termelésiütemezési feladat.
Az ütemezés célja a befejezési idők összegének minimalizálása, 
ezáltal az átlagos készletszint minimalizálása.
SPT Shortest Processing Time (műveleti idő szerint nemcsökkenő munkasorrend)
A megoldás optimális ütemtervet eredményez. 
-------------------------------------------------------------------------------*/



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

typedef struct{
                long id,
                     SetT,
                     ProcT,
                     OptT,
                     StartT,
                     EndT;
              }T_JOB;

int scheduler(int* Sch, T_JOB* job, int n);
long simulation(int* Sch, T_JOB* job, int n, long ref_T);

int main(int argc, char* argv[])
{
 T_JOB* job;
 int n; //jobok darabszama
 int i; //job futoindex
 int * Sch; //utemterv
 long sum_EndT;
 //virtualis adatbazis lekerdeze
 randomize();
 printf("\n Kerem a jobok szamat:");
 scanf("%d", &n); //n erteket kap bill-rol
 job = (T_JOB*) calloc(n, sizeof(T_JOB) );
 for (i=0; i<n; i++)
 {
  job[i].id = i;
  job[i].SetT = random (10) + 10;
  job[i].ProcT = random (100) + 10;
  job[i].OptT = job[i].SetT + job[i].ProcT;

 }

 //utemterv generalasa! MES modul
 //STP elv alkalmazasa optimalis megoldast ad
 //a befejezesi idok osszege szempontjabol
 Sch = (int*) calloc(n, sizeof(int));
 scheduler(Sch, job, n);
 //ell
 printf("\n Sch: \n ");
 for (i=0; i<n; i++)
   printf("\n jobid = %d \t OptT: %ld", Sch[i], job[Sch[i]].OptT );

 //finomprogram generalas szimulacioval
 sum_EndT = simulation(Sch, job, n, 0);

 //ell
 printf("\n Fine Sch: \n ");
 for (i=0; i<n; i++)
   printf("\n jobid = %d \t StartT: %ld \t EndT: %ld", Sch[i], job[Sch[i]].StartT, job[Sch[i]].EndT );

 printf("\n Bef. idop. osszege: %ld", sum_EndT);

 getch();
 free(Sch);
 free(job);
        return 0;
}
//---------------------------------------------------------------------------

int scheduler(int* Sch, T_JOB* job, int n)
{
 int i, j, temp;
 for (i=0; i<n; i++)
  Sch[i]=job[i].id;

 for (i=0; i<n-1; i++)
  for (j=i+1; j<n; j++)
   if (job[ Sch[i] ].OptT > job[ Sch[j] ].OptT)
   { //nem csokkeno OptT ertek szerint
     temp = Sch[i];
     Sch[i] = Sch[j];
     Sch[j] = temp;
   }
 return 1;
}

long simulation(int* Sch, T_JOB* job, int n, long ref_T)
{
 long sum_EndT = 0;
 int i;
 job[Sch[0]].StartT = ref_T; //kezdet
 job[Sch[0]].EndT = job[Sch[0]].StartT + job[Sch[0]].OptT;
 sum_EndT = job[Sch[0]].EndT;

 for (i=1; i<n; i++)
 {
  job[Sch[i]].StartT = job[Sch[i-1]].EndT;
  job[Sch[i]].EndT = job[Sch[i]].StartT + job[Sch[i]].OptT;
  sum_EndT += job[Sch[i]].EndT;
 }
 return sum_EndT;
}