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

#define SIZE_FULL_PATH_FILE 1024
//---------------------------------------------------------------------------
//Variables globales
typedef enum { false, true } bool;

typedef struct _Ventas {
    char nombre[10];
    int contadorventas;
    int ID;
}Ventas;

typedef struct _Nodo {
   Ventas Vendedor;
   struct _Nodo *sig;
}Nodo;

typedef struct _Lista{
   Nodo *primero;
   Nodo *ultimo;
   int numElementos; // Para simplificar operaciones sobre la lista
}Lista;

typedef struct _Equipos{
    char marca[10];
    char color[10];
    char procesador[10];
    char ram[5];
    char hdd[8];
    int cantidad;
    float preciocompra;
    float precioventa;
}Equipos;
//---------------------------------------------------------------------------
//Prototipos de funciones
int menu(void);
void AddPCS(void);
void AddSeller(void);
int ListSellers(bool);
void AddSale(void);
int ListStock(bool);
void ListSales(void);
void ListFilteredSalesBySeller(void);
bool ShowSalesByID(int ID,char *path);
void ShowRankingBestSeller(void);
void ShowSeller(Ventas Vendedor);
int ObtainSellerByPath(char *path,Ventas *Vendedor);
int clean_stdin(void);
bool input_string(char *buffer,int size);
void pause(void);

//Prototipos de funciones de manejo de la lista
Lista InicializarLista(void);
void ImprimirLista(Lista* lista);
Nodo* NuevoNodo(Lista* lista);
void LimpiarLista(Lista* lista);
void OrdenarPorVentasMayor(Lista* lista);
int InsertarVendedorEnLista(Lista *lista, char *namefile);
//---------------------------------------------------------------------------

// Devuelve una lista inicializada.
Lista InicializarLista()
{
   Lista toReturn;
   toReturn.primero = NULL;
   toReturn.ultimo = NULL;
   toReturn.numElementos = 0;

  return toReturn;
}
//---------------------------------------------------------------------------

void ImprimirLista(Lista* lista)
{
   Nodo *actual;

   //Muestro la lista ordenada
   actual=lista->primero;

   if(actual != NULL){
      printf("------------------------------------------------\n");
      while(actual != NULL){
         printf("Datos del vendedor:\n");
         printf("ID: %d\n",actual->Vendedor.ID);
         printf("Nombre: %s\n",actual->Vendedor.nombre);
         printf("Ventas realizadas: %d\n",actual->Vendedor.contadorventas);
         printf("------------------------------------------------\n");
         actual=actual->sig;
      }
   }
}
//---------------------------------------------------------------------------

// Añade un nuevo nodo a la lista
Nodo* NuevoNodo(Lista* lista)
{
   Nodo *nuevo;

   nuevo = (Nodo*)malloc(sizeof(Nodo));
   if(nuevo != NULL){
      if(nuevo != NULL){
         nuevo->sig = NULL;
         if( lista->primero== 0 ){
            lista->primero = nuevo;
            lista->ultimo = nuevo;
         }else{
            lista->ultimo->sig = nuevo;
            lista->ultimo = lista->ultimo->sig;
         }
         lista->numElementos++;
      }
   }
   return nuevo;
}
//---------------------------------------------------------------------------

// Elimina todos los nodos de la lista
void LimpiarLista(Lista* lista)
{
   Nodo* nodo = lista->primero;

   while( nodo )
   {
      Nodo* temp = nodo->sig;
      free(nodo);
      nodo = temp;
   }

   lista->primero = 0;
   lista->ultimo = 0;
   lista->numElementos = 0;
}
//---------------------------------------------------------------------------

void OrdenarPorVentasMayor(Lista* lista)
{
   int i,j;
   // Estructura auxiliar para ordenar
   // El último nodo será 0 para simplificar el proceso
   Nodo** nodos = (Nodo**)calloc(lista->numElementos+1,sizeof(Nodo*));

   // Se copian los nodos de la lista a nuestro arreglo
   Nodo* nodo = lista->primero;
   int index = 0;
   while(nodo)
   {
      nodos[index] = nodo;
      index++;
      nodo = nodo->sig;
   }

   // Se ordenan los nodos
   for (i = 0 ; i < lista->numElementos-1; i++)
   {
      for (j = 0 ; j < lista->numElementos - i - 1; j++)
      {
         if ( nodos[j]->Vendedor.contadorventas < nodos[j+1]->Vendedor.contadorventas)
         {
            Nodo* swap  = nodos[j];
            nodos[j]  = nodos[j+1];
            nodos[j+1] = swap;
         }
      }
   }

   // Se reconstruye la lista
   lista->primero = nodos[0];

   for( i=0; i<lista->numElementos; i++)
   {
      // Como el último nodo es NULL, el último nodo real de la lista acabará apuntando a NULL automáticamente
      nodos[i]->sig = nodos[i+1];
   }
   lista->ultimo = nodos[i-1];

   free(nodos);
}
//---------------------------------------------------------------------------

void pause()
{
   printf("\nPulse intro para continuar");
   getchar();
}
//---------------------------------------------------------------------------

int clean_stdin()
{
   char c;
   int contador=0;

   do{
      c=getchar();
      contador++;
   }while(c != '\n');
   return contador;
}
//---------------------------------------------------------------------------

bool input_string(char *buffer,int size)
{
   int len;
   bool overflow=false;

   memset(buffer,'\0',size);
   fgets(buffer,size,stdin);
   if(buffer[size-1] == '\0'){
      len=strlen(buffer);
      if(buffer[len-1] != '\n'){
         if(clean_stdin() > 1)
            overflow=true;
      }else
         buffer[len-1] = '\0';
   }
   return overflow;
}
//---------------------------------------------------------------------------

int menu(){
   int op;
   system("CLS");
   printf("\t\t\t***HYPER STORE MULTIMEDIA***\n\n");
   printf("1.Realizar venta\n");
   printf("2.Listar stock de PC's\n");
   printf("3.Listar ventas\n");
   printf("4.Listar ventas de un vendedor\n");
   printf("5.Mostrar Racking de ventas\n");
   printf("6.Incorporar PC's al stock\n");
   printf("7.Incorporar vendedor\n");
   printf("8.Salir\n\n");
   printf("Elije una opcion: ");
   if(scanf("%d",&op) == 0)
      clean_stdin();
   return op;
}
//---------------------------------------------------------------------------

void AddSeller(){
   FILE *archivoVendedor;
   Ventas Vendedor;
   bool salir=false;
   char pathFile[SIZE_FULL_PATH_FILE];

   printf("\n\t\t\tIngresa los datos del vendedor\n");
   printf("Nombre: ");
   input_string(Vendedor.nombre,sizeof(Vendedor.nombre));
   Vendedor.contadorventas=0;

   do{
      printf("ID: ");
      if(scanf("%d",&Vendedor.ID) == 0)
         clean_stdin();
      sprintf(pathFile,"Vendedores\\%d.bin",Vendedor.ID);
      archivoVendedor=fopen(pathFile,"rb");

      if(archivoVendedor==NULL){ //Todo correcto
         if((archivoVendedor=fopen(pathFile,"wb")) != NULL){
            if(fwrite(&Vendedor,sizeof(Ventas),1,archivoVendedor)==1){
               printf("\nVendedor creado satisfactoriamente\n");
               fclose(archivoVendedor);
               salir=true;
            }else{
               printf("\nHuvo un error al guardar los datos del vendedor\n");
               fclose(archivoVendedor);
               remove(pathFile);
               salir=true;
            }
         }else{
            printf("\nHubo algun error al crear el archivo para este vendedor\n");
            salir=true;
         }
      }else{
         fclose(archivoVendedor);
         printf("\nEl ID indicado ya existe. Vuelve a intentarlo\n");
      }
   }while(salir==false);
   clean_stdin();
}
//---------------------------------------------------------------------------

void AddPCS()
{
   FILE *archivoStock;
   Equipos PC;

   printf("\n\t\t\tIngresa los datos del equipo\n");
   printf("Marca: ");
   input_string(PC.marca,sizeof(PC.marca));
   printf("\nColor: ");
   input_string(PC.color,sizeof(PC.color));
   printf("\nProcesador: ");
   input_string(PC.procesador,sizeof(PC.procesador));
   printf("\nMemoria ram: ");
   input_string(PC.ram,sizeof(PC.ram));
   printf("\nDisco duro: ");
   input_string(PC.hdd,sizeof(PC.hdd));
   printf("\nPrecio de compra: ");
   if(scanf("%f",&PC.preciocompra) == 0)
      clean_stdin();
   printf("\nPrecio de venta: ");
   if(scanf("%f",&PC.precioventa) == 0)
      clean_stdin();
   printf("\nCantidad en stock: ");
   if(scanf("%d",&PC.cantidad) == 0)
      clean_stdin();

   if((archivoStock=fopen("Stock.bin","ab+")) != NULL){
      if(fwrite(&PC,sizeof(Equipos),1,archivoStock)==1)
         printf("\nArticulo añadido satisfactoriamente\n");
      else
         printf("\nHuvo un error al añadir el articulo al stock\n");
      fclose(archivoStock);
   }else{
      printf("\nHubo algun error al acceder al archivo del stock\n");
   }
   clean_stdin();
}
//---------------------------------------------------------------------------

int ListSellers(bool mostrar)
{
   DIR *id_dir;
   Ventas Vendedor;
   struct dirent *filedir;
   char pathFile[SIZE_FULL_PATH_FILE];
   int retval=0,leidos=0;

   id_dir=opendir(".\\Vendedores\\");

   while((filedir = readdir(id_dir)) != NULL && retval == 0){
      if(strcmp(filedir->d_name,".") != 0 && strcmp(filedir->d_name,"..") != 0){
         sprintf(pathFile,"Vendedores\\%s",filedir->d_name);
         retval = ObtainSellerByPath(pathFile, &Vendedor);
         if(retval == 0){
            leidos++;
            if(mostrar == true)
               ShowSeller(Vendedor);
         }
      }
   }
   if(leidos==0)
      printf("\nNo hay vendedores en este momento\n");
   closedir(id_dir);
   return leidos;
}
//---------------------------------------------------------------------------

bool AddSaleToFile(Ventas Vendedor,Equipos PC)
{
   char pathVentas[SIZE_FULL_PATH_FILE];
   FILE *archivoVentas;
   bool realizada = false;

   sprintf(pathVentas,"Ventas\\%s_%d.bin",Vendedor.nombre,Vendedor.ID);
   if((archivoVentas=fopen(pathVentas,"ab+")) != NULL){
      if(fwrite(&PC,sizeof(Equipos),1,archivoVentas) != 1){
         printf("\nNo se pudo agregar la venta. No se pudo escribir en el archivo\n");
      }else{
         realizada=true;
      }
      fclose(archivoVentas);
   }
   return realizada;
}
//---------------------------------------------------------------------------

bool CrearVendedorActualizado(Ventas Vendedor)
{
   FILE *archivoVendedor,*archivoVendedorAux;
   bool creado=false;
   int escritos;
   char pathVendedor[SIZE_FULL_PATH_FILE],pathVendedorAux[SIZE_FULL_PATH_FILE];

   sprintf(pathVendedor,"Vendedores\\%d.bin",Vendedor.ID);
   if((archivoVendedor=fopen(pathVendedor,"rb"))==NULL){
      printf("\nNo se pudo abrir el archivo del vendedor\n");
      return creado;
   }

   sprintf(pathVendedorAux,"Vendedores\\%d_aux.bin",Vendedor.ID);
   if((archivoVendedorAux=fopen(pathVendedorAux,"wb"))==NULL){
      printf("\nNo se pudo crear el archivo actualizado del vendedor\n");
      return creado;
   }

   Vendedor.contadorventas++;
   escritos = fwrite(&Vendedor,sizeof(Vendedor),1,archivoVendedorAux);
   fclose(archivoVendedor);
   fclose(archivoVendedorAux);

   if(escritos == 1){
      creado=true;
   }else{
      printf("\nNo se pudo escribir en el archivo actualizado del vendedor\n");
      remove("Stock_aux.bin");
   }

   return creado;
}
//---------------------------------------------------------------------------

bool CrearStockActualizado(Ventas Vendedor, int indexPC, int nVenta, int *nRegistros)
{
   char pathVendedor[SIZE_FULL_PATH_FILE];
   FILE *archivoStock,*archivoStockAux=NULL,*archivoVentas;
   Equipos PC;
   bool creado = true;

   if(nVenta <= 0){
      printf("Cantidad incorrecta\n");
      creado = false;
      return creado;
   }

   if(PC.cantidad < nVenta){
      printf("\nLa cantidad a vender sobrepasa a la de stock\n");
      creado = false;
      return creado;
   }

   if((archivoStock=fopen("Stock.bin","rb"))==NULL){
      printf("Hubo un error al abrir el archivo de stock\n");
      creado = false;
      return creado;
   }

   if((archivoStockAux=fopen("Stock_aux.bin","wb"))==NULL){
      printf("Hubo un error al crear el archivo de stock auxiliar\n");
      fclose(archivoStock);
      creado = false;
      return creado;
   }

   *nRegistros=0;

   while(fread(&PC,sizeof(Equipos),1,archivoStock)==1 && !feof(archivoStock)){
      if(ftell(archivoStock)!=((indexPC*sizeof(Equipos)) + sizeof(Equipos))){ //Si es el articulo elegido..
         if(fwrite(&PC,sizeof(Equipos),1,archivoStockAux) != 1){
            printf("\nNo se pudo escribir en el archivo auxiliar de stock\n");
            creado=false;
            break;
         }
      }else{
         if(PC.cantidad == nVenta)
            PC.cantidad = 0;
         else
            PC.cantidad -= nVenta;

         if(fwrite(&PC,sizeof(Equipos),1,archivoStockAux) != 1){
            printf("\nNo se pudo escribir en el archivo auxiliar de stock\n");
            creado=false;
            break;
         }
         (*nRegistros)++;
      }
   }
   fclose(archivoStock);
   fclose(archivoStockAux);

   if(creado == false && archivoStockAux != NULL)
      remove("Stock_aux.bin");

   return creado;
}
//---------------------------------------------------------------------------

int SolicitarIDValido(Ventas *Vendedor)
{
   bool salir = false;
   int id;
   char pathVendedor[SIZE_FULL_PATH_FILE];

   do{
      printf("\nSeleccione el ID del vendedor que realizara la venta: ");
      if(scanf("%d",&id) == 0)
         clean_stdin();
      sprintf(pathVendedor,"Vendedores\\%d.bin",id);

      if(ObtainSellerByPath(pathVendedor,Vendedor) == 0)
         salir=true;
      else
         printf("\nSolo IDs validos.");
   }while(salir == false);

   return id;
}
//---------------------------------------------------------------------------

int SolicitarIndiceProductoValido(int imax)
{
   bool salir = false;
   int iEquipo;

   do{
      printf("\n\nIntroduce el indice del equipo que desea vender: ");
      if(scanf("%d",&iEquipo) == 0)
         clean_stdin();
      if(iEquipo > imax || iEquipo < 0)
         printf("Introduce un indice valido\n");
      else
         salir = true;
   }while(salir == false);

   return iEquipo;
}
//---------------------------------------------------------------------------

bool ObtainStockByIndex(Equipos *PC, int index)
{
   FILE *archivoStock;
   bool retval=false;

   //Aqui voy a la posicion del archivo de stock indicada por el indice
   if((archivoStock=fopen("Stock.bin","rb"))==NULL){
      printf("Hubo un error al abrir el archivo de stock\n");
   }else{
      fseek(archivoStock,index*sizeof(Equipos),SEEK_SET);
      if(fread(&(*PC),sizeof(Equipos),1,archivoStock) == 1)
         retval = true;
      else
         printf("No se pudo leer el articulo del archivo de stock\n");

      fclose(archivoStock);
   }
   return retval;
}
//---------------------------------------------------------------------------

int ObtenerCantidadEquiposValida(Equipos PC)
{
   bool salir = false;
   int nEquipos;

   do{
      printf("\nIntroduce la cantidad a vender: ");
      if(scanf("%d",&nEquipos) == 0)
         clean_stdin();

      if(nEquipos > PC.cantidad || nEquipos == 0)
         printf("Cantidad no correcta. Vuelve a intentarlo.\n");
      else
         salir = true;
   }while(salir == false);

   return nEquipos;
}
//---------------------------------------------------------------------------

void GuardarDatosDeVenta(Ventas Vendedor, Equipos PC, int nRegistros)
{
   char pathVendedor[SIZE_FULL_PATH_FILE],pathVendedorAux[SIZE_FULL_PATH_FILE];

   if(AddSaleToFile(Vendedor,PC) == true){
      sprintf(pathVendedor,"%d.bin",Vendedor.ID);
      sprintf(pathVendedorAux,"%d_aux.bin",Vendedor.ID);
      remove(pathVendedor);
      rename(pathVendedorAux,pathVendedor);
      if(nRegistros > 0){
         remove("Stock.bin");
         rename("Stock_aux.bin","Stock.bin");
      }else{
         remove("Stock.bin");
         remove("Stock_aux.bin");
      }
      if(ObtainSellerByPath(pathVendedor,&Vendedor) == 0){
         printf("\n\t\t\tVendedor:\nID: %d\nNombre: %s\nVentas realizadas: %d\n",Vendedor.ID,Vendedor.nombre,Vendedor.contadorventas);
         printf("\nEquipo vendido\n");
      }
   }else{
      remove(pathVendedorAux);
      remove("Stock_aux.bin");
   }
}
//---------------------------------------------------------------------------

void AddSale()
{
   int id,iEquipo,nEquipos,nRegistrosStock;
   Ventas Vendedor;
   Equipos PC;

   if(ListSellers(false) == 0)
      return;

   nRegistrosStock=ListStock(false);
   if(nRegistrosStock <= 0)
      return;

   if(ListSellers(true) == 0)
      return;

   id = SolicitarIDValido(&Vendedor);
   printf("\n");

   nRegistrosStock=ListStock(true);
   if(nRegistrosStock <= 0)
      return;

   iEquipo = SolicitarIndiceProductoValido(nRegistrosStock-1);

   if(ObtainStockByIndex(&PC,iEquipo) == true){
      nEquipos = ObtenerCantidadEquiposValida(PC);

      if(CrearStockActualizado(Vendedor,iEquipo,nEquipos,&nRegistrosStock)==true && CrearVendedorActualizado(Vendedor) == true){
         PC.cantidad=nEquipos;
         GuardarDatosDeVenta(Vendedor,PC,nRegistrosStock);
      }
   }
   clean_stdin();
}
//---------------------------------------------------------------------------

int ListStock(bool mostrar)
{
   FILE *archivoStock;
   int count=0;
   Equipos PC;

   if((archivoStock=fopen("Stock.bin","rb")) != NULL){
      fseek(archivoStock,0,SEEK_END);
      if(ftell(archivoStock) != 0){
         fseek(archivoStock,0,SEEK_SET);
         if(mostrar==true)
            printf("------------------------------------------------\n");
         while(fread(&PC,sizeof(Equipos),1,archivoStock)==1 && !feof(archivoStock)){
            if(mostrar==true){
                  printf("\n\t\t\tDatos del equipo [%d]\n",count);
                  printf("\nMarca: %s\n",PC.marca);
                  printf("\nColor: %s\n",PC.color);
                  printf("\nProcesador: %s\n",PC.procesador);
                  printf("\nMemoria ram: %s\n",PC.ram);
                  printf("\nDisco duro: %s\n",PC.hdd);
                  printf("\nPrecio de compra: %.2f\n",PC.preciocompra);
                  printf("\nPrecio de venta: %.2f\n",PC.precioventa);
                  printf("\nCantidad en stock: %d\n",PC.cantidad);
                  printf("\n------------------------------------------------\n");
            }
            count++;
         }
      }else{
         printf("\nNo hay productos en stock\n");
      }
      fclose(archivoStock);
   }else{
      printf("\nNo se pudo abrir el archivo de stock\n");
      count=-1;
   }
   return count;
}
//---------------------------------------------------------------------------

bool ShowSalesByID(int ID,char *path)
{
   FILE *archivoVentas;
   Equipos PC;
   int count=0;
   bool retval=false;

   if((archivoVentas=fopen(path,"rb")) != NULL){
      while(fread(&PC,sizeof(Equipos),1,archivoVentas)==1 && !feof(archivoVentas)){
         printf("\n\t\t\tDatos de la venta [%d]\n",count++);
         printf("\nMarca: %s\n",PC.marca);
         printf("\nColor: %s\n",PC.color);
         printf("\nProcesador: %s\n",PC.procesador);
         printf("\nMemoria ram: %s\n",PC.ram);
         printf("\nDisco duro: %s\n",PC.hdd);
         printf("\nPrecio de compra: %.2f\n",PC.preciocompra);
         printf("\nPrecio de venta: %.2f\n",PC.precioventa);
         printf("\nCantidad vendida: %d\n",PC.cantidad);
         printf("\n------------------------------------------------\n");
      }
      fclose(archivoVentas);
      retval=true;
   }
   return retval;
}
//---------------------------------------------------------------------------

int ObtainSellerByPath(char *path,Ventas *Vendedor)
{
   FILE *archivoVendedor;
   int retval=0;

   archivoVendedor=fopen(path,"rb");
   if(archivoVendedor!=NULL){
      if(fread(Vendedor,sizeof(Ventas),1,archivoVendedor) != 1){
         printf("\nHuvo algun error al leer el vendedor\n");
         retval=-1;
      }
      fclose(archivoVendedor);
   }else{
      printf("\nHubo algun error al abrir el archivo del vendedor\n");
      retval=-1;
   }
   return retval;
}
//---------------------------------------------------------------------------

void ShowSeller(Ventas Vendedor)
{
   printf("Datos del vendedor:\n");
   printf("ID: %d\n",Vendedor.ID);
   printf("Nombre: %s\n",Vendedor.nombre);
   printf("Ventas realizadas: %d\n",Vendedor.contadorventas);
   printf("------------------------------------------------\n");
}
//---------------------------------------------------------------------------

void ListSales()
{
   DIR *id_dir;
   Ventas Vendedor;
   struct dirent *filedir;
   char pathFile[SIZE_FULL_PATH_FILE],stringID[SIZE_FULL_PATH_FILE];
   int x,id,contador=0;
   int retval=0;

   id_dir=opendir(".\\Vendedores\\");

   while((filedir = readdir(id_dir)) != NULL && retval == 0){
      if(strcmp(filedir->d_name,".") != 0 && strcmp(filedir->d_name,"..") != 0){
         sprintf(pathFile,"Vendedores\\%s",filedir->d_name);
         retval = ObtainSellerByPath(pathFile, &Vendedor);
         if(retval == 0){
            ShowSeller(Vendedor);
            sprintf(pathFile,"Ventas\\%s_%d.bin",Vendedor.nombre,Vendedor.ID);
            ShowSalesByID(Vendedor.ID,pathFile);
            contador++;
         }
      }
   }
   closedir(id_dir);
   if(contador == 0)
      printf("\nNo hay vendedores en este momento\n");
}
//---------------------------------------------------------------------------

void ListFilteredSalesBySeller()
{
   int id;
   bool i;
   char pathFile[SIZE_FULL_PATH_FILE];
   Ventas Vendedor;
   FILE *archivoVendedor;

   if(ListSellers(false) > 0){
      ListSellers(true);
      do{
         printf("\nIntroduce el ID de un vendedor: ");
         if(scanf("%d",&id) == 0)
            clean_stdin();
         sprintf(pathFile,"Vendedores\\%d.bin",id);

         if(ObtainSellerByPath(pathFile,&Vendedor) == 0){
            system("CLS");
            ShowSeller(Vendedor);
            sprintf(pathFile,"Ventas\\%s_%d.bin",Vendedor.nombre,Vendedor.ID);

            if((ShowSalesByID(id,pathFile))==false)
               printf("\nNo hay ventas para este vendedor\n");
         }else{
            printf("\nID incorrecto. Introduce un ID de la lista\n");
         }
      }while(archivoVendedor == NULL);
   }
   clean_stdin();
}
//---------------------------------------------------------------------------

//Leo los datos del vendedor desde un archivo y lo añado en la lista
int InsertarVendedorEnLista(Lista *lista, char *namefile)
{
   char pathFile[SIZE_FULL_PATH_FILE];
   Ventas Vendedor;
   int retval=0;
   Nodo *nuevo_elemento;

   if(strcmp(namefile,".") != 0 && strcmp(namefile,"..") != 0){
      //Abro cada archivo del directorio de vendedores
      sprintf(pathFile,"Vendedores\\%s",namefile);
      if(ObtainSellerByPath(pathFile,&Vendedor)==0){
         //Creo una lista enlazada simple con todos los vendedores
         nuevo_elemento = NuevoNodo(lista);
         if(nuevo_elemento == NULL){
            printf("\nHuvo un error al solicitar memoria para crear el ranking\n");
            retval = -1;
         }else{
            memcpy(&nuevo_elemento->Vendedor,&Vendedor,sizeof(Ventas));
         }
      }else{
         printf("\nHubo algun error al leer los vendedores\n");
         retval = -1;
      }
   }
   return retval;
}
//---------------------------------------------------------------------------

void ShowRankingBestSeller()
{
   struct dirent *filedir;
   DIR *id_dir;
   Lista Ranking;
   Ventas aux;
   int retval=0;

   if((id_dir=opendir(".\\Vendedores\\"))==NULL){
      printf("\nNo se pudo abrir el directorio de vendedores\n");
   }else{
      Ranking = InicializarLista();
      //Recorro todos los archivos del directorio de vendedores
      while((filedir = readdir(id_dir)) != NULL && retval == 0){
         retval = InsertarVendedorEnLista(&Ranking,filedir->d_name);
      }
      closedir(id_dir);
   }

   //Ordeno por ventas de mayor a menor
   OrdenarPorVentasMayor(&Ranking);

   if(Ranking.numElementos == 0)
      printf("\nNo hay vendedores en este momento\n");
   else{
      //Muestro la lista ordenada
      ImprimirLista(&Ranking);
   }

   //Libero la memoria de la lista enlazada de los vendedores
   LimpiarLista(&Ranking);
}
//---------------------------------------------------------------------------

int main () {
   int opcion,i;
   bool salir=false;
    FILE *fichero_equipos;

   do{
      opcion=menu();

      switch(opcion){
         case 1:
            system("CLS");
            AddSale();
            pause();
            break;

         case 2:
            system("CLS");
            ListStock(true);
            pause();
            break;

         case 3:
            system("CLS");
            ListSales();
            pause();
            break;

         case 4:
            system("CLS");
            ListFilteredSalesBySeller();
            pause();
            break;

         case 5:
            system("CLS");
            ShowRankingBestSeller();
            pause();
            break;

         case 6:
            system("CLS");
            AddPCS();
            pause();
            break;

         case 7:
            system("CLS");
            AddSeller();
            pause();
            break;

         case 8:
            salir=1;
            break;

         default:
            printf("\nOpcion no valida.");
            clean_stdin();
            pause();
            system("CLS");
            break;
      }
   }while(!salir);
   return 0;
}
//---------------------------------------------------------------------------