Tarea5

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include "conio.c"
#include <math.h>

#define CANTOPC   5
#define CANTOPC2  9
#define CANTOPC3  11
#define CANTOPC4  5
#define CANTOPC5  7
#define LENOPC   45

#define ENTER   13
#define ESC     27

#define ARRIBA    72
#define ABAJO     80
#define DERECHA   77
#define IZQUIERDA 75

#define CTOPCMEN  WHITE
#define CFOPCMEN  BLUE
#define CTSOPCMEN BLUE
#define CFSOPCMEN WHITE
#define MAXID 4
#define LENNOM 41
#define LENAPE 31

void mostraropcxy(char [][LENOPC],int,int,int,int);
int menuxy(char [][LENOPC],int,int,int,int);
void colordefault();
void setcolor(int,int);
float comprobarSalario(float salario);
char getEmpleados(int indice);
int cantidadDigitosNumero(float numero);
void menuListar(int opcionSeleccionada, int posicionY, int cantidadDeOpciones);

typedef struct{
 int dia,mes,agno;
}FECHA;
typedef struct{
 char idemp[MAXID], nombre1[LENNOM], nombre2[LENNOM], apellido1[LENAPE], apellido2[LENAPE];
 FECHA fnacim, fentrada;
 float salario;
}EMP;

int empleadoActual = 0, validarCampos, tamanoPuntero = 10, primerInicio=0, idBuscar = -1;

EMP *empleados; //= (EMP*) calloc(10, sizeof(EMP));
int main(int opc)
{
   system("mode 120,30");
   if(primerInicio==0)
   {
       empleados = (EMP*) calloc(tamanoPuntero, sizeof(EMP));
       primerInicio=1; opc = 0;
   }
   clrscr();
   /**Validar campos será 1 porque la fecha de entrada siempre estará validada**/
   validarCampos = 0;
   char opciones[CANTOPC][LENOPC] =
        {
        "Ingresar empleados ",
        "Modificar empleados",
        "Borrar empleados   ",
        "Lista de empleados ",
        "SALIR              "
         };
   char opciones2[CANTOPC2][LENOPC] =
    {
        "Primer nombre           *:",
        "Segundo nombre           :",
        "Primer apellido         *:",
        "Segundo apellido         :",
        "Salario                 *:",
        "F. Entrada[DD/MM/AA]     :",
        "F. Nacimiento[DD/MM/AA] *:",
        "GUARDAR                   ",
        "SALIR                     "
    };

    char opciones5[CANTOPC5][LENOPC] =
    {
        "Listar Empleados Normal               ",
        "Buscar Empleado by ID                :",
        "Buscar Empleado by Nombre            :",
        "Buscar Empleado by Apellido          :",
        "Buscar Empleado by RangoEdad [18-25] :",
        "Buscar Empleado RangoSalario [10-50] :",
        "Salir                                 "
    };
    char opciones3[CANTOPC3][LENOPC] =
    {
        "Listar Empleados                        ",
        "Verificar ID Empleado Ingresando Nombre:",
        "Ingresar ID Verificado del Empleado    :",
        "Modificar Primer Nombre                :",
        "Modificar Segundo Nombre               :",
        "Modificar Primer Apellido              :",
        "Modificar Segundo Apellido             :",
        "Modificar Fecha de Entrada             :",
        "Modificar Fecha de Nacimiento          :",
        "Modificar Salario                      :",
        "Sair                                   "
    };
    char opciones4[CANTOPC4][LENOPC] =
    {
        "Listar Empleados                        ",
        "Verificar ID Empleado Ingresando Nombre:",
        "Ingresar ID Verificado del Empleado    :",
        "BORRAR                                  ",
        "Salir"
    };
   int opc1 = 0, opc5 = 0, opc2=0, opc4=0;

   srand(time(NULL));
    do{
    opc = menuxy(opciones,CANTOPC,opc,1,1);
    while(opc == 0)
      {
         opc1 = menuxy(opciones2,CANTOPC2,opc1,17,opc+1);
         agregarDatos(opc1, opc+1+opc1, CANTOPC2);
      }
    while(opc == 1)
    {
        opc2 = menuxy(opciones3, CANTOPC3, opc2, 17, opc+1);
        menuModificar(opc2, opc+1+opc2, CANTOPC3);
    }
    while(opc == 3)
    {
        opc5 = menuxy(opciones5, CANTOPC5, opc5, 17, opc+1);
        menuListar(opc5, opc+1+opc5, CANTOPC5);
    }
    while(opc == 2)
    {
        opc4 = menuxy(opciones4, CANTOPC4, opc4, 17, opc+1);
        menuBorrar(opc4, opc+1+opc4, CANTOPC4);
    }
   }while(opc != CANTOPC - 1);
   free(empleados);
   exit(0);
   return 0;
}

void mostraropcxy(char opc[][LENOPC],int n,int sel,int px, int py)
{
   int ind;

   for (ind = 0; ind < n; ind ++ )
   {
      textcolor(LIGHTGRAY);
      if ( ind == sel)
         textcolor(LIGHTRED);

      gotoxy(px,py+ind);
      printf(" %s \n",opc[ind]);
   }

   colordefault();

   return;
}


int menuxy(char opc[][LENOPC],int n,int sel,int px, int py)
{
   char tecla;

   _setcursortype(0);
   do
   {
      mostraropcxy(opc,n,sel,px,py);
      tecla = getch();

      if ( tecla == ARRIBA )
      {
         sel --;
         if ( sel < 0 )
            sel = n - 1;
      }

      if ( tecla == ABAJO )
      {
         sel ++;
         if ( sel == n )
            sel = 0;
      }
   }while ( tecla != ENTER && tecla != ESC );

   if ( tecla == ESC )
      main(0);
   return sel;
}


void colordefault()
{
   textcolor(LIGHTGRAY);
   textbackground(BLACK);
}
/**
    Función: AgregarDatos
    Parámetros: opciónSeleccionada, posicionY y cantidadDeOpciones
    Objetivo: Agregar los datos de los empleados de forma organizada conservando buen diseño
**/
void agregarDatos(int opcionSeleccionada, int posicionY, int cantidadDeOpciones)
{
    textcolor(GREEN);
    int posicionX = 5+19+21, indice=0, posicionYdeError = cantidadDeOpciones+1;
    char oracion[LENNOM], letra;
    switch(opcionSeleccionada)
    {
    case 0:/**PRIMER NOMBRE**/
        obtenerCaracteres(posicionX, posicionY, 10,empleados[empleadoActual].nombre1,0);
        validarCampos++;
        break;
    case 1:/**SEGUNDO NOMBRE**/
        obtenerCaracteres(posicionX, posicionY, 10,empleados[empleadoActual].nombre2,0);
        //validarCampos++;
        break;
    case 2:/**PRIMER APELLIDO**/
        obtenerCaracteres(posicionX, posicionY,10, empleados[empleadoActual].apellido1,1);
        validarCampos++;
        break;
    case 3:/**SEGUNDO APELLIDO**/
        obtenerCaracteres(posicionX, posicionY, 10,empleados[empleadoActual].apellido2,1);
        //validarCampos++;
        break;
    case 4:/**SALARIO**/
        obtenerSalario(posicionX, posicionY, posicionYdeError, empleadoActual);
        validarCampos++;
        break;
    case 5:/**FECHA ENTRADA**/
        obtenerFechaEntrada(posicionX, posicionY,10, empleadoActual);
        //validarCampos++;
        break;
    case 6:/**FECHA NACIMIENTO**/
        obtenerFechaNacimiento(posicionX, posicionY,10,empleadoActual);
        validarCampos++;
        break;
    case 7:/**GUARDAR**/
        guardar();
        int c = comprobarSalida();
        /**Si decide guardar y no es mayor de edad...**/
        if(c>0)
        {
            if(comprobarMayorDeEdad() == 0)
            {
                gotoxy(1,10);
                printf("Debe tener al menos 18 anios para entrar a la empresa");
                fflush(stdin); getch();
                gotoxy(1,10);
                printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t\t\t");
            }
        }
        /**Si decide guardar y es mayor de edad...**/
       if(c>0)
        {
            if(comprobarMayorDeEdad() == 1)
            {
                main(0);
            }
        }
        /**Si decide guardar sin haber completado todo...**/
        if(c>0 && validarCampos < 4)
        {
            /**Pues equivale a salir sin guardar en tal caso**/
            salirSinGuardar();
        }
        /**Si no decide salir...**/
        if(c==0)
        {
            gotoxy(1,10);
            printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t\t\t");
        }
        break;
    case 8:
        salirSinGuardar();
        break;
    }
    colordefault();
    fflush(stdin);
}
/**
    Función: ObtenerCaracteres
    Parámetros: PosicionX, PosicionY, PosicionYdeError, texto y apellidos
    Objetivo: Evaluar si existe algún carácter no permitido por ejemplo números y espacios, a excepción de los apellidos que
    pueden recibir espacios
**/
void obtenerCaracteres(int posicionX, int posicionY, int posicionYdeError, char texto[], int apellidos)
{
    gotoxy(posicionX, posicionY);
    printf("\t\t\t\t\t\t");
    gotoxy(posicionX, posicionY);
    fflush(stdin);
    textcolor(GREEN);
    gets(texto);
    int c = comprobarTexto(texto, apellidos);
    if(c == 0)
        {
            textcolor(RED);
            gotoxy(1,posicionYdeError);
            printf("Solo se admite letras y guion en este campo, presione cualquier tecla para regresar nuevamente.");
            fflush(stdin); getch();
            limpiarArregloChar(texto);
            obtenerCaracteres(posicionX, posicionY, posicionYdeError,texto,apellidos);
        }
    else
    {
        gotoxy(1,posicionYdeError);
        printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
    }
    colordefault();
}
/**
    Función: ObtenerSalario
    Parámetros: PosicionX, PosicionY, PosicionYdeError, EmpleadoActual2
    Objetivo: Evaluar si el salario es válido
**/
void obtenerSalario(int posicionX, int posicionY, int posicionYdeError, int empleadoActual2)
{
    textcolor(GREEN);
    gotoxy(posicionX, posicionY);
    printf("\t\t\t\t\t\t\t\t\t\t");
    gotoxy(posicionX, posicionY);
    scanf("%f", &empleados[empleadoActual2].salario);
    if(comprobarSalario(empleados[empleadoActual2].salario) <= 0)
    {
        textcolor(RED);
        gotoxy(1, posicionYdeError);
        printf("El salario debe ser numerico y mayor a cero, presiona cualquier tecla para continuar...");
        fflush(stdin);
        getch();
        gotoxy(1,10);
        printf("\t\t\t\t\t\t\t\t\t\t\t\t");
        obtenerSalario(posicionX, posicionY, posicionYdeError, empleadoActual2);
    }
    colordefault();
}
/**
    Función: ObtenerFechaEntrada
    Parámetros: PosicionX, PosicionY, PosicionYdeError y EmpleadoActual2
    Objetivo: Obtener y evaluar la fecha de entrada, en caso de no ingresarse será el día de hoy
**/
void obtenerFechaEntrada(int posicionX, int posicionY, int posicionYdeError, int empleadoActual2)
{
    textcolor(GREEN);
    gotoxy(posicionX, posicionY); printf("\t\t\t\t\t\t"); gotoxy(posicionX, posicionY);
    scanf("%d/%d/%d", &empleados[empleadoActual2].fentrada.dia,&empleados[empleadoActual2].fentrada.mes, &empleados[empleadoActual2].fentrada.agno);
    if(comprobarFecha(empleados[empleadoActual2].fentrada.dia, empleados[empleadoActual2].fentrada.mes, empleados[empleadoActual2].fentrada.agno) == 0)
        {
            textcolor(RED);
            gotoxy(1,posicionYdeError); printf("Debes digitar la fecha como la entrada indica, presiona cualquier tecla para continuar...");
            fflush(stdin);
            getch();
            gotoxy(1,posicionYdeError); printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
            //gotoxy(posicionX, posicionY); printf("\t\t\t\t"); gotoxy(posicionX, posicionY);
            obtenerFechaEntrada(posicionX, posicionY, posicionYdeError, empleadoActual2);
        }
        colordefault();
}
/**
    Función: ObtenerFechaNacimiento
    Parámetros: posicionX, posicionY, posicionYdeError, empleadoActual2
    Objetivo: Validar que la fecha de nacimiento sea real
**/
void obtenerFechaNacimiento(int posicionX, int posicionY, int posicionYdeError, int empleadoActual2)
{
    textcolor(GREEN);
    gotoxy(posicionX, posicionY); printf("\t\t\t\t\t\t"); gotoxy(posicionX, posicionY);
    scanf("%d/%d/%d", &empleados[empleadoActual2].fnacim.dia,&empleados[empleadoActual2].fnacim.mes, &empleados[empleadoActual2].fnacim.agno);
    if(comprobarFecha(empleados[empleadoActual2].fnacim.dia, empleados[empleadoActual2].fnacim.mes, empleados[empleadoActual2].fnacim.agno) == 0)
        {
            textcolor(RED);
            gotoxy(1,posicionYdeError); printf("Fecha erronea, presiona cualquier tecla para reintentar...");
            fflush(stdin);
            getch();
            gotoxy(1,posicionYdeError); printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
            obtenerFechaNacimiento(posicionX, posicionY, posicionYdeError, empleadoActual2);
        }
        colordefault();
}
/**
    Función     : comprobarFecha
    Parámetros  : Dia, mes y Año
    Objetivo    : Comprobar que el día/mes/año no sea menor que 0 y también comprueba si el año es bisiesto en otra función
**/
int comprobarFecha(int dia, int mes, int anio)
{
    int diasMeses[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    int comprobarAnio = comprobarAnioBisiesto(anio);
    if(dia <=0 || mes <=0 || anio <=0)
        return 0;


    if(comprobarAnio == 0)
    {
        if(mes == 1 || mes == 3 ||mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12)
        {
            if(dia > 31)
            {
                return 0;
            }
            else
            {
                return 1;
            }
        }
        if(mes == 2 ||mes == 4 ||mes == 6 ||mes == 9 ||mes == 11)
        {
            if(mes == 2 && dia > 28)
            {
                return 0;
            }
            if(mes != 2 && dia > 30)
            {
                return 0;
            }
            else
            {
                return 1;
            }
        }
    }

    if(comprobarAnio == 1)
    {
        if(mes == 1 || mes == 3 ||mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12)
        {
            if(dia > 31)
            {
                return 0;
            }
            else
            {
                return 1;
            }
        }
        if(mes == 2 ||mes == 4 ||mes == 6 ||mes == 9 ||mes == 11)
        {
            if(mes == 2 && dia > 29)
            {
                return 0;
            }
            if(mes != 2 && dia > 30)
            {
                return 0;
            }
            else
            {
                return 1;
            }
        }
    }
}
/**
    Función     : ComprobarAnioBisiesto
    Parámetros  : Año
    Objetivo    : Comprobar si el año es bisiesto
**/
int comprobarAnioBisiesto(int anio)
{
     if ( anio % 4 == 0 && anio % 100 != 0 || anio % 400 == 0 )
        return 1;
    else
        return 0;
}
/**
    Función     : ComprobarSalario
    Parámetro   : salario
    Objetivo    : Comprobar si el salario es menor o igual a cero no es aceptable
**/
float comprobarSalario(float salario)
{
    if(salario <=0)
        return 0;
    else return 1;
}
/**
    Función     : comprobarTexto
    Parámetros  : texto y apellidos
    Objetivo:     Comprobar que el texto sea letras y guión si se trata del nombre
                  Y que acepte espacios si se trata del apellido
**/
int comprobarTexto(char texto[], int apellidos)
{
    int i=0, validar = 1;
    gotoxy(1,8); //printf("entrp");
    while(texto[i] != '\0')
    {
        texto[i] = toupper(texto[i]);
        if(apellidos == 1)/**SI SE ESTÁ VALIDANDO APELLIDOS SI SE PERMITE ESPACIOS**/
        {
            if((texto[i] < 'A' || texto[i] > 'Z')&& texto[i] != '-' && texto[i] != ' ')
            {
                //Hay numeros,espacios o caracteres extraños
                validar = 0;
            }
        }
        if(apellidos == 0)/**SI SE VALIDAN NOMBRES SOLO SE PERMITE GUION Y LETRAS**/
        {
            if((texto[i] < 'A' || texto[i] > 'Z')&& texto[i] != '-')// && texto[i] != '-' && texto[i] != 32)
            {
                //Hay numeros,espacios o caracteres extraños
                validar = 0;
            }
        }
        i++;
    }
    return validar;
}
/**
    Función     : comprobarMayorDeEdad
    Parámetros  : ninguno
    Objetivo    : Comprobar si el empleado es mayor de 18 años
**/
int comprobarMayorDeEdad()
{
    if(((empleados[empleadoActual].fentrada.agno-18) < empleados[empleadoActual].fnacim.agno))
        return 0;
    else return 1;
}
/**
    Función     : LimpiarArregloChar
    Parámetros  : arreglo
    Objetivo    : Limpiar el texto que se mande
**/
void limpiarArregloChar(char arreglo[])
{
    int i=0;
    while(arreglo[i] != '\0')
    {
        arreglo[i] = ' ';
        i++;
    }
}
/**
    Función     : SalirSinGuardar
    Parámetros  : Ninguno
    Objetivo    : En caso de que el usuario salga sin guardar se limpian los arreglos con la función memset
**/
void salirSinGuardar()
{
    memset(empleados[empleadoActual].nombre1,0, sizeof(empleados[empleadoActual].nombre1));
    memset(empleados[empleadoActual].nombre2,0, sizeof(empleados[empleadoActual].nombre2));
    memset(empleados[empleadoActual].apellido1,0, sizeof(empleados[empleadoActual].apellido1));
    memset(empleados[empleadoActual].apellido2,0, sizeof(empleados[empleadoActual].apellido2));
    memset(empleados[empleadoActual].idemp,0, sizeof(empleados[empleadoActual].idemp));
    empleados[empleadoActual].fentrada.dia =0;
    empleados[empleadoActual].fentrada.mes=0;
    empleados[empleadoActual].fentrada.agno=0;
    empleados[empleadoActual].fnacim.dia =0;
    empleados[empleadoActual].fnacim.mes=0;
    empleados[empleadoActual].fnacim.agno=0;
    empleados[empleadoActual].salario = 0;
    main(0);
}
/**
    Función     : Guardar
    Parámetros  : ninguno
    Objetivo    : Validar que se hayan escrito en los campos obligatorios y en caso de que la fecha de entrada no se haya digitado
                    (ya que no es obligatorio) pues se pone la fecha actual
**/
void guardar()
{
    //Obteniendo fecha actual:
    time_t t = time(NULL);
    struct tm tm = *localtime(&t);
    gotoxy(45,6);
    char respuesta;
    if(empleados[empleadoActual].fentrada.dia <= 0)
    {
        /**Si el usuario no quiso indicar la fecha de entrada, será por defecto**/
        printf("%d/%d/%d", tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900);
        empleados[empleadoActual].fentrada.dia = tm.tm_mday;
        empleados[empleadoActual].fentrada.mes = tm.tm_mon+1;
        empleados[empleadoActual].fentrada.agno     = tm.tm_year + 1900;
    }

    if(validarCampos >= 4 && comprobarMayorDeEdad() == 1)
    {
        if(empleadoActual == tamanoPuntero-1)
        {
            tamanoPuntero = tamanoPuntero + 10;
            empleados = (EMP*) realloc(empleados, tamanoPuntero);
            /**Se aumenta el tamaño al puntero**/
        }
        empleadoActual++;/**Se aumenta la cantidad de empleado**/
        main(0);
    }
    gotoxy(1,10);
    if(validarCampos < 4)
    {
        printf("Faltan campos por completar, en caso de salir se borrara todo...");
    }
    printf("\nEsta seguro que desea salir?\nSi [S]\nNo [N]\nRespuesta: ");

}
/**
    Función     : ComprobarSalida
    Parámetros  : ninguno
    Objetivo    : Comprobar si el usuario quiere salir o no, solo será usada en algunas circuntancias
**/
int comprobarSalida()
{
    char respuesta;
    do
    {
        fflush(stdin);
        respuesta = getch();
        respuesta = toupper(respuesta);
    }while(respuesta != 'S' && respuesta != 'N');
        if(respuesta == 'S')
                return 1;

        if(respuesta == 'N')
                return 0;
}

/**FUNCIONES DE LA SEGUNDA OPCIÓN DEL MENÚ**/
/**
    Función     : ListaEmpleados
    Parámetros  : PosicionYLista, tipoDeBusqueda, IDBuscar, NombreBuscar, ApellidoBuscar, edadMinima,
                    edadMaxima, salarioMinimo, salarioMaximo
    Objetivo    : Listar los empleados dependiendo de qué forma se busquen, por ejemplo, 0 es listar todo sin importar nada
**/
void listaEmpleados(int posicionYLista,int tipoDeBusqueda, int IDBuscar, char nombreBuscar[LENNOM], char apellidoBuscar[LENAPE], int edadMinima, int edadMaxima, int salarioMinimo, int salarioMaximo)
{
    //int posicionY = 11;
    int posicionY = posicionYLista;
    int posicionX = 1;
    int edadIndice;
    /**Las variables aquí abajo representan la cantidad de carácteres que tiene la palabra**/
    int nombres = 7, apellidos = 9, salario = 7, fechaEntrada = 13;
    /****/
    int xApellidos = obtenerPrimerNombreLargo() + obtenerSegundoNombreLargo() + 1;
    int xSalario = obtenerPrimerApellidoLargo() + obtenerSegundoApellidoLargo() + 1; //obtenerSalarioMayor();
    int xFechaEntrada = obtenerSalarioMayor();
    int xEdad = xApellidos + xSalario + xFechaEntrada;
    int indice=0;
    gotoxy(posicionX, posicionY);
    printf("ID");
    posicionX = posicionX + 5;
    gotoxy(posicionX, posicionY);
    printf("NOMBRES");

    if(xApellidos < nombres)
        xApellidos = xApellidos + nombres + 4;
    else xApellidos = xApellidos + nombres;

    gotoxy(xApellidos, posicionY);
    printf("APELLIDOS");

    if(xSalario < apellidos)
        xSalario = xSalario + xApellidos + nombres;
    else xSalario = xSalario + xApellidos + 1;

    gotoxy(xSalario, posicionY);
    printf("SALARIO");

    if(xFechaEntrada < salario)
        xFechaEntrada = xFechaEntrada + xSalario + 7;//+salario;
    else xFechaEntrada = xFechaEntrada + xSalario + 2;/**4 espacios porque hay un .00 del salario**/

    gotoxy(xFechaEntrada, posicionY);
    printf("FECHA ENTRADA");

    if(xEdad < fechaEntrada)
        xEdad = xEdad + salario + nombres + apellidos + fechaEntrada + 3;
    else xEdad = xEdad + fechaEntrada + salario + nombres +8;//+ apellidos;
        gotoxy(xEdad, posicionY);
    printf("EDAD");

    if(tipoDeBusqueda == 0)
    {
        while(indice < empleadoActual)
        {
            posicionY++;
            gotoxy(1, posicionY);
            imprimirID(indice);
            gotoxy(posicionX, posicionY);
            printf("%s %s", empleados[indice].nombre1, empleados[indice].nombre2);
            gotoxy(xApellidos, posicionY);
            printf("%s %s", empleados[indice].apellido1, empleados[indice].apellido2);
            gotoxy(xSalario, posicionY);
            printf("%1.2f", empleados[indice].salario);
            gotoxy(xFechaEntrada, posicionY);
            printf("%d/%d/%d", empleados[indice].fentrada.dia, empleados[indice].fentrada.mes, empleados[indice].fentrada.agno);
            gotoxy(xEdad, posicionY);
            printf("%d", obtenerEdad(indice));
            indice++;
        }
    }
    /**BUSQUEDA POR ID**/
    if(tipoDeBusqueda == 1)
    {
        while(indice < empleadoActual)
        {
            //posicionY++;
            //gotoxy(1, posicionY);
            if(indice == IDBuscar)
            {
                posicionY++;
                gotoxy(1, posicionY);
                imprimirID(indice);
                gotoxy(posicionX, posicionY);
                printf("%s %s", empleados[indice].nombre1, empleados[indice].nombre2);
                gotoxy(xApellidos, posicionY);
                printf("%s %s", empleados[indice].apellido1, empleados[indice].apellido2);
                gotoxy(xSalario, posicionY);
                printf("%1.2f", empleados[indice].salario);
                gotoxy(xFechaEntrada, posicionY);
                printf("%d/%d/%d", empleados[indice].fentrada.dia, empleados[indice].fentrada.mes, empleados[indice].fentrada.agno);
                gotoxy(xEdad, posicionY);
                printf("%d", obtenerEdad(indice));
            }
            indice++;
        }
    }
    /**BUSQUEDA POR NOMBRE**/
    if(tipoDeBusqueda == 2)
    {
        while(indice < empleadoActual)
        {
            if((strncmp(empleados[indice].nombre1, nombreBuscar,strlen(nombreBuscar)) == 0) || (strncmp(empleados[indice].nombre2, nombreBuscar,strlen(nombreBuscar)) == 0))
            {
                posicionY++;
                gotoxy(1, posicionY);
                imprimirID(indice);
                gotoxy(posicionX, posicionY);
                printf("%s %s", empleados[indice].nombre1, empleados[indice].nombre2);
                gotoxy(xApellidos, posicionY);
                printf("%s %s", empleados[indice].apellido1, empleados[indice].apellido2);
                gotoxy(xSalario, posicionY);
                printf("%1.2f", empleados[indice].salario);
                gotoxy(xFechaEntrada, posicionY);
                printf("%d/%d/%d", empleados[indice].fentrada.dia, empleados[indice].fentrada.mes, empleados[indice].fentrada.agno);
                gotoxy(xEdad, posicionY);
                printf("%d", obtenerEdad(indice));
            }
            indice++;
        }
    }
    /**BUSQUEDA POR APELLIDO**/
    if(tipoDeBusqueda == 3)
    {
        while(indice < empleadoActual)
        {
            if((strcmp(empleados[indice].apellido1, apellidoBuscar) == 0) || (strcmp(empleados[indice].apellido2, apellidoBuscar) == 0))
            {
                posicionY++;
                gotoxy(1, posicionY);
                imprimirID(indice);
                gotoxy(posicionX, posicionY);
                printf("%s %s", empleados[indice].nombre1, empleados[indice].nombre2);
                gotoxy(xApellidos, posicionY);
                printf("%s %s", empleados[indice].apellido1, empleados[indice].apellido2);
                gotoxy(xSalario, posicionY);
                printf("%1.2f", empleados[indice].salario);
                gotoxy(xFechaEntrada, posicionY);
                printf("%d/%d/%d", empleados[indice].fentrada.dia, empleados[indice].fentrada.mes, empleados[indice].fentrada.agno);
                gotoxy(xEdad, posicionY);
                printf("%d", obtenerEdad(indice));
            }
            indice++;
        }
    }
    /**BUSQUEDA MEDIANTE RANGO DE EDAD**/
    if(tipoDeBusqueda == 4)
    {
        while(indice < empleadoActual)
        {
            edadIndice = obtenerEdad(indice);
            if((edadIndice >= edadMinima) && (edadIndice <= edadMaxima))
            {
                posicionY++;
                gotoxy(1, posicionY);
                imprimirID(indice);
                gotoxy(posicionX, posicionY);
                printf("%s %s", empleados[indice].nombre1, empleados[indice].nombre2);
                gotoxy(xApellidos, posicionY);
                printf("%s %s", empleados[indice].apellido1, empleados[indice].apellido2);
                gotoxy(xSalario, posicionY);
                printf("%1.2f", empleados[indice].salario);
                gotoxy(xFechaEntrada, posicionY);
                printf("%d/%d/%d", empleados[indice].fentrada.dia, empleados[indice].fentrada.mes, empleados[indice].fentrada.agno);
                gotoxy(xEdad, posicionY);
                printf("%d", obtenerEdad(indice));
            }
            indice++;
        }
    }
    /**BUSQUEDA POR RANGO SALARIAL**/
    if(tipoDeBusqueda == 5)
    {
        while(indice < empleadoActual)
        {
            if((empleados[indice].salario >= salarioMinimo) && (empleados[indice].salario <= salarioMaximo))
            {
                posicionY++;
                gotoxy(1, posicionY);
                imprimirID(indice);
                gotoxy(posicionX, posicionY);
                printf("%s %s", empleados[indice].nombre1, empleados[indice].nombre2);
                gotoxy(xApellidos, posicionY);
                printf("%s %s", empleados[indice].apellido1, empleados[indice].apellido2);
                gotoxy(xSalario, posicionY);
                printf("%1.2f", empleados[indice].salario);
                gotoxy(xFechaEntrada, posicionY);
                printf("%d/%d/%d", empleados[indice].fentrada.dia, empleados[indice].fentrada.mes, empleados[indice].fentrada.agno);
                gotoxy(xEdad, posicionY);
                printf("%d", obtenerEdad(indice));
            }
            indice++;
        }
    }
}
/**
    Función     : ImprimirID
    Parámetros  : Indice
    Objetivo    : Imprimir el ID con los ceros correspondientes a la izquierda
**/
void imprimirID(int indice)
{
    indice++;
    if(indice <= 9)
    {
        printf("000%d", indice);
    }
    if(indice > 9 && indice <= 99)
    {
        printf("00%d", indice);
    }
    if(indice > 99 && indice <= 999)
    {
        printf("0%d", indice);
    }
    if(indice > 999)
    {
        printf("%d",indice);
    }
}
/**
    Función     : ObtenerSalarioMayor
    Parámetros  : ninguno
    Objetivo    : Conocer cual es el salario mayor para así justificar la salida
**/
int obtenerSalarioMayor()
{
    int cantidadMayor=0, indiceEmpleado=0; float salarioActual;
    while(indiceEmpleado < empleadoActual)
    {
        salarioActual = cantidadDigitosNumero(empleados[indiceEmpleado].salario);
        if(salarioActual > cantidadMayor)
        {
            cantidadMayor = salarioActual;
        }
        indiceEmpleado++;
    }
    return cantidadMayor;
}
/**
    Función     : cantidadDigitosNumero
    Parámetros  : numero
    Objetivo    : Devolver la cantidad de digitos que posee el salario
**/
int cantidadDigitosNumero(float numero)
{
    return (int) log10(numero) + 1;
}
/**
    Función     : ObtenerPrimerNombreLargo
    Parámetros  : ninguno
    Objetivo    : Conocer la cantidad de carácteres que posee el nombre mas largo
**/
int obtenerPrimerNombreLargo()
{
    int mayorLetras=0;
    int indiceEmpleado=0;
    int indiceNombre=0;
    int contadorLetras = 0;
    while(indiceEmpleado < empleadoActual)
    {
        while(empleados[indiceEmpleado].nombre1[indiceNombre] != '\0')
        {
            if(contadorLetras > mayorLetras)
            {
                mayorLetras = contadorLetras;
            }
            contadorLetras++;
            indiceNombre++;
        }
        indiceEmpleado++;
        //mayorLetras = contadorLetras;
    }
    return mayorLetras+1;
}
/**
    Función     : obtenerSegundoNombreLargo
    Parámetros  : ninguno
    Objetivo    : Conocer la cantidad de carácteres que posee el segundo nombre mas largo
**/
int obtenerSegundoNombreLargo()
{
    int mayorLetras=0;
    int indiceEmpleado=0;
    int indiceNombre=0;
    int contadorLetras = 0;
    while(indiceEmpleado < empleadoActual)
    {
        while(empleados[indiceEmpleado].nombre2[indiceNombre] != '\0')
        {
            if(contadorLetras > mayorLetras)
            {
                mayorLetras = contadorLetras;
            }
            contadorLetras++;
            indiceNombre++;
        }
        indiceEmpleado++;
        //mayorLetras = contadorLetras;
    }
    return mayorLetras+1;
}
/**
    Función     : ObtenerPrimerApellidoLargo
    Parámetros  : ninguno
    Objetivo    : Conocer la cantidad de carácteres que posee el apellido mas largo
**/
int obtenerPrimerApellidoLargo()
{
    int mayorLetras=0;
    int indiceEmpleado=0;
    int indiceNombre=0;
    int contadorLetras = 0;
    while(indiceEmpleado < empleadoActual)
    {
        while(empleados[indiceEmpleado].apellido1[indiceNombre] != '\0')
        {
            if(contadorLetras > mayorLetras)
            {
                mayorLetras = contadorLetras;
            }
            contadorLetras++;
            indiceNombre++;
        }
        indiceEmpleado++;
        //mayorLetras = contadorLetras;
    }
    return mayorLetras+1;
}
/**
    Función     : ObtenerSegundoNombreLargo
    Parámetros  : ninguno
    Objetivo    : Conocer la cantidad de carácteres que posee el segundo nombre mas largo
**/
int obtenerSegundoApellidoLargo()
{
    int mayorLetras=0;
    int indiceEmpleado=0;
    int indiceNombre=0;
    int contadorLetras = 0;
    while(indiceEmpleado < empleadoActual)
    {
        while(empleados[indiceEmpleado].apellido2[indiceNombre] != '\0')
        {
            if(contadorLetras > mayorLetras)
            {
                mayorLetras = contadorLetras;
            }
            contadorLetras++;
            indiceNombre++;
        }
        indiceEmpleado++;
        //mayorLetras = contadorLetras;
    }
    return mayorLetras+1;
}
/**
    Función     : ObtenerEdad
    Parámetros  : indice
    Objetivo    : Devolver la edad de la persona dada su fecha
**/
int obtenerEdad(int indice)
{
    time_t t = time(NULL);
    struct tm tm = *localtime(&t);
    int edad = (tm.tm_year+1900) - empleados[indice].fnacim.agno;
    return edad;
}
/**
    Función     : menuListar
    Parámetros  : opcionSeleccionada, posicionY, cantidadDeOpciones
    Objetivo    : Manejar las opciones dentro del menú Lista
**/
void menuListar(int opcionSeleccionada, int posicionY, int cantidadDeOpciones)
{
    int posicionX = 57, indice=0, posicionYdeError = cantidadDeOpciones+1;
    int idBuscar = -1, opc, opc5, edadMinima = -1, edadMaxima = -1,salarioMaximo=-1, salarioMinimo=-1;
    char enter, nombreBuscar[LENNOM], apellidoBuscar[LENNOM];
    switch(opcionSeleccionada)
    {
    case 0:
        listaEmpleados(11,0, -1, '0', '0', -1, -1, -1, -1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(3);
        break;
    case 1:
        busquedaID(11,idBuscar, posicionX, posicionY,3);
        break;
    case 2:
        busquedaNombre(11,nombreBuscar, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones,3);
        break;
    case 3:
        busquedaApellido(11,apellidoBuscar,posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones,3);
        break;
    case 4:
        busquedaRangoEdad(11,edadMinima, edadMaxima, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones,3);
        break;
    case 5:
        busquedaRangoSalario(11,salarioMinimo, salarioMaximo, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones,3);
        break;
    case 6:
        main(3);
        break;
    }
}
/**
    Función     : menuModificar
    Parámetros  : opcionSeleccionada, posicionY, cantidadDeOpciones
    Objetivo    : Manejar las opciones dentro del menú Modificar
**/
void menuModificar(int opcionSeleccionada, int posicionY, int cantidadDeOpciones)
{
    int posicionX = 59, posicionYdeError = cantidadDeOpciones+2;
    char enter, nombreBuscar[LENNOM], apellidoBuscar[LENNOM];
    switch(opcionSeleccionada)
    {
    case 0:
        listaEmpleados(15,0, -1, '0', '0', -1, -1, -1, -1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(1);
        break;
    case 1:
        busquedaNombre(15,nombreBuscar, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones,1);
        break;
    case 2:
        textcolor(GREEN);
        gotoxy(posicionX, posicionY);
        scanf("%d", &idBuscar);
        idBuscar = idBuscar - 1;
        if(idBuscar > empleadoActual || idBuscar < 0 || (idBuscar == 0 && empleados[idBuscar].salario == 0))
        {
            idBuscar = -1;
            gotoxy(1, posicionYdeError);
            textcolor(RED);
            printf("Empleado no existe");
            fflush(stdin);
            getch();
            gotoxy(1, posicionYdeError);
            printf("\t\t\t\t\t\t\t\t");
            colordefault();
            gotoxy(posicionX, posicionY); printf("\t\t\t\t");
        }
        else
        {
            textcolor(YELLOW);
            gotoxy(posicionX, posicionY+1);
            printf("%s", empleados[idBuscar].nombre1);
            gotoxy(posicionX, posicionY+2);
            printf("%s", empleados[idBuscar].nombre2);
            gotoxy(posicionX, posicionY+3);
            printf("%s", empleados[idBuscar].apellido1);
            gotoxy(posicionX, posicionY+4);
            printf("%s", empleados[idBuscar].apellido2);
            gotoxy(posicionX, posicionY+5);
            printf("%d/%d/%d", empleados[idBuscar].fentrada.dia, empleados[idBuscar].fentrada.mes, empleados[idBuscar].fentrada.agno);
            gotoxy(posicionX, posicionY+6);
            printf("%d/%d/%d", empleados[idBuscar].fnacim.dia, empleados[idBuscar].fnacim.mes, empleados[idBuscar].fnacim.agno);
            gotoxy(posicionX, posicionY+7);
            printf("%1.2f", empleados[idBuscar].salario);
        }

        break;
    case 3:/**Modificar primer nombre**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            obtenerCaracteres(posicionX, posicionY, posicionYdeError, empleados[idBuscar].nombre1,0);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t");
            colordefault();
        }
        break;
    case 4:/**Modificar segundo nombre**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            obtenerCaracteres(posicionX, posicionY,posicionYdeError, empleados[idBuscar].nombre2,0);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t");
            colordefault();
        }

        break;
    case 5:/**Modificar primer apellido**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            obtenerCaracteres(posicionX, posicionY, posicionYdeError,empleados[idBuscar].apellido1,1);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t");
            colordefault();
        }

        break;
    case 6:/**Modificar segundo apellido**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            obtenerCaracteres(posicionX, posicionY, posicionYdeError,empleados[idBuscar].apellido2,1);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t");
            colordefault();
        }
        break;
    case 7:/**Modificar fecha entrada**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            empleados[idBuscar].fentrada.agno = -1;
            obtenerFechaEntrada(posicionX, posicionY,posicionYdeError, idBuscar);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t");
            colordefault();
        }
        break;
    case 8:/**Modificar fecha nacimiento**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            empleados[idBuscar].fnacim.agno = -1;
            obtenerFechaNacimiento(posicionX, posicionY,posicionYdeError, idBuscar);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t");
            colordefault();
        }
        break;
    case 9:/**Modificar salario**/
        if(idBuscar == -1)
        {
            verificarIngresoID(idBuscar,posicionYdeError);
        }
        else
        {
            empleados[idBuscar].salario = -1;
            obtenerSalario(posicionX, posicionY, posicionYdeError, idBuscar);
            gotoxy(1, posicionYdeError);
            textcolor(LIGHTGREEN);
            printf("Modificado correctamente\t\t\t\t\t\t\t\t\t");
            colordefault();
        }
        break;
    case 10:
        main(1);
        break;
    }
}
/**
    Función     : verificarIngresoID
    Parámetros  : idBuscar, posicionYdeError
    Objetivo    : Verificar que el usuario quiera modificar un nombre/apellido,etc primero haya digitado un ID obviamente
**/
void verificarIngresoID(int idBuscar, int posicionYdeError)
{
    gotoxy(1, posicionYdeError);
    textcolor(RED);
    printf("Debe digitar un ID primero");
    fflush(stdin);
    getch();
    gotoxy(1, posicionYdeError);
    printf("\t\t\t\t\t\t\t\t\t\t");
}
/**
    Función     : menuBorrar
    Parámetros  : opcionSeleccionada, posicionY, cantidadDeOpciones
    Objetivo    : Manejar las opciones dentro del menú borrar
**/
void menuBorrar(int opcionSeleccionada, int posicionY, int cantidadDeOpciones)
{
    int posicionX = 59, posicionYdeError = cantidadDeOpciones+3, indice = 0;
    char enter, nombreBuscar[LENNOM];
    switch(opcionSeleccionada)
    {
    case 0:
        listaEmpleados(8,0, -1, '0', '0', -1, -1, -1, -1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(2);
        break;
    case 1:
        busquedaNombre(8, nombreBuscar, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones, 2);
        break;
    case 2:
        textcolor(GREEN);
        gotoxy(posicionX, posicionY);
        scanf("%d", &idBuscar);
        idBuscar = idBuscar - 1;
        if((idBuscar) > empleadoActual)
        {
            gotoxy(1, posicionYdeError);
            textcolor(RED);
            printf("Empleado no existe");
            fflush(stdin);
            getch();
            gotoxy(1, posicionYdeError);
            printf("\t\t\t\t\t\t\t\t");
            colordefault();
            gotoxy(posicionX, posicionY); printf("\t\t\t\t");
        }
        break;
    case 3:
        while(idBuscar <= empleadoActual)
        {
            empleados[idBuscar] = empleados[idBuscar+1];
            idBuscar++;
        }
        empleadoActual--;/**Se elimina una posicion de los empleados**/
        gotoxy(1, posicionYdeError);
        textcolor(RED);
        printf("Eliminado correctamente... Presione cualquier tecla para regresar");
        fflush(stdin);
        getch();
        colordefault();
        main(2);
        break;
    case 4:
        main(2);
        break;
    }
}
/**
    Función     : busquedaID
    Parámetros  : posicionYLista, idBuscar, posicionX, posicionY, retornoMain
    Objetivo    : Buscar los empleados que sea igual al ID Digitado
**/
void busquedaID(int posicionYLista, int idBuscar, int posicionX, int posicionY, int retornoMain)
{
        char enter;
        gotoxy(posicionX, posicionY);
        scanf("%d", &idBuscar);
        listaEmpleados(posicionYLista, 1,idBuscar-1, '0', '0', -1, -1,-1,-1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(retornoMain);
}
/**
    Función     : busquedaNombre
    Parámetros  : posicionYLista, nombreBuscar, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones, retornoMain
    Objetivo    : Buscar los empleados que sea igual al Nombre escrito
**/
void busquedaNombre(int posicionYLista, char nombreBuscar[LENNOM],int posicionX, int posicionY, int opcionSeleccionada, int cantidadDeOpciones, int retornoMain)
{
    char enter;
    gotoxy(posicionX, posicionY);
    fflush(stdin);
    textcolor(GREEN);
    gets(nombreBuscar);
    colordefault();
    if(comprobarTexto(nombreBuscar, 0) > 0)
    {
        listaEmpleados(posicionYLista,2,-1,nombreBuscar, '0', -1, -1, -1,-1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        if(retornoMain == 2)/**Es decir si vengo desde el menú de Borrar**/
        {
            printf("Y borrar el ID ya visualizado");
        }
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(retornoMain);
    }
    else
    {
        textcolor(RED);
        gotoxy(1,13);
        printf("El nombre no debe tener numeros u otros caracteres raros...");
        colordefault();
        fflush(stdin);
        getch();
        gotoxy(1,13);
        printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
        colordefault();
        gotoxy(posicionX,posicionY);
        printf("\t\t\t\t\t\t\t\t");
        busquedaNombre(posicionYLista,nombreBuscar,posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones, retornoMain);
    }
}
/**
    Función     : busquedaApellido
    Parámetros  : posicionYLista, apellidoBuscar, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones, retornoMain
    Objetivo    : Buscar los empleados que sea igual al Apellido escrito
**/
void busquedaApellido(int posicionYLista, char apellidoBuscar[LENAPE],int posicionX, int posicionY, int opcionSeleccionada, int cantidadDeOpciones, int retornoMain)
{
    char enter;
    gotoxy(posicionX, posicionY);
    fflush(stdin);
    gets(apellidoBuscar);
    if(comprobarTexto(apellidoBuscar,1) > 0)
    {
        listaEmpleados(posicionYLista,3,-1,'0', apellidoBuscar, -1, -1, -1,-1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(retornoMain);
    }
    else
    {
        textcolor(RED);
        gotoxy(1,11);
        printf("El apellido no debe tener numeros u otros caracteres raros...");
        fflush(stdin);
        getch();
        gotoxy(1,11);
        printf("\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
        colordefault();
        gotoxy(posicionX,posicionY);
        printf("\t\t\t\t\t\t\t\t");
        menuListar(opcionSeleccionada, posicionY, cantidadDeOpciones);
    }
}
/**
    Función     : busquedaRangoEdad
    Parámetros  : posicionYLista, edadMinima, edadMaxima, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones, retornoMain
    Objetivo    : Buscar los empleados que sea por rango de Edad
**/
void busquedaRangoEdad(int posicionYLista, int edadMinima, int edadMaxima, int posicionX, int posicionY, int opcionSeleccionada, int cantidadDeOpciones, int retornoMain)
{
    char enter;
    gotoxy(posicionX, posicionY);
    scanf("%d-%d", &edadMinima, &edadMaxima);
    if(edadMinima < 0 || edadMaxima < 0)
    {
        textcolor(RED);
        gotoxy(1,11);
        printf("Esta edad no existe o no se ha ingresado correctamente...");
        fflush(stdin);
        getch();
        gotoxy(1,11);
        printf("\t\t\t\t\t\t\t\t\t");
        colordefault();
        gotoxy(posicionX, posicionY);
        printf("\t\t\t\t\t\t\t");
        menuListar(opcionSeleccionada, posicionY, cantidadDeOpciones);
    }
    else
    {
        listaEmpleados(posicionYLista, 4, -1, '0','0', edadMinima, edadMaxima,-1,-1);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(retornoMain);
    }
}
/**
    Función     : busquedaRangoSalario
    Parámetros  : posicionYLista, salarioMinimo, salarioMaximo, posicionX, posicionY, opcionSeleccionada, cantidadDeOpciones, retornoMain
    Objetivo    : Buscar los empleados que sea por rango de salario
**/
void busquedaRangoSalario(int posicionYLista, int salarioMinimo, int salarioMaximo, int posicionX, int posicionY, int opcionSeleccionada, int cantidadDeOpciones, int retornoMain)
{
    char enter;
    gotoxy(posicionX, posicionY);
    scanf("%d-%d", &salarioMinimo, &salarioMaximo);
    if(salarioMinimo < 0 || salarioMaximo < 0)
    {
        textcolor(RED);
        gotoxy(1,11);
        printf("Esta edad no existe o no se ha ingresado correctamente...");
        fflush(stdin);
        getch();
        gotoxy(1,11);
        printf("\t\t\t\t\t\t\t\t\t");
        colordefault();
        gotoxy(posicionX, posicionY);
        printf("\t\t\t\t\t\t\t");
        menuListar(opcionSeleccionada, posicionY, cantidadDeOpciones);
    }
    else
    {
        listaEmpleados(posicionYLista, 5, -1, '0','0', -1, -1,salarioMinimo,salarioMaximo);
        textcolor(RED);
        printf("\nPresione enter para regresar...");
        colordefault();
        do
        {
            fflush(stdin);
            enter = getch();
        }while(enter != 13);
        main(retornoMain);
    }
}