/***

*/

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

#define TAMAX 100000 

void ObtenerDatosArchivos(int argc,char *argv[], int *arreglo, int *longitud );
FILE *AperturaArchivoVerificacion();
void ImprimirDatos( int *arreglo, int longitud );
void  LeerDatosArchivo( FILE *Arch, int *arreglo, int *longitud );
FILE *AbrirArchivo( char ruta_nombre[], char modo_apertura[] );
void CerrarArchivo(  FILE *arch);
int *AsignacionDinaminca( int tamanio);
void LiberarMemoria(int *arreglo);

//Nuevas funciones
int Menu ();
void Proceso(int opcion, int *arreglo, int longitud);


void OrdenarIterBurbuja (int *arreglo, int longitud);
void Intercala(int *ptrOrigen, int *ptrDestino);

int main(int argc,char *argv[])
{
  //arreglo de tamaņo indefinido
  int *arreglo;  
  int longitud=0;
  int opcion=0;
  
  //Asignacion dinamica de espacion en memoria
  arreglo = AsignacionDinaminca(TAMAX); 
  
  //Obtencion de datos    
  ObtenerDatosArchivos(argc, argv, arreglo, &longitud );
  
  /***NUEVO***/
  //  ImprimirDatos(arreglo, longitud );   
  do 
  {
    opcion = Menu ();
    
    Proceso(opcion, arreglo, longitud);
    
  }while (opcion != 10);
     
   
  //Liberar Memoria del apuntador
  LiberarMemoria(arreglo);
  
  return(0); 
 }



     
/**
 */
int *AsignacionDinaminca(int tamanio)
{
  int *arr;
      /***COMPLETE CODIGO **/
      
  return arr;
} 

/**
 */
void LiberarMemoria(int *arreglo)
{
          /***COMPLETE CODIGO **/
}

/**
 */
void ImprimirDatos( int *arreglo, int longitud )
 {
	int cont;
	printf("\n\n\tEl contenido del arreglo es: \n");
	for(cont=0; cont<longitud; cont++)
	{
		if(cont != 0 && cont % 10 == 0 )
		{
                printf("\n");
        }
        
		//printf("\n Arreglo[%d]=%d ", cont, arreglo[cont]);
		printf(" %d ", arreglo[cont]);

	}
}
 
/**
 */ 
void ObtenerDatosArchivos(int argc,char *argv[], int *arreglo, int *longitud )
{
  FILE *arch;
  
  //apertura del archivo en caso de que no se pase el nombre como argumento
  if( argc < 1 )
  {
		arch = AperturaArchivoVerificacion();
  }
  else
  {
	arch= AbrirArchivo( argv[1], "r+");
	if(	arch==NULL) 
	{
		arch = AperturaArchivoVerificacion();
	}
  }
  
  if(arch != NULL)
  {
    //Leer los datos del archivo de texto
    LeerDatosArchivo(arch, arreglo, longitud);   
    CerrarArchivo(arch); 
  }
}

/**
 */
FILE *AperturaArchivoVerificacion()
{
   FILE *arch;
   char ruta_nombre[200]; 
   
   do{
   
      printf("\n\n\tFORMATO Completo (puede auxiliarse del comando 'pwd' para obtener la ruta del archivo");
      printf(" \n Ejemplo: /lab/computacion/PA2/pa/DPPPractica1/Datos.txt");
      printf("\n\n\t Teclee el nombre del archivo:");
      setbuf(stdin, NULL);
	  scanf("%s", &ruta_nombre);
      arch= AbrirArchivo( ruta_nombre, "r+");
   }while(arch == NULL);
}
 
 /** 
*Descripcion: 
*Entrada: 
*Salida: 
**/
void  LeerDatosArchivo( FILE *Arch, int *arreglo, int *longitud )
{  
   int valor;
  *longitud=0;
  
       /***COMPLETE CODIGO **/
  
}


/** 
*Descripcion: 
*Entrada: 
*Salida: 
**/
FILE *AbrirArchivo( char ruta_nombre[], char modo_apertura[] )
{
   FILE *arch;
   
   arch=fopen(ruta_nombre,modo_apertura);
   
   if(arch==NULL)
   {
                 printf("\n\n\tERROR AL ABRIR EL ARCHIVO %s", ruta_nombre);
   }
   else
   {
                 printf("\n\tEl archivo se abrio con exito!!!");               
   }
   return (arch);
}

/** 
*Descripcion: 
*Entrada: 
*Salida: 
**/
void CerrarArchivo(  FILE *arch)
{
  fclose(arch);
}

/****************************** NUEVO ******************************/
/**
*/
int Menu ()
{
 int op;
 do 
  {
     printf(" \n \n\n\t MENU PRINCIPAL ");   
     printf(" \n 1) Algoritmo Iterativo de Ordenamiento - Burbuja");
     printf(" \n 2) Algoritmo Iterativo de Ordenamiento - Seleccion");
     printf(" \n 3) Algoritmo Iterativo de Ordenamiento - Inserccion"); 
     printf(" \n 4) Algoritmo Recursivo de Ordenamiento - QuickSort");
     printf(" \n 5) Algoritmo Recursivo de Ordenamiento - MergeSort");
     printf(" \n 6) Algoritmo Iterativo de Busqueda  - Secuencial");
     printf(" \n 7) Algoritmo Iterativo de Busqueda  - Binario (con ordenamiento)");
     printf(" \n 8) Algoritmo Recursivo de Busqueda  - Binario Rec. (con ordenamiento)");
     printf(" \n 9) Imprimir el Arreglo");
     printf(" \n 10) Salir"); 
     printf("\n Seleccion: ");
     scanf("%d", &op);
     
     if(  op < 1 ||  op > 10 )
     {
          printf("\n\t Seleccion incorrecta ");
     }
 }while ( op < 1 ||  op > 10);
 return op;
}

/**
*/
void Proceso(int opcion, int *arreglo, int longitud)
{
    time_t inicial, final;
    //Obtener el tiempo incial de ejecucion del algortimo
    inicial = time( NULL );


    switch (opcion)
    {
           case (1):{
                     printf("\n\n\t ORDENAMIENTO ITERATIVO - BURBUJA");
                     OrdenarIterBurbuja (arreglo, longitud);
                     break;
                     }
           case (2):{
                     printf("\n\n\t ORDENAMIENTO ITERATIVO - SELECCION");
                     //OrdenarIterSeleccion (arreglo, longitud);
                     break;
                     }
           case (3):{
                     printf("\n\n\t ORDENAMIENTO ITERATIVO - ISERCCION");
                     //OrdenarIterInserccion (arreglo, longitud);
                     break;
                     }
           case (4):{
                     printf("\n\n\t ORDENAMIENTO RECURSIVO - QUICKSORT");
                     //Verificar parametro fin
                     //OrdenarRecQuicksort (arreglo, 0, longitud); 
                     break;
                     }
           case (5):{
                     printf("\n\n\t ORDENAMIENTO RECURSIVO - MERGESORT");
                     //Verificar parametro fin
                     //OrdenarRecMergesort(arreglo, 0, longitud); 
                     break;
                     }
           case (6):{                     
                     printf("\n\n\t BUSQUEDA ITERATIVO  - SECUENCIAL");                     
                     printf("\n\t\tTeclee el elemento a buscar:");
                     scanf("%d", &elemento);
                     //BusquedaIterSecuencial(arreglo, longitud, elemento); 
                     break;
                     }
           case (7):{
                     printf("\n\n\t BUSQUEDA ITERATIVO  - BINARIO (ORDENAMIENTO POR XXXX ");
                     printf("\n\t\tTeclee el elemento a buscar:");
                     scanf("%d", &elemento);
                     
                     //Seleccione uno delos algoritmos de ordenamiento
                     //OrdenamientoXXXXXX
                     //BusquedaIterBinario(arreglo, longitud, elemento); 
                     break;
                     }                     
           case (8):{
                     printf("\n\n\t BUSQUEDA RECURSIVO  - BINARIO (ORDENAMIENTO POR XXXX ");
                     printf("\n\t\tTeclee el elemento a buscar:");
                     scanf("%d", &elemento);
                     
                     //Seleccione uno delos algoritmos de ordenamiento
                     //OrdenamientoXXXXXX

                     //Verificar el parametro de longitud
                     //BusquedaRecBinario(arreglo, 0, longitud, elemento); 
                     break;
                     }                                        
           case (9):{
                     printf("\n\n\t IMPRIMIR ARREGLO ");
                     ImprimirDatos(arreglo, longitud );                           
                     break;
                     }

    }
    //Obtener el tiempo final de ejecucion del algortimo
    final  = time( NULL );
      //Diferencia de tiempo  
    printf("\n\n\t El tiempo total es: %lf", difftime(final, inicial));
  
}

/**
*/
void OrdenarIterBurbuja (int *arreglo, int longitud)
{

  int cont1, cont2;


  for (cont1=0; cont1 < longitud-1; cont1++)
  {

	for ( cont2 =0; cont2< longitud -cont1 - 1 ; cont2++)
	{		
		if(arreglo[cont2] >= arreglo[cont2 + 1])
		{
			//printf("\n intercala: a[%d]: %d - a[%d]:%d", cont2, arreglo[cont2], cont2+1, arreglo[cont2+1]);
			Intercala(&arreglo[cont2],&arreglo[cont2+1] );
		}
	}
  }
}

/**
*/
void Intercala(int *ptrOrigen, int *ptrDestino)
{
  int auxiliar=0;

  if(*ptrOrigen != *ptrDestino) 
  {
	auxiliar = *ptrOrigen ;
	
	*ptrOrigen = *ptrDestino;

	*ptrDestino = auxiliar;
   }
}