/*-------------------------------------------------------------------------------
F|perm|max(Ci)  Ütemezési fedadat szimulációja.
Egyutas előzésnélküli többoperációs termelésütemezési feladat.
A Simulation_FS adott műveleti idők és adott indítási sorrend esetében kiszámítja 
az operációk indítási és befejezési időpontjait.
-------------------------------------------------------------------------------*/


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

typedef struct{
                int id;
                long *ProcT, /*vektorban tarolhato az operaciok ideje*/
                     *StartT,
                     *EndT;
                long T,  /* tardiness, csuszas */
                     d;  /* due date, hatariido */
              }T_JOB;

typedef struct{
               long Cmax;  /*Cmax Completion Time*/
              }T_OBJF;



void Simulation_FS(T_JOB* job, int N, int M, int* sch, long t);
void Evaluation(T_JOB* job, int N, int M, T_OBJF* obj);
void print_Machine_Gantt_FS(T_JOB* job, int N, int M, int* sch);
void print_Job_Gantt_FS(T_JOB* job, int N, int M, int* sch);

int main(int argc, char* argv[])
{
 T_JOB* job;  //munkak adatai
 int M; //gepek szama
 int m; //gepek indexe
 int* sch;
 T_OBJF obj;
 int N; //munkak szama
 int i; //munkak indexe

 printf("\n Kerem a munkak szamat:");
 scanf("%d", &N);
 printf("\n Kerem a gepek szamat:");
 scanf("%d", &M);


 randomize();
 job = (T_JOB*) calloc( N, sizeof(T_JOB));
 for (i=0; i<N; i++)
 {
    job[i].id = i;
    job[i].ProcT = (long*) calloc(M, sizeof(long));
    for (m=0; m<M; m++)
      job[i].ProcT[m] = 1 + random(20);
    job[i].StartT = (long*) calloc(M, sizeof(long));
    job[i].EndT = (long*) calloc(M, sizeof(long));

    job[i].d = 1 + random(10) * random(5) * N;
 }

 sch = (int*) calloc(N, sizeof(int));

 //Ad-hoc
 for (i=0; i<N; i++)
 {
  sch[i]=i; //elore
  //sch[i]=N-1-i;  //vissza
 }

 Simulation_FS(job, N, M, sch, 0);
 Evaluation(job, N, M, &obj);
 printf("\n Ad-hoc sorrend eseten Cmax=%ld", obj.Cmax);
 print_Machine_Gantt_FS(job, N, M, sch);
 printf("\n");
 print_Job_Gantt_FS(job, N, M, sch);
 getch();

 for( i=0; i<N; i++)
    {
     free( job[i].ProcT);
     free( job[i].StartT);
     free( job[i].EndT);
    }
 free (job);

 free (sch);

 return 0;
}

void Simulation_FS(T_JOB* job, int N, int M, int* sch, long t)
{
  int i; //munka futoindexe a vegrehajtas szerint
  int m; //gep futoindexe

  for( i=0; i<N; i++ )
    for ( m=0; m<M; m++ )
    {
      if ( i==0 ) //kezdo munka
      {
        if ( m==0 ) //kezdo gep
        {
          job[ sch[i] ].StartT[m] = t;  //eleje
        }
        else //nem az elso gep
        {
         //elozo geprol mikor erkezik
         job[ sch[i] ].StartT[m] = job[ sch[i] ].EndT[m-1];
        }
      }
      else //nem elso munka
      {
        if ( m==0 ) //kezdo gep
        {
         //elozo munka mikor fejezodik be
         job[ sch[i] ].StartT[m] = job[ sch[i-1] ].EndT[m];
        }
        else //nem az elso gep
        {
        //elozo geprol mikor erkezik, a gep elozo munkaja mikor fejezodik be
        job[ sch[i] ].StartT[m] = max( job[ sch[i] ].EndT[m-1], job[ sch[i-1] ].EndT[m] );
        }
      }
      job[ sch[i] ].EndT[m] = job[ sch[i] ].StartT[m] + job[ sch[i] ].ProcT[m];
    }

}

void print_Machine_Gantt_FS(T_JOB* job, int N, int M, int* sch)
{
 int i, m;

  for(m=0; m<M; m++)
  {

    printf("\n %d gep \n n: \t job \tStartT\t ProcT \t EndT", m);
    for (i=0; i<N; i++)
       printf("\n %d \t %d \t %ld \t %ld \t %ld",
              i,
              sch[i],
              job[sch[i]].StartT[m],
              job[sch[i]].ProcT[m],
              job[sch[i]].EndT[m]
              );
  }
}

void print_Job_Gantt_FS(T_JOB* job, int N, int M, int* sch)
{
 int i, m;

  for (i=0; i<N; i++)
  {
  printf("\n %d munka \n n: \t gep \tStartT\t ProcT \t EndT", i);
  for(m=0; m<M; m++)
       printf("\n %d \t %d \t %ld \t %ld \t %ld",
              i,
              m,
              job[i].StartT[m],
              job[i].ProcT[m],
              job[i].EndT[m]
              );
  }
}

void Evaluation(T_JOB* job, int N, int M, T_OBJF* obj)
{
  int i;
  obj->Cmax = job[0].EndT[M-1];
  for (i=1; i<N; i++)
     if ( job[i].EndT[M-1] > obj->Cmax )
         obj->Cmax = job[i].EndT[M-1];
}