PULSOFT

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio1 {

	public static void main(String[] args) {
		/* Crear y mostrar el menú principal para gestionar el inventario de frutas */
		MenuEjercicio1 menu = new MenuEjercicio1();
		menu.mostrarMenu();
	}
}

class Fruta {
	String nombreFruta;
	double cantidad;
	
	/* Método para solicitar y validar el nombre de la fruta */
	private String agregarNombreFruta(Scanner entrada) {
		while (true) {
			System.out.println("Introduce el nombre de la fruta:");
			this.nombreFruta = entrada.nextLine();
			
			/* Validación para evitar nombres vacíos */
			if (this.nombreFruta.equals("")) {
				System.out.println("El nombre de la fruta no puede quedar en blanco, introdúcelo de nuevo");
			} else {
				return this.nombreFruta;
			}
		}
	}
	
	/* Método para solicitar y validar la cantidad de una fruta */
	private Double agregarCantidad(Scanner entrada, String nombreFruta) {
		while (true) {
			try {
				System.out.println("Introduce la cantidad de " + nombreFruta);
				this.cantidad = Double.parseDouble(entrada.nextLine());
				
				/* Validación para que la cantidad sea positiva */
				if (this.cantidad <= 0) {
					System.out.println("La cantidad de fruta tiene que ser mayor que 0, introdúcela de nuevo");
				} else {
					return this.cantidad;
				}
			} catch (NumberFormatException e) {
				System.err.println("Formato de cantidad no válido, introdúcelo de nuevo");
			}
		}
	}
	
	/* Método para actualizar la cantidad de una fruta en el inventario */
	public LinkedHashMap<String, Double> actualizarFruta(Scanner entrada, LinkedHashMap<String, Double> listaFrutas) {
		if (listaFrutas.isEmpty()) {
			System.out.println("La lista de frutas está vacía aún");
		} else {
			this.nombreFruta = agregarNombreFruta(entrada);
			
			/* Comprobar si la fruta existe antes de actualizar */
			if (!listaFrutas.containsKey(this.nombreFruta)) {
				System.out.println("La fruta no se encuentra en la lista de la frutería");
			} else {
				this.cantidad = agregarCantidad(entrada, this.nombreFruta);
				listaFrutas.put(nombreFruta, this.cantidad);
				System.out.println("Fruta actualizada correctamente");
			}
		}
		return listaFrutas;
	}
	
	/* Método para eliminar una fruta del inventario */
	public LinkedHashMap<String, Double> eliminarFruta(Scanner entrada, LinkedHashMap<String, Double> listaFrutas) {
		if (listaFrutas.isEmpty()) {
			System.out.println("La lista de frutas está vacía aún");
		} else {
			this.nombreFruta = agregarNombreFruta(entrada);
			
			/* Comprobar si la fruta existe antes de eliminar */
			if (!listaFrutas.containsKey(this.nombreFruta)) {
				System.out.println("La fruta no se encuentra en la lista de la frutería");
			} else {
				char respuesta = ' ';
				
				/* Confirmación de borrado por parte del usuario */
				while (true) {
					System.out.println("¿Seguro que quieres borrar la fruta " + this.nombreFruta + " del inventario? (s)(n)");
					respuesta = entrada.nextLine().toLowerCase().charAt(0);
					
					if (respuesta != 's' && respuesta != 'n') {
						System.out.println("La respuesta tiene que ser (s) o (n), introdúcela de nuevo"); 
					} else {
						break;
					}
				}
				
				/* Verificar si el usuario confirmó la eliminación */
				if (respuesta == 'n') {
					System.out.println("Operación de borrado abortada");
				} else {
					listaFrutas.remove(this.nombreFruta);
					System.out.println("Fruta borrada con éxito");
				}
			}
		}
		return listaFrutas;
	}
	
	/* Método para agregar una nueva fruta al inventario */
	public LinkedHashMap<String, Double> agregarFruta(Scanner entrada, LinkedHashMap<String, Double> listaFrutas) {
		this.nombreFruta = agregarNombreFruta(entrada);
		
		/* Verificar si la fruta ya existe antes de agregar */
		if (listaFrutas.containsKey(this.nombreFruta)) {
			System.out.println("La fruta ya estaba dada de alta, no se agregará");
		} else {
			this.cantidad = agregarCantidad(entrada, this.nombreFruta);
			listaFrutas.put(nombreFruta, this.cantidad);
			System.out.println("Fruta agregada correctamente");
		}
		return listaFrutas;
	}
	
	/* Método para mostrar el inventario completo de frutas */
	public void mostrarInventario(LinkedHashMap<String, Double> listaFrutas) {
		if (listaFrutas.isEmpty()) {
			System.out.println("La lista de frutas está vacía aún");
		} else {
			System.out.println("Inventario de la frutería");
			for (String fruta : listaFrutas.keySet()) {
				System.out.println("Fruta: " + fruta + " Stock: " + listaFrutas.get(fruta));
			}
		}
	}
}

class MenuEjercicio1 {
	
	LinkedHashMap<String, Double> listaFrutas = new LinkedHashMap<String, Double>();
	Fruta fruta = new Fruta();
	Scanner entrada = new Scanner(System.in);
	int menu = 0;
	
	/* Método que muestra el menú principal y gestiona las opciones seleccionadas */
	public void mostrarMenu() {
		do {
			System.out.println("Menú Frutería");
			System.out.println("1. Añadir fruta");
			System.out.println("2. Actualizar fruta");
			System.out.println("3. Eliminar fruta");
			System.out.println("4. Listar frutas");
			System.out.println("5. Salir");
			System.out.println("Escoge opción:");
			
			try {
				menu = Integer.parseInt(entrada.nextLine());
				gestionarmenu(menu);
			} catch (NumberFormatException e) {
				System.err.println("Formato de menú incorrecto, introdúcelo de nuevo");
			}
		} while (menu != 5);
	}
	
	/* Método que gestiona las opciones del menú principal */
	private void gestionarmenu(int menu) {
		switch (menu) {
			case 1 -> listaFrutas = fruta.agregarFruta(entrada, listaFrutas);
			case 2 -> listaFrutas = fruta.actualizarFruta(entrada, listaFrutas);
			case 3 -> listaFrutas = fruta.eliminarFruta(entrada, listaFrutas);
			case 4 -> fruta.mostrarInventario(listaFrutas);
			case 5 -> {
				/* Mensaje de salida y cierre del recurso Scanner */
				System.out.println("Saliendo de la frutería ...");
				entrada.close();
				break;
			}
			default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo");
		}
	}
}

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio2 {

    public static void main(String[] args) {
        // Se crea una instancia del menú y se muestra el menú
        menuEjercicio2 menu = new menuEjercicio2();
        menu.mostrarMenu();
    }

}

/* Clase Libro que representa los libros de la biblioteca.
 * Cada libro tiene un título (String) y un estado (booleano) que indica si está disponible o prestado.
 */
class Libro {
    String titulo; // Título del libro
    boolean estado; // Estado del libro (true: disponible, false: prestado)
    
    /* Método privado para solicitar al usuario el título del libro. */
    private String campoTitulo(Scanner entrada) {
        while (true) {
            System.out.println("Introduce el titulo del libro:");
            this.titulo = entrada.nextLine(); // Se lee el título del libro
            
            if (this.titulo.equals("")) {
                System.out.println("El titulo no puede quedar en blanco, introdúcelo de nuevo");
            } else {
                return this.titulo; // Devuelve el título si no está vacío
            }
        }
    }
    
    /* Método para prestar un libro. Si el libro está disponible, su estado se cambia a "prestado". */
    public LinkedHashMap<String, Boolean> prestarLibros(Scanner entrada, LinkedHashMap<String, Boolean> listaLibros) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            this.titulo = campoTitulo(entrada); // Se solicita el título del libro
            
            if (!listaLibros.containsKey(this.titulo)) {
                System.out.println("El título no se encuentra en la biblioteca");
            } else if (listaLibros.containsKey(this.titulo) && !listaLibros.get(this.titulo)) {
                System.out.println("El libro ya se encuentra prestado");
            } else {
                listaLibros.put(this.titulo, false); // Se marca el libro como prestado
                System.out.println("Libro prestado correctamente");
            }
        }
        
        return listaLibros; // Devuelve la lista actualizada de libros
    }
    
    /* Método para devolver un libro. Si el libro estaba prestado, su estado se cambia a "disponible". */
    public LinkedHashMap<String, Boolean> devolverLibros(Scanner entrada, LinkedHashMap<String, Boolean> listaLibros) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            this.titulo = campoTitulo(entrada); // Se solicita el título del libro
            
            if (!listaLibros.containsKey(this.titulo)) {
                System.out.println("El título no se encuentra en la biblioteca");
            } else if (listaLibros.containsKey(this.titulo) && listaLibros.get(this.titulo)) {
                System.out.println("El libro no se encuentra prestado");
            } else {
                listaLibros.put(this.titulo, true); // Se marca el libro como disponible
                System.out.println("Libro devuelto correctamente");
            }
        }
        
        return listaLibros; // Devuelve la lista actualizada de libros
    }
    
    /* Método para listar todos los libros en la biblioteca con su estado actual (disponible o prestado). */
    public void listarLibros(LinkedHashMap<String, Boolean> listaLibros) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            System.out.println("Todos los libros de la biblioteca:");
            for (String libro : listaLibros.keySet()) {
                String estado = listaLibros.get(libro) ? "Disponible" : "Prestado"; // Determina el estado del libro
                System.out.println("Libro: " + libro + " Estado: " + estado);
            }
        }
    }
    
    /* Método para listar libros según su estado (disponible o prestado). */
    public void listarLibrosEstado(LinkedHashMap<String, Boolean> listaLibros, boolean estado) {
        if (listaLibros.isEmpty()) {
            System.out.println("Aún no hay libros dados de alta");
        } else {
            if (estado) {
                System.out.println("Todos los libros de la biblioteca sin prestar");
            } else {
                System.out.println("Todos los libros de la biblioteca prestados");
            }
            
            for (String libro : listaLibros.keySet()) {
                if (estado == listaLibros.get(libro)) {
                    System.out.println("Libro: " + libro); // Se muestra el libro según el estado
                }
            }
        }
    }
    
    /* Método para agregar un nuevo libro a la biblioteca. Inicialmente, el libro está disponible. */
    public LinkedHashMap<String, Boolean> agregarLibros(Scanner entrada, LinkedHashMap<String, Boolean> listaLibros) {
        this.titulo = campoTitulo(entrada); // Se solicita el título del libro
        
        if (listaLibros.containsKey(this.titulo)) {
            System.out.println("El título ya se encuentra en la biblioteca");
        } else {
            listaLibros.put(this.titulo, true); // Se agrega el libro como disponible
            System.out.println("Libro agregado correctamente");
        }
        
        return listaLibros; // Devuelve la lista actualizada de libros
    }
}

/* Clase menuEjercicio2 que maneja la interacción con el usuario para elegir opciones en el menú. */
class menuEjercicio2 {
    LinkedHashMap<String, Boolean> listaLibros = new LinkedHashMap<String, Boolean>(); // Lista de libros en la biblioteca
    Libro libro = new Libro(); // Instancia de la clase Libro
    Scanner entrada = new Scanner(System.in); // Scanner para leer la entrada del usuario
    int menu = 0; // Variable para almacenar la opción seleccionada en el menú
    
    /* Método que muestra el menú de opciones y gestiona las selecciones del usuario. */
    public void mostrarMenu() {
        do {
            System.out.println("Biblioteca");
            System.out.println("1. Agregar libro");
            System.out.println("2. Prestar libro");
            System.out.println("3. Devolver libro");
            System.out.println("4. Mostrar libros");
            System.out.println("5. Mostrar libros disponibles");
            System.out.println("6. Mostrar libros prestados");
            System.out.println("7. Salir");
            System.out.println("Escoge opción:");
            
            try {
                menu = Integer.parseInt(entrada.nextLine()); // Se lee la opción del usuario
                gestionarMenu(menu); // Se gestiona la opción seleccionada
            } catch (NumberFormatException e) {
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 7); // El ciclo continúa hasta que el usuario seleccione la opción 7 (Salir)
    }
    
    /* Método que gestiona la acción según la opción seleccionada en el menú. */
    private void gestionarMenu(int menu) {
        switch (menu) {
            case 1 -> listaLibros = libro.agregarLibros(entrada, listaLibros);
            case 2 -> listaLibros = libro.prestarLibros(entrada, listaLibros);
            case 3 -> listaLibros = libro.devolverLibros(entrada, listaLibros);
            case 4 -> libro.listarLibros(listaLibros);
            case 5 -> libro.listarLibrosEstado(listaLibros, true);
            case 6 -> libro.listarLibrosEstado(listaLibros, false);
            case 7 -> {
                System.out.println("Saliendo de la biblioteca ...");
                entrada.close(); // Cierra el scanner al salir
                break;
            }
            default -> System.out.println("Opción no contemplada, introdúcela de nuevo");
        }
    }
}

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio3 {

    // Método principal del programa
    public static void main(String[] args) {
        // Crear una instancia del menú para que el programa pueda interactuar con el usuario
        MenuEjercicio3 menu = new MenuEjercicio3();
        
        // Mostrar el menú al usuario, lo que iniciará el ciclo de interacción
        menu.mostrarMenu();
    }
}


class Producto {
    // Atributos de la clase Producto
    double precio;  // Precio del producto
    int cantidad;   // Cantidad del producto disponible en inventario
    String categoria; // Categoría del producto

    // Constructor vacío de la clase Producto
    public Producto() {

    }

    // Constructor con parámetros para inicializar el producto con valores dados
    public Producto(double precio, int cantidad, String categoria) {
        this.precio = precio;
        this.cantidad = cantidad;
        this.categoria = categoria;
    }

    // Métodos getter y setter para cada uno de los atributos

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public int getCantidad() {
        return cantidad;
    }

    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;
    }

    public String getCategoria() {
        return categoria;
    }

    public void setCategoria(String categoria) {
        this.categoria = categoria;
    }

    // Método toString que devuelve la representación en cadena del producto
    @Override
    public String toString() {
        return "\nP.V.P=" + precio + "€\nCantidad=" + cantidad + "\nCategoria=" + categoria;
    }

    // Método para agregar el precio de un producto validando la entrada del usuario
    private double agregarPrecio(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el P.V.P del producto:");
                this.precio = Double.parseDouble(entrada.nextLine());

                // Validación del precio: debe ser mayor que 0
                if (this.precio <= 0) {
                    System.err.println("El P.V.P no puede ser menor de 1 céntimo, introdúcelo de nuevo");
                } else {
                    return this.precio;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de precio inválido, introdúcelo de nuevo");
            }
        }
    }

    // Método para agregar la cantidad del producto, validando la entrada
    private int agregarCantidad(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce la cantidad del producto:");
                this.cantidad = Integer.parseInt(entrada.nextLine());

                // Validación de la cantidad: debe ser al menos 1
                if (this.cantidad < 1) {
                    System.err.println("La cantidad no puede ser menor de 1, introdúcelo de nuevo");
                } else {
                    return this.cantidad;
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de cantidad inválido, introdúcelo de nuevo");
            }
        }
    }

    // Método para agregar un campo de texto (como el nombre o categoría) y validarlo
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";

        while (true) {
            System.out.println("Introduce el " + campo + " del producto");
            dato = entrada.nextLine();

            // Validación: el campo no puede estar vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato;
            }
        }
    }

    // Método para actualizar el precio de un producto en el inventario
    public LinkedHashMap<String, Producto> actualizarPrecioProducto(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            String nombreProducto = campoTexto(entrada, "nombre");

            if (!inventario.containsKey(nombreProducto)) {
                System.out.println("El producto no se encuentra en el inventario");
            } else {
                System.out.println("Introduce el nuevo P.V.P del producto");
                double precioProducto = agregarPrecio(entrada);

                // Actualizar el precio del producto en el inventario
                inventario.get(nombreProducto).setPrecio(precioProducto);
                System.out.println("P.V.P del producto actualizado correctamente");
            }
        }

        return inventario;
    }

    // Método para actualizar la cantidad de un producto en el inventario
    public LinkedHashMap<String, Producto> actualizarCantidadProducto(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            boolean balance = false;

            char respuestaVenta = ' ';
            while (true) {
                System.out.println("¿Quieres hacer una (v)enta o una (a)ctualización de Stock?");
                respuestaVenta = entrada.nextLine().toLowerCase().charAt(0);

                // Validación de la respuesta
                if (respuestaVenta != 'v' && respuestaVenta != 'a') {
                    System.out.println("La respuesta tiene que ser venta (v) o actualización (a), introdúcela de nuevo");
                } else {
                    break;
                }
            }

            balance = respuestaVenta == 'v';

            String nombreProducto = campoTexto(entrada, "nombre");

            if (!inventario.containsKey(nombreProducto)) {
                System.out.println("El producto no se encuentra en el inventario");
            } else {
                int cantidad = agregarCantidad(entrada);

                // Actualización de la cantidad según el tipo de acción (venta o actualización)
                if (!balance) {
                    // Actualización de stock
                    inventario.get(nombreProducto).setCantidad(inventario.get(nombreProducto).getCantidad() + cantidad);
                    System.out.println("Stock del producto actualizado correctamente");
                } else {
                    // Venta del producto
                    if (cantidad > inventario.get(nombreProducto).getCantidad()) {
                        System.out.println("Stock insuficiente, abortada venta");
                    } else {
                        inventario.get(nombreProducto).setCantidad(inventario.get(nombreProducto).getCantidad() - cantidad);
                        System.out.println("Venta realizada con éxito");

                        // Si la cantidad llega a 0, se elimina el producto del inventario
                        if (inventario.get(nombreProducto).getCantidad() == 0) {
                            inventario.remove(nombreProducto);
                            System.out.println("El producto se ha quedado sin stock y se ha borrado del inventario.");
                        }
                    }
                }
            }
        }

        return inventario;
    }

    // Método para agregar un nuevo producto al inventario
    public LinkedHashMap<String, Producto> agregarProducto(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        String nombreProducto = campoTexto(entrada, "nombre");

        if (inventario.containsKey(nombreProducto)) {
            System.out.println("El producto ya está dado de alta en el inventario, no se agregará");
        } else {
            Producto producto = new Producto();

            // Agregar precio, cantidad y categoría del producto
            producto.setPrecio(agregarPrecio(entrada));
            producto.setCantidad(agregarCantidad(entrada));
            producto.setCategoria(campoTexto(entrada, "categoria"));

            // Añadir el producto al inventario
            inventario.put(nombreProducto, producto);
            System.out.println("Producto agregado con éxito al inventario");
        }

        return inventario;
    }

    // Método para listar todos los productos del inventario
    public void listarInventario(LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            System.out.println("Listado del inventario");
            int contadorProductos = 0;
            for (String nombreProducto : inventario.keySet()) {
                System.out.println("Producto: " + nombreProducto + inventario.get(nombreProducto).toString());
                contadorProductos++;
            }

            System.out.println("Hay un total de " + contadorProductos + " productos dados de alta en el inventario");
        }
    }

    // Método para mostrar el producto más caro y el más barato en el inventario
    public void productosTop(LinkedHashMap<String, Producto> inventario) {
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            double precioCaro = Double.MIN_VALUE;
            double precioBarato = Double.MAX_VALUE;
            Producto productoCaro = new Producto();
            Producto productoBarato = new Producto();
            String caro = "";
            String barato = "";

            // Buscar el producto más caro y el más barato
            for (String nombreProducto : inventario.keySet()) {
                if (inventario.get(nombreProducto).getPrecio() > precioCaro) {
                    precioCaro = inventario.get(nombreProducto).getPrecio();
                    productoCaro = inventario.get(nombreProducto);
                    caro = nombreProducto;
                }

                if (inventario.get(nombreProducto).getPrecio() < precioBarato) {
                    precioBarato = inventario.get(nombreProducto).getPrecio();
                    productoBarato = inventario.get(nombreProducto);
                    barato = nombreProducto;
                }
            }

            // Mostrar los resultados
            System.out.println("Datos del producto más caro");
            System.out.println("Producto: " + caro + productoCaro.toString());

            System.out.println("Datos del producto más barato");
            System.out.println("Producto: " + barato + productoBarato.toString());
        }
    }
	
 // Método para listar productos de una categoría específica en el inventario
    public void listarInventarioCategoria(Scanner entrada, LinkedHashMap<String, Producto> inventario) {
        // Verifica si el inventario está vacío
        if (inventario.isEmpty()) {
            System.out.println("El inventario aún está vacío");
        } else {
            // Solicita al usuario la categoría de los productos que desea listar
            String categoria = campoTexto(entrada, "categoria");

            // Variable para verificar si existe al menos un producto en la categoría especificada
            boolean existeCategoria = false;

            // Recorre el inventario para comprobar si existe algún producto de la categoría solicitada
            for (String nombreProducto : inventario.keySet()) {
                if (inventario.get(nombreProducto).getCategoria().equalsIgnoreCase(categoria)) {
                    existeCategoria = true; // Si encuentra al menos uno, cambia el valor a true
                }
            }

            // Si no existe ningún producto en la categoría solicitada, se informa al usuario
            if (!existeCategoria) {
                System.out.println("Ningún producto de esa categoría");
            } else {
                // Si existe al menos un producto, muestra un mensaje de inicio de listado
                System.out.println("Listado del inventario de la categoría " + categoria);
                int contadorProductos = 0;

                // Recorre nuevamente el inventario para listar solo los productos de la categoría especificada
                for (String nombreProducto : inventario.keySet()) {
                    if (inventario.get(nombreProducto).getCategoria().equalsIgnoreCase(categoria)) {
                        // Muestra la información de cada producto de la categoría
                        System.out.println("Producto: " + nombreProducto + inventario.get(nombreProducto).toString());
                        contadorProductos++; // Incrementa el contador de productos listados
                    }
                }

                // Muestra el número total de productos encontrados en la categoría solicitada
                System.out.println("Hay un total de " + contadorProductos + " productos dados de alta en el inventario de la categoría " + categoria);
            }
        }
    }

}

class MenuEjercicio3 {
    // Mapa que almacena productos, clave es el nombre del producto, valor es un objeto Producto
    LinkedHashMap<String, Producto> inventario = new LinkedHashMap<String, Producto>();
    // Instancia de Producto para manejar las operaciones de los productos
    Producto producto = new Producto();
    // Escáner para la entrada de datos del usuario
    Scanner entrada = new Scanner(System.in);
    // Variable para almacenar la opción seleccionada en el menú
    int menu = 0;

    // Método para mostrar el menú e interactuar con el usuario
    public void mostrarMenu() {
        // Ciclo do-while que muestra el menú y ejecuta las opciones hasta que el usuario elija salir
        do {
            System.out.println("MENU INVENTARIO");
            System.out.println("1. Agregar producto");
            System.out.println("2. Actualizar la cantidad de producto");
            System.out.println("3. Actualizar el precio producto");
            System.out.println("4. Listar todos los productos");
            System.out.println("5. Filtrar producto por categoria");
            System.out.println("6. Mostrar producto más barato y más caro");
            System.out.println("7. Salir del programa");
            System.out.println("Escoge opción:");

            try {
                // Lee la opción ingresada por el usuario
                menu = Integer.parseInt(entrada.nextLine());
                // Llama al método gestionarMenu para procesar la opción seleccionada
                gestionarMenu(menu);
            } catch (NumberFormatException e) {
                // Maneja la excepción en caso de que el usuario ingrese un valor no numérico
                System.err.println("Formato de menú no válido, introdúcelo de nuevo");
            }
        } while (menu != 7); // El ciclo continúa hasta que el usuario elige salir (opción 7)
    }

    // Método para gestionar las opciones del menú
    private void gestionarMenu(int menu) {
        // Estructura switch para manejar las distintas opciones del menú
        switch (menu) {
            case 1 -> inventario = producto.agregarProducto(entrada, inventario); // Agrega un producto
            case 2 -> inventario = producto.actualizarCantidadProducto(entrada, inventario); // Actualiza la cantidad de un producto
            case 3 -> inventario = producto.actualizarPrecioProducto(entrada, inventario); // Actualiza el precio de un producto
            case 4 -> producto.listarInventario(inventario); // Lista todos los productos del inventario
            case 5 -> producto.listarInventarioCategoria(entrada, inventario); // Filtra y lista productos por categoría
            case 6 -> producto.productosTop(inventario); // Muestra los productos más baratos y más caros
            case 7 -> {
                System.out.println("Saliendo del programa ..."); // Mensaje de salida
                entrada.close(); // Cierra el escáner para liberar recursos
                break; // Sale del ciclo y termina el programa
            }
            default -> System.out.println("Opción no contemplada en el menú, introdúcela de nuevo"); // Mensaje si la opción es inválida
        }
    }
}

package linkedhashmap; // Paquete que contiene las clases y archivos relacionados con LinkedHashMap

import java.util.LinkedHashMap; // Importación de la clase LinkedHashMap
import java.util.Scanner; // Importación de la clase Scanner para la entrada de datos por el usuario

public class Ejercicio4 {

    // Método principal del programa, donde se inicia la ejecución
    public static void main(String[] args) {
        
        // Creación de una instancia de la clase MenuEjercicio4
        // para gestionar y mostrar el menú de opciones al usuario
        MenuEjercicio4 menu = new MenuEjercicio4();
        
        // Llamada al método mostrarMenu() para desplegar el menú de opciones
        menu.mostrarMenu();
        
    }

}


class Empleado {
    // Atributos del empleado
    int codigoEmpleado; // Código único del empleado
    String nombre; // Nombre del empleado
    String departamento; // Departamento donde trabaja el empleado
    double salario; // Salario del empleado

    // Constructor sin parámetros
    public Empleado() {
    }

    // Constructor con parámetros para inicializar los atributos principales
    public Empleado(String nombre, String departamento, double salario) {
        this.nombre = nombre;
        this.departamento = departamento;
        this.salario = salario;
    }

    // Métodos getter y setter para cada atributo
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getDepartamento() {
        return departamento;
    }

    public void setDepartamento(String departamento) {
        this.departamento = departamento;
    }

    public double getSalario() {
        return salario;
    }

    public void setSalario(double salario) {
        this.salario = salario;
    }

    public int getCodigoEmpleado() {
        return codigoEmpleado;
    }

    // Método toString que muestra los datos del empleado en formato legible
    @Override
    public String toString() {
        return "\nNombre=" + nombre + "\nDepartamento=" + departamento + "\nSalario=" + salario + "€";
    }

    // Método para pedir datos de tipo texto al usuario con validación
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el " + campo + " del empleado:");
            dato = entrada.nextLine();
            
            // Validación para asegurarse de que el campo no esté vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato; // Retorna el dato cuando es válido
            }
        }
    }

    // Método para ingresar y validar el salario del empleado
    private double agregarSalario(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el salario del empleado:");
                this.salario = Double.parseDouble(entrada.nextLine());

                // Verifica que el salario sea igual o mayor que el salario mínimo interprofesional (SMI)
                if (this.salario < 1323) {
                    System.out.println("El SMI en España con 12 pagas es de 1323, introduce un salario igual o mayor a este");
                } else {
                    return this.salario; // Retorna el salario válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de salario no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para ingresar y validar el código del empleado
    private int agregarCodigo(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el código del empleado:");
                this.codigoEmpleado = Integer.parseInt(entrada.nextLine());

                // Verifica que el código de empleado sea positivo
                if (this.codigoEmpleado < 1) {
                    System.out.println("El código de empleado no puede ser menor que 1, introdúcelo de nuevo");
                } else {
                    return this.codigoEmpleado; // Retorna el código válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de código de empleado no válido, introdúcelo de nuevo");
            }
        }
    }

    // Método para actualizar el salario de un empleado en la lista de empleados
    private LinkedHashMap<Integer, Empleado> actualizarSalario(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados, int codigo) {
        this.salario = agregarSalario(entrada); // Pide el nuevo salario y lo asigna

        // Actualiza el salario en el LinkedHashMap con el código proporcionado
        listaEmpleados.get(codigo).setSalario(this.salario);

        System.out.println("Salario del empleado " + listaEmpleados.get(codigo).getNombre() + " actualizado con éxito a " + this.salario + "€");

        return listaEmpleados; // Retorna la lista actualizada
    }

    // Método para actualizar el departamento de un empleado en la lista de empleados
    private LinkedHashMap<Integer, Empleado> actualizarDepartamento(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados, int codigo) {
        this.departamento = campoTexto(entrada, "departamento"); // Pide el nuevo departamento y lo asigna

        // Actualiza el departamento en el LinkedHashMap con el código proporcionado
        listaEmpleados.get(codigo).setDepartamento(this.departamento);

        System.out.println("Departamento del empleado " + listaEmpleados.get(codigo).getNombre() + " actualizado con éxito a " + this.departamento);

        return listaEmpleados; // Retorna la lista actualizada
    }

    // Método para eliminar un empleado de la lista
    public LinkedHashMap<Integer, Empleado> eliminarEmpleado(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aún no hay empleados dados de alta en la empresa");
        } else {
            this.codigoEmpleado = agregarCodigo(entrada); // Pide el código del empleado a eliminar

            // Verifica si el empleado con ese código existe en la lista
            if (!listaEmpleados.containsKey(this.codigoEmpleado)) {
                System.out.println("No hay ningún empleado con ese código en la empresa");
            } else {
                char respuesta = ' ';

                // Confirma la eliminación del empleado con una respuesta del usuario
                while (true) {
                    System.out.println("¿Seguro que quieres borrar al empleado " + listaEmpleados.get(this.codigoEmpleado).getNombre() + " (s)(n)");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0);
                    
                    if (respuesta != 's' && respuesta != 'n') {
                        System.out.println("La respuesta tiene que ser (s) o (n)");
                    } else {
                        break;
                    }
                }
                
                // Si la respuesta es afirmativa, elimina al empleado
                if (respuesta == 's') {
                    listaEmpleados.remove(this.codigoEmpleado);
                    System.out.println("Empleado despedido con éxito");
                } else {
                    System.out.println("Operación de borrado de empleado abortada");
                }
            }
        }
        return listaEmpleados; // Retorna la lista actualizada
    }


	
 // Método para listar todos los empleados en la empresa
    public void listarEmpleados(LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            int cuentoEmpleados = 0;
            System.out.println("Listado de empleados en la empresa");

            // Recorre cada empleado en la lista e imprime sus datos
            for (Integer codigo : listaEmpleados.keySet()) {
                System.out.println("\nCodigo:" + codigo + listaEmpleados.get(codigo).toString());
                cuentoEmpleados++;
            }

            // Imprime el total de empleados listados
            System.out.println("Hay un total de " + cuentoEmpleados + " empleados en la empresa");
        }
    }

    // Método para calcular y mostrar el salario medio de los empleados
    public void calcularSalarioMedio(LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            double salarioMedio = 0.0;

            // Suma el salario de cada empleado
            for (Integer codigo : listaEmpleados.keySet()) {
                salarioMedio += listaEmpleados.get(codigo).getSalario();
            }

            // Calcula el salario medio dividiendo por el número de empleados
            salarioMedio = salarioMedio / listaEmpleados.size();

            // Muestra el salario medio redondeado a dos decimales
            System.out.println("El salario medio de los empleados es: " + String.format("%.2f", salarioMedio) + "€");
        }
    }

    // Método para listar empleados de un departamento específico
    public void listarEmpleadosDepartamentos(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            this.departamento = campoTexto(entrada, "departamento"); // Pide el departamento

            boolean existeDepartamento = false;

            // Verifica si hay empleados en el departamento especificado
            for (Integer codigo : listaEmpleados.keySet()) {
                if (listaEmpleados.get(codigo).getDepartamento().equalsIgnoreCase(departamento)) {
                    existeDepartamento = true;
                    break;
                }
            }
            if (!existeDepartamento) {
                System.out.println("El departamento no existe en nuestra empresa");
            } else {
                int cuentoEmpleados = 0;
                System.out.println("Listado de empleados del departamento " + departamento + " en la empresa");

                // Lista los empleados del departamento encontrado
                for (Integer codigo : listaEmpleados.keySet()) {
                    Empleado empleado = listaEmpleados.get(codigo);
                    if (empleado.getDepartamento().equalsIgnoreCase(departamento)) {
                        System.out.println("\nCodigo:" + codigo + empleado.toString());
                        cuentoEmpleados++;
                    }
                }

                // Muestra el total de empleados en el departamento
                System.out.println("En el departamento " + departamento + " hay un total de " + cuentoEmpleados + " empleados");
            }
        }
    }

    // Método para actualizar datos de un empleado específico
    public LinkedHashMap<Integer, Empleado> actualizarEmpleado(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        // Verifica si la lista está vacía
        if (listaEmpleados.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            this.codigoEmpleado = agregarCodigo(entrada); // Pide el código del empleado a actualizar

            // Verifica si el empleado con el código ingresado existe
            if (!listaEmpleados.containsKey(this.codigoEmpleado)) {
                System.out.println("No hay ningun empleado con ese codigo en la empresa");
            } else {
                int menuActualizo = 0;

                // Muestra el menú de opciones para actualizar
                do {
                    System.out.println("Opcion de actualizacion");
                    System.out.println("1. Actualizar salario");
                    System.out.println("2. Actualizar departamento");
                    System.out.println("Escoge opcion");

                    // Captura y valida la opción ingresada
                    try {
                        menuActualizo = Integer.parseInt(entrada.nextLine());
                    } catch (NumberFormatException e) {
                        System.err.println("Formato de menu no valido, introducelo de nuevo");
                    }

                } while (menuActualizo < 1 || menuActualizo > 2);

                // Actualiza el salario o el departamento del empleado según la opción elegida
                switch (menuActualizo) {
                    case 1 -> listaEmpleados = actualizarSalario(entrada, listaEmpleados, codigoEmpleado);
                    case 2 -> listaEmpleados = actualizarDepartamento(entrada, listaEmpleados, codigoEmpleado);
                }
            }
        }

        return listaEmpleados; // Retorna la lista de empleados actualizada
    }

    // Método para agregar un nuevo empleado a la lista
    public LinkedHashMap<Integer, Empleado> agregarEmpleado(Scanner entrada, LinkedHashMap<Integer, Empleado> listaEmpleados) {
        this.codigoEmpleado = agregarCodigo(entrada); // Pide el código único del empleado

        // Verifica si el código de empleado ya está en uso
        if (listaEmpleados.containsKey(this.codigoEmpleado)) {
            System.out.println("El codigo de empleado ya esta en uso");

        } else {
            // Crea un nuevo empleado con los datos ingresados y lo agrega a la lista
            Empleado empleado = new Empleado(
                    campoTexto(entrada, "nombre"),
                    campoTexto(entrada, "departamento"),
                    agregarSalario(entrada)
            );
            listaEmpleados.put(this.codigoEmpleado, empleado);
            System.out.println("Empleado agregado con exito");
        }
        return listaEmpleados; // Retorna la lista de empleados actualizada
    }

}

//Clase que representa el menú principal para gestionar empleados
class MenuEjercicio4 {
 // Mapa para almacenar empleados, donde la clave es un código único y el valor es el objeto Empleado
 LinkedHashMap<Integer, Empleado> listaEmpleados = new LinkedHashMap<Integer, Empleado>();
 // Instancia de Empleado para acceder a los métodos de gestión de empleados
 Empleado empleado = new Empleado();
 // Scanner para capturar la entrada del usuario
 Scanner entrada = new Scanner(System.in);
 int menu = 0; // Variable para almacenar la opción seleccionada en el menú

 // Método para mostrar y gestionar el menú principal de empleados
 public void mostrarMenu() {
     do {
         // Muestra las opciones del menú
         System.out.println("Menu Empleados");
         System.out.println("1. Agregar empleado");
         System.out.println("2. Actualizar empleado");
         System.out.println("3. Eliminar empleado");
         System.out.println("4. Listar todos los empleados");
         System.out.println("5. Buscar empleados por departamento");
         System.out.println("6. Calcular salario promedio");
         System.out.println("7. Salir");
         System.out.println("Escoge opcion:");

         try {
             // Intenta capturar y convertir la entrada del usuario a entero
             menu = Integer.parseInt(entrada.nextLine());
             // Llama al método para gestionar la opción seleccionada
             gestionarMenu(menu);
         } catch (NumberFormatException e) {
             // Muestra un mensaje de error si la entrada no es un número válido
             System.err.println("Formato de menu no valido, introducelo de nuevo");
         }
     } while (menu != 7); // El menú se repite hasta que el usuario elija la opción 7 (Salir)
 }

 // Método para ejecutar la acción correspondiente a la opción seleccionada en el menú
 private void gestionarMenu(int menu) {
     switch (menu) {
         case 1 -> // Llama al método para agregar un empleado
             listaEmpleados = empleado.agregarEmpleado(entrada, listaEmpleados);
         case 2 -> // Llama al método para actualizar un empleado
             listaEmpleados = empleado.actualizarEmpleado(entrada, listaEmpleados);
         case 3 -> // Llama al método para eliminar un empleado
             listaEmpleados = empleado.eliminarEmpleado(entrada, listaEmpleados);
         case 4 -> // Llama al método para listar todos los empleados
             empleado.listarEmpleados(listaEmpleados);
         case 5 -> // Llama al método para buscar empleados por departamento
             empleado.listarEmpleadosDepartamentos(entrada, listaEmpleados);
         case 6 -> // Llama al método para calcular el salario promedio de los empleados
             empleado.calcularSalarioMedio(listaEmpleados);
         case 7 -> {
             // Mensaje de despedida y cierre del Scanner
             System.out.println("Saliendo del programa de empleados");
             entrada.close();
             break; // Termina la ejecución del menú
         }
         default -> // Mensaje para opciones no válidas en el menú
             System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
     }
 }
}

package linkedhashmap;

import java.util.LinkedHashMap;
import java.util.Scanner;

public class Ejercicio5 {

	public static void main(String[] args) {
		
		// Creación de una instancia de la clase MenuEjercicio5
        // para gestionar y mostrar el menú de opciones al usuario
        MenuEjercicio5 menu = new MenuEjercicio5();
        
        // Llamada al método mostrarMenu() para desplegar el menú de opciones
        menu.mostrarMenu();

	}

}

class Herramienta{
	int codigo;
	String nombre;
	String categoria;
	int cantidad;
	double costo;
	
	public Herramienta() {
		
	}

	public Herramienta(String nombre, String categoria, int cantidad, double costo) {
		this.nombre = nombre;
		this.categoria = categoria;
		this.cantidad = cantidad;
		this.costo = costo;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getCategoria() {
		return categoria;
	}

	public void setCategoria(String categoria) {
		this.categoria = categoria;
	}

	public int getCantidad() {
		return cantidad;
	}

	public void setCantidad(int cantidad) {
		this.cantidad = cantidad;
	}

	public double getCosto() {
		return costo;
	}

	public void setCosto(double costo) {
		this.costo = costo;
	}

	public int getCodigo() {
		return codigo;
	}

	@Override
	public String toString() {
		return "\nNombre=" + nombre + "\ncategoria=" + categoria + "\ncantidad=" + cantidad + "\ncosto="
				+ costo + "€";
	}
	
	
    
    // Método para ingresar y validar el código de la herramienta
    private int agregarInt(Scanner entrada,String campo) {
    	int dato=0;
        while (true) {
            try {
                System.out.println("Introduce el " + campo + " de la herramienta:");
                dato = Integer.parseInt(entrada.nextLine());

                // Verifica que el código de la herramienta sea positivo
                if (dato < 1) {
                    System.out.println("El " + campo + " de la herramienta no puede ser menor que 1, introdúcelo de nuevo");
                } else {
                    return dato; // Retorna el código válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de " + campo + " de herramienta no válido, introdúcelo de nuevo");
            }
        }
    }
	
	// Método para pedir datos de tipo texto al usuario con validación
    private String campoTexto(Scanner entrada, String campo) {
        String dato = "";
        while (true) {
            System.out.println("Introduce el " + campo + " de la herramienta:");
            dato = entrada.nextLine();
            
            // Validación para asegurarse de que el campo no esté vacío
            if (dato.equals("")) {
                System.out.println("El campo " + campo + " no puede quedar vacío, introdúcelo de nuevo");
            } else {
                return dato; // Retorna el dato cuando es válido
            }
        }
    }
    
 // Método para ingresar y validar el costo de la herramienta
    private double agregarCosto(Scanner entrada) {
        while (true) {
            try {
                System.out.println("Introduce el precio de la herramienta:");
                this.costo = Double.parseDouble(entrada.nextLine());

                // Verifica que el salario sea igual o mayor que el salario mínimo interprofesional (SMI)
                if (this.costo < 0.01) {
                    System.out.println("El preciode la herramienta no puede ser inferior a 1 centimo de €, introducelo de nuevo");
                } else {
                    return this.costo; // Retorna el salario válido
                }
            } catch (NumberFormatException e) {
                System.err.println("Formato de salario no válido, introdúcelo de nuevo");
            }
        }
    }
	
	public LinkedHashMap<Integer, Herramienta> agregarHerramienta(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        this.codigo = agregarInt(entrada,"codigo"); // Pide el código único del empleado

        // Verifica si el código de empleado ya está en uso
        if (inventarioTaller.containsKey(this.codigo)) {
            System.out.println("El codigo de herramieta ya esta en uso");

        } else {
            // Crea un nuevo empleado con los datos ingresados y lo agrega a la lista
            Herramienta herramienta = new Herramienta(
                    campoTexto(entrada, "nombre"),
                    campoTexto(entrada, "categoria"),
                    agregarInt(entrada,"stock"),
                    agregarCosto(entrada)
            );
            inventarioTaller.put(this.codigo, herramienta);
            System.out.println("Empleado agregado con exito");
        }
        return inventarioTaller; // Retorna la lista de empleados actualizada
    }
	
	// Método para actualizar el departamento de un empleado en la lista de empleados
    public LinkedHashMap<Integer, Herramienta> actualizarStock(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
    	if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay empleados dados de alta en la empresa");
        } else {
            this.codigo = agregarInt(entrada,"codigo"); // Pide el código del empleado a actualizar

            // Verifica si el empleado con el código ingresado existe
            if (!inventarioTaller.containsKey(this.codigo)) {
                System.out.println("No hay ninguna herramienta con ese codigo en el taller");
            }else {
            	this.cantidad=agregarInt(entrada,"stock");
            	int cantidadPrevia=inventarioTaller.get(this.codigo).getCantidad();
            	// Actualiza el departamento en el LinkedHashMap con el código proporcionado
                inventarioTaller.get(this.codigo).setCantidad(inventarioTaller.get(this.codigo).getCantidad()+this.cantidad);
                
                System.out.println("Stock actualizado con exito");
                System.out.println("El stock de " + inventarioTaller.get(this.codigo).getNombre() + " pasa de " + cantidadPrevia + " unidades a " + inventarioTaller.get(this.codigo).getCantidad() + " unidades");

                
            }
            
        }
        
    	return inventarioTaller; // Retorna la lista actualizada

        
    }
    public LinkedHashMap<Integer, Herramienta> eliminarHerramienta(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        if (inventarioTaller.isEmpty()) {
            System.out.println("Aún no hay herramientas dadas de alta en el taller");
        } else {
            this.codigo = agregarInt(entrada,"codigo"); // Pide el código del empleado a eliminar

            // Verifica si el empleado con ese código existe en la lista
            if (!inventarioTaller.containsKey(this.codigo)) {
                System.out.println("No hay ningúna herramienta con ese código en la empresa");
            } else {
                char respuesta = ' ';

                // Confirma la eliminación del empleado con una respuesta del usuario
                while (true) {
                    System.out.println("¿Seguro que quieres borrar la herramienta " + inventarioTaller.get(this.codigo).getNombre() + " (s)(n)");
                    respuesta = entrada.nextLine().toLowerCase().charAt(0);
                    
                    if (respuesta != 's' && respuesta != 'n') {
                        System.out.println("La respuesta tiene que ser (s) o (n)");
                    } else {
                        break;
                    }
                }
                
                // Si la respuesta es afirmativa, elimina al empleado
                if (respuesta == 's') {
                	inventarioTaller.remove(this.codigo);
                    System.out.println("Herramienta borrada con éxito");
                } else {
                    System.out.println("Operación de borrado de herramienta abortada");
                }
            }
        }
        return inventarioTaller; // Retorna la lista actualizada
    }
	
    public void listarHerramientas(LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        // Verifica si la lista está vacía
        if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay herramientas dadas de alta en el taller");
        } else {
            
            System.out.println("Listado de herramientas en el taller");
            int cantidadHerramientas=0;
            // Recorre cada empleado en la lista e imprime sus datos
            for (Integer codigo : inventarioTaller.keySet()) {
                System.out.println("\nCodigo:" + codigo + inventarioTaller.get(codigo).toString());
                cantidadHerramientas+=inventarioTaller.get(codigo).getCantidad();
            }

            // Imprime el total de empleados listados
            System.out.println("Hay un total de " + inventarioTaller.size() + " herramientas diferentes en la empresa");
            System.out.println("Hay un total de " + cantidadHerramientas + " unidades de herramientas en la empresa");
        }
    }
    
    public void listarHerramientasCategorias(Scanner entrada, LinkedHashMap<Integer, Herramienta> inventarioTaller) {
        // Verifica si la lista está vacía
        if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay herramientas dadas de alta en el taller");
        } else {
            this.categoria = campoTexto(entrada, "categoria"); // Pide el departamento

            boolean existeCategoria = false;

            // Verifica si hay empleados en el departamento especificado
            for (Integer codigo : inventarioTaller.keySet()) {
                if (inventarioTaller.get(codigo).getCategoria().equalsIgnoreCase(this.categoria)) {
                    existeCategoria = true;
                    break;
                }
            }
            if (!existeCategoria) {
                System.out.println("La categoria no existe en nuestra empresa");
            } else {
                int cuentoHerramientas = 0;
                System.out.println("Listado de herramientas de la categoria " + this.categoria + " en la empresa");
                
                int totalHerramientas=0;
                // Lista los empleados del departamento encontrado
                for (Integer codigo : inventarioTaller.keySet()) {
                    Herramienta herramienta = inventarioTaller.get(codigo);
                    if (herramienta.getCategoria().equalsIgnoreCase(this.categoria)) {
                        System.out.println("\nCodigo:" + codigo + herramienta.toString());
                        cuentoHerramientas++;
                        totalHerramientas+=inventarioTaller.get(codigo).getCantidad();
                    }
                }

                // Muestra el total de empleados en el departamento
                System.out.println("En la categoria " + this.categoria + " hay un total de " + cuentoHerramientas + " modelos de herramientas");
                System.out.println("En la categoria hayun total de " + totalHerramientas + " herramientas");
            }
        }
    }
    
    public void valorInventario(LinkedHashMap<Integer,Herramienta> inventarioTaller) {
    	if (inventarioTaller.isEmpty()) {
            System.out.println("Aun no hay herramientas dadas de alta en el taller");
        }else {
        	double valorTotal=0.0;
        	for (Integer codigo : inventarioTaller.keySet()) {
        		valorTotal+=(inventarioTaller.get(codigo).getCosto()*inventarioTaller.get(codigo).getCantidad());
        	}
        	
        	System.out.println("El valor total del inventario es:" + String.format("%.2f", valorTotal) + "€");
        }
    }
}


class MenuEjercicio5{
	LinkedHashMap<Integer,Herramienta> inventarioTaller=new LinkedHashMap<Integer,Herramienta>();
	Herramienta herramienta=new Herramienta();
	Scanner entrada=new Scanner(System.in);
	int menu=0;
	
	public void mostrarMenu() {
	     do {
	         // Muestra las opciones del menú
	         System.out.println("Menu Empleados");
	         System.out.println("1. Agregar herramienta");
	         System.out.println("2. Actualizar stock");
	         System.out.println("3. Eliminar herramienta");
	         System.out.println("4. Listar todas las herraientas");
	         System.out.println("5. Buscar herramientas por categoria");
	         System.out.println("6. Calcular valor total del inventario");
	         System.out.println("7. Salir");
	         System.out.println("Escoge opcion:");

	         try {
	             // Intenta capturar y convertir la entrada del usuario a entero
	             menu = Integer.parseInt(entrada.nextLine());
	             // Llama al método para gestionar la opción seleccionada
	             gestionarMenu(menu);
	         } catch (NumberFormatException e) {
	             // Muestra un mensaje de error si la entrada no es un número válido
	             System.err.println("Formato de menu no valido, introducelo de nuevo");
	         }
	     } while (menu != 7); // El menú se repite hasta que el usuario elija la opción 7 (Salir)
	 }

	 // Método para ejecutar la acción correspondiente a la opción seleccionada en el menú
	 private void gestionarMenu(int menu) {
	     switch (menu) {
	         case 1 -> inventarioTaller=herramienta.agregarHerramienta(entrada, inventarioTaller);
	         case 2 -> inventarioTaller=herramienta.actualizarStock(entrada, inventarioTaller);
	         case 3 -> inventarioTaller=herramienta.eliminarHerramienta(entrada, inventarioTaller);
	         case 4 -> herramienta.listarHerramientas(inventarioTaller);
	         case 5 -> herramienta.listarHerramientasCategorias(entrada, inventarioTaller);
	         case 6 -> herramienta.valorInventario(inventarioTaller);
	         case 7 -> {
	             // Mensaje de despedida y cierre del Scanner
	             System.out.println("Saliendo del programa de taller");
	             entrada.close();
	             break; // Termina la ejecución del menú
	         }
	         default -> // Mensaje para opciones no válidas en el menú
	             System.out.println("Opcion no contemplada en el menu, introducela de nuevo");
	     }
	 }
}