#include <stdio.h>
#include <stdlib.h>
#include "variables.h"

void mensaje_de_error (void);
void ver_resultado (Ruta_DistT, int, int, int);

main (int argc, char *argv[])
{
  FILE *GRAFODATA;				//Descriptor del archivo con datos del grafo
  MatrizT Matriz;				//Matriz de adyacencias
  Ruta_DistT Ruta_Dist;				//Resumen de rutas y distancias
  int i,j, 					//Contadores
      N_Vertices, 				//Número de vértices en el grafo
      origen, 					//Vértice origen
      destino,					//Vértice destino	
      error = 0;				//Flag de error

  if ((argc < 2) || (argc > 3))                 //Si hay error en cantidad de parámetros...
     mensaje_de_error();                        //...informar al usuario....
   else                                         //No hay error en la cantidad de parámetros
     {
	GRAFODATA = fopen (argv[1], "r");	//Intentar abrir el archivo
	if (GRAFODATA == NULL)			//Si el archivo no existe...
	   mensaje_de_error();
	 else					//Hasta ahora, todo bien con los parámetros...
           {
	     N_Vertices = Calc_N_Vertices(GRAFODATA); //Calcular cantidad de nodos
	     if ((argc == 3) && ((origen = atoi(argv[2])) >= N_Vertices)) //Epa!! El nodo origen especificado NO existe!!
	       {
		mensaje_de_error();		//Informar al usuario
		error = 1;			//Setear flag de error.
               }//EndIf
              else
                if (argc == 2)			//No se especificó un nodo de origen...
		   origen = 0;			//Así que asignamos el origen por defecto
	     if (error == 0)			//Ahora si, tuito en orden...
                {
     		  Matriz = (MatrizT)Crear_Matriz (GRAFODATA, N_Vertices); //Crear la matriz de adyacencias
		  printf ("Matriz de adyacencias: \n");
		  for (i = -1; i < N_Vertices; i++)			  //Mostrar la matriz al usuario
		    for (j = 0; j < N_Vertices; j++)
		     {
		       if (i == -1)
		          printf ("  %d \t",j);
 		        else
			  printf ("%.2f \t", Matriz[i][j]);
		       if (j == (N_Vertices - 1))
			  printf ("\n");
		     }//EndFor						//Listo mostrar matriz
		  printf ("\n");
	          for (destino = 0; destino < N_Vertices; destino++)	//Aplicar Dijkstra a cada destino posible
		    {  
		      if (destino != origen)				//Obviamente, fijarse que destino != origen!!
			{
		          Ruta_Dist = (Ruta_DistT)OSPFdijkstra (Matriz, origen, destino, N_Vertices); 	//Aplicar Dijkstra
		          ver_resultado (Ruta_Dist, origen, destino, N_Vertices);			//Mostrar Resultado
		          Matriz = (MatrizT)Crear_Matriz(GRAFODATA, N_Vertices);			//Re-cargar matriz
			}//EndIf
		    }//EndFor
		  Destruir_Matriz (Matriz, N_Vertices);		//Liberar memoria
		 }//EndIf
	     }//EndElse
     }//EndElse
}//EndMain

//*****************************************************************************************************
//Funcion mensaje_de_error
//Si hubo error en los parámetros de la línea de comandos, se informa al usuario
void mensaje_de_error (void)
{
       printf ("\nError: Parámetos mal ingresados o el archivo especificado NO existe! \n");  //...informar al usuario....
       printf ("Modo de uso: \n");
       printf ("./dijkstra archivografo [nodo_de_origen]\n");
       printf ("\n");
       printf ("\"archivografo\" especifica el archivo del cual cargar el grafo\n\n");
       printf ("nodo_de_origen es un parámetro opcional que indica para que nodo de origen calcular las distancias\n");
       printf ("Por defecto, nodo_de_origen adopta el valor 0\n\n");
       printf ("No se me olvide que el nodo de origen especificado debe existir en el grafo!!\n\n");
}//End mensaje_de_error

//*****************************************************************************************************
//Función ver_resultado
//Esta función muestra la ruta más corta desde un nodo específico a otro
//El algoritmo de Dijkstra implementado en este programa, entrega una lista de saltos invertida (desde el destino hacia atrás)
//así que hay que ordenarla primero.
void ver_resultado (Ruta_DistT Ruta_Dist, int origen, int destino, int N_Vertices)
{
  int saltos = 0,	//Numero de saltos
      *Ruta,		//Secuencia de saltos ordenada
      vactual,		//Vertice actual
      i;		//Contador

  Ruta = (int *) malloc (N_Vertices*sizeof(int));	//Asignar memoria
  vactual = destino;					//Ir de atrás pa'delante...
  i = 0;
  do
   {
     Ruta[i] = vactual;					//Guardar el vértice actual en la lista de saltos
     i++;
     if (vactual != origen)				//Esto se usa para calcular la cantidad de saltos de la ruta
        saltos++;
     vactual = Ruta_Dist[vactual].ruta;			//Pasar al vertice anterior al actual en la ruta
   }
  while (vactual != origen);				//Repetir hasta que llegamos al origen.
  Ruta[i] = origen;					
  
  //Lo que sigue, es el despliegue de la información asociada a cada par origen-destino. 
  //Se detalla la cantidad de saltos, la métrica de la ruta y la ruta completa.

  printf ("Origen : %d ; Destino : %d\n",origen, destino);
  printf ("Número de saltos: %d\n", saltos);
  printf ("Métrica: %.4f\n", Ruta_Dist[destino].dist);
  printf ("Ruta   : ");
  for (i = saltos; i >= 0 ; i--)
    {
      printf ("%d ",Ruta[i]);
      if (i > 0)
         printf ("- ");
       else
         printf ("\n\n");
    }//EndFor
  free (Ruta);
}//Endver_resultado