#include "bellman.h"

/***************   Définition des variables globales   ***************/
int ordre;  /* remarque : 
		      les sommets s'appelent 0, 1, ordre-1 */
PERE ** graphe; /* le tableau pour les listes chaînées des pères */
int * distance; /* distance[s] contiendra la distance du sommet
			  s depuis un sommet donné */
int * antecedent; /* antecedent[s] contiendra l'avant-dernier sommet
			    dans un plus court depuis un sommet donné */
int * tableauDatePlusTot;
int * tableauDatePlusTard;
int derniereTache;
int tacheDepart;
int dureeTotaleProjet;
int * num;  /* contiendra la numerotation topologique */
int * deNum; /* contiendra l'inverse de la numerotation topologique.
		       Si num[x] = numero, alors deNum{numero] = x. */
/******************   Fin des variables globales  ************/

int main(void)
{
  char nomFichier[50];
  int r;
  PERE * p, * q;
  int i;
  int reussi;
  

  while( 1 )
	  {
  printf("Indiquez le nom du fichier qui définit le graphe\n");
  scanf("%s",&nomFichier);

  //if (nomFichier == "non") break;
 
  
  construire(nomFichier);
  num = (int *) malloc(ordre * sizeof(int));
  if (num == NULL)
    {
      printf("Pas assez de place\n");
      exit(1);
    }
  deNum = (int *) malloc(ordre * sizeof(int));
  if (deNum == NULL)
    {
      printf("Pas assez de place\n");
      exit(1);
    }
  reussi = triTopologique();
  if (!reussi) printf("Il y a un circuit\n");
  else 
    {
      distance = (int *) malloc(ordre * sizeof(int));
      if (distance == NULL)
	{
	  printf("Pas assez de place\n");
	  exit(1);
	}
	 tableauDatePlusTot = (int *) malloc(ordre * sizeof(int));
      if (tableauDatePlusTot == NULL)
	{
	  printf("Pas assez de place\n");
	  exit(1);
	} 
	tableauDatePlusTard = (int *) malloc(ordre * sizeof(int));
      if (tableauDatePlusTard == NULL)
	{
	  printf("Pas assez de place\n");
	  exit(1);
	}
      antecedent = (int *) malloc(ordre * sizeof(int));
      if (antecedent == NULL)
	{
	  printf("Pas assez de place\n");
	  exit(1);
	}
  //    while( 1 )
	 // {
	  //printf("Depuis quel sommet voulez-vous calculer les distances ? \n");
	 // printf("(taper -1 pour terminer) : ");
	  //scanf("%d", &r);
		r=0;
	  //printf("\n");
	  //if (r == -1) break;
	  printf(" \n \n\n commencons par donner pour chaque etape les dates au plus tot a laquelle elle doit commencer : \n ");
	  algoBellmanLong(r);
	  afficherLong(r);

		
	  printf(" \n \n\n determinons pour chaque etape la date au plus tard a laquelle elle doit commencer  : \n ");
		system("PAUSE");	
	  algoBellmanCourt();
	  printf(" \n determinons les etapes critiques  : \n ");
	  afficherEtapesCritiques();

	//}
      free(distance);
      free(antecedent);
    }

  /*  Désallocation (cette désallocation n'est pas vraiment nécessaire ici
      car la mémoire est de toute façon désallouée à la fin du programme.
      Mais, c'est plus propre, et c'est une bonne habitude de penser à 
      désallouer systématiquement tout espace-mémoire alloué */
  free(num);
  free(deNum);
  for (i = 0; i < ordre; i++)
    {
      p = graphe[i];
      while (p != NULL)
	{
	  q = p;
	  p = p->suivant;
	  free(q);
	}
	}
  free(graphe);
	  }
  return 0;
}

/****************  fonction ecrireValeurs  ************
/* Cette fonction sert à afficher à l'écran les valeurs mises 
   dans un tableau dont les indices sont compris entre 0 et ordre - 1.
   Elle sert ici à vérifier le calcul des degrés extérieurs 
   et celui des numéros topologiques. 
   La fonction désalloue, avant de "retourner", le tableau degreExt.*/
void ecrireValeurs(int * tableau)
{
  int i;

  for ( i = 0; i < ordre; i++)
    printf("Pour %d : %d\n", i, tableau[i]);
  printf("\n");
}