// MAL: captura donde se produce, sin poder decidir nada
public Material buscar(String referencia) {
    try {
        return catalogo.obtenerPorReferencia(referencia);
    } catch (MaterialNoEncontradoException e) {
        e.printStackTrace();       // no es una decision
        return null;               // y ahora devolvemos el null que tanto costo eliminar
    }
}

// BIEN: no se captura. Sube a quien pueda decidir.
public Material buscar(String referencia) {
    return catalogo.obtenerPorReferencia(referencia);
}

package com.nexussoftware.bibliotech.presentacion;

import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.dominio.BiblioTechException;

/**
 * Punto de entrada de BiblioTech con frontera de errores.
 *
 * Estructura de la frontera, de lo mas especifico a lo mas general:
 *   1. BiblioTechException : fallo esperado del dominio -> mensaje limpio, salida 1
 *   2. RuntimeException    : bug -> mensaje generico con incidencia, registro completo, salida 2
 *   3. Error               : fallo de la JVM -> registro minimo y salida inmediata, salida 3
 */
public class BiblioTechApp {

    private static final Logger LOG = Logger.getLogger(BiblioTechApp.class.getName());

    public static void main(String[] args) {
        ConfiguracionLog.inicializar();
        instalarManejadorGlobal();

        LOG.info("BiblioTech arrancando");

        try {
            new MenuBiblioTech().arrancar();
            LOG.info("BiblioTech finalizado correctamente");

        } catch (BiblioTechException e) {
            // Fallo ESPERADO del dominio que nadie manejo. Es raro, pero legible.
            System.err.println();
            System.err.println("La operacion no se pudo completar: " + e.getMessage());
            LOG.log(Level.WARNING, "Excepcion de dominio no manejada [" + e.getCodigo() + "]", e);
            System.exit(1);

        } catch (RuntimeException e) {
            // Fallo INESPERADO: es un bug. El usuario no debe ver los detalles.
            String incidencia = generarIdIncidencia();
            System.err.println();
            System.err.println("Se ha producido un error interno.");
            System.err.println("Incidencia: " + incidencia);
            System.err.println("Comunique este codigo al equipo de soporte de Nexus Software.");
            LOG.log(Level.SEVERE, "Error no controlado. Incidencia " + incidencia, e);
            System.exit(2);

        } catch (Error e) {
            // Fallo de la JVM: no se puede recuperar. Registrar lo minimo y salir.
            // Se captura AQUI y solo aqui, para dejar constancia antes de morir.
            System.err.println();
            System.err.println("Error irrecuperable de la maquina virtual: "
                    + e.getClass().getSimpleName());
            try {
                LOG.log(Level.SEVERE, "Error irrecuperable", e);
            } catch (Throwable ignorado) {
                // Si ni siquiera se puede registrar (p. ej. OutOfMemoryError),
                // no hay nada mas que hacer. No se propaga para no ocultar el Error.
            }
            System.exit(3);
        }
    }

    /** Identificador corto que el usuario puede comunicar a soporte. */
    private static String generarIdIncidencia() {
        return "INC-" + Long.toHexString(System.nanoTime()).toUpperCase().substring(0, 8);
    }

    private static void instalarManejadorGlobal() {
        Thread.setDefaultUncaughtExceptionHandler((hilo, fallo) ->
                LOG.log(Level.SEVERE, "Excepcion no capturada en el hilo '"
                        + hilo.getName() + "'", fallo));
    }
}

package com.nexussoftware.bibliotech.presentacion;

import java.util.logging.Level;
import java.util.logging.Logger;

public final class ManejadorGlobal {

    private static final Logger LOG = Logger.getLogger(ManejadorGlobal.class.getName());

    private ManejadorGlobal() { }

    public static void instalar() {
        Thread.setDefaultUncaughtExceptionHandler((hilo, fallo) -> {
            // Este codigo se ejecuta cuando una excepcion escapa de CUALQUIER hilo
            LOG.log(Level.SEVERE,
                    "Excepcion no capturada en el hilo '" + hilo.getName()
                            + "' (id " + hilo.threadId() + ")", fallo);

            if (fallo instanceof Error) {
                LOG.severe("Error irrecuperable: se solicita el apagado de la aplicacion");
                System.exit(3);
            }
        });

        // Hook de apagado: ultima oportunidad de limpieza (06-05)
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            LOG.info("BiblioTech apagandose: consolidando estado");
            // En el modulo 7, aqui se persistira el catalogo
        }, "apagado-bibliotech"));
    }

    public static void main(String[] args) {
        instalar();

        Thread hiloSecundario = new Thread(() -> {
            throw new IllegalStateException("Fallo en la tarea de mantenimiento");
        }, "mantenimiento");

        hiloSecundario.start();

        try { hiloSecundario.join(); } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("El hilo principal sigue vivo, pero el fallo QUEDO REGISTRADO");
    }
}

// Lo que ve el usuario
System.err.println("No se ha podido completar el prestamo.");
System.err.println("Incidencia: INC-A3F91C0B");
System.err.println("Comunique este codigo al equipo de soporte.");

// Lo que va al registro
LOG.log(Level.SEVERE, "Fallo al prestar LIB-0001 a EMP-001 el dia 12. Incidencia INC-A3F91C0B", e);

package com.nexussoftware.bibliotech.servicio;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Arranque de BiblioTech con degradacion elegante: la aplicacion funciona
 * aunque falten componentes opcionales, y solo aborta si falta algo esencial.
 */
public class ArranqueBiblioTech {

    private static final Logger LOG = Logger.getLogger(ArranqueBiblioTech.class.getName());

    private boolean avisosDisponibles = true;
    private boolean exportacionDisponible = true;

    public Catalogo arrancar(String rutaCatalogo) {
        Catalogo catalogo = new Catalogo();

        // --- Componente OPCIONAL 1: catalogo previo ---
        try {
            cargarCatalogo(catalogo, rutaCatalogo);
            LOG.info(() -> "Catalogo cargado: " + catalogo.tamano() + " materiales");

        } catch (CatalogoNoAccesibleException e) {
            // DEGRADACION: sin catalogo previo se puede trabajar; se empieza vacio.
            LOG.log(Level.WARNING,
                    "No se pudo cargar el catalogo desde '" + e.getRuta()
                            + "'. Se arranca con catalogo vacio.", e);
            System.out.println("Aviso: no habia catalogo previo. Se empieza de cero.");
        }

        // --- Componente OPCIONAL 2: servicio de avisos ---
        try {
            conectarServicioAvisos();
            LOG.info("Servicio de avisos disponible");
        } catch (RuntimeException e) {
            avisosDisponibles = false;
            LOG.log(Level.WARNING, "Servicio de avisos no disponible; se acumularan en cola", e);
            System.out.println("Aviso: los avisos de vencimiento no se enviaran en esta sesion.");
        }

        // --- Componente ESENCIAL: configuracion ---
        // Si esto falla, NO se degrada: se aborta. Continuar con una tarifa
        // desconocida produciria multas incorrectas, que es peor que no arrancar.
        int diasPrestamo = leerConfiguracionObligatoria("dias.prestamo");
        LOG.config(() -> "Configuracion: dias.prestamo=" + diasPrestamo);

        return catalogo;
    }

    public boolean puedeEnviarAvisos()  { return avisosDisponibles; }
    public boolean puedeExportar()      { return exportacionDisponible; }

    private void cargarCatalogo(Catalogo catalogo, String ruta) throws CatalogoNoAccesibleException {
        throw new CatalogoNoAccesibleException(ruta,
                new java.io.FileNotFoundException(ruta + " (No such file or directory)"));
    }

    private void conectarServicioAvisos() {
        throw new IllegalStateException("El servicio de avisos no responde en el puerto 8080");
    }

    private int leerConfiguracionObligatoria(String clave) {
        return 15;   // en el modulo 7 vendra de un fichero .properties
    }
}

// VALIDACION PREVIA: barata, el caso es frecuente y no hay carrera
if (catalogo.existe(referencia)) {
    Material m = catalogo.obtenerPorReferencia(referencia);
    // ...
}

// Mejor aun con el metodo que devuelve Optional
catalogo.buscarPorReferencia(referencia)
        .ifPresent(m -> System.out.println(m.getTitulo()));

// EXCEPCION: la conversion no se puede validar sin hacerla
try {
    int dias = Integer.parseInt(entrada);
} catch (NumberFormatException e) {
    // Escribir un validador de enteros correcto (signo, rango, overflow)
    // es mas propenso a errores que capturar
}

// EXCEPCION OBLIGATORIA: condicion de carrera
// Con ficheros o recursos compartidos, "comprobar y luego usar" no es atomico:
// entre el exists() y el open() otro proceso puede haber borrado el fichero.
try (BufferedReader r = new BufferedReader(new FileReader(ruta))) {
    // ...
} catch (FileNotFoundException e) {
    // La unica forma fiable
}

// Ya lo usas en BiblioTech desde 06-03
public Optional<Material> buscarPorReferencia(String referencia) {
    return Optional.ofNullable(indicePorReferencia.get(referencia));
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.List;

/**
 * Resultado de una operacion que puede fallar, SIN lanzar.
 *
 * Util cuando quieres acumular VARIOS errores en lugar de abortar en el primero:
 * validar un formulario, importar un fichero, comprobar reglas de negocio.
 */
public class Resultado {

    private final boolean exito;
    private final List<String> errores;

    private Resultado(boolean exito, List<String> errores) {
        this.exito = exito;
        this.errores = List.copyOf(errores);
    }

    public static Resultado ok() {
        return new Resultado(true, List.of());
    }

    public static Resultado conErrores(List<String> errores) {
        return new Resultado(false, errores);
    }

    public boolean esExito()         { return exito; }
    public List<String> getErrores() { return errores; }

    public String describir() {
        if (exito) { return "OK"; }
        return "Rechazado (" + errores.size() + " problemas):\n  - "
                + String.join("\n  - ", errores);
    }

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

    /** Ejemplo: validar un alta acumulando TODOS los problemas. */
    public static Resultado validarAlta(String referencia, String titulo, int anio, String isbn) {
        List<String> errores = new ArrayList<>();

        if (referencia == null || !referencia.matches("LIB-\\d{4}")) {
            errores.add("La referencia debe tener el formato LIB-NNNN, y era: " + referencia);
        }
        if (titulo == null || titulo.isBlank()) {
            errores.add("El titulo no puede estar vacio");
        }
        if (anio < 1450 || anio > 2100) {
            errores.add("El anio debe estar entre 1450 y 2100, y era: " + anio);
        }
        if (isbn == null || !isbn.matches("97[89]-\\d{10}")) {
            errores.add("El ISBN debe tener el formato 978-NNNNNNNNNN, y era: " + isbn);
        }

        return errores.isEmpty() ? ok() : conErrores(errores);
    }

    public static void main(String[] args) {
        System.out.println(validarAlta("LIB-0001", "Java Efectivo", 2018, "978-0000000001")
                .describir());
        System.out.println();
        System.out.println(validarAlta("L-1", "", 1200, "12345").describir());
    }
}

OK

Rechazado (4 problemas):
  - La referencia debe tener el formato LIB-NNNN, y era: L-1
  - El titulo no puede estar vacio
  - El anio debe estar entre 1450 y 2100, y era: 1200
  - El ISBN debe tener el formato 978-NNNNNNNNNN, y era: 12345

// NO idempotente: dos llamadas, dos prestamos
gestor.prestar("LIB-0001", "EMP-001", 12);

// Idempotente: la segunda llamada no hace nada
sesion.close();
colaReservas.cancelar("LIB-0001", "EMP-001");   // si no habia, no pasa nada

public Prestamo prestar(String idOperacion, String referencia, String idEmpleado, int dia) {
    // Si esta operacion ya se proceso, se devuelve el resultado anterior
    Prestamo yaHecho = operacionesProcesadas.get(idOperacion);
    if (yaHecho != null) {
        LOG.info(() -> "Operacion " + idOperacion + " ya procesada; se devuelve el resultado previo");
        return yaHecho;
    }
    // ... proceso normal ...
}

// System.out.println
System.out.println("AVISO: referencia duplicada");

AVISO: referencia duplicada

// Logger
LOG.warning("Alta rechazada: referencia LIB-0001 duplicada, ya la usa 'Java Efectivo'");

2026-08-05 11:42:07.312 [main] WARNING com.nexussoftware.bibliotech.servicio.Catalogo registrar
  Alta rechazada: referencia LIB-0001 duplicada, ya la usa 'Java Efectivo'

package com.nexussoftware.bibliotech.servicio;

import java.util.logging.Logger;

public class Catalogo {

    /**
     * Un Logger por clase, estatico y final, nombrado con el nombre completo
     * de la clase. Es la convencion universal, y permite filtrar por paquete:
     * activar el nivel FINE para com.nexussoftware.bibliotech.servicio y dejar
     * el resto en INFO.
     */
    private static final Logger LOG = Logger.getLogger(Catalogo.class.getName());

    // ...
}

LOG.severe("Mensaje grave");
LOG.warning("Aviso");
LOG.info("Informacion");
LOG.config("Configuracion");
LOG.fine("Detalle de depuracion");

// Forma general, con el nivel explicito
LOG.log(Level.INFO, "Mensaje");

// CON EXCEPCION: la forma correcta de registrar un fallo
LOG.log(Level.SEVERE, "Mensaje descriptivo", excepcion);

// MAL: la concatenacion se hace SIEMPRE, aunque FINE este desactivado
LOG.fine("Buscando " + referencia + " en un catalogo de " + materiales.size()
        + " materiales, indice con " + indice.size() + " entradas");

// BIEN: la lambda solo se evalua si el nivel FINE esta activo
LOG.fine(() -> "Buscando " + referencia + " en un catalogo de " + materiales.size()
        + " materiales, indice con " + indice.size() + " entradas");

if (LOG.isLoggable(Level.FINE)) {
    LOG.fine("Mensaje caro: " + calcularDiagnostico());
}

// Activar el detalle SOLO en la capa de servicio
Logger.getLogger("com.nexussoftware.bibliotech.servicio").setLevel(Level.FINE);
// El resto sigue en INFO

package com.nexussoftware.bibliotech.presentacion;

import java.io.IOException;
import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

/**
 * Configuracion del sistema de registro de BiblioTech.
 *
 * Dos destinos:
 *   - CONSOLA: solo INFO y superiores, en formato compacto de una linea.
 *   - FICHERO: todo desde FINE, con rotacion, para diagnostico posterior.
 */
public final class ConfiguracionLog {

    private static final String RUTA_LOG = "bibliotech-%g.log";   // %g = numero de rotacion
    private static final int TAMANO_MAXIMO = 1_000_000;           // 1 MB por fichero
    private static final int FICHEROS_ROTACION = 5;               // 5 ficheros como maximo

    private static boolean inicializado = false;

    private ConfiguracionLog() { }

    public static synchronized void inicializar() {
        if (inicializado) {
            return;                          // idempotente (06-06)
        }
        inicializado = true;

        Logger raiz = Logger.getLogger("");

        // 1. Quitar los handlers por defecto: los sustituimos por los nuestros
        for (Handler h : raiz.getHandlers()) {
            raiz.removeHandler(h);
        }

        // 2. El logger raiz acepta todo; cada handler filtra por su cuenta
        raiz.setLevel(Level.ALL);

        // 3. CONSOLA: solo lo importante, formato compacto
        ConsoleHandler consola = new ConsoleHandler();
        consola.setLevel(Level.INFO);
        consola.setFormatter(new FormatoCompacto());
        raiz.addHandler(consola);

        // 4. FICHERO: todo el detalle, con rotacion
        try {
            FileHandler fichero = new FileHandler(RUTA_LOG, TAMANO_MAXIMO, FICHEROS_ROTACION, true);
            fichero.setLevel(Level.FINE);
            fichero.setFormatter(new FormatoDetallado());
            raiz.addHandler(fichero);
        } catch (IOException e) {
            // Si no se puede crear el fichero, la aplicacion NO debe caerse:
            // se degrada a solo consola y se avisa. Degradacion elegante.
            raiz.log(Level.WARNING,
                    "No se pudo crear el fichero de log; solo habra registro en consola", e);
        }

        // 5. Nivel especifico por paquete
        Logger.getLogger("com.nexussoftware.bibliotech.servicio").setLevel(Level.FINE);
        Logger.getLogger("com.nexussoftware.bibliotech.dominio").setLevel(Level.INFO);

        Logger.getLogger(ConfiguracionLog.class.getName()).config("Sistema de registro inicializado");
    }

    /** Una linea por evento: nivel, clase corta y mensaje. */
    private static class FormatoCompacto extends Formatter {
        @Override
        public String format(LogRecord registro) {
            String clase = registro.getSourceClassName();
            String corta = (clase == null) ? "?" : clase.substring(clase.lastIndexOf('.') + 1);

            StringBuilder sb = new StringBuilder();
            sb.append(String.format("[%-7s] %-18s %s%n",
                    registro.getLevel().getName(), corta, formatMessage(registro)));

            if (registro.getThrown() != null) {
                sb.append("          causa: ").append(registro.getThrown()).append('\n');
            }
            return sb.toString();
        }
    }

    /** Formato completo para el fichero, con marca de tiempo, hilo y stack trace. */
    private static class FormatoDetallado extends Formatter {
        @Override
        public String format(LogRecord registro) {
            StringBuilder sb = new StringBuilder();

            // Marca de tiempo. Se usa el instante en milisegundos y se formatea
            // sin java.time, que es materia de 10-05.
            sb.append(String.format("%tF %<tT.%<tL", registro.getMillis()));
            sb.append(String.format(" [%-6d] %-7s ",
                    registro.getLongThreadID(), registro.getLevel().getName()));
            sb.append(registro.getSourceClassName()).append('.')
              .append(registro.getSourceMethodName()).append(" - ");
            sb.append(formatMessage(registro)).append('\n');

            // El stack trace completo, indentado
            Throwable t = registro.getThrown();
            if (t != null) {
                sb.append("    ").append(t).append('\n');
                for (StackTraceElement marco : t.getStackTrace()) {
                    sb.append("        at ").append(marco).append('\n');
                }
                // Causas y suprimidas (06-01, 06-06)
                Throwable causa = t.getCause();
                int nivel = 1;
                while (causa != null && nivel <= 5) {
                    sb.append("    Caused by: ").append(causa).append('\n');
                    causa = causa.getCause();
                    nivel++;
                }
                for (Throwable suprimida : t.getSuppressed()) {
                    sb.append("    Suppressed: ").append(suprimida).append('\n');
                }
            }
            return sb.toString();
        }
    }
}

# logging.properties de BiblioTech

# Handlers globales
handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler

# Nivel del logger raiz: deja pasar todo, los handlers filtran
.level = ALL

# --- Consola: solo INFO y superiores ---
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# --- Fichero: todo desde FINE, con rotacion ---
java.util.logging.FileHandler.pattern = bibliotech-%g.log
java.util.logging.FileHandler.limit = 1000000
java.util.logging.FileHandler.count = 5
java.util.logging.FileHandler.append = true
java.util.logging.FileHandler.level = FINE
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

# Formato de SimpleFormatter: fecha, nivel, clase.metodo, mensaje, excepcion
java.util.logging.SimpleFormatter.format = %1$tF %1$tT.%1$tL %4$-7s [%2$s] %5$s%6$s%n

# --- Niveles por paquete ---
com.nexussoftware.bibliotech.level = INFO
com.nexussoftware.bibliotech.servicio.level = FINE
com.nexussoftware.bibliotech.dominio.level = INFO

java -Djava.util.logging.config.file=logging.properties \
     -cp . com.nexussoftware.bibliotech.presentacion.BiblioTechApp

try {
    gestor.prestar(referencia, idEmpleado, dia);

} catch (BiblioTechException e) {

    // ==================== CORRECTO ====================
    // El Throwable va como TERCER argumento: el Formatter imprime el stack
    // trace completo, con sus causas y suprimidas, en el mismo evento de log.
    LOG.log(Level.WARNING, "No se pudo prestar " + referencia + " a " + idEmpleado, e);

    // ==================== INCORRECTO ====================

    // 1. printStackTrace: va a System.err, sin nivel, sin fecha, sin filtro
    e.printStackTrace();

    // 2. Solo el mensaje: pierde el stack trace y todas las causas
    LOG.warning("Error: " + e.getMessage());

    // 3. Concatenar la excepcion: da solo toString(), sin pila
    LOG.warning("Error: " + e);

    // 4. Registrar Y relanzar: el mismo fallo aparecera dos veces
    LOG.log(Level.SEVERE, "Error", e);
    throw e;
}

// Hoy: Empleado.toString() devuelve "EMP-001 (Marta Ruiz)". Parece inofensivo.
LOG.fine(() -> "Procesando " + empleado);

// Dentro de un ano alguien anade el DNI y el telefono al toString()...
// y de repente estas registrando datos personales en todos los ficheros de log,
// sin que nadie haya tocado esta linea.

LOG.fine(() -> "Procesando empleado " + empleado.getIdentificador());

/** Deja visibles los ultimos 4 caracteres: 978-0000000001 -> ***0001 */
private static String enmascarar(String valor) {
    if (valor == null || valor.length() <= 4) {
        return "****";
    }
    return "***" + valor.substring(valor.length() - 4);
}

LOG.info(() -> "[" + idOperacion + "] Prestamo " + referenciaPrestamo + " completado");

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Catalogo {

    private static final Logger LOG = LoggerFactory.getLogger(Catalogo.class);

    public void registrar(Material material) {
        // Sintaxis de marcadores {}: sin concatenacion y sin lambda.
        // El mensaje solo se compone si el nivel esta activo.
        LOG.debug("Registrando {} en un catalogo de {} materiales",
                  material.getReferencia(), materiales.size());
        // ...
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;

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, version final del modulo 6.
 *
 * Cambios respecto a 06-04:
 *   - Cero System.out.println: todo el diagnostico va al Logger.
 *   - Los mensajes de log llevan identificadores, no nombres de personas.
 *   - Los mensajes caros usan Supplier para no construirse si el nivel esta desactivado.
 */
public class Catalogo {

    private static final Logger LOG = Logger.getLogger(Catalogo.class.getName());

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

    private String propietarioDelBloqueo = null;

    public void registrar(Material material) {
        Objects.requireNonNull(material, "El material a registrar no puede ser nulo");
        String referencia = material.getReferencia();

        // FINE: detalle de depuracion, desactivado en produccion.
        // Con Supplier, la concatenacion no se ejecuta si FINE esta apagado.
        LOG.fine(() -> "Registrando " + referencia + " (catalogo actual: "
                + materiales.size() + " materiales)");

        Material existente = indicePorReferencia.get(referencia);
        if (existente != null) {
            // Se registra a nivel FINE y se LANZA. No se registra a nivel superior
            // porque quien capture decidira su gravedad: en una importacion masiva
            // un duplicado es rutina, en un alta manual es un aviso.
            LOG.fine(() -> "Alta rechazada: referencia " + referencia + " duplicada");
            throw new ReferenciaDuplicadaException(
                    ReferenciaDuplicadaException.Tipo.REFERENCIA, referencia,
                    existente.getTitulo());
        }

        if (material instanceof Libro libro) {
            String tituloExistente = titulosPorIsbn.get(libro.getIsbn());
            if (tituloExistente != null) {
                LOG.fine(() -> "Alta rechazada: ISBN duplicado en " + referencia);
                throw new ReferenciaDuplicadaException(
                        ReferenciaDuplicadaException.Tipo.ISBN, libro.getIsbn(), tituloExistente);
            }
            titulosPorIsbn.put(libro.getIsbn(), libro.getTitulo());
        }

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

        // INFO: hito de negocio. Se lee como la historia de lo que hace la aplicacion.
        LOG.info(() -> "Material registrado: " + referencia
                + " (total " + materiales.size() + ")");
    }

    public Material obtenerPorReferencia(String referencia) {
        Objects.requireNonNull(referencia, "La referencia no puede ser nula");

        Material encontrado = indicePorReferencia.get(referencia);
        if (encontrado == null) {
            LOG.fine(() -> "Referencia no encontrada: " + referencia);
            throw new MaterialNoEncontradoException(referencia, materiales.size());
        }
        return encontrado;
    }

    public Optional<Material> buscarPorReferencia(String referencia) {
        if (referencia == null) { return Optional.empty(); }
        return Optional.ofNullable(indicePorReferencia.get(referencia));
    }

    public void bloquear(String idPropietario) {
        if (propietarioDelBloqueo != null && !propietarioDelBloqueo.equals(idPropietario)) {
            LOG.warning(() -> "Bloqueo denegado a " + idPropietario
                    + ": lo tiene " + propietarioDelBloqueo);
            throw new IllegalStateException(
                    "El catalogo esta bloqueado por " + propietarioDelBloqueo);
        }
        propietarioDelBloqueo = idPropietario;
        LOG.fine(() -> "Bloqueo del catalogo adquirido por " + idPropietario);
    }

    public void desbloquear(String idPropietario) {
        if (!Objects.equals(propietarioDelBloqueo, idPropietario)) {
            // WARNING: algo raro pasa, pero no impide continuar
            LOG.warning(() -> "Intento de desbloqueo por " + idPropietario
                    + " sin ser el propietario (" + propietarioDelBloqueo + ")");
            return;
        }
        propietarioDelBloqueo = null;
        LOG.fine(() -> "Bloqueo del catalogo liberado por " + idPropietario);
    }

    public boolean estaBloqueado()  { return propietarioDelBloqueo != null; }
    public boolean existe(String r) { return r != null && indicePorReferencia.containsKey(r); }
    public int tamano()             { return materiales.size(); }
    public List<Material> listar()  { return List.copyOf(materiales); }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.dominio.*;

/** Orquesta prestamos con registro completo y estado coherente. */
public class GestorPrestamos {

    private static final Logger LOG = Logger.getLogger(GestorPrestamos.class.getName());

    private final Catalogo catalogo;
    private final Map<String, Empleado> empleados = new HashMap<>();
    private final Map<String, Prestamo> prestamos = new HashMap<>();

    private int contador = 0;

    public GestorPrestamos(Catalogo catalogo) {
        this.catalogo = Objects.requireNonNull(catalogo, "El catalogo no puede ser nulo");
    }

    public void darDeAlta(Empleado empleado) {
        Objects.requireNonNull(empleado, "El empleado no puede ser nulo");
        empleados.put(empleado.getIdentificador(), empleado);
        // Se registra el IDENTIFICADOR, no el nombre: el nombre es un dato personal
        LOG.info(() -> "Empleado dado de alta: " + empleado.getIdentificador());
    }

    public Prestamo prestar(String idOperacion, String referencia, String idEmpleado, int dia) {
        Objects.requireNonNull(idOperacion, "El identificador de operacion no puede ser nulo");
        Objects.requireNonNull(referencia, "La referencia no puede ser nula");
        Objects.requireNonNull(idEmpleado, "El identificador de empleado no puede ser nulo");
        if (dia < 1) {
            throw new IllegalArgumentException("El dia debe ser 1 o posterior, y era: " + dia);
        }

        LOG.fine(() -> "[" + idOperacion + "] Iniciando prestamo de " + referencia
                + " a " + idEmpleado + " el dia " + dia);

        // --- Fase 1: lectura y validacion (no modifica nada) ---
        Material material = catalogo.obtenerPorReferencia(referencia);
        Empleado empleado = empleados.get(idEmpleado);
        if (empleado == null) {
            throw new MaterialNoEncontradoException(idEmpleado, empleados.size());
        }
        if (!material.estaDisponible()) {
            throw new MaterialNoDisponibleException(referencia, material.getTitulo(),
                    "otro empleado", dia + Prestamo.DIAS_PRESTAMO);
        }
        if (!empleado.puedeTomarPrestado()) {
            throw new LimitePrestamosExcedidoException(idEmpleado, empleado.getNombre(),
                    empleado.getPrestamosAcumulados(), Empleado.MAX_PRESTAMOS_SIMULTANEOS);
        }

        // --- Fase 2: modificacion con compensacion (06-05) ---
        boolean materialMarcado = false;
        boolean cupoConsumido = false;
        boolean completado = false;
        String referenciaPrestamo = siguienteReferencia();

        try {
            material.prestar();
            materialMarcado = true;

            empleado.registrarPrestamo();
            cupoConsumido = true;

            Prestamo prestamo = new Prestamo(referenciaPrestamo, material, empleado, dia);
            prestamos.put(referenciaPrestamo, prestamo);
            completado = true;

            LOG.info(() -> "[" + idOperacion + "] Prestamo " + referenciaPrestamo
                    + " registrado: " + referencia + " -> " + idEmpleado + " (dia " + dia + ")");
            return prestamo;

        } finally {
            if (!completado) {
                // WARNING, no SEVERE: la compensacion es el comportamiento previsto
                LOG.warning(() -> "[" + idOperacion + "] Prestamo incompleto de " + referencia
                        + "; compensando");
                try {
                    if (cupoConsumido)   { empleado.registrarDevolucion(); }
                    if (materialMarcado) { material.devolver(); }
                    LOG.fine(() -> "[" + idOperacion + "] Estado restaurado");
                } catch (RuntimeException fallo) {
                    // SEVERE de verdad: la compensacion fallo y el estado puede
                    // haber quedado incoherente. Esto SI requiere intervencion.
                    LOG.log(Level.SEVERE, "[" + idOperacion
                            + "] LA COMPENSACION FALLO. Estado posiblemente incoherente en "
                            + referencia, fallo);
                }
            }
        }
    }

    public void devolver(String idOperacion, String referenciaPrestamo, int dia) {
        Prestamo prestamo = prestamos.get(referenciaPrestamo);
        if (prestamo == null) {
            throw new MaterialNoEncontradoException(referenciaPrestamo, prestamos.size());
        }
        if (prestamo.estaDevuelto()) {
            throw new PrestamoYaDevueltoException(referenciaPrestamo, prestamo.getDiaInicio());
        }

        prestamo.registrarDevolucion(dia);
        prestamo.getTitular().registrarDevolucion();

        int retraso = prestamo.calcularDiasRetraso(dia);
        if (retraso > 0) {
            LOG.info(() -> "[" + idOperacion + "] Devolucion de " + referenciaPrestamo
                    + " con " + retraso + " dias de retraso");
        } else {
            LOG.info(() -> "[" + idOperacion + "] Devolucion de " + referenciaPrestamo + " en plazo");
        }
    }

    private String siguienteReferencia() {
        contador++;
        return String.format("PR-%04d", contador);
    }

    public int prestamosRegistrados() { return prestamos.size(); }
}

package com.nexussoftware.bibliotech.presentacion;

import java.util.logging.Level;
import java.util.logging.Logger;

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

/**
 * Capa de presentacion: la UNICA que captura para el usuario, la unica que
 * imprime por consola lo que el usuario ha pedido ver, y la unica que decide
 * que mensaje mostrar en cada caso.
 */
public class OperacionesConsola {

    private static final Logger LOG = Logger.getLogger(OperacionesConsola.class.getName());

    private final GestorPrestamos gestor;
    private int contadorOperaciones = 0;

    public OperacionesConsola(GestorPrestamos gestor) {
        this.gestor = gestor;
    }

    /**
     * Ejecuta un prestamo traduciendo cada fallo a un mensaje comprensible.
     *
     * Aqui SI se captura: es la frontera con el usuario y hay decisiones que tomar.
     */
    public void prestar(String referencia, String idEmpleado, int dia) {
        String idOperacion = siguienteIdOperacion();

        try {
            gestor.prestar(idOperacion, referencia, idEmpleado, dia);
            // SALIDA del programa, no log: es lo que el usuario ha pedido ver
            System.out.println("Prestado " + referencia + " a " + idEmpleado
                    + ". Devolucion prevista: dia " + (dia + Prestamo.DIAS_PRESTAMO));

        } catch (MaterialNoEncontradoException e) {
            // Fallo esperado y corregible: mensaje amable, log de bajo nivel
            System.out.println("No existe el material '" + e.getReferenciaBuscada() + "'.");
            if (e.catalogoVacio()) {
                System.out.println("El catalogo esta vacio: cargue primero los materiales.");
            }
            LOG.fine(() -> "[" + idOperacion + "] Referencia inexistente: "
                    + e.getReferenciaBuscada());

        } catch (MaterialNoDisponibleException e) {
            System.out.println("'" + e.getTitulo() + "' esta prestado.");
            System.out.println("Disponible previsiblemente en " + e.diasDeEspera(dia) + " dias.");
            System.out.println("Puede reservarlo con la opcion 5.");
            LOG.fine(() -> "[" + idOperacion + "] Material no disponible: " + e.getReferencia());

        } catch (LimitePrestamosExcedidoException e) {
            System.out.printf("Ha alcanzado el limite de %d prestamos simultaneos.%n",
                    e.getLimite());
            System.out.printf("Debe devolver %d material(es) antes de tomar otro.%n",
                    e.devolucionesNecesarias());
            LOG.fine(() -> "[" + idOperacion + "] Limite excedido por " + e.getIdEmpleado());

        } catch (BiblioTechException e) {
            // Red de seguridad del dominio: capturable gracias a la raiz comun (06-04)
            System.out.println("No se pudo completar la operacion: " + e.getMessage());
            LOG.log(Level.WARNING, "[" + idOperacion + "] Fallo de dominio no previsto ["
                    + e.getCodigo() + "]", e);

        } catch (RuntimeException e) {
            // BUG: el usuario no ve los detalles, el registro los ve todos
            System.out.println("Se ha producido un error interno.");
            System.out.println("Incidencia: " + idOperacion);
            LOG.log(Level.SEVERE, "[" + idOperacion + "] Error no controlado al prestar "
                    + referencia + " a " + idEmpleado, e);
        }
    }

    private String siguienteIdOperacion() {
        contadorOperaciones++;
        return String.format("OP-%05d", contadorOperaciones);
    }

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

    public static void main(String[] args) {
        ConfiguracionLog.inicializar();

        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"));

        OperacionesConsola consola = new OperacionesConsola(gestor);

        System.out.println("\n----- Operaciones -----");
        consola.prestar("LIB-0001", "EMP-001", 10);
        consola.prestar("LIB-0001", "EMP-002", 11);    // no disponible
        consola.prestar("LIB-9999", "EMP-001", 11);    // no encontrado
        consola.prestar("LIB-0002", "EMP-001", 11);
        consola.prestar("LIB-0003", "EMP-001", 11);
        consola.prestar("LIB-0002", "EMP-001", 12);    // no disponible (ya lo tiene)
    }
}

[INFO   ] Catalogo           Material registrado: LIB-0001 (total 1)
[INFO   ] Catalogo           Material registrado: LIB-0002 (total 2)
[INFO   ] Catalogo           Material registrado: LIB-0003 (total 3)
[INFO   ] GestorPrestamos    Empleado dado de alta: EMP-001
[INFO   ] GestorPrestamos    Empleado dado de alta: EMP-002

----- Operaciones -----
[INFO   ] GestorPrestamos    [OP-00001] Prestamo PR-0001 registrado: LIB-0001 -> EMP-001 (dia 10)
Prestado LIB-0001 a EMP-001. Devolucion prevista: dia 25
'Java Efectivo' esta prestado.
Disponible previsiblemente en 14 dias.
Puede reservarlo con la opcion 5.
No existe el material 'LIB-9999'.
[INFO   ] GestorPrestamos    [OP-00004] Prestamo PR-0002 registrado: LIB-0002 -> EMP-001 (dia 11)
Prestado LIB-0002 a EMP-001. Devolucion prevista: dia 26
[INFO   ] GestorPrestamos    [OP-00005] Prestamo PR-0003 registrado: LIB-0003 -> EMP-001 (dia 11)
Prestado LIB-0003 a EMP-001. Devolucion prevista: dia 26
'Patrones de Diseno' esta prestado.
Disponible previsiblemente en 14 dias.
Puede reservarlo con la opcion 5.

2026-08-05 11:42:07.104 [1     ] CONFIG  ...ConfiguracionLog.inicializar - Sistema de registro inicializado
2026-08-05 11:42:07.118 [1     ] FINE    ...Catalogo.registrar - Registrando LIB-0001 (catalogo actual: 0 materiales)
2026-08-05 11:42:07.119 [1     ] INFO    ...Catalogo.registrar - Material registrado: LIB-0001 (total 1)
...
2026-08-05 11:42:07.201 [1     ] FINE    ...GestorPrestamos.prestar - [OP-00002] Iniciando prestamo de LIB-0001 a EMP-002 el dia 11
2026-08-05 11:42:07.202 [1     ] FINE    ...OperacionesConsola.prestar - [OP-00002] Material no disponible: LIB-0001
2026-08-05 11:42:07.205 [1     ] FINE    ...Catalogo.obtenerPorReferencia - Referencia no encontrada: LIB-9999
2026-08-05 11:42:07.206 [1     ] FINE    ...OperacionesConsola.prestar - [OP-00003] Referencia inexistente: LIB-9999

public class MenuBiblioTech {

    public void arrancar() {
        while (true) {
            try {
                System.out.print("Opcion: ");
                int opcion = Integer.parseInt(new Scanner(System.in).nextLine());
                switch (opcion) {
                    case 1: prestar(); break;
                    case 2: devolver(); break;
                    case 0: System.exit(0);
                }
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
    }

    private void prestar() throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.print("Referencia: ");
        String ref = sc.nextLine();
        System.out.print("Empleado: ");
        String emp = sc.nextLine();

        try {
            gestor.prestar(ref, emp, 1);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println(e.getStackTrace()[0]);
            throw e;
        } finally {
            sc.close();
        }
    }

    private void devolver() {
        try {
            gestor.devolver(leerReferencia(), 1);
        } catch (Exception e) {
        }
        System.out.println("Devolucion procesada");
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.io.IOException;
import java.util.NoSuchElementException;
import java.util.logging.Level;

import com.nexussoftware.bibliotech.dominio.BiblioTechException;

/**
 * Clasifica un Throwable y recomienda como tratarlo.
 * Materializa la tabla de decisiones de esta leccion.
 */
public final class PoliticaDeErrores {

    /** Recomendacion completa para un fallo concreto (record, 04-07). */
    public record Recomendacion(Level nivel, boolean mensajeAptoParaUsuario,
                                boolean requiereIncidencia, String accion) {

        @Override
        public String toString() {
            return String.format("nivel=%-7s | usuario=%-5s | incidencia=%-5s | %s",
                    nivel.getName(), mensajeAptoParaUsuario, requiereIncidencia, accion);
        }
    }

    private PoliticaDeErrores() { }

    public static Recomendacion decidir(Throwable t) {
        if (t == null) {
            return new Recomendacion(Level.INFO, false, false, "Nada que hacer");
        }

        // 1. Error de la JVM: irrecuperable
        if (t instanceof Error) {
            return new Recomendacion(Level.SEVERE, false, true,
                    "Registrar (protegido) y terminar de forma ordenada. NO continuar.");
        }

        // 2. Excepcion del dominio: fallo esperado, mensaje ya escrito para el usuario
        if (t instanceof BiblioTechException bte) {
            if (bte.esCorregiblePorElUsuario()) {
                return new Recomendacion(Level.FINE, true, false,
                        "Mostrar el mensaje tal cual y permitir reintentar.");
            }
            return new Recomendacion(Level.WARNING, true, false,
                    "Mostrar el mensaje e indicar que no depende del usuario.");
        }

        // 3. Fallos de E/S: condicion del entorno
        if (t instanceof IOException) {
            return new Recomendacion(Level.SEVERE, false, true,
                    "Degradar si hay alternativa; si no, abortar la operacion. Avisar a operaciones.");
        }

        // 4. Validaciones tecnicas frecuentes en la frontera con el usuario
        if (t instanceof NumberFormatException) {
            return new Recomendacion(Level.FINE, true, false,
                    "Pedir el dato de nuevo indicando el formato esperado.");
        }
        if (t instanceof NoSuchElementException) {
            return new Recomendacion(Level.FINE, true, false,
                    "Informar de que no se encontro y ofrecer alternativas.");
        }

        // 5. Fallos de programacion: el usuario no debe ver detalles
        if (t instanceof NullPointerException
                || t instanceof IndexOutOfBoundsException
                || t instanceof ClassCastException) {
            return new Recomendacion(Level.SEVERE, false, true,
                    "BUG: mensaje generico con incidencia, stack trace completo al registro.");
        }

        // 6. Resto de no comprobadas: probablemente tambien un bug
        if (t instanceof RuntimeException) {
            return new Recomendacion(Level.SEVERE, false, true,
                    "Tratar como bug hasta demostrar lo contrario.");
        }

        // 7. Comprobadas no contempladas
        return new Recomendacion(Level.WARNING, false, true,
                "Condicion externa: registrar con detalle y decidir en la capa superior.");
    }

    public static void main(String[] args) {
        Throwable[] casos = {
                new NumberFormatException("For input string: \"doce\""),
                new IllegalArgumentException("El anio debe estar entre 1450 y 2100, y era: 1200"),
                new IOException("catalogo.txt (No such file or directory)"),
                new NullPointerException("Cannot invoke \"Empleado.getNombre()\""),
                new OutOfMemoryError("Java heap space"),
                new NoSuchElementException("No line found")
        };

        System.out.printf("%-32s %s%n", "EXCEPCION", "RECOMENDACION");
        System.out.println("-".repeat(120));
        for (Throwable t : casos) {
            System.out.printf("%-32s %s%n", t.getClass().getSimpleName(), decidir(t));
        }
    }
}

EXCEPCION                        RECOMENDACION
------------------------------------------------------------------------------------------------------------------------
NumberFormatException            nivel=FINE    | usuario=true  | incidencia=false | Pedir el dato de nuevo indicando el formato esperado.
IllegalArgumentException         nivel=SEVERE  | usuario=false | incidencia=true  | Tratar como bug hasta demostrar lo contrario.
IOException                      nivel=SEVERE  | usuario=false | incidencia=true  | Degradar si hay alternativa; si no, abortar la operacion. Avisar a operaciones.
NullPointerException             nivel=SEVERE  | usuario=false | incidencia=true  | BUG: mensaje generico con incidencia, stack trace completo al registro.
OutOfMemoryError                 nivel=SEVERE  | usuario=false | incidencia=true  | Registrar (protegido) y terminar de forma ordenada. NO continuar.
NoSuchElementException           nivel=FINE    | usuario=true  | incidencia=false | Informar de que no se encontro y ofrecer alternativas.

package com.nexussoftware.bibliotech.servicio;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.nexussoftware.bibliotech.dominio.BiblioTechException;

/**
 * Envuelve operaciones de BiblioTech aportando registro, medicion y
 * politica uniforme de errores.
 *
 * Es un ejemplo del patron "decorador de servicios" que en el modulo 11
 * hacen los frameworks con aspectos y anotaciones.
 */
public class RegistroOperaciones {

    private static final Logger LOG = Logger.getLogger(RegistroOperaciones.class.getName());

    /** Estadisticas acumuladas de una operacion (mutable a proposito). */
    private static class Estadistica {
        int ejecuciones;
        int exitos;
        int fallos;
        long nanosTotales;

        double mediaMs() {
            return (ejecuciones == 0) ? 0.0 : (nanosTotales / 1_000_000.0) / ejecuciones;
        }
    }

    private final Map<String, Estadistica> estadisticas = new HashMap<>();
    private int contador = 0;

    /**
     * Ejecuta una operacion registrando inicio, fin, duracion y fallos.
     *
     * @param nombreOperacion nombre logico (PRESTAR, DEVOLVER, IMPORTAR...)
     * @param idEmpleado      IDENTIFICADOR del empleado, nunca su nombre
     * @param operacion       la operacion a ejecutar
     */
    public <T> T ejecutar(String nombreOperacion, String idEmpleado, Supplier<T> operacion) {
        String idOperacion = siguienteId();
        long inicio = System.nanoTime();
        boolean exito = false;

        // Forma perezosa: si FINE esta desactivado, la cadena no se construye
        LOG.fine(() -> "[" + idOperacion + "] INICIO " + nombreOperacion
                + " (empleado " + idEmpleado + ")");

        try {
            T resultado = operacion.get();
            exito = true;
            return resultado;

        } catch (BiblioTechException e) {
            // Fallo ESPERADO del dominio: WARNING con la excepcion como
            // tercer argumento, y se RELANZA para que decida quien llame.
            LOG.log(Level.WARNING, "[" + idOperacion + "] " + nombreOperacion
                    + " rechazada [" + e.getCodigo() + "]", e);
            throw e;

        } catch (RuntimeException e) {
            // Fallo INESPERADO: es un bug. SEVERE con el identificador como
            // incidencia, y se ENVUELVE conservando la causa (06-03).
            LOG.log(Level.SEVERE, "[" + idOperacion + "] Error no controlado en "
                    + nombreOperacion, e);
            throw new IllegalStateException(
                    "Error interno en " + nombreOperacion + ". Incidencia: " + idOperacion, e);

        } finally {
            // La duracion se registra SIEMPRE, con exito y con fallo (06-05)
            long duracion = System.nanoTime() - inicio;
            acumular(nombreOperacion, exito, duracion);

            final boolean huboExito = exito;
            final double ms = duracion / 1_000_000.0;

            if (huboExito) {
                LOG.info(() -> String.format("[%s] FIN %s OK (%.2f ms)",
                        idOperacion, nombreOperacion, ms));
            } else {
                LOG.fine(() -> String.format("[%s] FIN %s FALLIDA (%.2f ms)",
                        idOperacion, nombreOperacion, ms));
            }
        }
    }

    /** Variante sin resultado. */
    public void ejecutarSinResultado(String nombreOperacion, String idEmpleado, Runnable operacion) {
        ejecutar(nombreOperacion, idEmpleado, () -> {
            operacion.run();
            return null;
        });
    }

    private synchronized void acumular(String nombre, boolean exito, long nanos) {
        Estadistica e = estadisticas.computeIfAbsent(nombre, n -> new Estadistica());
        e.ejecuciones++;
        e.nanosTotales += nanos;
        if (exito) { e.exitos++; } else { e.fallos++; }
    }

    private synchronized String siguienteId() {
        contador++;
        return String.format("OP-%05d", contador);
    }

    public void volcarEstadisticas() {
        System.out.println();
        System.out.printf("%-14s %-12s %-9s %-9s %s%n",
                "OPERACION", "EJECUCIONES", "EXITOS", "FALLOS", "MEDIA (ms)");
        System.out.println("-".repeat(62));

        estadisticas.forEach((nombre, e) ->
                System.out.printf("%-14s %-12d %-9d %-9d %.2f%n",
                        nombre, e.ejecuciones, e.exitos, e.fallos, e.mediaMs()));
    }

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

    public static void main(String[] args) {
        com.nexussoftware.bibliotech.presentacion.ConfiguracionLog.inicializar();

        Catalogo catalogo = new Catalogo();
        catalogo.registrar(new com.nexussoftware.bibliotech.dominio.Libro(
                "LIB-0001", "Java Efectivo", "Bloch", 2018, "978-0000000001"));
        catalogo.registrar(new com.nexussoftware.bibliotech.dominio.Libro(
                "LIB-0002", "Patrones de Diseno", "GoF", 1994, "978-0000000002"));

        RegistroOperaciones registro = new RegistroOperaciones();

        System.out.println("\n----- Operaciones -----");

        // 1 y 2: correctas
        registro.ejecutar("CONSULTAR", "EMP-001",
                () -> catalogo.obtenerPorReferencia("LIB-0001").getTitulo());
        registro.ejecutar("CONSULTAR", "EMP-002",
                () -> catalogo.obtenerPorReferencia("LIB-0002").getTitulo());

        // 3: fallo de dominio esperado, se relanza tal cual
        try {
            registro.ejecutar("CONSULTAR", "EMP-001",
                    () -> catalogo.obtenerPorReferencia("LIB-9999").getTitulo());
        } catch (BiblioTechException e) {
            System.out.println("Rechazada: " + e.getMessage());
        }

        // 4: alta correcta
        registro.ejecutarSinResultado("ALTA", "EMP-003", () ->
                catalogo.registrar(new com.nexussoftware.bibliotech.dominio.Libro(
                        "LIB-0003", "Refactorizacion", "Fowler", 1999, "978-0000000003")));

        // 5: alta duplicada, fallo de dominio
        try {
            registro.ejecutarSinResultado("ALTA", "EMP-003", () ->
                    catalogo.registrar(new com.nexussoftware.bibliotech.dominio.Libro(
                            "LIB-0001", "Copia", "X", 2020, "978-0000000009")));
        } catch (BiblioTechException e) {
            System.out.println("Rechazada: " + e.getMessage());
        }

        // 6: BUG simulado, se envuelve con incidencia
        try {
            registro.ejecutar("INFORME", "EMP-001", () -> {
                String nulo = null;
                return nulo.length();          // NullPointerException
            });
        } catch (IllegalStateException e) {
            System.out.println("Error interno: " + e.getMessage());
            System.out.println("  causa registrada: " + e.getCause().getClass().getSimpleName());
        }

        registro.volcarEstadisticas();
    }
}

----- Operaciones -----
[INFO   ] RegistroOperaciones [OP-00001] FIN CONSULTAR OK (0,08 ms)
[INFO   ] RegistroOperaciones [OP-00002] FIN CONSULTAR OK (0,01 ms)
[WARNING] RegistroOperaciones [OP-00003] CONSULTAR rechazada [MATERIALNOENCONTRADO]
          causa: com.nexussoftware.bibliotech.dominio.MaterialNoEncontradoException: No existe...
Rechazada: No existe ningun material con la referencia 'LIB-9999' (el catalogo tiene 2 materiales)
[INFO   ] Catalogo            Material registrado: LIB-0003 (total 3)
[INFO   ] RegistroOperaciones [OP-00004] FIN ALTA OK (0,15 ms)
[WARNING] RegistroOperaciones [OP-00005] ALTA rechazada [REFERENCIADUPLICADA]
Rechazada: Ya existe un material con la referencia LIB-0001: 'Java Efectivo'
[SEVERE ] RegistroOperaciones [OP-00006] Error no controlado en INFORME
Error interno: Error interno en INFORME. Incidencia: OP-00006
  causa registrada: NullPointerException

OPERACION      EJECUCIONES  EXITOS    FALLOS    MEDIA (ms)
--------------------------------------------------------------
CONSULTAR      3            2         1         0.04
ALTA           2            1         1         0.09
INFORME        1            0         1         0.05

package com.nexussoftware.bibliotech.presentacion;

import java.util.NoSuchElementException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

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

/**
 * Menu principal de BiblioTech, version final del modulo 6.
 *
 * Politica de errores:
 *   - Un unico Scanner de instancia sobre System.in, que NUNCA se cierra.
 *   - Se captura por TIPO, del mas especifico al mas general.
 *   - Los fallos de dominio producen mensajes para el usuario y log FINE.
 *   - Los bugs producen un mensaje generico con incidencia y log SEVERE.
 *   - No se captura Throwable: los Error suben a la frontera del main.
 *   - Cero System.out.println de diagnostico.
 */
public class MenuBiblioTech {

    private static final Logger LOG = Logger.getLogger(MenuBiblioTech.class.getName());

    private static final int DIAS_PRESTAMO = 15;

    /** UN SOLO Scanner, creado una vez y jamas cerrado (06-06). */
    private final Scanner scanner = new Scanner(System.in);

    private final GestorPrestamos gestor;
    private int contadorOperaciones = 0;
    private boolean salir = false;

    public MenuBiblioTech(GestorPrestamos gestor) {
        this.gestor = gestor;
    }

    public void arrancar() {
        LOG.info("Menu de BiblioTech iniciado");

        while (!salir) {
            mostrarMenu();
            int opcion = leerOpcion(0, 3);

            // Cada opcion maneja SUS PROPIOS errores: aqui no hay red que
            // capture de todo, porque una red asi ocultaria bugs.
            switch (opcion) {
                case 1 -> prestar();
                case 2 -> devolver();
                case 3 -> listar();
                case 0 -> salir();
                default -> System.out.println("Opcion no reconocida: " + opcion);
            }
        }
        LOG.info("Menu de BiblioTech finalizado");
    }

    private void mostrarMenu() {
        System.out.println("""

                ===== BiblioTech - Nexus Software =====
                1. Prestar material
                2. Devolver material
                3. Listar catalogo
                0. Salir
                =======================================""");
    }

    /** Reintento indefinido: hay una persona delante que puede corregir (06-02). */
    private int leerOpcion(int min, int max) {
        while (true) {
            System.out.print("Opcion: ");
            String linea = scanner.nextLine().trim();
            try {
                int valor = Integer.parseInt(linea);
                if (valor < min || valor > max) {
                    System.out.printf("Debe estar entre %d y %d.%n", min, max);
                    continue;
                }
                return valor;
            } catch (NumberFormatException e) {
                System.out.println("'" + linea + "' no es un numero. Escriba un digito de "
                        + min + " a " + max + ".");
                LOG.fine(() -> "Entrada no numerica en el menu: '" + linea + "'");
            }
        }
    }

    private void prestar() {
        String idOperacion = siguienteIdOperacion();

        System.out.print("Referencia del material: ");
        String referencia = scanner.nextLine().trim();
        System.out.print("Identificador del empleado: ");
        String idEmpleado = scanner.nextLine().trim();
        int dia = leerEnteroConLimite("Dia del prestamo (1-365)", 1, 365);
        if (dia == -1) {
            System.out.println("Operacion cancelada.");
            return;
        }

        try {
            gestor.prestar(idOperacion, referencia, idEmpleado, dia);
            // SALIDA del programa (lo que el usuario pidio ver), no log
            System.out.println("Prestado " + referencia + ". Devolucion prevista: dia "
                    + (dia + DIAS_PRESTAMO));

        } catch (MaterialNoEncontradoException e) {
            System.out.println("No existe el material '" + e.getReferenciaBuscada() + "'.");
            LOG.fine(() -> "[" + idOperacion + "] Referencia inexistente: "
                    + e.getReferenciaBuscada());

        } catch (MaterialNoDisponibleException e) {
            System.out.println("'" + e.getTitulo() + "' esta prestado.");
            System.out.println("Disponible en unos " + e.diasDeEspera(dia) + " dias.");
            LOG.fine(() -> "[" + idOperacion + "] Material no disponible: " + e.getReferencia());

        } catch (LimitePrestamosExcedidoException e) {
            System.out.printf("Limite de %d prestamos alcanzado. Devuelva %d material(es).%n",
                    e.getLimite(), e.devolucionesNecesarias());
            LOG.fine(() -> "[" + idOperacion + "] Limite excedido por " + e.getIdEmpleado());

        } catch (BiblioTechException e) {
            System.out.println("No se pudo completar el prestamo: " + e.getMessage());
            LOG.log(Level.WARNING, "[" + idOperacion + "] Fallo de dominio no previsto ["
                    + e.getCodigo() + "]", e);

        } catch (RuntimeException e) {
            // BUG. El usuario ve una incidencia; el registro, todo el detalle.
            System.out.println("Error interno. Incidencia: " + idOperacion);
            LOG.log(Level.SEVERE, "[" + idOperacion + "] Error no controlado al prestar "
                    + referencia + " a " + idEmpleado, e);
        }
        // NO se captura Throwable: un Error debe subir a la frontera del main.
    }

    private void devolver() {
        String idOperacion = siguienteIdOperacion();

        System.out.print("Referencia del prestamo (PR-NNNN): ");
        String referenciaPrestamo = scanner.nextLine().trim();
        int dia = leerEnteroConLimite("Dia de la devolucion (1-365)", 1, 365);
        if (dia == -1) {
            System.out.println("Operacion cancelada.");
            return;
        }

        try {
            gestor.devolver(idOperacion, referenciaPrestamo, dia);
            // DENTRO del try: solo se afirma el exito si de verdad lo hubo
            System.out.println("Devolucion de " + referenciaPrestamo + " procesada.");

        } catch (PrestamoYaDevueltoException e) {
            System.out.println("Ese prestamo ya se devolvio el dia "
                    + e.getDiaDevolucionOriginal() + ".");
            LOG.fine(() -> "[" + idOperacion + "] Devolucion duplicada de "
                    + e.getReferenciaPrestamo());

        } catch (MaterialNoEncontradoException e) {
            System.out.println("No existe el prestamo '" + e.getReferenciaBuscada() + "'.");
            LOG.fine(() -> "[" + idOperacion + "] Prestamo inexistente: "
                    + e.getReferenciaBuscada());

        } catch (BiblioTechException e) {
            System.out.println("No se pudo completar la devolucion: " + e.getMessage());
            LOG.log(Level.WARNING, "[" + idOperacion + "] Fallo de dominio en devolucion", e);

        } catch (RuntimeException e) {
            System.out.println("Error interno. Incidencia: " + idOperacion);
            LOG.log(Level.SEVERE, "[" + idOperacion + "] Error no controlado al devolver "
                    + referenciaPrestamo, e);
        }
    }

    private void listar() {
        System.out.println("(listado del catalogo)");
    }

    /**
     * Salida ORDENADA: se marca la bandera y el bucle termina solo.
     * Nada de System.exit aqui: eso saltaria los finally y la limpieza (06-05).
     */
    private void salir() {
        salir = true;
        System.out.println("Hasta luego.");
    }

    private int leerEnteroConLimite(String peticion, int min, int max) {
        for (int intento = 1; intento <= 3; intento++) {
            System.out.print(peticion + ": ");
            String linea;
            try {
                linea = scanner.nextLine().trim();
            } catch (NoSuchElementException e) {
                // Ocurre si System.in se cierra o llega al final (entrada redirigida)
                LOG.log(Level.WARNING, "Entrada estandar agotada; se cancela la operacion", e);
                return -1;
            }
            try {
                int valor = Integer.parseInt(linea);
                if (valor < min || valor > max) {
                    System.out.printf("Fuera de rango [%d..%d]. Intento %d de 3.%n",
                            min, max, intento);
                    continue;
                }
                return valor;
            } catch (NumberFormatException e) {
                System.out.printf("'%s' no es un numero. Intento %d de 3.%n", linea, intento);
            }
        }
        return -1;
    }

    private String siguienteIdOperacion() {
        contadorOperaciones++;
        return String.format("OP-%05d", contadorOperaciones);
    }
}