// Con excepciones estandar
try {
    gestor.prestar("LIB-0001", "EMP-001", 12);
} catch (IllegalStateException e) {
    // ¿Que ha pasado? ¿El material esta prestado? ¿El empleado ha llegado al limite?
    // ¿El prestamo ya estaba devuelto? Hay que leer el MENSAJE para saberlo.
    if (e.getMessage().contains("limite")) {      // frágil, horrible, y se rompe al traducir
        // ...
    }
}

// Con excepciones del dominio
try {
    gestor.prestar("LIB-0001", "EMP-001", 12);
} catch (MaterialNoDisponibleException e) {
    ofrecerReserva(e.getReferencia(), e.getDiaPrevistoDevolucion());
} catch (LimitePrestamosExcedidoException e) {
    mostrarPrestamosActivos(e.getEmpleado());
}

throw new IllegalStateException(
        "El empleado EMP-001 (Marta Ruiz) ya tiene 3 prestamos, el maximo es 3");

throw new LimitePrestamosExcedidoException(empleado, Empleado.MAX_PRESTAMOS_SIMULTANEOS);

// Y quien captura:
} catch (LimitePrestamosExcedidoException e) {
    Empleado emp = e.getEmpleado();               // el objeto, no su nombre en una cadena
    int limite  = e.getLimite();                  // el numero, no un texto
    int actuales = e.getPrestamosActuales();

    System.out.printf("%s tiene %d de %d prestamos.%n",
            emp.getNombre(), actuales, limite);
    ofrecerDevolucionAnticipada(emp);             // se puede USAR el objeto
}

package com.nexussoftware.bibliotech.dominio;

/** Version minima: solo el nombre y el mensaje. */
public class MaterialNoEncontradoException extends RuntimeException {

    public MaterialNoEncontradoException(String mensaje) {
        super(mensaje);
    }
}

throw new MaterialNoEncontradoException("No existe el material LIB-9999");

// MAL: extender Throwable directamente
public class MiExcepcion extends Throwable { }      // legal, pero nunca correcto

// MAL: extender Error
public class MiExcepcion extends Error { }          // Error es para fallos de la JVM

// MAL: extender una excepcion estandar muy especifica sin motivo
public class MiExcepcion extends NumberFormatException { }   // hereda una semantica ajena

package com.nexussoftware.bibliotech.dominio;

/** Excepcion con los cuatro constructores canonicos. */
public class BiblioTechException extends RuntimeException {

    /** 1. Sin mensaje ni causa. Poco util, pero completa el contrato. */
    public BiblioTechException() {
        super();
    }

    /** 2. Con mensaje. El mas usado al ORIGINAR un fallo. */
    public BiblioTechException(String mensaje) {
        super(mensaje);
    }

    /** 3. Con mensaje y causa. El que debes usar al ENVOLVER (06-03). */
    public BiblioTechException(String mensaje, Throwable causa) {
        super(mensaje, causa);
    }

    /** 4. Solo causa: el mensaje se deriva de causa.toString(). */
    public BiblioTechException(Throwable causa) {
        super(causa);
    }
}

protected Throwable(String message, Throwable cause,
                    boolean enableSuppression, boolean writableStackTrace)

package com.nexussoftware.bibliotech.dominio;

/**
 * El material solicitado no existe en el catalogo.
 *
 * Transporta la referencia buscada para que quien la capture pueda
 * ofrecerla en un mensaje, buscar alternativas o registrarla, sin
 * tener que parsear el mensaje de texto.
 */
public class MaterialNoEncontradoException extends BiblioTechException {

    private static final long serialVersionUID = 1L;

    /** Los campos de una excepcion deben ser final: una excepcion es inmutable. */
    private final String referenciaBuscada;
    private final int tamanoCatalogo;

    public MaterialNoEncontradoException(String referenciaBuscada, int tamanoCatalogo) {
        // El mensaje se construye a partir de los datos: una sola fuente de verdad
        super("No existe ningun material con la referencia '" + referenciaBuscada
                + "' (el catalogo tiene " + tamanoCatalogo + " materiales)");
        this.referenciaBuscada = referenciaBuscada;
        this.tamanoCatalogo = tamanoCatalogo;
    }

    /** Variante para cuando se envuelve otro fallo. */
    public MaterialNoEncontradoException(String referenciaBuscada, int tamanoCatalogo,
                                         Throwable causa) {
        super("No existe ningun material con la referencia '" + referenciaBuscada
                + "' (el catalogo tiene " + tamanoCatalogo + " materiales)", causa);
        this.referenciaBuscada = referenciaBuscada;
        this.tamanoCatalogo = tamanoCatalogo;
    }

    public String getReferenciaBuscada() { return referenciaBuscada; }
    public int getTamanoCatalogo()       { return tamanoCatalogo; }

    /** Metodo de conveniencia: la excepcion puede aportar logica util. */
    public boolean catalogoVacio() {
        return tamanoCatalogo == 0;
    }
}

try {
    Material m = catalogo.obtenerPorReferencia(entradaUsuario);
    gestor.prestar(m.getReferencia(), "EMP-001", dia);
} catch (MaterialNoEncontradoException e) {

    if (e.catalogoVacio()) {
        System.out.println("El catalogo esta vacio. ¿Ha cargado el fichero de materiales?");
    } else {
        System.out.println("No se encontro '" + e.getReferenciaBuscada() + "'.");
        // Se pueden usar los DATOS para ayudar: sugerencias por prefijo
        List<Material> parecidos = catalogo.buscarPorPrefijo(
                e.getReferenciaBuscada().substring(0, 3));
        if (!parecidos.isEmpty()) {
            System.out.println("¿Quiza queria decir alguno de estos?");
            parecidos.forEach(m -> System.out.println("  " + m.getReferencia()));
        }
    }
}

// Nivel 1: cualquier fallo del dominio BiblioTech (frontera de errores)
catch (BiblioTechException e) { ... }

// Nivel 2: cualquier fallo relacionado con prestamos
catch (PrestamoException e) { ... }

// Nivel 3: este fallo concreto, con sus datos
catch (LimitePrestamosExcedidoException e) { usar(e.getLimite()); }

try {
    gestor.prestar(referencia, idEmpleado, dia);
} catch (LimitePrestamosExcedidoException e) {      // hoja
    ofrecerDevolucionAnticipada(e.getIdEmpleado());
} catch (PrestamoException e) {                      // rama
    System.out.println("No se pudo completar el prestamo: " + e.getMessage());
} catch (BiblioTechException e) {                    // raiz
    System.out.println("Fallo de BiblioTech: " + e.getMessage());
}

try {
    aplicacion.arrancar();
} catch (BiblioTechException e) {
    // Fallo ESPERADO del dominio: mensaje limpio para el usuario
    System.out.println("Operacion no completada: " + e.getMessage());
} catch (RuntimeException e) {
    // Fallo INESPERADO: es un bug. Mensaje generico + registro completo
    System.out.println("Error interno. Consulte el registro (incidencia " + id + ").");
    logger.log(Level.SEVERE, "Fallo no controlado", e);
}

public abstract class BiblioTechException extends RuntimeException {

    /** Codigo estable para el log y para la documentacion de soporte. */
    public String getCodigo() {
        return getClass().getSimpleName().replace("Exception", "").toUpperCase();
    }

    /**
     * ¿Es un fallo que el usuario puede corregir por si mismo?
     * Las subclases lo redefinen cuando no sea asi.
     */
    public boolean esCorregiblePorElUsuario() {
        return true;
    }

    /** Mensaje apto para mostrar en pantalla, sin detalles internos. */
    public String getMensajeParaUsuario() {
        return getMessage();
    }
}

// Qué + dato + esperado
"El empleado EMP-001 (Marta Ruiz) tiene 3 prestamos activos y el limite es 3"

// Qué + dato + contexto útil para actuar
"El material LIB-0001 ('Java Efectivo') esta prestado a EMP-002 desde el dia 12"

// Qué + los dos datos que colisionan
"Ya existe un material con la referencia LIB-0001: 'Java Efectivo'"

warning: [serial] serializable class MaterialNoEncontradoException has no definition
of serialVersionUID

public class MaterialNoEncontradoException extends BiblioTechException {
    private static final long serialVersionUID = 1L;
    // ...
}

// PROBLEMATICO si la excepcion viaja por red y Empleado no es Serializable
private final Empleado empleado;

// SEGURO: String e int siempre son serializables
private final String idEmpleado;
private final int limite;

// ESTANDAR: validacion tecnica sin significado de negocio
Objects.requireNonNull(referencia, "La referencia no puede ser nula");
if (dia < 1) {
    throw new IllegalArgumentException("El dia debe ser 1 o posterior, y era: " + dia);
}
if (!referencia.matches("LIB-\\d{4}")) {
    throw new IllegalArgumentException("Formato de referencia invalido: " + referencia);
}

// PROPIA: regla de negocio con nombre y con datos
if (!material.estaDisponible()) {
    throw new MaterialNoDisponibleException(referencia, material.getTitulo(),
                                            material.getDiaPrevistoDevolucion());
}

protected Throwable(String message, Throwable cause,
                    boolean enableSuppression,      // ¿admite excepciones suprimidas? (06-06)
                    boolean writableStackTrace)     // ¿captura la pila?

package com.nexussoftware.bibliotech.servicio;

/**
 * Excepcion de senal, sin stack trace.
 *
 * ADVERTENCIA: usar SOLO cuando se cumplan las tres condiciones:
 *   1. Se lanza en un bucle muy caliente (miles de veces por segundo).
 *   2. Se captura inmediatamente en el mismo metodo o muy cerca.
 *   3. El stack trace no aporta NADA, porque el punto de lanzamiento es unico.
 *
 * Si no se cumplen las tres, esta optimizacion solo consigue que un fallo
 * real sea imposible de diagnosticar. Es la definicion de optimizacion prematura.
 */
public class BusquedaInterrumpidaException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    private final int posicion;

    public BusquedaInterrumpidaException(int posicion) {
        //      mensaje, causa, supresion, stackTrace
        super("Busqueda interrumpida en la posicion " + posicion, null, false, false);
        this.posicion = posicion;
    }

    public int getPosicion() { return posicion; }
}

/** Una unica instancia reutilizada: cero asignaciones de memoria. */
private static final BusquedaInterrumpidaException SENAL =
        new BusquedaInterrumpidaException(-1);

// ...
throw SENAL;                          // no construye nada

package com.nexussoftware.bibliotech.dominio;

/**
 * Raiz de todas las excepciones del dominio de BiblioTech.
 *
 * Es abstracta porque nadie debe lanzarla directamente: seria tan poco
 * informativa como el 'false' mudo que este modulo esta eliminando.
 *
 * Es NO COMPROBADA (extiende RuntimeException) porque representa reglas de
 * negocio que el llamador normalmente no puede resolver en el sitio, y porque
 * obligar a declararlas contaminaria toda la aplicacion, incluidas las lambdas.
 */
public abstract class BiblioTechException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    protected BiblioTechException(String mensaje) {
        super(mensaje);
    }

    protected BiblioTechException(String mensaje, Throwable causa) {
        super(mensaje, causa);
    }

    /**
     * Codigo estable del fallo, derivado del nombre de la clase.
     * Sirve para el log y para la documentacion de soporte:
     * MATERIALNOENCONTRADO, LIMITEPRESTAMOSEXCEDIDO, etc.
     */
    public String getCodigo() {
        return getClass().getSimpleName()
                .replace("Exception", "")
                .toUpperCase();
    }

    /**
     * ¿Puede el usuario corregir esto por si mismo?
     * Por defecto si; las subclases que representen fallos del sistema lo redefinen.
     */
    public boolean esCorregiblePorElUsuario() {
        return true;
    }
}

package com.nexussoftware.bibliotech.dominio;

/** Fallos relacionados con el catalogo de materiales. */
public abstract class CatalogoException extends BiblioTechException {

    private static final long serialVersionUID = 1L;

    protected CatalogoException(String mensaje) { super(mensaje); }

    protected CatalogoException(String mensaje, Throwable causa) { super(mensaje, causa); }
}

package com.nexussoftware.bibliotech.dominio;

/** Fallos relacionados con prestamos y devoluciones. */
public abstract class PrestamoException extends BiblioTechException {

    private static final long serialVersionUID = 1L;

    protected PrestamoException(String mensaje) { super(mensaje); }

    protected PrestamoException(String mensaje, Throwable causa) { super(mensaje, causa); }
}

package com.nexussoftware.bibliotech.dominio;

/** No existe ningun material con la referencia buscada. */
public class MaterialNoEncontradoException extends CatalogoException {

    private static final long serialVersionUID = 1L;

    private final String referenciaBuscada;
    private final int tamanoCatalogo;

    public MaterialNoEncontradoException(String referenciaBuscada, int tamanoCatalogo) {
        super("No existe ningun material con la referencia '" + referenciaBuscada
                + "' (el catalogo tiene " + tamanoCatalogo + " materiales)");
        this.referenciaBuscada = referenciaBuscada;
        this.tamanoCatalogo = tamanoCatalogo;
    }

    public String getReferenciaBuscada() { return referenciaBuscada; }
    public int getTamanoCatalogo()       { return tamanoCatalogo; }
    public boolean catalogoVacio()       { return tamanoCatalogo == 0; }
}

package com.nexussoftware.bibliotech.dominio;

/** Se intenta registrar un material con una referencia o un ISBN que ya existen. */
public class ReferenciaDuplicadaException extends CatalogoException {

    private static final long serialVersionUID = 1L;

    /** Tipo de identificador que colisiona. Un enum (04-07) evita cadenas magicas. */
    public enum Tipo { REFERENCIA, ISBN }

    private final Tipo tipo;
    private final String valorDuplicado;
    private final String tituloExistente;

    public ReferenciaDuplicadaException(Tipo tipo, String valorDuplicado, String tituloExistente) {
        super("Ya existe un material con " + (tipo == Tipo.ISBN ? "el ISBN " : "la referencia ")
                + valorDuplicado + ": '" + tituloExistente + "'");
        this.tipo = tipo;
        this.valorDuplicado = valorDuplicado;
        this.tituloExistente = tituloExistente;
    }

    public Tipo getTipo()              { return tipo; }
    public String getValorDuplicado()  { return valorDuplicado; }
    public String getTituloExistente() { return tituloExistente; }
}

package com.nexussoftware.bibliotech.dominio;

/** El material existe pero esta prestado a otro empleado. */
public class MaterialNoDisponibleException extends PrestamoException {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final String titulo;
    private final String idTitularActual;
    private final int diaPrevistoDevolucion;

    public MaterialNoDisponibleException(String referencia, String titulo,
                                         String idTitularActual, int diaPrevistoDevolucion) {
        super("El material " + referencia + " ('" + titulo + "') esta prestado a "
                + idTitularActual + " y se espera su devolucion el dia " + diaPrevistoDevolucion);
        this.referencia = referencia;
        this.titulo = titulo;
        this.idTitularActual = idTitularActual;
        this.diaPrevistoDevolucion = diaPrevistoDevolucion;
    }

    public String getReferencia()         { return referencia; }
    public String getTitulo()             { return titulo; }
    public String getIdTitularActual()    { return idTitularActual; }
    public int getDiaPrevistoDevolucion() { return diaPrevistoDevolucion; }

    /** Dias que faltan para que el material vuelva a estar libre. */
    public int diasDeEspera(int diaActual) {
        return Math.max(0, diaPrevistoDevolucion - diaActual);
    }
}

package com.nexussoftware.bibliotech.dominio;

/** El empleado ha alcanzado el maximo de prestamos simultaneos. */
public class LimitePrestamosExcedidoException extends PrestamoException {

    private static final long serialVersionUID = 1L;

    private final String idEmpleado;
    private final String nombreEmpleado;
    private final int prestamosActuales;
    private final int limite;

    public LimitePrestamosExcedidoException(String idEmpleado, String nombreEmpleado,
                                            int prestamosActuales, int limite) {
        super("El empleado " + idEmpleado + " (" + nombreEmpleado + ") tiene "
                + prestamosActuales + " prestamos activos y el limite es " + limite);
        this.idEmpleado = idEmpleado;
        this.nombreEmpleado = nombreEmpleado;
        this.prestamosActuales = prestamosActuales;
        this.limite = limite;
    }

    public String getIdEmpleado()     { return idEmpleado; }
    public String getNombreEmpleado() { return nombreEmpleado; }
    public int getPrestamosActuales() { return prestamosActuales; }
    public int getLimite()            { return limite; }

    /** Cuantos materiales debe devolver para poder tomar otro prestado. */
    public int devolucionesNecesarias() {
        return Math.max(1, prestamosActuales - limite + 1);
    }
}

package com.nexussoftware.bibliotech.dominio;

/** Se intenta devolver un prestamo que ya se habia devuelto. */
public class PrestamoYaDevueltoException extends PrestamoException {

    private static final long serialVersionUID = 1L;

    private final String referenciaPrestamo;
    private final int diaDevolucionOriginal;

    public PrestamoYaDevueltoException(String referenciaPrestamo, int diaDevolucionOriginal) {
        super("El prestamo " + referenciaPrestamo + " ya se devolvio el dia "
                + diaDevolucionOriginal);
        this.referenciaPrestamo = referenciaPrestamo;
        this.diaDevolucionOriginal = diaDevolucionOriginal;
    }

    public String getReferenciaPrestamo()  { return referenciaPrestamo; }
    public int getDiaDevolucionOriginal()  { return diaDevolucionOriginal; }

    /**
     * Este fallo casi siempre indica un problema de secuencia en el codigo
     * o un doble clic del usuario, no algo que el usuario pueda "corregir".
     */
    @Override
    public boolean esCorregiblePorElUsuario() {
        return false;
    }
}

package com.nexussoftware.bibliotech.servicio;

/**
 * El catalogo persistido no se puede leer o escribir.
 *
 * Es COMPROBADA porque representa un fallo del entorno (disco, permisos,
 * fichero ausente) del que la aplicacion SI tiene una alternativa razonable:
 * arrancar con el catalogo vacio. Obligar a decidirlo explicitamente es
 * justamente lo que se quiere.
 *
 * No extiende BiblioTechException porque esa raiz es no comprobada y
 * representa reglas de negocio; esto es un fallo de infraestructura.
 * El modulo 7 desarrollara la parte de E/S.
 */
public class CatalogoNoAccesibleException extends Exception {

    private static final long serialVersionUID = 1L;

    private final String ruta;

    public CatalogoNoAccesibleException(String ruta, Throwable causa) {
        super("No se pudo acceder al catalogo en '" + ruta + "'", causa);
        this.ruta = ruta;
    }

    public String getRuta() { return ruta; }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

import com.nexussoftware.bibliotech.dominio.Libro;
import com.nexussoftware.bibliotech.dominio.Material;
import com.nexussoftware.bibliotech.dominio.MaterialNoEncontradoException;
import com.nexussoftware.bibliotech.dominio.ReferenciaDuplicadaException;

/** Catalogo de BiblioTech con excepciones del dominio. */
public class Catalogo {

    private final List<Material> materiales = new ArrayList<>();
    private final Map<String, Material> indicePorReferencia = new HashMap<>();
    private final Map<String, String> titulosPorIsbn = new HashMap<>();

    /**
     * Registra un material.
     *
     * @throws NullPointerException          si el material es nulo (fallo tecnico)
     * @throws ReferenciaDuplicadaException  si la referencia o el ISBN ya existen
     */
    public void registrar(Material material) {
        // Validacion tecnica: excepcion ESTANDAR
        Objects.requireNonNull(material, "El material a registrar no puede ser nulo");

        String referencia = material.getReferencia();

        // Regla de negocio: excepcion PROPIA, con datos
        Material existente = indicePorReferencia.get(referencia);
        if (existente != null) {
            throw new ReferenciaDuplicadaException(
                    ReferenciaDuplicadaException.Tipo.REFERENCIA,
                    referencia, existente.getTitulo());
        }

        if (material instanceof Libro libro) {
            String tituloConEseIsbn = titulosPorIsbn.get(libro.getIsbn());
            if (tituloConEseIsbn != null) {
                throw new ReferenciaDuplicadaException(
                        ReferenciaDuplicadaException.Tipo.ISBN,
                        libro.getIsbn(), tituloConEseIsbn);
            }
            titulosPorIsbn.put(libro.getIsbn(), libro.getTitulo());
        }

        materiales.add(material);
        indicePorReferencia.put(referencia, material);
    }

    /**
     * Obtiene un material EXIGIENDO que exista. Nunca devuelve null.
     *
     * @throws MaterialNoEncontradoException si no existe
     */
    public Material obtenerPorReferencia(String referencia) {
        Objects.requireNonNull(referencia, "La referencia no puede ser nula");

        Material encontrado = indicePorReferencia.get(referencia);
        if (encontrado == null) {
            throw new MaterialNoEncontradoException(referencia, materiales.size());
        }
        return encontrado;
    }

    /** Busca ADMITIENDO que no exista. Nunca devuelve null: devuelve Optional. */
    public Optional<Material> buscarPorReferencia(String referencia) {
        if (referencia == null) { return Optional.empty(); }
        return Optional.ofNullable(indicePorReferencia.get(referencia));
    }

    public List<Material> buscarPorPrefijo(String prefijo) {
        List<Material> resultado = new ArrayList<>();
        for (Material m : materiales) {
            if (m.getReferencia().startsWith(prefijo)) {
                resultado.add(m);
            }
        }
        return resultado;
    }

    public boolean existe(String referencia) {
        return referencia != null && indicePorReferencia.containsKey(referencia);
    }

    public int tamano()             { return materiales.size(); }
    public List<Material> listar()  { return List.copyOf(materiales); }
}

package com.nexussoftware.bibliotech.presentacion;

import com.nexussoftware.bibliotech.dominio.*;
import com.nexussoftware.bibliotech.servicio.Catalogo;
import com.nexussoftware.bibliotech.servicio.GestorPrestamos;

/**
 * Demuestra la diferencia entre capturar por TIPO con datos estructurados
 * y capturar tipos estandar leyendo el mensaje.
 */
public class DemoExcepcionesDominio {

    public static void main(String[] args) {
        Catalogo catalogo = new Catalogo();
        catalogo.registrar(new Libro("LIB-0001", "Java Efectivo", "Bloch", 2018, "978-0000000001"));
        catalogo.registrar(new Libro("LIB-0002", "Patrones de Diseno", "GoF", 1994, "978-0000000002"));
        catalogo.registrar(new Libro("LIB-0003", "Refactorizacion", "Fowler", 1999, "978-0000000003"));

        GestorPrestamos gestor = new GestorPrestamos(catalogo);
        gestor.darDeAlta(new Empleado("Marta Ruiz", "EMP-001"));
        gestor.darDeAlta(new Empleado("Diego Alonso", "EMP-002"));

        // Marta agota su cupo
        gestor.prestar("LIB-0001", "EMP-001", 10);
        gestor.prestar("LIB-0002", "EMP-001", 10);
        gestor.prestar("LIB-0003", "EMP-001", 10);

        System.out.println("=== Fallos, cada uno con SU manejador ===\n");

        operar(gestor, catalogo, "LIB-9999", "EMP-001", 12);   // no encontrado
        operar(gestor, catalogo, "LIB-0001", "EMP-002", 12);   // no disponible
        operar(gestor, catalogo, "LIB-0001", "EMP-001", 12);   // no disponible (y limite)

        System.out.println("\n=== Duplicados ===\n");
        registrar(catalogo, new Libro("LIB-0001", "Otro titulo", "X", 2020, "978-0000000009"));
        registrar(catalogo, new Libro("LIB-0004", "Copia", "Bloch", 2018, "978-0000000001"));

        System.out.println("\n=== Captura por la RAIZ: todo el dominio de una vez ===\n");
        try {
            catalogo.obtenerPorReferencia("LIB-7777");
        } catch (BiblioTechException e) {
            System.out.println("Codigo: " + e.getCodigo());
            System.out.println("Mensaje: " + e.getMessage());
            System.out.println("¿Corregible por el usuario? " + e.esCorregiblePorElUsuario());
        }
    }

    /** Cada tipo de fallo se maneja de forma DISTINTA usando sus datos. */
    private static void operar(GestorPrestamos gestor, Catalogo catalogo,
                               String referencia, String idEmpleado, int dia) {
        System.out.println("--- prestar(" + referencia + ", " + idEmpleado + ") ---");
        try {
            gestor.prestar(referencia, idEmpleado, dia);
            System.out.println("  OK");

        } catch (MaterialNoEncontradoException e) {
            // Usa los DATOS de la excepcion para ayudar al usuario
            System.out.println("  No se encontro '" + e.getReferenciaBuscada() + "'.");
            if (e.catalogoVacio()) {
                System.out.println("  El catalogo esta vacio: cargue primero los materiales.");
            } else {
                var parecidos = catalogo.buscarPorPrefijo(
                        e.getReferenciaBuscada().substring(0, 4));
                System.out.println("  Materiales con prefijo similar: " + parecidos.size());
            }

        } catch (MaterialNoDisponibleException e) {
            System.out.println("  '" + e.getTitulo() + "' lo tiene " + e.getIdTitularActual() + ".");
            System.out.println("  Vuelve en " + e.diasDeEspera(dia) + " dias.");
            System.out.println("  -> Se anade a la cola de reservas de " + e.getReferencia());

        } catch (LimitePrestamosExcedidoException e) {
            System.out.println("  " + e.getNombreEmpleado() + " tiene "
                    + e.getPrestamosActuales() + "/" + e.getLimite() + " prestamos.");
            System.out.println("  Debe devolver " + e.devolucionesNecesarias()
                    + " material(es) antes de tomar otro.");
        }
    }

    private static void registrar(Catalogo catalogo, Material material) {
        try {
            catalogo.registrar(material);
            System.out.println("Registrado: " + material.getReferencia());
        } catch (ReferenciaDuplicadaException e) {
            // El TIPO del duplicado permite un mensaje preciso, sin parsear texto
            String queColisiona = (e.getTipo() == ReferenciaDuplicadaException.Tipo.ISBN)
                    ? "El ISBN" : "La referencia";
            System.out.println(queColisiona + " " + e.getValorDuplicado()
                    + " ya la usa '" + e.getTituloExistente() + "'. Alta rechazada.");
        }
    }
}

=== Fallos, cada uno con SU manejador ===

--- prestar(LIB-9999, EMP-001) ---
  No se encontro 'LIB-9999'.
  Materiales con prefijo similar: 0
--- prestar(LIB-0001, EMP-002) ---
  'Java Efectivo' lo tiene EMP-001.
  Vuelve en 13 dias.
  -> Se anade a la cola de reservas de LIB-0001
--- prestar(LIB-0001, EMP-001) ---
  'Java Efectivo' lo tiene EMP-001.
  Vuelve en 13 dias.
  -> Se anade a la cola de reservas de LIB-0001

=== Duplicados ===

La referencia LIB-0001 ya la usa 'Java Efectivo'. Alta rechazada.
El ISBN 978-0000000001 ya la usa 'Java Efectivo'. Alta rechazada.

=== Captura por la RAIZ: todo el dominio de una vez ===

Codigo: MATERIALNOENCONTRADO
Mensaje: No existe ningun material con la referencia 'LIB-7777' (el catalogo tiene 3 materiales)
¿Corregible por el usuario? true

public class ErrorReserva extends Throwable {
    public ErrorReserva() { }
}

public class ReservaNoValida extends ErrorReserva {
    public String mensaje;
    public ReservaNoValida(String m) { this.mensaje = m; }
}

public class ErrorFechaReserva extends Exception {
    public ErrorFechaReserva(String m) { super(m); }
}

public class ReservaDuplicadaError extends ReservaNoValida {
    public ReservaDuplicadaError() { super("Error"); }
}

// Uso tipico en el codigo:
// try {
//     colaReservas.reservar(referencia, idEmpleado, dia);
// } catch (Throwable t) {
//     if (t.getMessage() != null && t.getMessage().startsWith("Error")) {
//         System.out.println("Fallo de reserva");
//     }
// }

package com.nexussoftware.bibliotech.dominio;

import java.util.List;

/**
 * El empleado ha acumulado una multa que le impide tomar mas prestamos
 * hasta saldarla.
 *
 * Transporta el desglose completo para que la capa de presentacion pueda
 * mostrar un recibo, y para que la de servicio pueda decidir si aplica
 * una excepcion a la regla.
 */
public class MultaExcesivaException extends PrestamoException {

    private static final long serialVersionUID = 1L;

    public static final double MULTA_MAXIMA = 20.0;

    private final String idEmpleado;
    private final String nombreEmpleado;
    private final double importeAcumulado;
    private final double umbralPermitido;
    private final List<String> materialesConMulta;

    public MultaExcesivaException(String idEmpleado, String nombreEmpleado,
                                  double importeAcumulado, double umbralPermitido,
                                  List<String> materialesConMulta) {
        super(construirMensaje(idEmpleado, nombreEmpleado, importeAcumulado,
                umbralPermitido, materialesConMulta));
        this.idEmpleado = idEmpleado;
        this.nombreEmpleado = nombreEmpleado;
        this.importeAcumulado = importeAcumulado;
        this.umbralPermitido = umbralPermitido;
        // Copia defensiva: la excepcion debe ser inmutable aunque la lista
        // original cambie despues (03-07)
        this.materialesConMulta = List.copyOf(materialesConMulta);
    }

    public MultaExcesivaException(String idEmpleado, String nombreEmpleado,
                                  double importeAcumulado, double umbralPermitido,
                                  List<String> materialesConMulta, Throwable causa) {
        super(construirMensaje(idEmpleado, nombreEmpleado, importeAcumulado,
                umbralPermitido, materialesConMulta), causa);
        this.idEmpleado = idEmpleado;
        this.nombreEmpleado = nombreEmpleado;
        this.importeAcumulado = importeAcumulado;
        this.umbralPermitido = umbralPermitido;
        this.materialesConMulta = List.copyOf(materialesConMulta);
    }

    /**
     * El mensaje se construye en un metodo estatico porque hay que llamarlo
     * en el super(...), antes de que los campos existan.
     */
    private static String construirMensaje(String idEmpleado, String nombreEmpleado,
                                           double importe, double umbral,
                                           List<String> materiales) {
        return String.format(
                "El empleado %s (%s) acumula %.2f EUR de multa, por encima del umbral de %.2f EUR, "
                        + "en %d material(es)",
                idEmpleado, nombreEmpleado, importe, umbral, materiales.size());
    }

    public String getIdEmpleado()      { return idEmpleado; }
    public String getNombreEmpleado()  { return nombreEmpleado; }
    public double getImporteAcumulado(){ return importeAcumulado; }
    public double getUmbralPermitido() { return umbralPermitido; }

    /** Ya es inmutable por List.copyOf, pero se devuelve explicitamente asi. */
    public List<String> getMaterialesConMulta() {
        return materialesConMulta;
    }

    // ---------- Metodos de conveniencia ----------

    /** Cuanto hay que pagar como minimo para volver a estar por debajo del umbral. */
    public double getExceso() {
        return Math.max(0.0, importeAcumulado - umbralPermitido);
    }

    /** ¿Se ha alcanzado el tope absoluto de multa del sistema? */
    public boolean superaLaMultaMaxima() {
        return importeAcumulado >= MULTA_MAXIMA;
    }

    /** Desglose legible, una linea por material. */
    public String getResumen() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Multa de %s: %.2f EUR (umbral %.2f, exceso %.2f)%n",
                nombreEmpleado, importeAcumulado, umbralPermitido, getExceso()));
        for (String referencia : materialesConMulta) {
            sb.append("  - ").append(referencia).append('\n');
        }
        if (superaLaMultaMaxima()) {
            sb.append(String.format("  ATENCION: se ha alcanzado la multa maxima (%.2f EUR)%n",
                    MULTA_MAXIMA));
        }
        return sb.toString();
    }

    /** El empleado puede resolverlo pagando: es corregible por el. */
    @Override
    public boolean esCorregiblePorElUsuario() {
        return true;
    }

    // ---------- Demostracion ----------

    public static void main(String[] args) {
        try {
            throw new MultaExcesivaException(
                    "EMP-001", "Marta Ruiz",
                    23.75, 10.0,
                    List.of("LIB-0001", "LIB-0002", "REV-0007"));

        } catch (MultaExcesivaException e) {
            System.out.println("=== Captura especifica ===");
            System.out.println("Codigo            : " + e.getCodigo());
            System.out.println("Mensaje           : " + e.getMessage());
            System.out.println("Empleado          : " + e.getIdEmpleado()
                    + " (" + e.getNombreEmpleado() + ")");
            System.out.printf ("Importe acumulado : %.2f EUR%n", e.getImporteAcumulado());
            System.out.printf ("Umbral permitido  : %.2f EUR%n", e.getUmbralPermitido());
            System.out.printf ("Exceso a pagar    : %.2f EUR%n", e.getExceso());
            System.out.println("Supera el maximo  : " + e.superaLaMultaMaxima());
            System.out.println("Materiales        : " + e.getMaterialesConMulta());
            System.out.println("Corregible por el usuario: " + e.esCorregiblePorElUsuario());

            System.out.println("\n=== Resumen para el recibo ===");
            System.out.print(e.getResumen());

            // Demostracion de que la lista es INMUTABLE
            System.out.println("=== Inmutabilidad ===");
            try {
                e.getMaterialesConMulta().add("LIB-9999");
            } catch (UnsupportedOperationException uoe) {
                System.out.println("La lista de materiales no se puede modificar. Correcto.");
            }
        }

        // Captura por la rama y por la raiz
        System.out.println("\n=== Captura por la rama PrestamoException ===");
        try {
            throw new MultaExcesivaException("EMP-002", "Diego Alonso",
                    12.5, 10.0, List.of("LIB-0003"));
        } catch (PrestamoException e) {
            System.out.println("Fallo de prestamo [" + e.getCodigo() + "]: " + e.getMessage());
        }
    }
}

=== Captura especifica ===
Codigo            : MULTAEXCESIVA
Mensaje           : El empleado EMP-001 (Marta Ruiz) acumula 23,75 EUR de multa, por encima del umbral de 10,00 EUR, en 3 material(es)
Empleado          : EMP-001 (Marta Ruiz)
Importe acumulado : 23,75 EUR
Umbral permitido  : 10,00 EUR
Exceso a pagar    : 13,75 EUR
Supera el maximo  : true
Materiales        : [LIB-0001, LIB-0002, REV-0007]
Corregible por el usuario: true

=== Resumen para el recibo ===
Multa de Marta Ruiz: 23,75 EUR (umbral 10,00, exceso 13,75)
  - LIB-0001
  - LIB-0002
  - REV-0007
  ATENCION: se ha alcanzado la multa maxima (20,00 EUR)
=== Inmutabilidad ===
La lista de materiales no se puede modificar. Correcto.

=== Captura por la rama PrestamoException ===
Fallo de prestamo [MULTAEXCESIVA]: El empleado EMP-002 (Diego Alonso) acumula 12,50 EUR de multa, por encima del umbral de 10,00 EUR, en 1 material(es)

package com.nexussoftware.bibliotech.dominio;

/** Raiz de los fallos del subsistema de reservas. */
public abstract class ReservaException extends BiblioTechException {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final String idEmpleado;

    protected ReservaException(String mensaje, String referencia, String idEmpleado) {
        super(mensaje);
        this.referencia = referencia;
        this.idEmpleado = idEmpleado;
    }

    protected ReservaException(String mensaje, String referencia, String idEmpleado,
                               Throwable causa) {
        super(mensaje, causa);
        this.referencia = referencia;
        this.idEmpleado = idEmpleado;
    }

    /** Datos comunes a toda la familia: se declaran una sola vez, en la raiz. */
    public String getReferencia() { return referencia; }
    public String getIdEmpleado() { return idEmpleado; }
}

package com.nexussoftware.bibliotech.dominio;

/** El empleado ya tiene una reserva activa de ese material. */
public class ReservaDuplicadaException extends ReservaException {

    private static final long serialVersionUID = 1L;

    private final int posicionActual;

    public ReservaDuplicadaException(String referencia, String idEmpleado, int posicionActual) {
        super("El empleado " + idEmpleado + " ya tiene una reserva de " + referencia
                + " en la posicion " + posicionActual + " de la cola",
                referencia, idEmpleado);
        this.posicionActual = posicionActual;
    }

    public int getPosicionActual() { return posicionActual; }
}

package com.nexussoftware.bibliotech.dominio;

/** El dia de la reserva no es valido para ese material. */
public class DiaReservaInvalidoException extends ReservaException {

    private static final long serialVersionUID = 1L;

    private final int diaSolicitado;
    private final int diaMinimo;

    public DiaReservaInvalidoException(String referencia, String idEmpleado,
                                       int diaSolicitado, int diaMinimo) {
        super("La reserva de " + referencia + " se solicito para el dia " + diaSolicitado
                + ", pero el material no estara disponible hasta el dia " + diaMinimo,
                referencia, idEmpleado);
        this.diaSolicitado = diaSolicitado;
        this.diaMinimo = diaMinimo;
    }

    public int getDiaSolicitado() { return diaSolicitado; }
    public int getDiaMinimo()     { return diaMinimo; }
    public int getDiasDeEspera()  { return Math.max(0, diaMinimo - diaSolicitado); }
}

try {
    int posicion = colaReservas.reservar(referencia, idEmpleado, dia);
    System.out.println("Reservado. Posicion en la cola: " + posicion);

} catch (ReservaDuplicadaException e) {
    // Se usan los DATOS, no el texto
    System.out.println("Ya tenia una reserva de " + e.getReferencia()
            + ", en la posicion " + e.getPosicionActual() + ". No se ha duplicado.");

} catch (DiaReservaInvalidoException e) {
    System.out.println("Ese material no estara libre hasta dentro de "
            + e.getDiasDeEspera() + " dias.");
    System.out.println("¿Desea reservarlo para el dia " + e.getDiaMinimo() + "? (s/n)");

} catch (ReservaException e) {
    // Red de seguridad de la RAMA, no de Throwable
    System.out.println("No se pudo completar la reserva [" + e.getCodigo() + "]: "
            + e.getMessage());
}

package com.nexussoftware.bibliotech.dominio;

/** Raiz de los fallos de la cola de reservas. */
public abstract class ReservaException extends BiblioTechException {
    private static final long serialVersionUID = 1L;
    protected ReservaException(String mensaje) { super(mensaje); }
}

package com.nexussoftware.bibliotech.dominio;

public class ReservaDuplicadaException extends ReservaException {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final String idEmpleado;
    private final int posicionActual;

    public ReservaDuplicadaException(String referencia, String idEmpleado, int posicionActual) {
        super("El empleado " + idEmpleado + " ya tiene reservado " + referencia
                + " (posicion " + posicionActual + " de la cola)");
        this.referencia = referencia;
        this.idEmpleado = idEmpleado;
        this.posicionActual = posicionActual;
    }

    public String getReferencia()  { return referencia; }
    public String getIdEmpleado()  { return idEmpleado; }
    public int getPosicionActual() { return posicionActual; }
}

package com.nexussoftware.bibliotech.dominio;

public class ColaReservasLlenaException extends ReservaException {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final int maximo;
    private final int diaEstimadoDisponibilidad;

    public ColaReservasLlenaException(String referencia, int maximo,
                                      int diaEstimadoDisponibilidad) {
        super("La cola de reservas de " + referencia + " esta llena (" + maximo
                + " reservas). Disponibilidad estimada: dia " + diaEstimadoDisponibilidad);
        this.referencia = referencia;
        this.maximo = maximo;
        this.diaEstimadoDisponibilidad = diaEstimadoDisponibilidad;
    }

    public String getReferencia()             { return referencia; }
    public int getMaximo()                    { return maximo; }
    public int getDiaEstimadoDisponibilidad() { return diaEstimadoDisponibilidad; }

    @Override
    public boolean esCorregiblePorElUsuario() {
        return false;   // el usuario no puede hacer nada: la cola esta llena
    }
}

package com.nexussoftware.bibliotech.dominio;

public class ReservaNoEncontradaException extends ReservaException {

    private static final long serialVersionUID = 1L;

    private final String referencia;
    private final String idEmpleado;

    public ReservaNoEncontradaException(String referencia, String idEmpleado) {
        super("El empleado " + idEmpleado + " no tiene ninguna reserva de " + referencia);
        this.referencia = referencia;
        this.idEmpleado = idEmpleado;
    }

    public String getReferencia() { return referencia; }
    public String getIdEmpleado() { return idEmpleado; }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

import com.nexussoftware.bibliotech.dominio.ColaReservasLlenaException;
import com.nexussoftware.bibliotech.dominio.ReservaDuplicadaException;
import com.nexussoftware.bibliotech.dominio.ReservaException;
import com.nexussoftware.bibliotech.dominio.ReservaNoEncontradaException;

/**
 * Cola FIFO de reservas por material (retoma el ArrayDeque de 05-07).
 *
 * Politica de errores:
 *  - Argumentos invalidos      -> excepciones ESTANDAR (NPE, IllegalArgument).
 *  - Reglas de negocio         -> excepciones PROPIAS con datos.
 */
public class ColaReservas {

    public static final int MAX_RESERVAS_POR_MATERIAL = 5;
    private static final int DIAS_ESTIMADOS_POR_TURNO = 15;

    /** Reserva de un empleado sobre un material (record, 04-07). */
    public record Reserva(String referencia, String idEmpleado, int dia) { }

    private final Map<String, Deque<Reserva>> colasPorMaterial = new HashMap<>();

    /**
     * Anade una reserva al final de la cola del material.
     *
     * @return posicion en la cola, siendo 1 el siguiente en ser atendido
     * @throws NullPointerException        si algun argumento es nulo
     * @throws IllegalArgumentException    si el dia es menor que 1
     * @throws ReservaDuplicadaException   si ese empleado ya reservo ese material
     * @throws ColaReservasLlenaException  si la cola alcanzo el maximo
     */
    public int reservar(String referencia, String idEmpleado, int dia) {
        // Validacion tecnica: excepciones estandar
        Objects.requireNonNull(referencia, "La referencia no puede ser nula");
        Objects.requireNonNull(idEmpleado, "El identificador del empleado no puede ser nulo");
        if (dia < 1) {
            throw new IllegalArgumentException("El dia debe ser 1 o posterior, y era: " + dia);
        }

        Deque<Reserva> cola = colasPorMaterial.computeIfAbsent(referencia, r -> new ArrayDeque<>());

        // Regla de negocio 1: no duplicar
        int yaEsta = posicionEn(cola, idEmpleado);
        if (yaEsta > 0) {
            throw new ReservaDuplicadaException(referencia, idEmpleado, yaEsta);
        }

        // Regla de negocio 2: cola llena
        if (cola.size() >= MAX_RESERVAS_POR_MATERIAL) {
            int diaEstimado = dia + cola.size() * DIAS_ESTIMADOS_POR_TURNO;
            throw new ColaReservasLlenaException(referencia, MAX_RESERVAS_POR_MATERIAL, diaEstimado);
        }

        cola.addLast(new Reserva(referencia, idEmpleado, dia));
        return cola.size();
    }

    /**
     * Cancela la reserva de un empleado sobre un material.
     *
     * @throws ReservaNoEncontradaException si no habia tal reserva
     */
    public void cancelar(String referencia, String idEmpleado) {
        Objects.requireNonNull(referencia, "La referencia no puede ser nula");
        Objects.requireNonNull(idEmpleado, "El identificador del empleado no puede ser nulo");

        Deque<Reserva> cola = colasPorMaterial.get(referencia);
        if (cola == null) {
            throw new ReservaNoEncontradaException(referencia, idEmpleado);
        }

        // removeIf sobre un Deque: forma segura de eliminar mientras se itera (05-04)
        boolean eliminada = cola.removeIf(r -> r.idEmpleado().equals(idEmpleado));
        if (!eliminada) {
            throw new ReservaNoEncontradaException(referencia, idEmpleado);
        }
        if (cola.isEmpty()) {
            colasPorMaterial.remove(referencia);       // no dejar colas vacias en el mapa
        }
    }

    /**
     * Saca al primero de la cola. Devuelve Optional vacio si no hay nadie
     * esperando: aqui la ausencia es un caso NORMAL, no un fallo.
     */
    public Optional<Reserva> atenderSiguiente(String referencia) {
        Deque<Reserva> cola = colasPorMaterial.get(referencia);
        if (cola == null || cola.isEmpty()) {
            return Optional.empty();
        }
        Reserva primera = cola.pollFirst();
        if (cola.isEmpty()) {
            colasPorMaterial.remove(referencia);
        }
        return Optional.of(primera);
    }

    /** Posicion del empleado en la cola de ese material, o -1 si no esta. */
    public int posicionDe(String referencia, String idEmpleado) {
        Deque<Reserva> cola = colasPorMaterial.get(referencia);
        if (cola == null) { return -1; }
        int p = posicionEn(cola, idEmpleado);
        return (p > 0) ? p : -1;
    }

    /** Devuelve la posicion 1..n, o 0 si no esta. */
    private int posicionEn(Deque<Reserva> cola, String idEmpleado) {
        int posicion = 1;
        for (Iterator<Reserva> it = cola.iterator(); it.hasNext(); posicion++) {
            if (it.next().idEmpleado().equals(idEmpleado)) {
                return posicion;
            }
        }
        return 0;
    }

    public int tamanoCola(String referencia) {
        Deque<Reserva> cola = colasPorMaterial.get(referencia);
        return (cola == null) ? 0 : cola.size();
    }

    // ------------------------------------------------------------------

    public static void main(String[] args) {
        ColaReservas colas = new ColaReservas();
        String LIBRO = "LIB-0001";

        System.out.println("=== Reservas correctas ===");
        System.out.println("Marta -> posicion " + colas.reservar(LIBRO, "EMP-001", 10));
        System.out.println("Diego -> posicion " + colas.reservar(LIBRO, "EMP-002", 11));
        System.out.println("Nuria -> posicion " + colas.reservar(LIBRO, "EMP-003", 12));

        System.out.println("\n=== Fallos ===");
        intentar("Reserva duplicada", () -> colas.reservar(LIBRO, "EMP-001", 13));
        intentar("Cancelar inexistente", () -> colas.cancelar(LIBRO, "EMP-009"));
        intentar("Dia invalido", () -> colas.reservar(LIBRO, "EMP-004", 0));
        intentar("Referencia nula", () -> colas.reservar(null, "EMP-004", 5));

        // Llenar la cola hasta el maximo
        colas.reservar(LIBRO, "EMP-004", 13);
        colas.reservar(LIBRO, "EMP-005", 14);
        System.out.println("\nCola de " + LIBRO + ": " + colas.tamanoCola(LIBRO)
                + "/" + MAX_RESERVAS_POR_MATERIAL);
        intentar("Cola llena", () -> colas.reservar(LIBRO, "EMP-006", 15));

        System.out.println("\n=== Atencion FIFO ===");
        Optional<Reserva> siguiente;
        while ((siguiente = colas.atenderSiguiente(LIBRO)).isPresent()) {
            Reserva r = siguiente.get();
            System.out.println("  Atendido " + r.idEmpleado() + " (reservo el dia " + r.dia() + ")");
        }
        System.out.println("Cola vacia: " + (colas.tamanoCola(LIBRO) == 0));
    }

    /** Manejador que captura por la RAMA y usa getCodigo() de la raiz. */
    private static void intentar(String descripcion, Runnable accion) {
        try {
            accion.run();
            System.out.println("[" + descripcion + "] -> no fallo (inesperado)");
        } catch (ReservaException e) {
            System.out.println("[" + descripcion + "] [" + e.getCodigo() + "] " + e.getMessage()
                    + " | corregible: " + e.esCorregiblePorElUsuario());
        } catch (NullPointerException | IllegalArgumentException e) {
            System.out.println("[" + descripcion + "] [TECNICO] "
                    + e.getClass().getSimpleName() + ": " + e.getMessage());
        }
    }
}

=== Reservas correctas ===
Marta -> posicion 1
Diego -> posicion 2
Nuria -> posicion 3

=== Fallos ===
[Reserva duplicada] [RESERVADUPLICADA] El empleado EMP-001 ya tiene reservado LIB-0001 (posicion 1 de la cola) | corregible: true
[Cancelar inexistente] [RESERVANOENCONTRADA] El empleado EMP-009 no tiene ninguna reserva de LIB-0001 | corregible: true
[Dia invalido] [TECNICO] IllegalArgumentException: El dia debe ser 1 o posterior, y era: 0
[Referencia nula] [TECNICO] NullPointerException: La referencia no puede ser nula

Cola de LIB-0001: 5/5
[Cola llena] [COLARESERVASLLENA] La cola de reservas de LIB-0001 esta llena (5 reservas). Disponibilidad estimada: dia 90 | corregible: false

=== Atencion FIFO ===
  Atendido EMP-001 (reservo el dia 10)
  Atendido EMP-002 (reservo el dia 11)
  Atendido EMP-003 (reservo el dia 12)
  Atendido EMP-004 (reservo el dia 13)
  Atendido EMP-005 (reservo el dia 14)
Cola vacia: true