//Librerias
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <ctype.h>
#include <dos.h>

//Tracking de Mejoras pendientes

//ME: Carga de parametros para comparacion contra los resultados de la evacuacion
//GER: revisar que cuando se ingresa la opcion numero 5 dentro del menu del administrador, tira un "opcion incorrecta"
//y vuelve al menu principal. Esto último es bizarro. siendo que la funcion deberia permitir el retorno al menu
//al presionar la tecla 5.    (LISTO)
/*Con MAYOR PRIORIDAD hay que revisar la funcion de evacuacion en ultimo piso del edificio. Una vez que termina la evacua
cion de ese piso, no sigue con la del de abajo!  (LISTO)
Ademas, una vez que termina la simulacion, vuelve al menu principal, cosa que está bien, pero si quiero correr la simulacion
nuevamente, el programa se cuelga. (ENCONTRÉ LA SOLUCIÓN (AL MANEJAR VIA ARCHIVOS, YA ESTARÍA) FALTA APLICARLA) */


//Definicion de Constantes
#define FILE_USUARIOS "usuarios.dat"
#define FILE_CONFIG "config.dat"

//*****Declaración de Estructuras*****

//ESTRUCTURAS PARA EL MANEJO DE USUARIOS
typedef struct
{
    char propiedad[30]; //Estructura para verificar la existencia del archivo usuarios
    char valor[30];
} Config;

typedef struct
{
    int valido; //Estructura para la validacion del usuario que se esta logueando
    char clave[11];
} Validacion;

typedef struct
{
    char nombre[50];
    char clave[11];
}Usuario; //Struct que almacena usuario

/* typedef struct
{
    int codigo;
    long posicion;
}Indice; //Revisar*/

//ESTRUCTURAS PARA EL MANEJO DE LA SIMULACIÓN
typedef struct
{
    int     c_pisos;  //cantidad de pisos.
    int     h_piso;   //altura de un piso.
   float c_escal;  //aqui se autocalculará la cantidad de escalones, a sabiendas que la altura reglamentaria para los mismos es 18 cm.
   int  m2xpiso;  //metros cuadrados de un piso (se utilizara para medir la cantidad de humo soportable). //PARA TERMINAR.
   int  c_per_x_piso[8];//Hoy dia es hardcode la cantidad de pisos. //Ver si se puede colocar en forma dinamica
}edificio;  // Esta estructura se guarda en el archivo. Los unicos que corren la simulacion son los ADMINISTRADORES, no los usuarios finales.

typedef struct
{
    int fire_alarm;  //cant de segs a los que se dará la alarma de incendio.
   int evac_1ro;    //cant de segs a los que comenzara la evacuacion del piso. // Del primer piso a evacuar.
   int duracc;      //cant de segs que durara la simulacion.
}tsimulac;

typedef struct
{
    int fc_pisos;
   int fc_per_x_piso[8];
}f_evac;  //  Estructura auxiliar. No esta dentro del codigo. REVISAR

typedef struct        //GER: AGREGAR!!!
{
   //Campos de la estructura edificio:
    int c_pisos;
   int h_piso;
   float c_escal;
   int m2xpiso;
   int c_per_x_piso[8];
   //Campos de la estructura tsimulac:
   int fire_alarm;
   int evac_1ro;
   int duracc;
}parametros;

typedef struct
{
    time_t  t1;
   time_t   t2;
   time_t   taux;
   double   diferencia;
   int      minutos;
   int      segundos;
   int      temp;
}ejecsimul; //todas estas variables son las necesarias para el avance del tiempo en la simulacion.ME: es como un reloj interno para la simulacion.

//*****PROTOTIPOS DE FUNCIONES*****

//*****Funciones Login*****
// Funcion Helper
int             ExisteArchivo(char* FileName) ;

// Archivo de configuracion
Config      LeerPropiedad(char* propiedad); //Verificar dado que la funcion no esta en el codigo
void            EscribirPropiedad(char* propiedad, char* valor);
void ruiditos(int);

//*****Funciones Validaciones de Usuario*****
void            AgregarUsuario(void);
void            alta_usuario(void);
int             RealizarValidacion(char* usu);
void            ingreso_de_clave(void);
char            menu(void);
Validacion  validar_usuario(char*);

//*****Funciones Menu*****
int             menu_principal(void);
int             menu_admin1(void);
int             menu_simulacion(void);

//*****Funciones de Carga de Datos Del Administrador*****
void            carga_edif(edificio*);
void            carga_tiempos(tsimulac*);

//*****Funcion para grabar los parametros ingresados por el administrador en el HD*****
void AgregarParametros(edificio*, tsimulac*);  //AGREGAR!

/* GER: PENDIENTE!! MUY IMPORTANTE!!!
//***Funciones de Registro de los Parametros Igresados
void ModificarParametros(void);   //AGREGAR!
long ObtenerPosicionParametro(int);  //AGREGAR!

//*****Funciones de Progreso de la Simulacion*****
void            correr_simulacion(tsimulac *,ejecsimul *);
void            evacuacion(edificio* /*,tsimulac *ts*/); //Ger: Le agregué los sets de tiempos de puntos clave en la simulación, definidos por el admin.

//*****Funcion para Revisar los Parámetros de la Simulación*****
void            ver_parametros(edificio*, tsimulac*);

//*****Funciones de Consulta*****
void            consulta_usuarios(void);

//*****MAIN Inicio*****
main()
{
    tsimulac    ts;
   edificio     edif;
   ejecsimul    cronometro;
   int          op, opsubmenu;  //variables que almacenan las selecciones en los menues.
   int          intentosFallidos=0;
   char                 usu[11];

    do
    {
        if (RealizarValidacion(usu) == 0)
            break;
        else
                {
                   FILE  * flog;
                   struct tm *tlocal;
                   time_t tiempo;
                   char fechahora[64];

           intentosFallidos++;

               tiempo = time(0);
                   tlocal = localtime(&tiempo);
                   strftime(fechahora,64,"%c",tlocal);

                   flog = fopen( "logins.txt", "a+" );
                   fprintf( flog, "%s %s", usu, fechahora );
                   fclose(flog);
                }

        if (intentosFallidos == 3) exit(0);
    }   while (intentosFallidos < 3);

    if(ExisteArchivo(FILE_CONFIG)==0)
    {
        EscribirPropiedad("codclien","1");
        EscribirPropiedad("codpeli","1");
    }
   clrscr();

   do
   {
    op=menu_principal();

      switch(op)
      {
        case 1:
         do
         {
            opsubmenu=menu_admin1();
            if (opsubmenu == 1){ carga_edif(&edif); clrscr();}
            if (opsubmenu == 2){ carga_tiempos(&ts);  clrscr();}
            if (opsubmenu == 3){ alta_usuario(); clrscr();}
            if (opsubmenu == 4){ consulta_usuarios(); clrscr();}



         }while(opsubmenu!=5);

         break;

         case 2:

         do
         {
            opsubmenu=menu_simulacion();

                if (opsubmenu == 1) correr_simulacion(&ts,&cronometro);
               clrscr();

            if (opsubmenu == 2) evacuacion(&edif/*,&ts*/);
            clrscr();

            if (opsubmenu == 3) ver_parametros(&edif,&ts);

            //La funcion 2 sera la muestra de datos estadisticos.
               clrscr();

         }while(opsubmenu!=4);

         break;
      }
   }while(op < 3);

   return 0;
}
//*****MAIN Fin*****

// INICIO - Manejo de Claves

void EscribirPropiedad(char* propiedad, char* valor)    //Propiedad es un flag para corroborar si existe el archivo. Si existe dejo una marca para no
                                                                          //tener que hacer el control nuevamente
{
    FILE    *p1;
    int existe,cant;
    long posicion;
    Config aux,*paux;

    paux = &aux;

    // Si el archivo no existe, lo crea
    if (ExisteArchivo(FILE_CONFIG)==0)
    {
        if((p1 = fopen(FILE_CONFIG,"w+b")) == NULL)
        {
            gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
        printf("Error al generar el archivo de configuracion. Presione una tecla para continuar.");
            getch();
            return;
        }
        else
        {
            fclose(p1);
        }
    }

    // Lo abro en modo lectura primero para buscar si la propiedad existe.
    if((p1 = fopen(FILE_CONFIG,"r+b")) == NULL)
    {
       gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
        printf("Error al abrir el archivo. Presione una tecla para continuar.");
        getch();
        return;
    }

    for( ; ; )
    {
        posicion = ftell(p1);
        cant = fread(&aux,sizeof(Config),1,p1);

        if(cant!=1)
        {
            if(feof(p1)!=0)
            {
                existe = 0;
                break;
            }
            else
            {
                clreol();
               gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
                printf("\n Error al leer el archivo. Presione una Tecla para continuar.");
                getch();
                return;
            }
        }
        else
        {
            if(strcmpi(paux->propiedad,propiedad)==0)
            {
                existe = 1;
                break;
            }
        }
    }

    strcpy(paux->propiedad,propiedad);
    strcpy(paux->valor,valor);

    // Se posiciona el puntero o abre el archivo en modo Append segun corresponda
    if (existe == 1)
    {
        fseek(p1,posicion,SEEK_SET);
    }
    else
    {
        fclose(p1);
        if((p1 = fopen(FILE_CONFIG,"a+b")) == NULL)
        {
           gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
            printf("Error al abrir el archivo. Presione una Tecla para continuar.");
            getch();
            return;
        }
    }
    // Escribimos el dato
    if (fwrite(&aux,sizeof(Config),1,p1)!=1)
    {
       gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
        printf("Error de escritura en el archivo. Presione una Tecla para continuar.");
        getch();
        return;
    }
    fclose(p1);
}


int ExisteArchivo(char* FileName)
{
  FILE *EXISTEARCHIVO;

  if ((EXISTEARCHIVO=fopen(FileName,"rb"))==NULL)
  {
        return 0;
  }
  else
  {
        fclose(EXISTEARCHIVO);
        return 1;
  }
}

int RealizarValidacion( char* usuario ) //Valida Login
{
   // 0 Usuario OK, 1 - Clave Incorrecta - 1 Usuario Inexistente
    char pass[11],car;
    char usu[11];
    int i=0;
    Validacion x;

    clrscr();
    gotoxy(30,16);

   printf("Usuario>");

    fflush(stdin);
    gets(usu);

    x=validar_usuario(usu);

    if(x.valido==1)
    {
       gotoxy(30,18);
    printf("Clave>");

        while((car=(char)getch())!='\r'&& i <11 )
        {
            pass[i++]=car;
            printf("%c",'*');
        }

        pass[i]=NULL;

        if(strcmp(x.clave,pass)==0)
            return 0;
        else
            return 1;
    }
    else
        return -1;
}

void alta_usuario(void) //Las altas de usuario las da el ADMIN.
{
    FILE *ptr;
    char aux[50],cla1[11],cla2[11], car='\0';
    int i=0, j=0;
    Usuario reg;
   //Inicializacion de vectores

   aux[50] =NULL;
   cla1[0]=NULL;
   cla2[0]=NULL;


    ptr=fopen(FILE_USUARIOS,"a+b");

    clrscr();
   printf("\n =----------------------------------=");
   printf("\n  INGRESO DE DATOS DE NUEVO USUARIO");
   printf("\n =----------------------------------=");
   gotoxy(35,25);
   printf("\n =----------------------------------------------------------=");
   printf("\n Notas");
   printf("\n");
   printf("\n - Cantidad maxima de caracteres para la clave: 9");
   printf("\n - El nombre de usuario reconoce mayusculas y minusculas.");
   printf("\n =----------------------------------------------------------=");
   gotoxy(10,10);
    printf("\n Ingrese el Nombre y Apellido: ");

    fflush(stdin);

    gets(aux);

    strcpy(reg.nombre,aux);

    printf("\n Ingrese clave : ");

    if ((car=(char)getch())=='\r')
   {
       gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
    printf("\n\n Ingrese la clave correctamente! ");
        getch();
   }
   else
    {
        cla1[i++]=car;
        printf("%c",'*');

    while((car=(char)getch())!='\r'&& i <10)
        {

            cla1[i++]=car;
            printf("%c",'*');
      }

       cla1[i]='\0';

        printf("\n\n Confirme clave: ");

      if ((car=(char)getch())=='\r')
    {
           gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
        printf("\n\n Ingrese la clave correctamente! ");
            getch();
      }

      else

      {
        cla2[j++]=car;
            printf("%c",'*');

         while((car=(char)getch())!='\r'&& i <10)
            {
                cla2[j++]=car;
                printf("%c",'*');

            }
         cla2[j]='\0';
       }
    }

        if(strcmp(cla1,cla2)==0)
        {
            strcpy(reg.clave,cla1);
            fwrite(&reg,sizeof(reg),1,ptr);
           gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
        printf ("\n\n\n\n Usuario creado exitosamente. Presione una tecla para continuar. ");
        }
      else
      {
           gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
        printf ("\n\n\n\n Las claves no coinciden. Por favor ingrese los datos nuevamente. ");

      }

      getch();
       clrscr();
        fclose(ptr);
}

Validacion validar_usuario(char*usu)
{
    FILE *ptr;
    Usuario reg;
    Validacion reg1;
    int x=0;

    if (strcmpi(usu,"admin") == 0)
    {
        reg1.valido = 1;
        strcpy(reg1.clave,"admin123");
    }
    else //Sino es admin voy al archivo de claves para validar usuario
    {
        ptr=fopen(FILE_USUARIOS,"rb");

        fread(&reg,sizeof(reg),1,ptr);

        while(!feof(ptr))
        {

            if(strcmp(reg.nombre,usu)==0)
            {
                strcpy(reg1.clave,reg.clave);
                x=1;
                break;
            }
            fread(&reg,sizeof(reg),1,ptr);
        }

        reg1.valido=x;
        fclose(ptr);
    }
    return reg1;
}
// FIN - Manejo de Claves


// INICIO - Funciones de Carga de Datos del Administrador -

void carga_edif(edificio *edif)
{
   int i;

    clrscr();

   printf("\n\n- PARAMETROS DEL EDIFICIO -");
   printf("\n\nIngrese la cantidad de pisos (menor a 8): ");
   scanf("%d",&edif->c_pisos);
   printf("\n\nIngrese la altura de un piso en metros: ");
   scanf("%d",&edif->h_piso);
   edif->c_escal=((edif->h_piso)/(0.18));
   printf("\n\nLa cantidad de escalones entre pisos ha sido calculada automaticamente: %.f",edif->c_escal);
   printf("\n\nIngrese la superficie en metros cuadrados de un piso: "); //Esto sera para el calculo de la densidad maxima a tolerar de humo
   scanf("%d",&edif->m2xpiso);
   printf("\n\nPersonas por piso");

   for(i=0;i<edif->c_pisos;i++)
   {
    printf("\nCantidad de personas en el piso %d: ",i+1);
      scanf("%d",&edif->c_per_x_piso[i]);
   }

   gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
   printf("\n\nCarga de parametros finalizada. Presione una tecla.");

   getch();
   clrscr();
}

void carga_tiempos(tsimulac *ts)
{
    clrscr();
   printf("\n\n-PARAMETROS DE TIEMPO-");
   printf("\n\nIngrese la cantidad de segundos a los que se \ndara la alarma de incendio: ");
   scanf("%d",&ts->fire_alarm);
   printf("\n\nIngrese la cantidad de segundos a los que comenzara \nla evacuacion de un piso desde que se da la alarma: ");
   scanf("%d",&ts->evac_1ro);
   printf("\n\nIngrese la cantidad de segundos que durara la simulacion: ");
   scanf("%d",&ts->duracc);
   printf("\n\nCarga de parametros finalizada. Presione una tecla.");
   getch();
   clrscr();
}

// FIN - Funciones de Carga de Datos del Administrador -

// INICIO - FUNCIONES DE MENU -  (Impresion de menues)

int menu_principal(void)
{
    int op;
    do
    {
        clrscr();
        gotoxy(30,16);
        printf("- ME QUEMO-SYSTEM -");
        gotoxy(30,20);
        printf("1 - Menu Administrador");  //Solo para administradores
      gotoxy(30,22);
        printf("2 - Menu Simulacion");   //Para usuarios finales y administradores
      gotoxy(30,24);
        printf("3 - Salir");
      gotoxy(30,26);
      printf("Ingrese opcion: ");
      scanf("%d",&op);

    if(op<1 || op>3)
      {
        gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
            printf ("Opcion invalida. Presione una tecla para continuar.");
         getch();
      }

   }while(op<1||op>3);
    return op;
}

int menu_admin1(void)
{
    int op;
    do
    {
        clrscr();
        gotoxy(30,16);
        printf("- MENU ADMINISTRADOR -");
        gotoxy(30,18);
        printf("1 - Carga de parametros del edificio");
      gotoxy(30,20);
        printf("2 - Carga de tiempos de la simulacion");
      gotoxy(30,22);
        printf("3 - Crear usuario");
      gotoxy(30,24);
        printf("4 - Consultar usuario (Listado)");
      gotoxy(30,26);
        printf("5 - Volver al Menu Principal");
      gotoxy(30,28);
      printf("Ingrese opcion: ");
      scanf("%d",&op);

      if(op<1 || op>5)
      {
        printf ("Opcion invalida. Presione una tecla para continuar.");
         getch();
      }
   }while(op<1||op>6);
    return op;
}

int menu_simulacion(void)
{
    int op;
   do
   {
    clrscr();
      gotoxy(30,16);
      printf("- MENU SIMULACION -");
      gotoxy(30,20);
      printf("1 - Iniciar simulacion en tiempo real");
      gotoxy(30,22);
      printf("2 - Iniciar simulacion con estadisticas y avisos");
      gotoxy(30,24);
      printf("3 - Ver Parametros Seteados");
      gotoxy(30,26);
      printf("4 - Volver al Menu Principal");
      gotoxy(30,28);
      printf("Ingrese opcion: ");
      scanf("%d",&op);

         if(op<1 || op>5)
          {
               gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
            printf ("\n\n Opcion invalida. Presione una tecla para continuar.");
            getch();
       }

   }while(op<1||op>5);
   return op;
}

// FIN - FUNCIONES DE MENU -

// INICIO - Funciones de Progreso de la Simulacion -

void correr_simulacion(tsimulac *ts, ejecsimul *cronometro)
{
    clrscr();
   printf("\n\nComienzo de la simulacion");
   gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
   printf("\nPresione una tecla.");
   getch();

   cronometro->segundos=0;
   cronometro->t1=time(NULL); //Obtengo tiempo 1

   while(cronometro->diferencia < ts->duracc)
   {
    cronometro->t2=time(NULL); //Obtengo tiempo 2
      cronometro->diferencia=difftime(cronometro->t2,cronometro->t1); //difftime me devuelve un double
      cronometro->minutos=cronometro->diferencia / 60.0;
      cronometro->segundos=cronometro->diferencia - cronometro->minutos * 60;

      if(cronometro->temp != cronometro->segundos) //Ha transcurrido un segundo
      {
        cronometro->temp=cronometro->segundos; //Guarda el valor previo

         if(cronometro->segundos==ts->fire_alarm && cronometro->minutos==0)
        {
            clrscr();

            printf("\n%02d:%02d\n",cronometro->minutos,cronometro->segundos);

            printf("\nFUEGO EN EL EDIFICIO!!");

               gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario

            printf("\nPresione una tecla para continuar la simulacion.");

            getch();

            cronometro->taux=time(NULL);

            cronometro->t1+=difftime(cronometro->taux,cronometro->t2);
         }
         if(cronometro->segundos==(ts->fire_alarm + ts->evac_1ro))
         {
            printf("\nEl piso 'x' esta listo para comenzar la evacuacion ");  //Aca deberia figurar el piso que seleccione como comienzo de la evacuacion.

               gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario

            printf("\nPresione una tecla para continuar la simulacion ");

            getch();

            cronometro->taux=time(NULL);

            cronometro->t1+=difftime(cronometro->taux,cronometro->t2);
         }
         clrscr();
         printf("\n%02d:%02d\n",cronometro->minutos,cronometro->segundos);
      }
   }
    gotoxy(35,35);//Pie de pagina estandar para el comunicado de errores al usuario
   printf("\n\nSimulacion realizada con exito!");
   printf("\n\nPresione una tecla para volver al Menu Principal.");
   getch();
}

void ver_parametros(edificio *edif, tsimulac *ts)        //GER: REEMPLAZAR!!!!
{
   int i,aux;
   i=aux=0;

   clrscr();

   gotoxy(10,5);
    printf("-Parametros actuales con los que corre la simulacion-");
   gotoxy(10,6);
   printf("-----------------------------------------------------");

   gotoxy(10,8);
   printf("-Parametros del edificio-");
   gotoxy(10,9);
   printf("-------------------------");
   gotoxy(10,10);
   printf("Cantidad de Pisos: %d",edif->c_pisos);
   gotoxy(10,11);
   printf("Altura de los pisos: %d",edif->h_piso);
   gotoxy(10,12);
   printf("Cantidad de escalones calculada: %.f",edif->c_escal);
   gotoxy(10,13);
   printf("Metros cuadrados de un piso: %d",edif->m2xpiso);
   gotoxy(10,14);
   printf("Personas por piso: ");
   for(i=0;i<edif->c_pisos;i++)
   {
    printf("%d ",edif->c_per_x_piso[i]);
      aux+=(edif->c_per_x_piso[i]);
   }
   gotoxy(10,15);
   printf("Total de personal en el edificio: %d",aux);
   gotoxy(10,17);
   printf("-Parametros del correr del tiempo-");
   gotoxy(10,18);
   printf("----------------------------------");
   gotoxy(10,20);
   printf("Cant de segs a los que se dara la alarma de incendio: %d",ts->fire_alarm);
   gotoxy(10,22);
   printf("Cant de segs a los que comenzara la evacuacion del piso seleccionado: %d",ts->evac_1ro);
   gotoxy(10,24);
   printf("Cant de segs que durara la simulacion: %d",ts->duracc);
   gotoxy(10,26);
   printf("Presione una tecla para volver al menu anterior ");
   getch();
}

void evacuacion(edificio *edif, tsimulac *ts)        //GER: REEMPLAZAR!!
{
   //ESTADO ACTUAL:
   //Función de evacuación corriendo. (Ger: está hardcodeada en 7. Implementación de archivos PENDIENTE!)

   int pisos[7]; //A este array le incorporo los datos de la carga inicial de parametros.
   int acumul[7]={0}; //Este array acumulará la cantidad de personas en descenso por tramo de escalera.
   int evacuados[7]={0}; //Este array se usará como flag para identificar a los pisos ya evacuados.
   int primero;
   int max=7;
   int cpisos=edif->c_pisos;
   int cescalxp=edif->c_escal; //Levanto la cantidad de escalones por piso, de acuerdo a lo seteado por el admin.
   int i,j,k,m,n,o,p,q;
   int aux, aux2, aux3;
   int cantescal=0;
   int cantidad=0;
   int *escal;
   int cuentasegs=0; //Este acumulador me permitira medir posibles riesgos durante el transcurso de la simulación. Además de permitirme efectuar los correspondientes reportes.

   //Calculo la cantidad de personas que puede haber descendiendo en la escalera.
   cantidad=(max*(cescalxp/2));

   clrscr();
   printf("\nControl: ");
   printf("\nCantidad de posiciones a descender: %d",cantidad);
   getch();
   clrscr();

   if((escal=(int*)malloc(cantidad))==NULL) //Esta asignación dinámica me parece que es cualquier cosa! Revisarla. Pero por algún motivo, funciona :S
   {
      printf("\nNo hay memoria suficiente para alojar el buffer");
      exit(1);
   }


   //Inicio todas las escaleras con cero personas en ellas.
   for(i=0;i<cantidad;i++)
   {
      //clrscr();
      //printf("\nEscal %d: %d",i,escal[i]);
    escal[i]=0;
      //printf("\nEscal %d: %d",i,escal[i]);
   }

   //Inicio el acumulador de personas en las escaleras con cero.
   for(i=0;i<7;i++)
   {
      //clrscr();
      //printf("\nEscal %d: %d",i,escal[i]);
    acumul[i]=0;
      //printf("\nEscal %d: %d",i,escal[i]);
   }


   //Levanto la cantidad de personas asignada durante la carga de parámetros.
   pisos[0]=0; // Defino que en planta baja no va a haber nadie...
   for(i=0;i<7;i++)
   {
      pisos[i+1]=edif->c_per_x_piso[i];
   }
   clrscr();


   do
   {
    printf("\nIngrese el numero de piso donde se iniciara la simulacion de incendio: ");
    scanf("%d",&primero);
   }while(primero<0 && primero>7);

   //Este método de evacuación funciona!!
    aux=0;
    aux2=0;
      do
      {
         //Cuando comienza la evacuación, resto una persona y la hago descender una posición en la escalera.
         if(aux==0)
         {
            pisos[primero]--;
            escal[((primero)*(cescalxp/2))-1]++;
         }
         clrscr();

         //FUNCION DE DESPLAZAMIENTO DE LAS PERSONAS EN LA ESCALERA.-

        if(aux>0)
         {
            for(i=0;i<7;i++)
            {
               for(j=0;j<(cescalxp/2);j++)    //aca borre un -1 , que me parece que es totalmente correcto...
                {
                  aux2=escal[((i*(cescalxp/2))+j)];    //aca borre un +1
                  escal[((i*(cescalxp/2))+j)-1]=+aux2;
                escal[((i*(cescalxp/2))+j)]-aux2;
               }
            }
            //Una vez que las personas se desplazaron, evacúo al siguiente.
            if(pisos[primero]>0)
            {
                pisos[primero]--;
                escal[((primero)*(cescalxp/2))-1]++;
            }

            //Controlo si ya termino de evacuar el 1er piso. En ese caso, sigo con el inmediatamente superior.
            //Mientras no sea la azotea, claro esta, para lo cual tambien hago ese control.

            if((primero < cpisos) && ((pisos[primero])==0) && (pisos[primero+1]>0))
            {
               if(evacuados[primero]==0)
               {
                printf("\nPiso %d sin personal. Comenzando la evacuacion del piso %d.\n",primero,primero+1);
                  printf("\nCiclos transcurridos: %d\n",cuentasegs);
                  evacuados[primero]++;
               }
                pisos[(primero+1)]--;
                escal[((primero+1)*(cescalxp/2))-1]++;
            }

            //Ahora hago lo mismo, pero para el piso inferior al primero que se evacuo. Si no es planta baja.

            if((primero < cpisos) && (primero > 1) && ((pisos[primero])==0) && (pisos[primero+1]==0) && (pisos[primero-1]>0))
            {
               if(evacuados[primero]>0)
               {
                printf("\nPiso %d sin personal. Comenzando la evacuacion del piso %d.\n",primero+1,primero-1);
                  printf("\nCiclos transcurridos: %d\n",cuentasegs);
                  evacuados[primero]++;
               }
                pisos[(primero-1)]--;
                escal[((primero-1)*(cescalxp/2))-1]++;
            }
         }

         //Acumulo la cantidad de ciclos transcurridos.-
         cuentasegs++;

         //FUNCION DE ACUMULADOR POR TRAMOS DE ESCALERA.-

         for(k=0;k<7;k++)  //GER: ESTE 7 ESTA SUPER HARDCODEADO. REVISARLO!!
        {
            aux3=acumul[k];
            acumul[k]=acumul[k]-aux3;
            for(m=0;m<((cescalxp/2));m++)
            {
                acumul[k]=acumul[k]+escal[((k*(cescalxp/2))+m)];
               if(acumul[k] > (cescalxp/2))
                printf("\nEn el piso %d se predice un amontonamiento de personal en evacuacion no recomendado",k); //GER: Esto lo agregue hoy.
            }

            //printf("\nacumul i%d : %d",k,acumul[k]);
        }

         //En este ciclo for acumulo la cantidad de personas que hay en evacuación en las escaleras.

         //FUNCION DE IMPRESION
         for(q=cpisos;q>(-1);q--)
         {
            printf("\n   --------   //  %d   //",acumul[q]);
            printf("\nP%d | %d   |   //      //",q,pisos[q]);
            printf("\n   --------   //      //");
         }

         cantescal=0;
         //Lo reseteo cada vez porque en algún momento debe dar cero (esa es mi condición para terminar con el ciclo principal)
         for(p=0;p<7;p++)
         {
            cantescal=cantescal+acumul[p];
         }

         /*Ger: A Desarrollar:
                 - Corregir el desplazamiento por las escaleras y la representación gráfica. LISTO!
                - Habría que permitir una comparación entre el estado de la evacuación y el momento en que llegarían
                  los bomberos. PENDIENTE.
                  (De acuerdo a las noticias leidas, estos arriban entre 4 y 10 minutos después del llamado.)
                - Guardar y notificar el momento en que se evacúa el 1er piso (utilizando el nuevo "acumulador
                  de segundos" y un auxiliar). LISTO!
                - Precisar el tiempo que toma el control efectivo de todos el personal del primer piso evacuado
                  y la consecuente notificación al lider de evacuación del piso inmediatamente superior.
                  Luego de ello, comenzaría la evacuación de este piso. LISTO!
                  Este punto, por supuesto que hay que setearlo en la carga de parametros. COMPARACION PENDIENTE
                - Lo mismo para el piso de abajo. Siempre y cuando, no sea la planta baja. LISTO! (la 1er parte)
                - Ver por qué no vuelve al menú principal. LISTO!
        */


        //Incremento este auxiliar. Es mi punto de corte del while que simula la evacuacion.
         aux++;

         getch();
         clrscr();
      }while(cantescal!=0); //A esta condición va a haber que agregarle que el acumulador de la escalera esté totalmente en CERO.
     //GER: Listo, esa funcionalidad ya está agregada.

     printf("\nSALIO!!");

     getch();
}


// FIN - Funciones de Progreso de la Simulacion -

void consulta_usuarios()         //Agregue el prototipo de esta funciòn
{
    FILE *p;
   Usuario dato;

   p = fopen (FILE_USUARIOS, "rb+");

   if(p == NULL)
   {
    printf("Error al abrir el archivo FILE_USUARIOS...");
        exit(1);
    }

   fseek (p, 0L, SEEK_SET);

   fread(&dato, sizeof(Usuario), 1, p);

   while (!feof(p))
   {
    printf("\n %100s", dato.nombre);

      fread(&dato, sizeof(Usuario), 1, p);
   }

   fclose(p);
    getch();
}


//Funciones de Registro de Parametros Ingresados por el Admin
//Versión con índice 01;
/*
void AgregarParametros(edificio *edif, tsimulac *ts)
{

//GER: voy a tener que cambiar el enfoque, a fin de simplificar la obtencion de los parametros para su consecuente
//registro y utilizacion en la funcion de evacuacion (LISTO!).

    long cantreg;
    int cantidad;
   int i;
    int codigo=0;
    char codigoStr[30];
    Config config;
    FILE *p1,*p2;

    //Creo las estructuras auxiliares
    parametros reg; //GER: ESTRUCTURA QUE AGRUPARA TODOS LOS PARAMETROS: LISTO, DEFINIDA.
    Indice reg1;
    p1=fopen(FILE_PARAMETROS,"a+b");
    p2=fopen(FILE_PARAMETROS_INDICE,"a+b");

    //El almacenamiento de los archivos va a ser en la ubicacion por default.

    //Obtengo la cantidad de registros de "Parametros" ya almacenados.
    fseek(p1,0l,SEEK_END);
    cantreg=ftell(p1)/sizeof(reg);
    clrscr();

    //CARGA DE DATOS
    //Hay que crear una función para obtener el código automáticamente: LISTO.
    //codigo_parametro(codigo);

    printf("\n\n- CARGA DE PARAMETROS -");

   //ACA SE COPIA A UNA UNICA ESTRUCT TODO LO INGRESADO PREVIAMENTE EN LOS PROCESOS DE CARGA.

   reg.c_pisos=edif->c_pisos;  //cantidad de pisos.
    reg.h_piso=edif->h_piso;   //altura de un piso.
   reg.c_escal=edif->c_escal;  //aqui se autocalculará la cantidad de escalones, a sabiendas que la altura reglamentaria para los mismos es 18 cm.
   reg.m2xpiso=edif->m2xpiso;  //metros cuadrados de un piso (se utilizara para medir la cantidad de humo soportable). //GER: TERMINAR.
   for(i=0;i<reg.c_pisos;i++)
    reg.c_per_x_piso[i]=edif->c_per_x_piso[i];
    reg.fire_alarm=ts->fire_alarm;  //cant de segs a los que se dará la alarma de incendio.
   reg.evac_1ro=ts->evac_1ro;    //cant de segs a los que comenzara la evacuacion del piso. // Del primer piso a evacuar.
   reg.duracc=ts->duracc;

   //GER: IMPORTANTE: AHORA HAY QUE ADECUAR LA FUNCION PRINCIPAL PARA QUE LEVANTE LOS DATOS DESDE EL ARCHIVO.

    config = LeerPropiedad("codparam");
    printf("Codigo: ");
    printf("%s",config.valor);
    codigo = atoi(config.valor);
    reg.codigo=codigo;

   //la carga de los parametros ya esta definida en una funcion externa.
   //Esta funcion lo unico que hace es fusionar los dos tipos de datos ingresados por el administrador
   //y grabarlos en un archivo.


    // Informacion para archivo "Indice"  (GER: IMPORTANTE: Tengo que definir esta estructura!!)
    reg1.codigo=reg.codigo;
    reg1.posicion=cantreg;

    //Grabamos archivo "Registro" e "Indice"
    if (fwrite(&reg,sizeof(reg),1,p1) != 1 || fwrite(&reg1,sizeof(reg1),1,p2)!=1)  //GER: Revisar esta sentencia.
    {
        printf("ERROR DE ESCRITURA");
        getch();
    }
    else
    {
        // Grabo bien y actualizamos el Codigo de los Parametros
        codigo++;
        EscribirPropiedad("codparam",itoa(codigo,codigoStr, 10));
   }
    fclose(p1);
    fclose(p2);
}

long ObtenerPosicionParametro(int codigo)
{
    parametros reg;
    FILE    *p1;
    int ss;
    long ret;

    p1=fopen(FILE_PARAMETROS,"rb");
    if(p1==NULL)
    {
        clrscr();
        gotoxy(22,10);
        printf("ERROR EN APERTURA DE ARCHIVO");
      fflush(stdout);
        getch();
        exit(1);
    }

    rewind(p1);
    while(!feof(p1))
    {
        flushall();
        ret = ftell(p1);
        if(fread(&reg,sizeof(parametros),1,p1)!=1 && (!feof(p1)))exit(1);

        ss=0;
        if(codigo == reg.codigo)
        {
            ss=1;
            break;
        }
    }
    fclose(p1);
    if(ss==0)
    {
        // Parametro No Encontrado
        ret = -1;
    }
    return ret;
}

Config LeerPropiedad(char* propiedad) //GER: AGREGAR!! (Esta función revisa los codigos generados hasta el momento)
{
    Config reg;
    FILE    *p1;
    int s = 0;

    p1=fopen(FILE_CONFIG,"rb");
    if(p1==NULL)
    {
        clrscr();
        gotoxy(22,10);
        printf("ERROR EN APERTURA DE ARCHIVO");
        getch();
        exit(1);
    }

    rewind(p1);
    while(!feof(p1))
    {
        if(!feof(p1))
        {
            flushall();
            if(fread(&reg,sizeof(Config),1,p1)!=1 && (!feof(p1)))exit(1);

            if (strcmp(strlwr(propiedad),strlwr(reg.propiedad))==0)
            {
                s = 1;
                break;
            }
        }
    }
    fclose(p1);
    if(s==0)
    {
        strcpy(reg.valor,"");
        strcpy(reg.propiedad,"");
    }
    return reg;
}

Parametro* EncuentraParametros(void) //EliminarPel...
{
   /*
    Para recordar la estructura de la struct parametros
   //Campos de la estructura edificio:
    int c_pisos;
   int h_piso;
   float c_escal;
   int m2xpiso;
   int c_per_x_piso[8];
   //Campos de la estructura tsimulac:
   int fire_alarm;
   int evac_1ro;
   int duracc;
   //Agrego un codigo de identificacion del usuario para poder utilizarlo indexado.
   int codigo;


    int codigo;
    char otro,conf;
    parametros param_aux;
    long posicion;
    FILE *p1;

    clrscr();
    gotoxy(24,1);
    printf("Codigo del Admin?: ");
    scanf("%d",&codigo);
    posicion=ObtenerPosicionParametro(codigo);

   clrscr();
    if(posicion == -1)
    {
        gotoxy(25,20);
        printf("PARAMETRO NO ENCONTRADO");
        getch();
        return;
    }

    // Carga previa del archivo de parametros
    if((p1 = fopen(FILE_PARAMETROS,"r+b")) == NULL)
    {
        gotoxy(25,13);
        printf("ERROR AL GENERAR ARCHIVO DE PARAMETROS %s",FILE_PARAMETROS);
        getch();
        return;
    }

    fseek(p1,posicion,SEEK_SET); //Cambiar nombre de funcion y modificar codigo

    if (fread(&param_aux,sizeof(parametros),1,p1) != 1)
    {
        clreol();
        printf("\aERROR AL LEER ARCHIVO!!!!");
        getch();
        return;
    }

    clrscr();
   return param_aux;

   fclose(p1);
}*/


//FUNCION PARA AGREGARLE SONIDOS AL SISTEMA.-
//GER: AGREGAR!!
void ruiditos(int tipo)
{
  switch (tipo)
  {
    case 1:
        // sound(1000);
        // delay(50);
        // sound(3000);
        // delay(50);
        // sound(2000);
        // delay(50);
        // nosound();
        break;
     case 2:
        // sound(120);
        // delay(500);
        // sound(100);
        // delay(800);
        // nosound();
     break;
  }
}


//Funciones de Registro de Parametros Ingresados por el Admin
//Versión sin índice 01;

void AgregarParametros(edificio *edif, tsimulac *ts)
{
   FILE *ptr;
    int valida,i;
    char otro,conf;
    parametros reg;

   // textcolor(WHITE);
    // textbackground(BLACK);

    //if((ptr=fopen(FILE_PARAMETROS,"a+b"))==NULL)
    if((ptr = fopen(FILE_PARAMETROS,"w+b"))==NULL)   //if((p1 = fopen(FILE_CONFIG,"w+b")) == NULL)
    {
        ruiditos(2);
        gotoxy(25,13);
        printf("ERROR AL ABRIR ARCHIVO DE PARAMETROS");
        getch();
        return;
    }

    //ACA SE COPIA A UNA UNICA ESTRUCT TODO LO INGRESADO PREVIAMENTE EN LOS PROCESOS DE CARGA.

   reg.c_pisos=edif->c_pisos;  //cantidad de pisos.
    reg.h_piso=edif->h_piso;   //altura de un piso.
   reg.c_escal=edif->c_escal;
   reg.m2xpiso=edif->m2xpiso;  //metros cuadrados de un piso (se utilizara para medir la cantidad de humo soportable). //GER: TERMINAR.
   for(i=0;i<reg.c_pisos;i++)
    reg.c_per_x_piso[i]=edif->c_per_x_piso[i];
    reg.fire_alarm=ts->fire_alarm;  //cant de segs a los que se dará la alarma de incendio.
   reg.evac_1ro=ts->evac_1ro;    //cant de segs a los que comenzara la evacuacion del piso. // Del primer piso a evacuar.
   reg.duracc=ts->duracc;

    //proceso de grabación en el archivo.

    rewind(ptr);
    ruiditos(1);
    if (fwrite(&reg,sizeof(parametros),1,ptr)!=1)   //fwrite(&reg,sizeof(reg),1,ptr);
    {
        gotoxy(25,16);
        printf("ERROR DE ESCRITURA");
        ruiditos(2);
    }
    else
    {
        gotoxy(25,17);
        printf("PARAMETROS ALMACENADOS");
        ruiditos(1);
    }

  fclose(ptr);
}