PI ENTREGA 3.2

#include <iostream> //LIBRERIA IOSTREAM permite ingresar y mostrar en pantalla texto.
#include <cstring>  //LIBRERIA CSTRING facilita el uso de strings, con comandos como lenght.
#include <stdlib.h> //LIBRERIA STDLIB es una biblioteca estandar, se agrego para la funcion limpiar().
#include <conio.h>  //LIBRERIA CONIO.H permite usar la funcion getch(), hace que no se cierre la terminal al ser ejecutado el programa.
using namespace std;

// Funcion del programa
// Sistema para registrar, administrar y consultar prestamos

/*
===================
     VARIABLES
===================
*/

const int dFisica = 100; // DIMENSION FISICA DE LOS ARREGLOS

int cantidad_categorias = 0;   // Variable para saber la dimension logica de las categorias
int cantidad_prestamos = 0;    // Lo mismo que la anterior para los prestamos
int cantidad_prestatarios = 0; // Lo mismo para los prestatarios

/*
================
     STRUCS
================
*/

struct c
{ // Plantilla del struct para las categorias
    int codigo_categoria;
    string descripcion;
};

struct pr
{ // Plantilla del struct para los prestamos
    int codigo_categoria;
    int prestatario;
    string descripcion;
    bool estado;
};

struct pres
{ // Plantilla del struct para prestatarios
    int codigo_prestatario;
    string apellido;
    string nombre;
};

c categorias[dFisica];
pr prestamos[dFisica]; // Definicion de los 3 arreglos para almacenar categorias,prestamos y prestatarios.
pres prestatarios[dFisica];

/*
===================
     FUNCIONES
===================
*/

void limpiar()
{
    // Funcion limpiar
    // PROPOSITO: Limpiar la pantalla mediante system("cls")
    // PARAMETROS: No pide ningun parametro
    // RETORNO:No retorna nada ya que es del tipo void

    system("cls");
}

string mayuscula(string cadena)
{
    // Funcion mayuscula
    // PROPOSITO: Hacer que el string ingresado, retorne en mayusculas, sirve para normalizar los string que se utilicen y evitar errores al compararlos
    // PARAMETROS: Un string deseado para convertirlo en mayusculas
    // RETORNO: Retorna un string que es el mismo que el ingresado, pero con todas sus letras en mayusculas

    for (int i = 0; i < cadena.length(); i++)
    {
        cadena[i] = toupper(cadena[i]);
    }
    return cadena;
}

string agregarCategoria(string descripcion)
{
    // Funcion agregar_categoria
    // PROPOSITO: Agregar una categoria al struct categorias, le asigna un codigo interno a la categoria y revisa que la categoria no este repetida
    // PARAMETROS: Descripcion de la categoria a agregar
    // RETORNO: Retorna un string que dice si se agrego o no la categoria
    for (int i = 0; i <= cantidad_categorias; i++)
    {
        if (mayuscula(descripcion) == mayuscula(categorias[i].descripcion))
        {
            return ("La categoria que desea agregar ya existe!");
        }
        else
        {
            for (int j = cantidad_categorias; j < dFisica; j++)
            {
                categorias[j].codigo_categoria = cantidad_categorias;
                categorias[j].descripcion = descripcion;
                cantidad_categorias++;
                return ("Categoria agregada satisfatoriamente!");
            }
        }
    }
    return ("default");
}

string modificarCategoria(string descripcion)
{
    // Funcion modificar_categoria
    // PROPOSITO: Modificar una categoria existente en el struct categorias
    // PARAMETROS: Descripcion de la categoria a modificar
    // RETORNO: Retorna un string que dice si la modificacion fue satisfatoria o no
    string categoria_modif;
    string aux = descripcion;
    for (int i = 0; i <= cantidad_categorias; i++)
    {
        if (mayuscula(categorias[i].descripcion) == mayuscula(aux))
        {
            cout << "La categoria a modificar ingresada es correcta!" << endl;
            cout << "\nA continuacion ingrese el nuevo nombre para la categoria: ";
            cin >> categoria_modif;
            categorias[i].descripcion = categoria_modif;
            limpiar();
            return ("Categoria modificada satisfactoriamente!");
        }
        else
        {
            return ("La categoria que desea modificar no existe!");
        }
    }
    return ("default");
}

string eliminarCategoria(string descripcion)
{
    // Funcion eliminar_categoria
    // PROPOSITO: Eliminar una categoria del struct antes nombrado, si y solo si la categoria no tiene un prestamo en activo
    // PARAMETROS: Descripcion de la categoria a eliminar
    // RETORNO: Retorna un string que dice si se pudo eliminar o no la categoria
    string descripcion_aux = descripcion;
    int posicion = 0;
    int codigo_cat = 0;
    int codigoexiste = 0;
    int codigoocupado = 0;
    for (int i = 0; i < cantidad_categorias; i++)
    {
        if (mayuscula(descripcion_aux) == mayuscula(categorias[i].descripcion))
        {
            codigoexiste = 1;
            codigo_cat = categorias[i].codigo_categoria;
        }
        else
        {
            codigoexiste = 0;
        }
    }
    for (int i = 0; i < cantidad_prestamos; i++)
    {
        if (codigo_cat == prestamos[i].codigo_categoria)
        {
            codigoocupado = 1;
        }
        else
        {
            codigoocupado = 0;
        }
    }
    if (codigoexiste == 1 && codigoocupado == 0)
    {
        for (int i = posicion; i < cantidad_categorias; i++)
        {
            categorias[i].descripcion = categorias[i + 1].descripcion;
            categorias[i].codigo_categoria = categorias[i + 1].codigo_categoria;
            return ("La categoria se ha eliminado satisfactoriamente!");
        }
    }
    else if (codigoexiste == 1 && codigoocupado == 1)
    {
        return ("La categoria que desea eliminar existe pero esta adjudicada a un prestamo!");
    }
    else if (codigoexiste == 0)
    {
        return ("La categoria que desea eliminar no existe!");
    }
}

string agregarPrestatario(string nombre, string apellido)
{
    int repetidos = 0;
    for (int i = 0; i <= cantidad_prestatarios; i++)
    {
        if (mayuscula(nombre) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido) == mayuscula(prestatarios[i].apellido))
        {
            repetidos++;
        }
    }
    if (repetidos == 0)
    {
        prestatarios[cantidad_prestatarios].nombre = nombre;
        prestatarios[cantidad_prestatarios].apellido = apellido;
        prestatarios[cantidad_prestatarios].codigo_prestatario = cantidad_prestatarios;
        cantidad_prestatarios++;
        return ("Prestatario agregado satisfatoriamente!");
    }
    return ("El prestatario que desea agregar ya existe!");
}

string modificarPrestatario(string nombre, string apellido)
{
    string nombre_modif;
    string apellido_modif;
    string nombre_aux = nombre;
    string apellido_aux = apellido;
    for (int i = 0; i < cantidad_prestatarios; i++)
    {
        if (mayuscula(nombre_aux) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido_aux) == mayuscula(prestatarios[i].apellido))
        {
            cout << "El prestatario a modificar es correcto!" << endl;
            cout << "Ingrese el nuevo nombre del prestatario: ";
            cin >> nombre_modif;
            cout << "Ingrese el nuevo apellido del prestatario: ";
            cin >> apellido_modif;
            prestatarios[i].nombre = nombre_modif;
            prestatarios[i].apellido = apellido_modif;
            return ("Prestatario modificado satisfactoriamente!");
        }
        else
        {
            return ("El prestatario que desea modificar no existe!");
        }
    }
    return ("default");
}

string eliminarPrestatario(string nombre, string apellido)
{
    // Funcion eliminarPrestatario
    // PROPOSITO: Eliminar un prestatario ya inscripto, como las anteriores que dependen de que este inscripto o no, notifica al usuario si el prestatario no se encuentra registrado
    // tambien checkea si el prestatario a eliminar no tiene un prestamo en activo, en caso de ser asi permite elminarlo, en caso de que tenga un prestamo no lo permite
    // PARAMETROS: Nombre y apellido del prestatario a modificar
    // RETORNO: Retorna un string que indica si se elimino o no al prestatario que se desea
    for (int i = 0; i <= cantidad_prestatarios; i++)
    {
        if (mayuscula(nombre) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido) == mayuscula(prestatarios[i].apellido))
        {
            for (; i < cantidad_prestatarios; i++)
            {
                prestatarios[i].nombre = prestatarios[i + 1].nombre;
                prestatarios[i].apellido = prestatarios[i + 1].apellido;
            }
            return ("Prestatario eliminado correctamente");
        }
    }
    return ("Prestatario no encontrado");
}

string agregarPrestamo(string categoria, string nombre, string apellido, string descripcion)
{
    // Funcion agregarPrestamo
    // PROPOSITO: Agregar un prestamo al struct de los mismos, generando un booleano que indica el estado del prestamo, TRUE=prestamo activo, FALSE=prestamo finalizado
    // PARAMETROS: Categoria del prestamo(aclaracion es un string ya que no se usara el codigo de la categoria, sino la descripcion del primer struct
    // llamado categorias para hacer mas facil al usuario el ingreso), aparte de este, se pide nombre y apellido del prestatario
    // y por ultimo una descripcion del prestamo
    // RETORNO: Retorna un string que indica si se agrego o no satisfatoriamente el prestamo a la base de datos

    string categoria_aux = categoria;
    string nombre_aux = nombre;
    string apellido_aux = apellido;
    string descripcion_aux = descripcion;
    for (int i = 0; i < cantidad_categorias; i++)
    {
        if (mayuscula(categoria_aux) == mayuscula(categorias[i].descripcion))
        {
            for (int j = 0; i <= cantidad_prestatarios; j++)
            {
                if (mayuscula(nombre_aux) == mayuscula(prestatarios[j].nombre) && mayuscula(apellido_aux) == mayuscula(prestatarios[j].apellido))
                {
                    prestamos[i].codigo_categoria = categorias[i].codigo_categoria;
                    prestamos[i].prestatario = prestatarios[i].codigo_prestatario;
                    prestamos[i].descripcion = descripcion_aux;
                    prestamos[i].estado = true;
                    cantidad_prestamos++;
                    return ("Prestamo agregado satisfactoriamente!");
                }
                else
                {
                    return ("El prestatario al que desea adjudicar el prestamo no existe!");
                }
            }
        }
        else
        {
            return ("La categoria a la que adjudica el prestamo no existe!");
        }
    }
    return ("default");
}

string modificarPrestamo(string descripcion)
{
    // Funcion modificar_prestamo
    // PROPOSITO: Modificar la descripcion de un prestamo que se encuentre en la base de datos, en caso de que no se encuentre se informa al usuario
    // PARAMETROS: Descripcion del prestamo a modificar
    // RETORNO: Retorna un string informando al usuario sobre el estado de la operacion realizada, en otras palabras si la modificacion salio bien o no

    for (int i = 0; i <= cantidad_prestamos; i++)
    {
        string nuevaDescripcion;
        cout << "INGRESE LA DESCRIPCION NUEVA: ";
        getline(cin >> ws, nuevaDescripcion);
        if (mayuscula(descripcion) == mayuscula(prestamos[i].descripcion))
        {
            prestamos[i].descripcion = nuevaDescripcion;

            return "LA DESCRIPCION SE ELIMINO CORRECTAMENTE!";
        }
        else
        {
            return "LA DESCRIPCION NO SE PUDO ELIMINAR!";
        }
    }
}

string eliminarPrestamo(string descripcion)
{
    // Funcion eliminar_prestamo
    // PROPOSITO: Eliminar un prestamo de la base de datos
    // PARAMETROS: Se pide la descripcion del prestamo a eliminar
    // RETORNO: Retorna un string que indica el estado de la operacion realizada
    for (int i = 0; i <= cantidad_prestamos; i++)
    {
        if (mayuscula(descripcion) == mayuscula(prestamos[i].descripcion) && prestamos[i].estado == false)
        {
            prestamos[i].codigo_categoria = prestamos[i + 1].codigo_categoria;
            prestamos[i].prestatario = prestamos[i + 1].prestatario;
            prestamos[i].descripcion = prestamos[i + 1].descripcion;
            cantidad_prestamos--;
            return "EL PRESTAMO SE ELIMINO CORRECTAMENTE!";
        }
        else
        {
            return "EL PRESTAMO NO SE PUDO ELIMINAR!";
        }
    }
}

string terminar_prestamo(string descripcion)
{
    // Funcion terminar_prestamo
    // PROPOSITO: Terminar un prestamo en activo, cambiando su parte booleana de true a false
    // PARAMETROS: La descripcion del prestamo a terminar
    // RETORNO: Retorna un string y como todas las anteriores, este string indica si la operacion fue satisfatoria o no
    string descripcion_aux = descripcion;
    for (int i = 0; i < cantidad_prestamos; i++)
    {
        if (mayuscula(descripcion_aux) == mayuscula(prestamos[i].descripcion))
        {
            prestamos[i].estado = false;
            return ("El prestamo ha terminado satisfactoriamente");
        }
        else
        {
            return ("El prestamo que desea finalizar no existe");
        }
    }
    return ("default");
}
string title(string frase){
    string frase_aux=frase;
    frase_aux[0]=toupper(frase_aux[0]);
    for(int i=1;i<frase_aux.length();i++){
        frase_aux[i]=tolower(frase_aux[i]);
    }
    return(frase_aux);
}

void cantidad_objetos_categoria(string descripcion){
    //Funcion cantidad_objetos_categoria
    //Proposito:Imprimir la cantidad de objetos para una categoria dada
    //Parametros:Descripcion de la categoria a buscar
    //Retorno:Void, no retorna nada
    string descripcion_aux=mayuscula(descripcion);
    int codigo_aux=0;
    int cantidad_aux=0;
    bool existe=false;
    for(int i=0;i<cantidad_categorias;i++){
        if(descripcion_aux==mayuscula(categorias[i].descripcion)){
            codigo_aux=categorias[i].codigo_categoria;
            existe=true;
        }

    }
    if(existe==true){
        for(int j=0;j<cantidad_prestamos;j++){
            if(codigo_aux==prestamos[j].codigo_categoria){
                cantidad_aux++;
            }
        }
        cout<<"La cantidad de objetos de la categoria deseada es:" << cantidad_aux <<endl;
    }
    else{
        cout<<"La categoria que desea consultar no existe"<<endl;
    }
}

void imprimirObjetos_Categoria(c categorias[], int cantidad_categorias)
{
    // Funcion imprimirObjetos_Categoria
    // PROPOSITO: Imprimir lista de objetos prestados
    // PARAMETROS: Struct de categorias
    // RETORNO: Void, no retorna
    for (int i = 0; i < cantidad_categorias; i++)
    {
        cout << "Objeto Prestado: " << categorias[i].descripcion << endl;
    }
}

void imprimirPrestatarios(pres prestatarios[], int cantidad_prestatarios)
{
    // Funcion imprimirPrestatarios
    // PROPOSITO: Imprimir lista de prestatarios
    // PARAMETROS: Struct prestatarios
    // RETORNO: Void, no retorna
    for (int i = 0; i < cantidad_prestatarios; i++)
    {
        cout << "Prestatario: " << prestatarios[i].nombre << " " << prestatarios[i].apellido << endl;
    }
}

void imprimir_prestamos_por_categoria(string descripcion){
    //Funcion imprimir_prestamos_por_categoria
    //PROPOSITO: Imprimir los prestamos que presentan la categoria deseada
    //Parametro: La descripcion de la categoria
    //Retorno: Void, no retorna nada
    string descripcion_aux=mayuscula(descripcion);
    int codigo_aux=0;
    bool existe=false;
    for(int i=0;i<cantidad_categorias;i++){
        if(descripcion_aux==categorias[i].descripcion){
            codigo_aux=categorias[i].codigo_categoria;
            existe=true;
        }
    }
    if(existe==true){
        for(int j=0;j<cantidad_prestamos;j++){
            if(codigo_aux==prestamos[j].codigo_categoria){
                cout<<"Prestamo"<<j<<endl;
                cout<<"Descripcion:"<<title(prestamos[j].descripcion)<<endl;
            }
    }
}
    else{
        cout<<"La categoria ingresada no existe"<<endl;
    }
}

void imprimirOrdenCategoria()
{
    // Funcion imprimirPorCategoria
    // PROPOSITO: Imprimir lista de prestamos por orden categoria
    // PARAMETROS: Ninguno
    // RETORNO: Void, no retorna
    int cantidad_aux1=0;
    for(int i=0;i<cantidad_categorias;i++){
        cout<<"Los prestamos de"<<categorias[i].descripcion<<"son:"<<endl;
        for(int j=0;j<cantidad_prestamos;j++){
            if(categorias[i].codigo_categoria==prestamos[j].codigo_categoria){
                cantidad_aux1++;
                cout<<"Prestamo "<<cantidad_aux1<<endl;
                cout<<prestamos[j].descripcion<<endl;
            }
        }
    }
}

void imprimirOrdenPrestatario()
{
    // Funcion imprimirPorCategoria
    // PROPOSITO: Imprimir lista de prestamos por orden prestatario
    // PARAMETROS: Ninguno
    // RETORNO: Void, no retorna
    int cantidad_aux2=0;
    for(int i=0;i<cantidad_prestatarios;i++){
        cout<<"Los prestamos de"<<prestatarios[i].nombre<<" "<<prestatarios[i].apellido<<"son:"<<endl;
        for(int j=0;j<cantidad_prestamos;j++){
            if(prestatarios[i].codigo_prestatario==prestamos[j].prestatario){
                cantidad_aux2++;
                cout<<"Prestamo "<<cantidad_aux2<<endl;
                cout<<prestamos[j].descripcion<<endl;
            }
        }
    }
}

void imprimirPrestatarioActivo()
{
    // Funcion imprimirPrestatarioActivo
    // PROPOSITO: Imprimir lista de prestatarios con prestamos activos
    // PARAMETROS: Ninguno
    // RETORNO: Void, no retorna
    cout << "\nLista de prestatarios con prestamos activos: " << endl;
    cout << endl;
    for (int i = 0; i < cantidad_prestamos; i++){
        if(prestamos[i].estado==true){
            for(int j=0; i<cantidad_prestatarios;j++){
                if(prestamos[i].prestatario==prestatarios[j].codigo_prestatario){
                    cout<<prestatarios[j].nombre<<prestatarios[j].apellido<<endl;
                }
            }
        }
    }

}

/*
======================
     FUNCION MAIN
======================
*/

int main()
{

    char seleccion, seleccionA, seleccionB, seleccionC;                                                                  // variables donde se almacenara la opcion del usuario
    string categoriaAgregar, categoriaModificar, categoriaEliminar;                                                      // variables donde se almacenara los datos del usuario del inciso A
    string nombrePrestatario, apellidoPrestatario, nombreModificar, apellidoModificar, nombreEliminar, apellidoEliminar; // variables donde se almacenara los datos del usuario del inciso A
    string seleccionMenuB, ingresarCategoriaB, agregarNombreB, agregarApellidoB, descripcionPrestamoB;                   // Variables utilizadas en inciso B
    string seleccionMenuC;                                                                                               // Variables usadas en el inciso C

    // Menu principal, loopeado mediante un do/while

    do
    {                                            // Do del menu principal, para permitir volver al menu tras realizada cualquier opcion del menu
        cout << "\nBienvenido al menu!" << endl; // Se muestra el menu mediante un COUT
        cout << "\nA: Administrar y consultar Categorias y Prestatarios." << endl;
        cout << "B: Administrar Prestamos." << endl;
        cout << "C: Consultar Prestamos." << endl;
        cout << "D: Salir." << endl;
        cout << "\nElija la opcion a utilizar: ";
        cin >> seleccion; // CIN ingresa la opcion deseada

        seleccion = toupper(seleccion); // convertimos la letra en mayusculas para que sea indiferente el ingreso de mayuscula o minuscula

        switch (seleccion)
        {
        case 'A':      // PRIMER CASO DEL MENU PRINCIPAL
            limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
            do
            { // Do del menu de la opcion A, para permitir volver al menu tras realizada cualquier seleccion
                cout << "\nOPCION A: Administracion y consulta de Categorias y Prestatarios!" << endl;
                cout << "\nA: Agregar categoria." << endl;
                cout << "B: Modificar categoria." << endl;   // Se pone en pantalla las opciones del apartado
                cout << "C: Eliminar categoria." << endl;    // Administracion y consultas de categorias
                cout << "\nD: Agregar prestatario." << endl; // Con un funcionamiento casi igual al principal
                cout << "E: Modificar prestatario." << endl; // Permite ingresar al usuario otra opcion del menu
                cout << "F: Eliminar prestatario." << endl;  // Y como en el principal, se comprueba si la opcion ingresada
                cout << "\nG: Volver al menu principal." << endl;
                cout << "\nElija la opcion a utilizar: "; // Es o no correcta.
                cin >> seleccionA;

                seleccionA = toupper(seleccionA);

                switch (seleccionA)
                {
                case 'A':
                    cout << "\nOPCION A: Ingrese la categoria a agregar: "; // Se pide la categoria a agregar
                    getline(cin >> ws, categoriaAgregar);                   // Se ingresa en la variable
                    limpiar();                                              // Limpia pantalla
                    cout << agregarCategoria(categoriaAgregar) << endl;     // Se ejecuta la funcion que la agrega en el struct
                    break;

                case 'B':
                    cout << "\nOPCION B: Ingrese la categoria a modificar: "; // Se pide categoria a modificar
                    getline(cin >> ws, categoriaModificar);                   // Se ingresa en la variable para ser modificada
                    limpiar();                                                // Limpia pantalla
                    cout << modificarCategoria(categoriaModificar) << endl;   // Se ejecuta la funcion que modifica la categoria
                    break;

                case 'C':
                    cout << "\nOPCION C: Ingrese categoria a eliminar: "; // Se pide categoria a eliminar
                    getline(cin >> ws, categoriaEliminar);                // Se ingresa la categoria
                    limpiar();                                            // Se limpia pantalla
                    cout << eliminarCategoria(categoriaEliminar) << endl; // Se elimina la categoria mediante la funcion
                    break;

                case 'D':
                    cout << "\nOPCION D: Ingrese nombre del prestatario: ";                     // Se pide el nombre del prestatario
                    getline(cin >> ws, nombrePrestatario);                                      // Se ingresa el nombre en la variable
                    cout << "\nIngrese appelido del prestatario: ";                             // Se pide el apellido del prestatario
                    getline(cin >> ws, apellidoPrestatario);                                    // Se ingresa el apellido en la variable
                    limpiar();                                                                  // Se limpia pantalla
                    cout << agregarPrestatario(nombrePrestatario, apellidoPrestatario) << endl; // Se procesan los datos en la funcion
                    break;

                case 'E':
                    cout << "\nOPCION E: Ingrese nombre a modificar: ";                       // Se pide el nombre del prestatario a modificar
                    getline(cin >> ws, nombreModificar);                                      // Se ingresa el nombre en la variable
                    cout << "\nIngrese apellido a modificar: ";                               // Se pide el apellido del prestatario a modificar
                    getline(cin >> ws, apellidoModificar);                                    // Se ingresa el apellido en la variable
                    limpiar();                                                                // Se limpia pantalla
                    cout << modificarPrestatario(nombreModificar, apellidoModificar) << endl; // Se modifica el nombre y apellido del prestatario mediante la funcion
                    break;

                case 'F':
                    cout << "OPCION F: Ingrese nombre del prestatario a eliminar: ";       // Se pide el nombre del prestatario a modificar
                    getline(cin >> ws, nombreEliminar);                                    // Se ingresa el nombre en la variable
                    cout << "\nIngrese apellido del prestatario a eliminar: ";             // Se pide el apellido del prestatario a modificar
                    getline(cin >> ws, apellidoEliminar);                                  // Se ingresa el apellido en la variable
                    limpiar();                                                             // Se limpia pantalla
                    cout << eliminarPrestatario(nombreEliminar, apellidoEliminar) << endl; // Se elimina el prestatario mdeiante la funcion
                    break;
                case 'G':
                    limpiar();
                    cout << "'G': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA Y REGRESA AL MENU PRINCIPAL
                    break;

                default:
                    // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
                    // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
                    limpiar(); // se limpia la pantalla
                    cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
                    break;
                }
            } while (seleccionA != 'G');
            break;

        case 'B':      // SEGUNDO CASO DEL MENU PRINCIPAL
            limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
            do
            { // Do del menu B, para permitir volver al menu tras realizada cualquier seleccion
                cout << "\nOPCION B: Administracion de Prestamos!" << endl;
                cout << "\nA: Agregar prestamo." << endl;
                cout << "B: Modificar prestamo." << endl; // Se ponen en pantalla las opciones del la opcion B
                cout << "C: Eliminar prestamo." << endl;
                cout << "D: Devolver prestamo." << endl;
                cout << "\nE: Volver al menu principal." << endl;
                cout << "\nElija la opcion a utilizar: ";
                cin >> seleccionB; // Se ingresa la opcion seleccionada

                seleccionB = toupper(seleccionB);

                switch (seleccionB)
                {
                case 'A':
                    limpiar();
                    cout << "Desea ver las categorias actuales para su Prestamo?" << endl; // Se pregunta al usuario si desea ver las categorias existentes para su prestamo
                    cout << "S/N: ";
                    cin >> seleccionMenuB; // Se ingresa s o n para si o no respectivamente
                    if (mayuscula(seleccionMenuB) == "S")
                    { // Se comprueba que se elija si

                        imprimirObjetos_Categoria(categorias, cantidad_categorias); // Se realizaria la muestra de las categorias para los prestamos

                        cout << "Ingrese una categoria para el prestamo: ";
                        cin >> ingresarCategoriaB; // Y le permite ingresar la descripcion de la categoria
                    }
                    else if (mayuscula(seleccionMenuB) == "N")
                    {                                                       // Se comprueba si eligio no
                        cout << "Ingrese una categoria para el prestamo: "; // En caso de que no, se le da la opcion a ingresar una categoria sin ver todas
                        cin >> ingresarCategoriaB;                          // Se ingresa la eleccion
                    }

                    cout << "Desea ver los prestatarios ya inscriptos?" << endl; // Se realiza lo mismo que en la pregunta anterior pero con los prestatarios
                    cout << "S/N: ";
                    cin >> seleccionMenuB;
                    if (mayuscula(seleccionMenuB) == "S")
                    { // Caso Si

                        imprimirPrestatarios(prestatarios, cantidad_prestatarios); // Se realizaria la muestra de los prestatarios

                        cout << "Ingrese el nombre del prestatario para el prestamo: "; // Se pide el nombre del prestatario
                        cin >> agregarNombreB;                                          // Se ingresa el nombre
                        cout << "Ingrese el apellido para el prestamo: ";               // Se pide el apellido del prestatario
                        cin >> agregarApellidoB;                                        // Se ingresa
                    }

                    // ACLARACION, en la funcion se busca el codigo del prestatario y el codigo de la categoria, para poder almacenar en el struct prestamos

                    else if (mayuscula(seleccionMenuB) == "N")
                    {                                                                   // Caso No
                        cout << "Ingrese el nombre del prestatario para el prestamo: "; // Se piden e ingresan directamente nombre y
                        cin >> agregarNombreB;                                          // apellido del prestatario para el prestamo
                        cout << "Ingrese el apellido del prestatario para el prestamo: ";
                        cin >> agregarApellidoB;
                    }

                    cout << "Ingrese una descripcion para el prestamo: "; // Se pide ingresar una descripcion al prestamo
                    cin >> descripcionPrestamoB;                          // Se ingresa
                    limpiar();
                    cout << agregarPrestamo(ingresarCategoriaB, agregarNombreB, agregarApellidoB, descripcionPrestamoB) << endl;
                    // Se llama a la funcion para agregar prestamo y con el cout se impreme el retorno de la funcion que es un mensaje de error o no error
                    break;

                case 'B':
                    limpiar();
                    cout << "\nOPCION B: Ingrese la descripcion del prestamo a modificar: "; // Se le pide al usuario ingresarla
                    cin >> descripcionPrestamoB;                                             // Se ingresa
                    limpiar();
                    cout << modificarPrestamo(descripcionPrestamoB) << endl;
                    // Se llama a la funcion modificar_prestamo y con el cout se imprime el mensaje de error o no que devuelve la funcion
                    break;

                case 'C':
                    limpiar();
                    cout << "\nOPCION C: Ingrese la descripcion del prestamo a eliminar: "; // Se pide al usuario
                    cin >> descripcionPrestamoB;                                            // Se Ingresa
                    cout << eliminarPrestamo(descripcionPrestamoB) << endl;                 // Se llama a la funcion con un cout como en los anteriores casos para poder devolver el mensaje de error o lo contrario
                    break;

                case 'D':
                    limpiar();
                    cout << "\nOPCION D: Ingrese la descripcion del prestamo a devolver: "; // Se pide al usuario
                    cin >> descripcionPrestamoB;                                            // Se ingresa
                    cout << terminar_prestamo(descripcionPrestamoB) << endl;                // Se llama a la funcion con el parametro de la descripcion ingresada y se devuelve el mensaje de correcto o error
                    break;

                case 'E':
                    limpiar();
                    cout << "'E': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA
                    break;

                default:
                    // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
                    // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
                    limpiar(); // se limpia la pantalla
                    cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
                    break;
                }
            } while (seleccionB != 'E');
            break;

        case 'C':      // TERCER CASO DEL MENU PRINCIPAL
            limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
            do
            { // Do del menu de la opcion C, para permitir volver al menu tras realizada cualquier seleccion
                cout << "\nOPCION C:Consultas de Prestamos!" << endl;
                cout << "\nA: Cantidad de objetos prestados por categoria." << endl;
                cout << "B: Listado de prestamos por categoria." << endl; // Se ponen en pantalla las opciones
                cout << "C: Listado de prestamos ordenados por prestatario o categoria." << endl;
                cout << "D: Prestatarios con objetos en prestamo." << endl;
                cout << "\nE: Volver al menu principal." << endl;
                cout << "\nElija la opcion a utilizar: ";
                cin >> seleccionC; // Se ingresa el numero de opcion

                seleccionC = toupper(seleccionC);

                switch (seleccionC)
                {
                case 'A':
                    limpiar();
                    cout << "OPCION A" << endl;
                    cout<<"Ingrese la categoria de la que desea conocer cantidad de objetos en prestamo";
                    getline(cin >> ws, categoriaAgregar);
                    cantidad_objetos_categoria(categoriaAgregar);
                    break;

                case 'B':
                    limpiar();
                    cout << "OPCION B" << endl;
                    cout<<"Ingrese la categoria de la que desea conocer los prestamos activos";
                    getline(cin >> ws, categoriaAgregar);
                    imprimir_prestamos_por_categoria(categoriaAgregar);
                    break;

                case 'C':
                    limpiar();
                    cout << "OPCION C" << endl;
                    cout << "Desea ver los prestamos ordenados por categoria o por prestatario(C/P)"<<endl;
                    string opcion_c;
                    cin>>opcion_c;
                    if(mayuscula(opcion_c)=="C"){
                        imprimirOrdenCategoria();
                        break;
                    }
                    else if(mayuscula(opcion_c)=="P"){
                        imprimirOrdenPrestatario();
                        break;
                    }

                case 'D':
                    limpiar();                                                // LIMPIA LA PANTALLA
                    cout << "\nOPCION D" << endl;                             // MUESTRA EN PANTALLA
                    imprimirPrestatarioActivo(); // SE EJECUTA LA FUNCION QUE MUESTRA LOS PRESTATARIOS ACTIVOS
                    break;

                case 'E':
                    limpiar();
                    cout << "'E': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA
                    break;

                default:
                    // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
                    // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
                    limpiar(); // se limpia la pantalla
                    cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
                    break;
                }
            } while (seleccionC != 'E');
            break;

        case 'D':
            cout << "\nSELECCIONO LA OPCION SALIR." << endl; // MUESTRA EN PANTALLA QUE OPCION SELECCIONO
            break;

        default:
            // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
            // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
            limpiar(); // se limpia la pantalla
            cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
            break;
        }
    } while (seleccion != 'D');

    cout << "\nFIN DEL PROGRAMA." << endl; // MUESTRA EN PANTALLA UN MENSAJE DE FIN

    getch();
    return 0;
}