import java.util.Calendar;
import java.util.Date;

public class ApiAntigua {

    public static void main(String[] args) {

        // Crear el 15 de marzo de 2026
        Calendar c = Calendar.getInstance();
        c.set(2026, 2, 15);          // ¡2 es MARZO! Los meses empiezan en 0
        Date fecha = c.getTime();

        System.out.println(fecha);

        // Sumar 30 dias: MUTA el objeto
        c.add(Calendar.DAY_OF_MONTH, 30);
        System.out.println(c.getTime());

        // Y el objeto original ha cambiado tambien, porque es el mismo
        Date otraReferencia = fecha;
        System.out.println(otraReferencia);
    }
}

package com.nexussoftware.bibliotech;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

public class BugDeSimpleDateFormat {

    // Parece razonable: un formateador reutilizable, para no crear uno por llamada
    private static final SimpleDateFormat FORMATO = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

    public static void main(String[] args) throws Exception {

        ExecutorService pool = Executors.newFixedThreadPool(10);
        Date fecha = new Date();

        for (int i = 0; i < 20; i++) {
            pool.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName()
                            + " -> " + FORMATO.format(fecha));
                } catch (Exception e) {
                    System.out.println("EXCEPCIÓN: " + e);
                }
            });
        }
        pool.shutdown();
        pool.awaitTermination(5, TimeUnit.SECONDS);
    }
}

pool-1-thread-1 -> 05/08/2026 14:32:07
pool-1-thread-3 -> 05/08/2026 14:32:07
pool-1-thread-2 -> 05/08/2026 04:32:07     <-- hora incorrecta
pool-1-thread-5 -> 05/08/2020 14:32:07     <-- año incorrecto
EXCEPCIÓN: java.lang.NumberFormatException: multiple points
pool-1-thread-4 -> 05/08/2026 14:32:07

// DateTimeFormatter es INMUTABLE y SEGURO entre hilos.
// Compartirlo como constante static final es lo CORRECTO.
private static final DateTimeFormatter FORMATO =
        DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");

LocalDate hoy = LocalDate.of(2026, 8, 5);
LocalDate futuro = hoy.plusDays(30);

System.out.println(hoy);      // 2026-08-05   sin cambios
System.out.println(futuro);   // 2026-09-04

LocalDateTime vencimiento = LocalDateTime.now()
        .plusDays(21)
        .withHour(18)
        .withMinute(0)
        .withSecond(0)
        .withNano(0);

YearMonth agosto = YearMonth.of(2026, 8);
System.out.println(agosto.lengthOfMonth());        // 31
System.out.println(agosto.atDay(15));              // 2026-08-15
System.out.println(agosto.atEndOfMonth());         // 2026-08-31

MonthDay navidad = MonthDay.of(12, 25);
System.out.println(navidad.atYear(2026));          // 2026-12-25

Year año = Year.of(2026);
System.out.println(año.isLeap());                  // false
System.out.println(año.length());                  // 365

LocalDateTime local = LocalDateTime.of(2026, 8, 5, 9, 30);

// El MISMO LocalDateTime en dos zonas son dos INSTANTES distintos
ZonedDateTime enMadrid = local.atZone(ZoneId.of("Europe/Madrid"));
ZonedDateTime enTokio  = local.atZone(ZoneId.of("Asia/Tokyo"));

System.out.println(enMadrid);              // 2026-08-05T09:30+02:00[Europe/Madrid]
System.out.println(enTokio);               // 2026-08-05T09:30+09:00[Asia/Tokyo]

System.out.println(enMadrid.toInstant());  // 2026-08-05T07:30:00Z
System.out.println(enTokio.toInstant());   // 2026-08-05T00:30:00Z

// Siete horas de diferencia entre dos "mismas" horas
System.out.println(Duration.between(enTokio.toInstant(), enMadrid.toInstant()));  // PT7H

// --- now(): el momento actual ---
LocalDate hoy = LocalDate.now();
LocalTime ahora = LocalTime.now();
LocalDateTime ahoraCompleto = LocalDateTime.now();
ZonedDateTime enMadrid = ZonedDateTime.now(ZoneId.of("Europe/Madrid"));
Instant instante = Instant.now();

// --- of(): construir con valores explicitos ---
LocalDate fecha = LocalDate.of(2026, 8, 5);
LocalDate fecha2 = LocalDate.of(2026, Month.AUGUST, 5);      // con el enum: mas legible
LocalTime hora = LocalTime.of(9, 30);
LocalTime horaConSegundos = LocalTime.of(9, 30, 45);
LocalDateTime completa = LocalDateTime.of(2026, 8, 5, 9, 30);
LocalDateTime combinada = LocalDateTime.of(fecha, hora);      // combinando

// --- parse(): desde texto ISO-8601 ---
LocalDate p1 = LocalDate.parse("2026-08-05");
LocalTime p2 = LocalTime.parse("09:30:00");
LocalDateTime p3 = LocalDateTime.parse("2026-08-05T09:30:00");
ZonedDateTime p4 = ZonedDateTime.parse("2026-08-05T09:30:00+02:00[Europe/Madrid]");
Instant p5 = Instant.parse("2026-08-05T07:30:00Z");

// --- Conversiones entre tipos ---
LocalDateTime deFecha = fecha.atTime(9, 30);
LocalDateTime deFecha2 = fecha.atStartOfDay();               // 2026-08-05T00:00
LocalDate soloFecha = completa.toLocalDate();
LocalTime soloHora = completa.toLocalTime();
ZonedDateTime conZona = completa.atZone(ZoneId.of("Europe/Madrid"));
Instant aInstante = conZona.toInstant();

LocalDate.of(2026, 2, 30);

Exception in thread "main" java.time.DateTimeException:
    Invalid date 'FEBRUARY 30'

LocalDate.of(2026, Month.AUGUST, 5);

LocalDate fecha = LocalDate.of(2026, 8, 5);

System.out.println(fecha.getYear());            // 2026
System.out.println(fecha.getMonthValue());      // 8
System.out.println(fecha.getMonth());           // AUGUST (enum Month)
System.out.println(fecha.getDayOfMonth());      // 5
System.out.println(fecha.getDayOfWeek());       // WEDNESDAY (enum DayOfWeek)
System.out.println(fecha.getDayOfYear());       // 217

System.out.println(fecha.lengthOfMonth());      // 31
System.out.println(fecha.lengthOfYear());       // 365
System.out.println(fecha.isLeapYear());         // false

LocalTime hora = LocalTime.of(9, 30, 45, 123_000_000);
System.out.println(hora.getHour());             // 9
System.out.println(hora.getMinute());           // 30
System.out.println(hora.getSecond());           // 45
System.out.println(hora.getNano());             // 123000000

DayOfWeek dia = fecha.getDayOfWeek();

// switch de expresion (02-03, y lo verás moderno en 10-06)
String tipo = switch (dia) {
    case SATURDAY, SUNDAY -> "fin de semana";
    default -> "día laborable";
};

// Nombre localizado
System.out.println(dia.getDisplayName(TextStyle.FULL, new Locale("es", "ES")));  // miércoles

// Aritmetica de dias
System.out.println(dia.plus(3));                // SATURDAY
System.out.println(dia.getValue());             // 3 (1=lunes ... 7=domingo, ISO)

Month mes = fecha.getMonth();
System.out.println(mes.length(false));          // 31 (false = no bisiesto)
System.out.println(mes.getDisplayName(TextStyle.FULL, new Locale("es", "ES")));  // agosto

System.out.println(fecha.get(ChronoField.DAY_OF_WEEK));       // 3
System.out.println(fecha.get(ChronoField.ALIGNED_WEEK_OF_YEAR)); // 31

// Numero de semana ISO (la que usan los sistemas europeos)
System.out.println(fecha.get(WeekFields.ISO.weekOfWeekBasedYear()));  // 32

LocalDate hoy = LocalDate.of(2026, 8, 5);

System.out.println(hoy.plusDays(21));           // 2026-08-26
System.out.println(hoy.plusWeeks(3));           // 2026-08-26
System.out.println(hoy.plusMonths(1));          // 2026-09-05
System.out.println(hoy.minusYears(1));          // 2025-08-05

System.out.println(hoy.withDayOfMonth(1));      // 2026-08-01
System.out.println(hoy.withMonth(12));          // 2026-12-05
System.out.println(hoy.withYear(2030));         // 2030-08-05

// Encadenamiento fluido
LocalDateTime vencimiento = LocalDateTime.of(2026, 8, 5, 14, 23, 51)
        .plusDays(21)
        .withHour(23)
        .withMinute(59)
        .withSecond(59);
System.out.println(vencimiento);                // 2026-08-26T23:59:59

LocalDate vencimiento = LocalDate.of(2026, 8, 5);
vencimiento.plusDays(21);                        // ¡NO HACE NADA!
System.out.println(vencimiento);                 // 2026-08-05

String s = "hola";
s.toUpperCase();                                 // no hace nada
System.out.println(s);                           // hola

s = s.toUpperCase();                             // asi si

LocalDate finDeEnero = LocalDate.of(2026, 1, 31);
System.out.println(finDeEnero.plusMonths(1));    // 2026-02-28  ¡no el 31!
System.out.println(finDeEnero.plusMonths(3));    // 2026-04-30  ¡no el 31!

// Y no es reversible
System.out.println(finDeEnero.plusMonths(1).minusMonths(1));   // 2026-01-28

LocalDate bisiesto = LocalDate.of(2024, 2, 29);
System.out.println(bisiesto.plusYears(1));       // 2025-02-28

LocalDate a = LocalDate.of(2026, 8, 5);
LocalDate b = LocalDate.of(2026, 8, 26);

System.out.println(a.isBefore(b));               // true
System.out.println(a.isAfter(b));                // false
System.out.println(a.isEqual(b));                // false
System.out.println(a.equals(b));                 // false

// Tambien son Comparable (05-09), asi que se ordenan
List<LocalDate> fechas = new ArrayList<>(List.of(b, a));
Collections.sort(fechas);
System.out.println(fechas);                      // [2026-08-05, 2026-08-26]

// Y con streams (10-04)
Optional<LocalDate> masReciente = fechas.stream().max(Comparator.naturalOrder());

ZonedDateTime madrid = ZonedDateTime.of(2026, 8, 5, 9, 30, 0, 0, ZoneId.of("Europe/Madrid"));
ZonedDateTime londres = madrid.withZoneSameInstant(ZoneId.of("Europe/London"));

System.out.println(madrid.isEqual(londres));     // true: es el MISMO instante
System.out.println(madrid.equals(londres));      // false: distinta zona y hora local

// DURATION: tiempo de maquina
Duration d1 = Duration.ofHours(48);
Duration d2 = Duration.ofMinutes(90);
Duration d3 = Duration.ofSeconds(3600);
Duration d4 = Duration.between(Instant.now(), Instant.now().plusSeconds(7200));

System.out.println(d1);                          // PT48H
System.out.println(d1.toDays());                 // 2
System.out.println(d1.toHours());                // 48
System.out.println(d2.toMinutes());              // 90
System.out.println(d2.toHoursPart() + "h " + d2.toMinutesPart() + "m");   // 1h 30m

// PERIOD: tiempo humano
Period p1 = Period.ofDays(21);
Period p2 = Period.of(1, 2, 3);                  // 1 año, 2 meses, 3 dias
Period p3 = Period.between(LocalDate.of(2026, 1, 15), LocalDate.of(2026, 8, 5));

System.out.println(p1);                          // P21D
System.out.println(p3);                          // P6M21D
System.out.printf("%d años, %d meses, %d días%n",
        p3.getYears(), p3.getMonths(), p3.getDays());   // 0 años, 6 meses, 21 días

LocalDate enero = LocalDate.of(2026, 1, 1);
LocalDate febrero = LocalDate.of(2026, 2, 1);

System.out.println(ChronoUnit.DAYS.between(enero, febrero));      // 31

LocalDate febrero2 = LocalDate.of(2026, 2, 1);
LocalDate marzo = LocalDate.of(2026, 3, 1);
System.out.println(ChronoUnit.DAYS.between(febrero2, marzo));     // 28

// Y en un año bisiesto
System.out.println(ChronoUnit.DAYS.between(
        LocalDate.of(2024, 2, 1), LocalDate.of(2024, 3, 1)));     // 29

Period unMes = Period.ofMonths(1);
System.out.println(unMes.getDays());             // 0, no 30: no hay dias en este periodo

// Para saber cuantos dias son, hace falta una fecha concreta
LocalDate desde = LocalDate.of(2026, 1, 31);
LocalDate hasta = desde.plus(unMes);
System.out.println(ChronoUnit.DAYS.between(desde, hasta));        // 28

ZoneId madrid = ZoneId.of("Europe/Madrid");

// La noche del cambio a horario de verano: 29 de marzo de 2026
ZonedDateTime antes = ZonedDateTime.of(2026, 3, 28, 12, 0, 0, 0, madrid);

ZonedDateTime conPeriod = antes.plus(Period.ofDays(1));
ZonedDateTime conDuration = antes.plus(Duration.ofDays(1));

System.out.println("Origen:        " + antes);
System.out.println("+ Period 1D:   " + conPeriod);
System.out.println("+ Duration 1D: " + conDuration);

Origen:        2026-03-28T12:00+01:00[Europe/Madrid]
+ Period 1D:   2026-03-29T12:00+02:00[Europe/Madrid]
+ Duration 1D: 2026-03-29T13:00+02:00[Europe/Madrid]

LocalDate prestamo = LocalDate.of(2026, 8, 5);
LocalDate vencimiento = LocalDate.of(2026, 8, 26);
LocalDate hoy = LocalDate.of(2026, 9, 3);

System.out.println(ChronoUnit.DAYS.between(prestamo, vencimiento));   // 21
System.out.println(ChronoUnit.DAYS.between(vencimiento, hoy));        // 8  (retraso)
System.out.println(ChronoUnit.WEEKS.between(prestamo, hoy));          // 4
System.out.println(ChronoUnit.MONTHS.between(prestamo, hoy));         // 0
System.out.println(ChronoUnit.YEARS.between(prestamo, hoy));          // 0

System.out.println(ChronoUnit.MONTHS.between(
        LocalDate.of(2026, 8, 5), LocalDate.of(2026, 9, 4)));     // 0
System.out.println(ChronoUnit.MONTHS.between(
        LocalDate.of(2026, 8, 5), LocalDate.of(2026, 9, 5)));     // 1

System.out.println(ChronoUnit.DAYS.between(hoy, prestamo));       // -29 (negativo)

Instant inicio = Instant.now();
Instant fin = inicio.plusSeconds(9_045);

System.out.println(ChronoUnit.HOURS.between(inicio, fin));        // 2
System.out.println(ChronoUnit.MINUTES.between(inicio, fin));      // 150
System.out.println(ChronoUnit.SECONDS.between(inicio, fin));      // 9045

LocalDate a = LocalDate.of(2026, 1, 15);
LocalDate b = LocalDate.of(2027, 3, 20);

// ChronoUnit: UNA unidad, valor total
System.out.println(ChronoUnit.DAYS.between(a, b));      // 429
System.out.println(ChronoUnit.MONTHS.between(a, b));    // 14

// Period: DESCOMPUESTO en años, meses y dias
Period p = Period.between(a, b);
System.out.printf("%d años, %d meses, %d días%n",
        p.getYears(), p.getMonths(), p.getDays());      // 1 años, 2 meses, 5 días

LocalDate hoy = LocalDate.of(2026, 8, 5);        // miércoles

System.out.println(hoy.with(TemporalAdjusters.firstDayOfMonth()));      // 2026-08-01
System.out.println(hoy.with(TemporalAdjusters.lastDayOfMonth()));       // 2026-08-31
System.out.println(hoy.with(TemporalAdjusters.firstDayOfNextMonth()));  // 2026-09-01
System.out.println(hoy.with(TemporalAdjusters.firstDayOfYear()));       // 2026-01-01
System.out.println(hoy.with(TemporalAdjusters.lastDayOfYear()));        // 2026-12-31

// Dias de la semana
System.out.println(hoy.with(TemporalAdjusters.next(DayOfWeek.MONDAY)));         // 2026-08-10
System.out.println(hoy.with(TemporalAdjusters.nextOrSame(DayOfWeek.WEDNESDAY))); // 2026-08-05
System.out.println(hoy.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY)));     // 2026-07-31

// El primer y ultimo dia concreto del mes
System.out.println(hoy.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY))); // 2026-08-03
System.out.println(hoy.with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY)));  // 2026-08-28
System.out.println(hoy.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.TUESDAY))); // 2026-08-11

package com.nexussoftware.bibliotech.servicio;

import java.time.*;
import java.time.temporal.*;
import java.util.Set;

/**
 * Ajustadores de calendario de Nexus Software.
 */
public final class AjustadoresBiblioTech {

    private AjustadoresBiblioTech() { }

    /** Festivos fijos de la biblioteca (MonthDay: se repiten cada año). */
    private static final Set<MonthDay> FESTIVOS = Set.of(
            MonthDay.of(1, 1),     // Año Nuevo
            MonthDay.of(1, 6),     // Reyes
            MonthDay.of(5, 1),     // Trabajo
            MonthDay.of(8, 15),    // Asunción
            MonthDay.of(10, 12),   // Fiesta Nacional
            MonthDay.of(11, 1),    // Todos los Santos
            MonthDay.of(12, 6),    // Constitución
            MonthDay.of(12, 8),    // Inmaculada
            MonthDay.of(12, 25));  // Navidad

    public static boolean esFestivo(LocalDate fecha) {
        return FESTIVOS.contains(MonthDay.from(fecha));
    }

    public static boolean esHabil(LocalDate fecha) {
        DayOfWeek dia = fecha.getDayOfWeek();
        return dia != DayOfWeek.SATURDAY
            && dia != DayOfWeek.SUNDAY
            && !esFestivo(fecha);
    }

    /**
     * Ajustador: mueve la fecha al siguiente dia habil si no lo es.
     * TemporalAdjuster es funcional: se puede escribir como lambda.
     */
    public static TemporalAdjuster siguienteDiaHabil() {
        return temporal -> {
            LocalDate fecha = LocalDate.from(temporal);
            while (!esHabil(fecha)) {
                fecha = fecha.plusDays(1);
            }
            return temporal.with(fecha);
        };
    }

    /** Suma N dias HABILES, saltando fines de semana y festivos. */
    public static TemporalAdjuster masDiasHabiles(int dias) {
        return temporal -> {
            LocalDate fecha = LocalDate.from(temporal);
            int restantes = dias;
            while (restantes > 0) {
                fecha = fecha.plusDays(1);
                if (esHabil(fecha)) {
                    restantes--;
                }
            }
            return temporal.with(fecha);
        };
    }

    /** Cuenta dias habiles entre dos fechas (para multas justas). */
    public static long diasHabilesEntre(LocalDate desde, LocalDate hasta) {
        return desde.datesUntil(hasta)                  // Stream<LocalDate> (Java 9)
                    .filter(AjustadoresBiblioTech::esHabil)
                    .count();
    }
}

LocalDate viernes = LocalDate.of(2026, 8, 14);

System.out.println("Viernes 14:            " + viernes);
System.out.println("+ 1 día natural:       " + viernes.plusDays(1));
System.out.println("Ajustado a hábil:      "
        + viernes.plusDays(1).with(AjustadoresBiblioTech.siguienteDiaHabil()));
System.out.println("+ 5 días hábiles:      "
        + viernes.with(AjustadoresBiblioTech.masDiasHabiles(5)));
System.out.println("Días hábiles de agosto: "
        + AjustadoresBiblioTech.diasHabilesEntre(
                LocalDate.of(2026, 8, 1), LocalDate.of(2026, 9, 1)));

Viernes 14:            2026-08-14
+ 1 día natural:       2026-08-15
Ajustado a hábil:      2026-08-17
+ 5 días hábiles:      2026-08-24
Días hábiles de agosto: 20

// ZoneId: identificador IANA "Region/Ciudad"
ZoneId madrid = ZoneId.of("Europe/Madrid");
ZoneId tokio = ZoneId.of("Asia/Tokyo");
ZoneId nuevaYork = ZoneId.of("America/New_York");
ZoneId utc = ZoneId.of("UTC");
ZoneId porDefecto = ZoneId.systemDefault();

// ZoneOffset: desfase fijo
ZoneOffset masDos = ZoneOffset.ofHours(2);
ZoneOffset cero = ZoneOffset.UTC;

// Cuantas zonas hay
System.out.println(ZoneId.getAvailableZoneIds().size());    // unas 600

ZonedDateTime enMadrid = ZonedDateTime.of(2026, 8, 5, 9, 30, 0, 0, ZoneId.of("Europe/Madrid"));

// MISMO instante, otra zona: la hora local CAMBIA
ZonedDateTime enTokio = enMadrid.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));

// MISMA hora local, otra zona: el instante CAMBIA
ZonedDateTime otroInstante = enMadrid.withZoneSameLocal(ZoneId.of("Asia/Tokyo"));

System.out.println("Madrid:              " + enMadrid);
System.out.println("Mismo instante:      " + enTokio);
System.out.println("Misma hora local:    " + otroInstante);
System.out.println("¿Mismo instante?     " + enMadrid.isEqual(enTokio));
System.out.println("¿Mismo instante?     " + enMadrid.isEqual(otroInstante));

Madrid:              2026-08-05T09:30+02:00[Europe/Madrid]
Mismo instante:      2026-08-05T16:30+09:00[Asia/Tokyo]
Misma hora local:    2026-08-05T09:30+09:00[Asia/Tokyo]
¿Mismo instante?     true
¿Mismo instante?     false

package com.nexussoftware.bibliotech.presentacion;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Locale;

public class RelojMundialBiblioTech {

    private static final DateTimeFormatter FORMATO =
            DateTimeFormatter.ofPattern("EEEE dd/MM/yyyy HH:mm", new Locale("es", "ES"));

    public static void main(String[] args) {

        Instant ahora = Instant.now();

        List<String> sedes = List.of(
                "Europe/Madrid", "Europe/London", "America/New_York",
                "Asia/Tokyo", "Australia/Sydney", "UTC");

        System.out.println("Sedes de Nexus Software -- instante: " + ahora);
        System.out.println("-".repeat(62));

        sedes.stream()
             .map(ZoneId::of)
             .map(zona -> ahora.atZone(zona))
             .sorted(java.util.Comparator.comparing(z -> z.getOffset().getTotalSeconds()))
             .forEach(z -> System.out.printf("  %-20s %-32s %s%n",
                     z.getZone(), z.format(FORMATO), z.getOffset()));
    }
}

Sedes de Nexus Software -- instante: 2026-08-05T12:47:31.204Z
--------------------------------------------------------------
  America/New_York     miércoles 05/08/2026 08:47            -04:00
  UTC                  miércoles 05/08/2026 12:47            Z
  Europe/London        miércoles 05/08/2026 13:47            +01:00
  Europe/Madrid        miércoles 05/08/2026 14:47            +02:00
  Asia/Tokyo           miércoles 05/08/2026 21:47            +09:00
  Australia/Sydney     miércoles 05/08/2026 22:47            +10:00

package com.nexussoftware.bibliotech;

import java.time.*;

public class HoraQueNoExiste {

    public static void main(String[] args) {

        ZoneId madrid = ZoneId.of("Europe/Madrid");

        // 29 de marzo de 2026: cambio a horario de verano
        LocalDateTime inexistente = LocalDateTime.of(2026, 3, 29, 2, 30);

        System.out.println("LocalDateTime:  " + inexistente);

        ZonedDateTime resultado = inexistente.atZone(madrid);
        System.out.println("atZone():       " + resultado);
        System.out.println("Desfase:        " + resultado.getOffset());

        // Comprobarlo explicitamente
        var reglas = madrid.getRules();
        System.out.println("¿Es un hueco?   " + (reglas.getTransition(inexistente) != null));
        System.out.println("Duración salto: "
                + reglas.getTransition(inexistente).getDuration());
    }
}

LocalDateTime:  2026-03-29T02:30
atZone():       2026-03-29T03:30+02:00[Europe/Madrid]
Desfase:        +02:00
¿Es un hueco?   true
Duración salto: PT1H

package com.nexussoftware.bibliotech;

import java.time.*;

public class HoraDuplicada {

    public static void main(String[] args) {

        ZoneId madrid = ZoneId.of("Europe/Madrid");

        // 25 de octubre de 2026: vuelta al horario de invierno
        LocalDateTime ambigua = LocalDateTime.of(2026, 10, 25, 2, 30);

        System.out.println("LocalDateTime:      " + ambigua);

        // Por defecto elige la PRIMERA ocurrencia (verano, +02:00)
        ZonedDateTime porDefecto = ambigua.atZone(madrid);
        System.out.println("atZone() por defecto: " + porDefecto);

        // Eleccion explicita
        ZonedDateTime primera = ambigua.atZone(madrid).withEarlierOffsetAtOverlap();
        ZonedDateTime segunda = ambigua.atZone(madrid).withLaterOffsetAtOverlap();

        System.out.println("Primera (verano):     " + primera);
        System.out.println("Segunda (invierno):   " + segunda);
        System.out.println("Diferencia real:      "
                + Duration.between(primera.toInstant(), segunda.toInstant()));

        var reglas = madrid.getRules();
        System.out.println("Desfases válidos:     " + reglas.getValidOffsets(ambigua));
    }
}

LocalDateTime:      2026-10-25T02:30
atZone() por defecto: 2026-10-25T02:30+02:00[Europe/Madrid]
Primera (verano):     2026-10-25T02:30+02:00[Europe/Madrid]
Segunda (invierno):   2026-10-25T02:30+01:00[Europe/Madrid]
Diferencia real:      PT1H
Desfases válidos:     [+02:00, +01:00]

LocalDate fecha = LocalDate.of(2026, 8, 5);
LocalDateTime completa = LocalDateTime.of(2026, 8, 5, 9, 30, 45);
ZonedDateTime conZona = completa.atZone(ZoneId.of("Europe/Madrid"));

System.out.println(fecha.format(DateTimeFormatter.ISO_DATE));            // 2026-08-05
System.out.println(completa.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)); // 2026-08-05T09:30:45
System.out.println(conZona.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
// 2026-08-05T09:30:45+02:00[Europe/Madrid]
System.out.println(conZona.format(DateTimeFormatter.ISO_INSTANT));       // 2026-08-05T07:30:45Z
System.out.println(fecha.format(DateTimeFormatter.BASIC_ISO_DATE));      // 20260805

DateTimeFormatter español = DateTimeFormatter.ofPattern("dd/MM/yyyy");
DateTimeFormatter conHora = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");
DateTimeFormatter legible = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy",
                                                        new Locale("es", "ES"));

System.out.println(fecha.format(español));       // 05/08/2026
System.out.println(completa.format(conHora));    // 05/08/2026 09:30:45
System.out.println(fecha.format(legible));       // miércoles, 5 de agosto de 2026

DateTimeFormatter formato = DateTimeFormatter.ofPattern("dd/MM/yyyy");

LocalDate fecha = LocalDate.parse("05/08/2026", formato);
System.out.println(fecha);                       // 2026-08-05

// Sin formateador: se espera ISO-8601
LocalDate iso = LocalDate.parse("2026-08-05");

package com.nexussoftware.bibliotech.presentacion;

import java.time.LocalDate;
import java.time.format.*;
import java.util.Optional;

public class LectorDeFechas {

    private static final DateTimeFormatter ENTRADA =
            DateTimeFormatter.ofPattern("dd/MM/yyyy");

    /** Devuelve Optional en lugar de lanzar: la entrada mala del usuario es esperable (10-04). */
    public static Optional<LocalDate> leer(String texto) {
        if (texto == null || texto.isBlank()) {
            return Optional.empty();
        }
        try {
            return Optional.of(LocalDate.parse(texto.strip(), ENTRADA));
        } catch (DateTimeParseException e) {
            System.out.printf("  Fecha no válida: \"%s\" (posición %d: %s)%n",
                    e.getParsedString(), e.getErrorIndex(), e.getMessage());
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        for (String entrada : new String[] {
                "05/08/2026", "31/02/2026", "2026-08-05", "cinco de agosto", "  05/08/2026  " }) {

            System.out.println("Entrada: \"" + entrada + "\"");
            leer(entrada).ifPresentOrElse(
                    f  -> System.out.println("  -> " + f + " (" + f.getDayOfWeek() + ")"),
                    () -> System.out.println("  -> descartada"));
        }
    }
}

Entrada: "05/08/2026"
  -> 2026-08-05 (WEDNESDAY)
Entrada: "31/02/2026"
  Fecha no válida: "31/02/2026" (posición 0: Text '31/02/2026' could not be parsed:
    Invalid date 'FEBRUARY 31')
  -> descartada
Entrada: "2026-08-05"
  Fecha no válida: "2026-08-05" (posición 0: Text '2026-08-05' could not be parsed at index 2)
  -> descartada
Entrada: "cinco de agosto"
  Fecha no válida: "cinco de agosto" (posición 0: ...)
  -> descartada
Entrada: "  05/08/2026  "
  -> 2026-08-05 (WEDNESDAY)

DateTimeFormatter tolerante = new DateTimeFormatterBuilder()
        .parseCaseInsensitive()                       // acepta "AGO" y "ago"
        .appendPattern("dd/MM/yyyy")
        .optionalStart()                              // la hora es opcional
        .appendPattern(" HH:mm")
        .optionalEnd()
        .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)  // si falta, medianoche
        .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
        .toFormatter(new Locale("es", "ES"));

System.out.println(LocalDateTime.parse("05/08/2026", tolerante));         // 2026-08-05T00:00
System.out.println(LocalDateTime.parse("05/08/2026 14:30", tolerante));   // 2026-08-05T14:30

LocalDate fecha = LocalDate.of(2026, 8, 5);

DateTimeFormatter sinLocale = DateTimeFormatter.ofPattern("EEEE d 'de' MMMM");
DateTimeFormatter conEspanol = DateTimeFormatter.ofPattern("EEEE d 'de' MMMM",
                                                           new Locale("es", "ES"));
DateTimeFormatter conCatalan = DateTimeFormatter.ofPattern("EEEE d 'de' MMMM",
                                                           new Locale("ca", "ES"));

System.out.println(fecha.format(sinLocale));     // Wednesday 5 de August  (si la JVM esta en ingles)
System.out.println(fecha.format(conEspanol));    // miércoles 5 de agosto
System.out.println(fecha.format(conCatalan));    // dimecres 5 de agost

Locale es = new Locale("es", "ES");

System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT).withLocale(es)));
// 5/8/26
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(es)));
// 5 ago 2026
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).withLocale(es)));
// 5 de agosto de 2026
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(es)));
// miércoles, 5 de agosto de 2026

Locale es = new Locale("es", "ES");

System.out.println(DayOfWeek.WEDNESDAY.getDisplayName(TextStyle.FULL, es));    // miércoles
System.out.println(DayOfWeek.WEDNESDAY.getDisplayName(TextStyle.SHORT, es));   // mié
System.out.println(Month.AUGUST.getDisplayName(TextStyle.FULL, es));           // agosto
System.out.println(Month.AUGUST.getDisplayName(TextStyle.SHORT, es));          // ago

// Date -> Instant -> java.time
Date fechaAntigua = new Date();
Instant instante = fechaAntigua.toInstant();
LocalDateTime local = instante.atZone(ZoneId.systemDefault()).toLocalDateTime();
LocalDate soloFecha = instante.atZone(ZoneId.systemDefault()).toLocalDate();

// java.time -> Date
Instant deVuelta = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant();
Date fechaAntigua2 = Date.from(deVuelta);

// Calendar
Calendar cal = Calendar.getInstance();
ZonedDateTime deCalendar = ((GregorianCalendar) cal).toZonedDateTime();
GregorianCalendar aCalendar = GregorianCalendar.from(ZonedDateTime.now());

// java.sql
java.sql.Date sqlDate = java.sql.Date.valueOf(LocalDate.now());
LocalDate deSql = sqlDate.toLocalDate();
java.sql.Timestamp ts = java.sql.Timestamp.valueOf(LocalDateTime.now());
LocalDateTime deTs = ts.toLocalDateTime();

package com.nexussoftware.bibliotech.persistencia;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Locale;
import java.util.stream.Stream;

public class InventarioDeRespaldos {

    private static final DateTimeFormatter FORMATO =
            DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm", new Locale("es", "ES"));

    private static final ZoneId ZONA = ZoneId.of("Europe/Madrid");

    public record Respaldo(Path ruta, LocalDateTime modificado, long bytes) {

        public long diasDeAntiguedad(LocalDate hoy) {
            return java.time.temporal.ChronoUnit.DAYS.between(modificado.toLocalDate(), hoy);
        }
    }

    /** Lista los respaldos con su fecha real, no con un FileTime opaco. */
    public List<Respaldo> inventariar(Path directorio) throws IOException {
        try (Stream<Path> rutas = Files.list(directorio)) {
            return rutas
                    .filter(Files::isRegularFile)
                    .filter(p -> p.getFileName().toString().endsWith(".bak"))
                    .map(this::describir)
                    .sorted(java.util.Comparator.comparing(Respaldo::modificado).reversed())
                    .toList();
        }
    }

    private Respaldo describir(Path ruta) {
        try {
            BasicFileAttributes atributos = Files.readAttributes(ruta, BasicFileAttributes.class);

            // FileTime -> Instant -> LocalDateTime en la zona de la biblioteca
            FileTime modificado = atributos.lastModifiedTime();
            LocalDateTime fecha = modificado.toInstant().atZone(ZONA).toLocalDateTime();

            return new Respaldo(ruta, fecha, atributos.size());

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    /** Marca un fichero con una fecha concreta: java.time -> FileTime. */
    public void fecharComo(Path fichero, LocalDateTime cuando) throws IOException {
        Instant instante = cuando.atZone(ZONA).toInstant();
        Files.setLastModifiedTime(fichero, FileTime.from(instante));
    }

    /** Borra los respaldos anteriores a la fecha de corte. */
    public int purgarAnterioresA(Path directorio, LocalDate corte) throws IOException {
        List<Respaldo> caducados = inventariar(directorio).stream()
                .filter(r -> r.modificado().toLocalDate().isBefore(corte))
                .toList();

        for (Respaldo r : caducados) {
            Files.delete(r.ruta());
        }
        return caducados.size();
    }

    public static void main(String[] args) throws IOException {

        InventarioDeRespaldos inventario = new InventarioDeRespaldos();
        LocalDate hoy = LocalDate.now(ZONA);

        System.out.printf("%-28s %-18s %10s %8s%n",
                "FICHERO", "MODIFICADO", "TAMAÑO", "DÍAS");
        System.out.println("-".repeat(68));

        inventario.inventariar(Path.of("respaldos")).forEach(r ->
                System.out.printf("%-28s %-18s %8d KB %8d%n",
                        r.ruta().getFileName(),
                        r.modificado().format(FORMATO),
                        r.bytes() / 1024,
                        r.diasDeAntiguedad(hoy)));

        LocalDate corte = hoy.minusMonths(3).with(
                java.time.temporal.TemporalAdjusters.firstDayOfMonth());
        System.out.println("\nPurgando respaldos anteriores a " + corte + "...");
        System.out.println("Eliminados: " + inventario.purgarAnterioresA(Path.of("respaldos"), corte));
    }
}

FICHERO                      MODIFICADO             TAMAÑO     DÍAS
--------------------------------------------------------------------
catalogo-20260804.bak        04/08/2026 03:00        1284 KB        1
catalogo-20260728.bak        28/07/2026 03:00        1271 KB        8
catalogo-20260630.bak        30/06/2026 03:00        1198 KB       36
catalogo-20260401.bak        01/04/2026 03:00        1044 KB      126

Purgando respaldos anteriores a 2026-05-01...
Eliminados: 1

public class CalculadoraMultas {

    public double calcular(Prestamo prestamo) {
        LocalDate hoy = LocalDate.now();                    // <-- el problema
        long retraso = ChronoUnit.DAYS.between(prestamo.getFechaVencimiento(), hoy);
        return retraso <= 0 ? 0.0 : retraso * 0.25;
    }
}

// Reloj del sistema en la zona por defecto
Clock sistema = Clock.systemDefaultZone();

// Reloj del sistema en una zona concreta
Clock madrid = Clock.system(ZoneId.of("Europe/Madrid"));

// Reloj FIJO: siempre devuelve el mismo instante
Clock fijo = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"), ZoneId.of("Europe/Madrid"));

// Reloj desplazado respecto a otro
Clock dentroDe30Dias = Clock.offset(sistema, Duration.ofDays(30));

// Reloj con granularidad reducida (util para pruebas deterministas)
Clock porSegundos = Clock.tickSeconds(ZoneId.of("Europe/Madrid"));

LocalDate.now(reloj);
LocalDateTime.now(reloj);
ZonedDateTime.now(reloj);
Instant.now(reloj);

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Prestamo;

import java.time.*;
import java.time.temporal.ChronoUnit;

/**
 * Calculadora de multas con reloj INYECTADO.
 * En produccion recibe el reloj del sistema; en pruebas, uno fijo.
 */
public class CalculadoraMultas {

    private static final double EURO_POR_DIA = 0.25;
    private static final double TOPE = 20.0;
    private static final int DIAS_DE_CORTESIA = 2;

    private final Clock reloj;

    /** Constructor de produccion. */
    public CalculadoraMultas() {
        this(Clock.system(ZoneId.of("Europe/Madrid")));
    }

    /** Constructor para pruebas y para escenarios con zona explicita. */
    public CalculadoraMultas(Clock reloj) {
        this.reloj = java.util.Objects.requireNonNull(reloj, "reloj");
    }

    public LocalDate hoy() {
        return LocalDate.now(reloj);        // nunca LocalDate.now() a secas
    }

    public long diasDeRetraso(Prestamo prestamo) {
        long dias = ChronoUnit.DAYS.between(prestamo.getFechaVencimiento(), hoy());
        return Math.max(0, dias);
    }

    public double calcular(Prestamo prestamo) {
        long retraso = diasDeRetraso(prestamo);
        if (retraso <= DIAS_DE_CORTESIA) {
            return 0.0;
        }
        return Math.min((retraso - DIAS_DE_CORTESIA) * EURO_POR_DIA, TOPE);
    }

    public boolean estaVencido(Prestamo prestamo) {
        return hoy().isAfter(prestamo.getFechaVencimiento());
    }

    public boolean venceEnLosProximos(Prestamo prestamo, int dias) {
        LocalDate limite = hoy().plusDays(dias);
        LocalDate vencimiento = prestamo.getFechaVencimiento();
        return !vencimiento.isBefore(hoy()) && !vencimiento.isAfter(limite);
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.Prestamo;
import com.nexussoftware.bibliotech.servicio.CalculadoraMultas;

import java.time.*;

public class PruebaCalculadoraMultas {

    private static final ZoneId MADRID = ZoneId.of("Europe/Madrid");

    public static void main(String[] args) {

        // El "hoy" de la prueba es FIJO: 5 de agosto de 2026
        Clock hoyFijo = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"), MADRID);
        CalculadoraMultas calculadora = new CalculadoraMultas(hoyFijo);

        System.out.printf("%-24s %-12s %8s %10s%n",
                "CASO", "VENCIMIENTO", "RETRASO", "MULTA");
        System.out.println("-".repeat(58));

        comprobar(calculadora, "Sin vencer",              LocalDate.of(2026, 8, 20));
        comprobar(calculadora, "Vence hoy",               LocalDate.of(2026, 8,  5));
        comprobar(calculadora, "1 día (cortesía)",        LocalDate.of(2026, 8,  4));
        comprobar(calculadora, "2 días (cortesía)",       LocalDate.of(2026, 8,  3));
        comprobar(calculadora, "3 días (primera multa)",  LocalDate.of(2026, 8,  2));
        comprobar(calculadora, "30 días",                 LocalDate.of(2026, 7,  6));
        comprobar(calculadora, "1 año (tope)",            LocalDate.of(2025, 8,  5));

        // Y ahora "viajamos" 100 dias al futuro sin tocar el reloj del sistema
        System.out.println("\n--- El mismo préstamo, 100 días después ---");
        Clock futuro = Clock.offset(hoyFijo, Duration.ofDays(100));
        CalculadoraMultas enElFuturo = new CalculadoraMultas(futuro);
        System.out.println("Hoy para la calculadora: " + enElFuturo.hoy());
        comprobar(enElFuturo, "Sin vencer (antes)", LocalDate.of(2026, 8, 20));
    }

    private static void comprobar(CalculadoraMultas c, String caso, LocalDate vencimiento) {
        Prestamo p = new Prestamo("PR-TEST", "978-0000000001", "Marta Ruiz",
                                  vencimiento.minusDays(21), vencimiento);
        System.out.printf("%-24s %-12s %8d %8.2f €%n",
                caso, vencimiento, c.diasDeRetraso(p), c.calcular(p));
    }
}

CASO                     VENCIMIENTO   RETRASO      MULTA
----------------------------------------------------------
Sin vencer               2026-08-20          0     0,00 €
Vence hoy                2026-08-05          0     0,00 €
1 día (cortesía)         2026-08-04          1     0,00 €
2 días (cortesía)        2026-08-03          2     0,00 €
3 días (primera multa)   2026-08-02          3     0,25 €
30 días                  2026-07-06         30     7,00 €
1 año (tope)             2025-08-05        365    20,00 €

--- El mismo préstamo, 100 días después ---
Hoy para la calculadora: 2026-11-13
Sin vencer (antes)       2026-08-20         85    20,00 €

package com.nexussoftware.bibliotech.dominio;

import com.nexussoftware.bibliotech.anotaciones.CampoCsv;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;

/**
 * Prestamo con fechas REALES.
 *
 * ANTES:  private final int diaPrestamo;
 *         private final int diaVencimiento;
 * AHORA:  LocalDate, porque un prestamo es un hecho de CALENDARIO,
 *         no un instante: no le afecta el horario de verano.
 */
public class Prestamo implements Identificable {

    /** Plazo estandar de prestamo en Nexus Software. */
    public static final Period PLAZO_ESTANDAR = Period.ofDays(21);

    /** ISO-8601 para persistir: inequivoco en cualquier pais y sistema. */
    private static final DateTimeFormatter ISO = DateTimeFormatter.ISO_LOCAL_DATE;

    @CampoCsv(nombre = "Referencia", orden = 1)
    private final String referencia;

    @CampoCsv(nombre = "ISBN", orden = 2)
    private final String isbn;

    @CampoCsv(nombre = "Empleado", orden = 3, sensible = true)
    private final String empleado;

    @CampoCsv(nombre = "Fecha préstamo", orden = 4)
    private final LocalDate fechaPrestamo;

    @CampoCsv(nombre = "Fecha vencimiento", orden = 5)
    private final LocalDate fechaVencimiento;

    /** Instante EXACTO del registro: para auditoria se guarda Instant, no LocalDate. */
    private final Instant registradoEn;

    private LocalDate fechaDevolucion;              // null mientras siga prestado

    private final List<Incidencia> incidencias = new ArrayList<>();

    public Prestamo(String referencia, String isbn, String empleado,
                    LocalDate fechaPrestamo, LocalDate fechaVencimiento) {
        this.referencia = Objects.requireNonNull(referencia, "referencia");
        this.isbn = Objects.requireNonNull(isbn, "isbn");
        this.empleado = Objects.requireNonNull(empleado, "empleado");
        this.fechaPrestamo = Objects.requireNonNull(fechaPrestamo, "fechaPrestamo");
        this.fechaVencimiento = Objects.requireNonNull(fechaVencimiento, "fechaVencimiento");

        if (fechaVencimiento.isBefore(fechaPrestamo)) {
            throw new IllegalArgumentException(
                    "El vencimiento (" + fechaVencimiento + ") no puede ser anterior "
                    + "al préstamo (" + fechaPrestamo + ")");
        }
        this.registradoEn = Instant.now();
    }

    /** Fabrica que aplica el plazo estandar en dias HABILES. */
    public static Prestamo conPlazoEstandar(String referencia, String isbn,
                                            String empleado, LocalDate fechaPrestamo) {
        LocalDate vencimiento = fechaPrestamo.plus(PLAZO_ESTANDAR)
                .with(com.nexussoftware.bibliotech.servicio
                        .AjustadoresBiblioTech.siguienteDiaHabil());
        return new Prestamo(referencia, isbn, empleado, fechaPrestamo, vencimiento);
    }

    // --- Consultas dependientes del "hoy": SIEMPRE reciben la fecha ---

    /** Dias de retraso. 0 si aun no ha vencido. */
    public long diasDeRetraso(LocalDate hoy) {
        LocalDate referencia = fechaDevolucion != null ? fechaDevolucion : hoy;
        return Math.max(0, ChronoUnit.DAYS.between(fechaVencimiento, referencia));
    }

    public boolean tieneRetraso(LocalDate hoy) {
        return diasDeRetraso(hoy) > 0;
    }

    public boolean venceEn(LocalDate hoy, int dias) {
        LocalDate limite = hoy.plusDays(dias);
        return !fechaVencimiento.isBefore(hoy) && !fechaVencimiento.isAfter(limite);
    }

    /** Descomposicion humana del tiempo transcurrido. */
    public Period antiguedad(LocalDate hoy) {
        return Period.between(fechaPrestamo, hoy);
    }

    public void devolver(LocalDate cuando) {
        if (fechaDevolucion != null) {
            throw new IllegalStateException(
                    "El préstamo " + referencia + " ya se devolvió el " + fechaDevolucion);
        }
        if (cuando.isBefore(fechaPrestamo)) {
            throw new IllegalArgumentException("No se puede devolver antes de prestar");
        }
        this.fechaDevolucion = cuando;
    }

    // --- Serializacion: SIEMPRE ISO-8601 ---

    public String aLineaCsv() {
        return String.join(";",
                referencia, isbn, empleado,
                fechaPrestamo.format(ISO),
                fechaVencimiento.format(ISO),
                fechaDevolucion == null ? "" : fechaDevolucion.format(ISO),
                registradoEn.toString());          // Instant.toString() ya es ISO
    }

    public static Prestamo desdeLineaCsv(String linea) {
        String[] c = linea.split(";", -1);
        Prestamo p = new Prestamo(c[0], c[1], c[2],
                LocalDate.parse(c[3], ISO),
                LocalDate.parse(c[4], ISO));
        if (!c[5].isEmpty()) {
            p.devolver(LocalDate.parse(c[5], ISO));
        }
        return p;
    }

    // --- Getters ---
    @Override public String getId() { return referencia; }
    public String getIsbn() { return isbn; }
    public String getEmpleado() { return empleado; }
    public LocalDate getFechaPrestamo() { return fechaPrestamo; }
    public LocalDate getFechaVencimiento() { return fechaVencimiento; }
    public Optional<LocalDate> getFechaDevolucion() { return Optional.ofNullable(fechaDevolucion); }
    public Instant getRegistradoEn() { return registradoEn; }
    public List<Incidencia> getIncidencias() { return List.copyOf(incidencias); }

    public record Incidencia(String descripcion, Gravedad gravedad, LocalDate cuando) { }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Prestamo;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

public class ServicioAvisos {

    private static final DateTimeFormatter LEGIBLE =
            DateTimeFormatter.ofPattern("EEEE d 'de' MMMM", new Locale("es", "ES"));

    private final Clock reloj;

    public ServicioAvisos(Clock reloj) {
        this.reloj = Objects.requireNonNull(reloj);
    }

    private LocalDate hoy() {
        return LocalDate.now(reloj);
    }

    /** Prestamos que vencen en los proximos N dias, agrupados por empleado. */
    public Map<String, List<Prestamo>> avisosDeVencimiento(List<Prestamo> prestamos, int dias) {
        LocalDate limite = hoy().plusDays(dias);
        return prestamos.stream()
                .filter(p -> p.getFechaDevolucion().isEmpty())
                .filter(p -> !p.getFechaVencimiento().isBefore(hoy()))
                .filter(p -> !p.getFechaVencimiento().isAfter(limite))
                .collect(Collectors.groupingBy(Prestamo::getEmpleado, TreeMap::new,
                         Collectors.toList()));
    }

    /** El aviso se envia el siguiente dia HABIL: nadie lee correos el domingo. */
    public LocalDate cuandoEnviarAviso(Prestamo prestamo, int diasDeAntelacion) {
        return prestamo.getFechaVencimiento()
                .minusDays(diasDeAntelacion)
                .with(AjustadoresBiblioTech.siguienteDiaHabil());
    }

    /** Fecha del informe mensual: ultimo viernes del mes. */
    public LocalDate fechaDelInformeMensual() {
        return hoy().with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY));
    }

    /** Fecha del inventario trimestral: primer lunes del proximo trimestre. */
    public LocalDate fechaDelInventarioTrimestral() {
        LocalDate hoy = hoy();
        int mesActual = hoy.getMonthValue();
        int primerMesDelProximoTrimestre = ((mesActual - 1) / 3 + 1) * 3 + 1;

        LocalDate base = primerMesDelProximoTrimestre > 12
                ? LocalDate.of(hoy.getYear() + 1, 1, 1)
                : LocalDate.of(hoy.getYear(), primerMesDelProximoTrimestre, 1);

        return base.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
    }

    public String redactarAviso(String empleado, List<Prestamo> prestamos) {
        StringBuilder sb = new StringBuilder();
        sb.append("Estimado/a ").append(empleado).append(":\n\n");
        sb.append("Le recordamos que tiene ").append(prestamos.size())
          .append(prestamos.size() == 1 ? " material pendiente" : " materiales pendientes")
          .append(" de devolución:\n\n");

        prestamos.stream()
                .sorted(Comparator.comparing(Prestamo::getFechaVencimiento))
                .forEach(p -> {
                    long dias = java.time.temporal.ChronoUnit.DAYS
                            .between(hoy(), p.getFechaVencimiento());
                    sb.append(String.format("  - %s   vence el %s (%s)%n",
                            p.getIsbn(),
                            p.getFechaVencimiento().format(LEGIBLE),
                            dias == 0 ? "hoy" : "en " + dias + (dias == 1 ? " día" : " días")));
                });

        sb.append("\nBiblioTech -- Nexus Software\n");
        sb.append("Generado el ").append(hoy().format(LEGIBLE)).append('\n');
        return sb.toString();
    }
}

package com.nexussoftware.bibliotech.persistencia;

import java.time.*;
import java.util.Properties;

/**
 * Configuracion (07-07) con la zona horaria de la biblioteca EXPLICITA.
 * Depender de ZoneId.systemDefault() significa que el comportamiento
 * cambia al desplegar en un servidor configurado en UTC.
 */
public class ConfiguracionTemporal {

    private final ZoneId zona;
    private final Clock reloj;
    private final LocalTime aperturaBiblioteca;
    private final LocalTime cierreBiblioteca;
    private final Period plazoDePrestamo;

    public ConfiguracionTemporal(Properties propiedades) {
        this.zona = ZoneId.of(propiedades.getProperty("bibliotech.zona", "Europe/Madrid"));
        this.reloj = Clock.system(zona);
        this.aperturaBiblioteca = LocalTime.parse(
                propiedades.getProperty("bibliotech.apertura", "09:00"));
        this.cierreBiblioteca = LocalTime.parse(
                propiedades.getProperty("bibliotech.cierre", "20:00"));
        this.plazoDePrestamo = Period.parse(
                propiedades.getProperty("bibliotech.plazo", "P21D"));
    }

    public ZoneId zona() { return zona; }
    public Clock reloj() { return reloj; }
    public Period plazoDePrestamo() { return plazoDePrestamo; }

    public boolean estaAbierta(LocalDateTime cuando) {
        DayOfWeek dia = cuando.getDayOfWeek();
        if (dia == DayOfWeek.SATURDAY || dia == DayOfWeek.SUNDAY) {
            return false;
        }
        LocalTime hora = cuando.toLocalTime();
        return !hora.isBefore(aperturaBiblioteca) && hora.isBefore(cierreBiblioteca);
    }

    public boolean estaAbiertaAhora() {
        return estaAbierta(LocalDateTime.now(reloj));
    }
}

# bibliotech.properties
bibliotech.zona=Europe/Madrid
bibliotech.apertura=09:00
bibliotech.cierre=20:00
bibliotech.plazo=P21D

Referencia;ISBN;Empleado;Fecha préstamo;Fecha vencimiento;Fecha devolución;Registrado en
PR-2026-0041;978-0000000001;Marta Ruiz;2026-07-15;2026-08-05;;2026-07-15T09:14:22.481Z
PR-2026-0042;978-0000000003;Diego Alonso;2026-07-06;2026-07-27;2026-08-03;2026-07-06T11:02:17.903Z

package com.nexussoftware.bibliotech.servicio;

import java.time.*;
import java.time.format.TextStyle;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * Calendario laboral de la biblioteca de Nexus Software.
 * Reloj inyectado: probable de forma determinista.
 */
public class CalendarioBiblioTech {

    private static final Locale ES = new Locale("es", "ES");

    /** Festivos de fecha FIJA: MonthDay, porque se repiten cada año. */
    private static final Map<MonthDay, String> FESTIVOS_FIJOS = Map.ofEntries(
            Map.entry(MonthDay.of(1, 1),   "Año Nuevo"),
            Map.entry(MonthDay.of(1, 6),   "Epifanía"),
            Map.entry(MonthDay.of(5, 1),   "Día del Trabajo"),
            Map.entry(MonthDay.of(8, 15),  "Asunción"),
            Map.entry(MonthDay.of(10, 12), "Fiesta Nacional"),
            Map.entry(MonthDay.of(11, 1),  "Todos los Santos"),
            Map.entry(MonthDay.of(12, 6),  "Constitución"),
            Map.entry(MonthDay.of(12, 8),  "Inmaculada"),
            Map.entry(MonthDay.of(12, 25), "Navidad"));

    private final Clock reloj;

    /** Cache de festivos moviles por año: el calculo no cambia nunca. */
    private final Map<Integer, Map<LocalDate, String>> movilesPorAno = new HashMap<>();

    public CalendarioBiblioTech(Clock reloj) {
        this.reloj = Objects.requireNonNull(reloj, "reloj");
    }

    public LocalDate hoy() {
        return LocalDate.now(reloj);
    }

    // ------------------------------------------------------------------
    // 1. Dias habiles y festivos
    // ------------------------------------------------------------------

    public boolean esFinDeSemana(LocalDate fecha) {
        DayOfWeek d = fecha.getDayOfWeek();
        return d == DayOfWeek.SATURDAY || d == DayOfWeek.SUNDAY;
    }

    public Optional<String> nombreDelFestivo(LocalDate fecha) {
        String fijo = FESTIVOS_FIJOS.get(MonthDay.from(fecha));
        if (fijo != null) {
            return Optional.of(fijo);
        }
        return Optional.ofNullable(festivosMoviles(fecha.getYear()).get(fecha));
    }

    public boolean esFestivo(LocalDate fecha) {
        return nombreDelFestivo(fecha).isPresent();
    }

    public boolean esHabil(LocalDate fecha) {
        return !esFinDeSemana(fecha) && !esFestivo(fecha);
    }

    /**
     * Algoritmo de Butcher (o de Meeus/Jones/Butcher) para el domingo de Pascua
     * en el calendario gregoriano. A partir de el se derivan los demas.
     */
    private Map<LocalDate, String> festivosMoviles(int ano) {
        return movilesPorAno.computeIfAbsent(ano, y -> {
            LocalDate pascua = domingoDePascua(y);
            Map<LocalDate, String> moviles = new LinkedHashMap<>();
            moviles.put(pascua.minusDays(3), "Jueves Santo");
            moviles.put(pascua.minusDays(2), "Viernes Santo");
            moviles.put(pascua.plusDays(1),  "Lunes de Pascua");
            return moviles;
        });
    }

    public static LocalDate domingoDePascua(int ano) {
        int a = ano % 19;
        int b = ano / 100;
        int c = ano % 100;
        int d = b / 4;
        int e = b % 4;
        int f = (b + 8) / 25;
        int g = (b - f + 1) / 3;
        int h = (19 * a + b - d - g + 15) % 30;
        int i = c / 4;
        int k = c % 4;
        int l = (32 + 2 * e + 2 * i - h - k) % 7;
        int m = (a + 11 * h + 22 * l) / 451;
        int mes = (h + l - 7 * m + 114) / 31;
        int dia = ((h + l - 7 * m + 114) % 31) + 1;
        return LocalDate.of(ano, mes, dia);
    }

    // ------------------------------------------------------------------
    // 2. Navegacion por dias habiles
    // ------------------------------------------------------------------

    public LocalDate siguienteHabil(LocalDate desde) {
        LocalDate fecha = desde;
        while (!esHabil(fecha)) {
            fecha = fecha.plusDays(1);
        }
        return fecha;
    }

    public LocalDate sumarDiasHabiles(LocalDate desde, int dias) {
        if (dias < 0) {
            throw new IllegalArgumentException("Días negativos: " + dias);
        }
        LocalDate fecha = desde;
        int restantes = dias;
        while (restantes > 0) {
            fecha = fecha.plusDays(1);
            if (esHabil(fecha)) {
                restantes--;
            }
        }
        return fecha;
    }

    // ------------------------------------------------------------------
    // 3-5. Consultas agregadas con streams (10-04)
    // ------------------------------------------------------------------

    /** datesUntil (Java 9) devuelve un Stream<LocalDate>: el puente con 10-04. */
    public long diasHabilesEntre(LocalDate desde, LocalDate hastaExclusivo) {
        return desde.datesUntil(hastaExclusivo)
                    .filter(this::esHabil)
                    .count();
    }

    public Map<Month, Long> habilesPorMes(int ano) {
        return LocalDate.of(ano, 1, 1)
                .datesUntil(LocalDate.of(ano + 1, 1, 1))
                .filter(this::esHabil)
                .collect(Collectors.groupingBy(LocalDate::getMonth,
                         () -> new EnumMap<>(Month.class),
                         Collectors.counting()));
    }

    public List<Map.Entry<LocalDate, String>> festivosDe(int ano) {
        return LocalDate.of(ano, 1, 1)
                .datesUntil(LocalDate.of(ano + 1, 1, 1))
                .filter(this::esFestivo)
                .map(f -> Map.entry(f, nombreDelFestivo(f).orElse("?")))
                .sorted(Map.Entry.comparingByKey())
                .toList();
    }

    // ------------------------------------------------------------------
    // 6. Calendario visual
    // ------------------------------------------------------------------

    public String calendarioDelMes(YearMonth mes) {
        StringBuilder sb = new StringBuilder();

        String titulo = mes.getMonth().getDisplayName(TextStyle.FULL, ES).toUpperCase()
                + " " + mes.getYear();
        sb.append(String.format("%s%n", centrar(titulo, 28)));
        sb.append(" Lu  Ma  Mi  Ju  Vi  Sá  Do\n");

        LocalDate primero = mes.atDay(1);
        // getValue(): 1 = lunes ... 7 = domingo (ISO)
        int huecoInicial = primero.getDayOfWeek().getValue() - 1;
        sb.append("    ".repeat(huecoInicial));

        for (int dia = 1; dia <= mes.lengthOfMonth(); dia++) {
            LocalDate fecha = mes.atDay(dia);

            String marca;
            if (esFestivo(fecha))            marca = "*";     // festivo
            else if (esFinDeSemana(fecha))   marca = ".";     // fin de semana
            else                             marca = " ";     // habil

            sb.append(String.format("%3d%s", dia, marca));

            if (fecha.getDayOfWeek() == DayOfWeek.SUNDAY) {
                sb.append('\n');
            }
        }
        if (mes.atEndOfMonth().getDayOfWeek() != DayOfWeek.SUNDAY) {
            sb.append('\n');
        }

        long habiles = diasHabilesEntre(mes.atDay(1), mes.plusMonths(1).atDay(1));
        sb.append(String.format("%nDías hábiles: %d de %d   (* festivo, . fin de semana)%n",
                habiles, mes.lengthOfMonth()));

        festivosDe(mes.getYear()).stream()
                .filter(e -> YearMonth.from(e.getKey()).equals(mes))
                .forEach(e -> sb.append(String.format("  %s  %s%n",
                        e.getKey().getDayOfMonth(), e.getValue())));

        return sb.toString();
    }

    private static String centrar(String texto, int ancho) {
        int izquierda = Math.max(0, (ancho - texto.length()) / 2);
        return " ".repeat(izquierda) + texto;
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.servicio.CalendarioBiblioTech;

import java.time.*;

public class PruebaCalendario {

    public static void main(String[] args) {

        Clock fijo = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"),
                                 ZoneId.of("Europe/Madrid"));
        CalendarioBiblioTech calendario = new CalendarioBiblioTech(fijo);

        System.out.println("Hoy: " + calendario.hoy() + " ("
                + calendario.hoy().getDayOfWeek() + "), hábil: "
                + calendario.esHabil(calendario.hoy()));

        System.out.println("\nPascua 2026: " + CalendarioBiblioTech.domingoDePascua(2026));
        System.out.println("Pascua 2027: " + CalendarioBiblioTech.domingoDePascua(2027));

        System.out.println("\n--- Festivos de 2026 ---");
        calendario.festivosDe(2026).forEach(e ->
                System.out.printf("  %s  %-18s (%s)%n",
                        e.getKey(), e.getValue(), e.getKey().getDayOfWeek()));

        System.out.println("\n--- Días hábiles por mes en 2026 ---");
        calendario.habilesPorMes(2026).forEach((mes, n) ->
                System.out.printf("  %-12s %2d %s%n", mes, n, "#".repeat(n.intValue())));

        System.out.println("\n" + calendario.calendarioDelMes(YearMonth.of(2026, 4)));
        System.out.println(calendario.calendarioDelMes(YearMonth.of(2026, 8)));

        System.out.println("--- Navegación ---");
        LocalDate viernes = LocalDate.of(2026, 8, 14);
        System.out.println("Viernes 14/08:            " + viernes);
        System.out.println("Siguiente hábil desde 15: "
                + calendario.siguienteHabil(viernes.plusDays(1)));
        System.out.println("+10 días hábiles:         "
                + calendario.sumarDiasHabiles(viernes, 10));
    }
}

Hoy: 2026-08-05 (WEDNESDAY), hábil: true

Pascua 2026: 2026-04-05
Pascua 2027: 2027-03-28

--- Festivos de 2026 ---
  2026-01-01  Año Nuevo          (THURSDAY)
  2026-01-06  Epifanía           (TUESDAY)
  2026-04-02  Jueves Santo       (THURSDAY)
  2026-04-03  Viernes Santo      (FRIDAY)
  2026-04-06  Lunes de Pascua    (MONDAY)
  2026-05-01  Día del Trabajo    (FRIDAY)
  2026-08-15  Asunción           (SATURDAY)
  2026-10-12  Fiesta Nacional    (MONDAY)
  2026-11-01  Todos los Santos   (SUNDAY)
  2026-12-06  Constitución       (SUNDAY)
  2026-12-08  Inmaculada         (TUESDAY)
  2026-12-25  Navidad            (FRIDAY)

--- Días hábiles por mes en 2026 ---
  JANUARY      20 ####################
  FEBRUARY     20 ####################
  MARCH        22 ######################
  APRIL        19 ###################
  MAY          20 ####################
  JUNE         22 ######################
  JULY         23 #######################
  AUGUST       21 #####################
  SEPTEMBER    22 ######################
  OCTOBER      21 #####################
  NOVEMBER     21 #####################
  DECEMBER     21 #####################

            ABRIL 2026
 Lu  Ma  Mi  Ju  Vi  Sá  Do
              1   2*  3*  4.  5.
  6*  7   8   9  10  11.  12.
 13  14  15  16  17  18.  19.
 20  21  22  23  24  25.  26.
 27  28  29  30

Días hábiles: 19 de 30   (* festivo, . fin de semana)
  2  Jueves Santo
  3  Viernes Santo
  6  Lunes de Pascua

           AGOSTO 2026
 Lu  Ma  Mi  Ju  Vi  Sá  Do
                  1.  2.
  3   4   5   6   7   8.  9.
 10  11  12  13  14  15*  16.
 17  18  19  20  21  22.  23.
 24  25  26  27  28  29.  30.
 31

Días hábiles: 21 de 31   (* festivo, . fin de semana)
  15  Asunción

--- Navegación ---
Viernes 14/08:            2026-08-14
Siguiente hábil desde 15: 2026-08-17
+10 días hábiles:         2026-08-31

package com.nexussoftware.bibliotech.dominio;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.Objects;

/**
 * Reserva de sala con zona horaria explicita.
 * ZonedDateTime porque hay que respetar el horario laboral LOCAL
 * de cada sede y el cambio de hora.
 */
public record Reserva(String id, String sala, String empleado,
                      ZonedDateTime inicio, Duration duracion) {

    private static final DateTimeFormatter LEGIBLE =
            DateTimeFormatter.ofPattern("EEE dd/MM HH:mm", new Locale("es", "ES"));

    public Reserva {
        Objects.requireNonNull(id, "id");
        Objects.requireNonNull(sala, "sala");
        Objects.requireNonNull(empleado, "empleado");
        Objects.requireNonNull(inicio, "inicio");
        Objects.requireNonNull(duracion, "duracion");
        if (duracion.isNegative() || duracion.isZero()) {
            throw new IllegalArgumentException("La duración debe ser positiva: " + duracion);
        }
        if (duracion.toHours() > 8) {
            throw new IllegalArgumentException("Una reserva no puede durar más de 8 horas");
        }
    }

    public ZonedDateTime fin() {
        return inicio.plus(duracion);
    }

    /**
     * Compara INSTANTES, no horas locales.
     * Asi funciona aunque las dos reservas esten en zonas distintas
     * y aunque haya cambio de horario de por medio.
     */
    public boolean solapaCon(Reserva otra) {
        if (!sala.equals(otra.sala)) {
            return false;
        }
        Instant miInicio = inicio.toInstant();
        Instant miFin = fin().toInstant();
        Instant suInicio = otra.inicio.toInstant();
        Instant suFin = otra.fin().toInstant();

        return miInicio.isBefore(suFin) && suInicio.isBefore(miFin);
    }

    /** La misma reserva vista desde otra zona: MISMO instante, otro reloj. */
    public Reserva vistaDesde(ZoneId zona) {
        return new Reserva(id, sala, empleado, inicio.withZoneSameInstant(zona), duracion);
    }

    public String describir() {
        return String.format("%-8s %-12s %-14s %s -- %s (%dh%02dm) [%s]",
                id, sala, empleado,
                inicio.format(LEGIBLE), fin().format(LEGIBLE),
                duracion.toHours(), duracion.toMinutesPart(),
                inicio.getZone());
    }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Reserva;

import java.time.*;
import java.util.*;
import java.util.stream.Collectors;

public class GestorReservas {

    /** Sede de cada sala: define su horario laboral local. */
    private static final Map<String, ZoneId> SEDE_DE_LA_SALA = Map.of(
            "Madrid-A",   ZoneId.of("Europe/Madrid"),
            "Madrid-B",   ZoneId.of("Europe/Madrid"),
            "NuevaYork-1", ZoneId.of("America/New_York"),
            "Tokio-1",    ZoneId.of("Asia/Tokyo"));

    private static final LocalTime APERTURA = LocalTime.of(8, 0);
    private static final LocalTime CIERRE   = LocalTime.of(20, 0);

    private final List<Reserva> reservas = new ArrayList<>();
    private final Clock reloj;

    public GestorReservas(Clock reloj) {
        this.reloj = Objects.requireNonNull(reloj);
    }

    public Resultado<Reserva> reservar(String id, String sala, String empleado,
                                       ZonedDateTime inicio, Duration duracion) {

        ZoneId sede = SEDE_DE_LA_SALA.get(sala);
        if (sede == null) {
            return Resultado.fallo("No existe la sala '" + sala + "'");
        }

        // 1. No se reserva en el pasado: comparacion de INSTANTES
        if (inicio.toInstant().isBefore(Instant.now(reloj))) {
            return Resultado.fallo("No se puede reservar en el pasado (" + inicio + ")");
        }

        Reserva candidata;
        try {
            candidata = new Reserva(id, sala, empleado, inicio, duracion);
        } catch (IllegalArgumentException e) {
            return Resultado.fallo(e.getMessage());
        }

        // 2. Horario laboral EN LA ZONA DE LA SALA, no en la de quien reserva
        ZonedDateTime inicioLocal = inicio.withZoneSameInstant(sede);
        ZonedDateTime finLocal = candidata.fin().withZoneSameInstant(sede);

        if (esFinDeSemana(inicioLocal)) {
            return Resultado.fallo(String.format(
                    "La sala %s está cerrada: %s es %s en %s",
                    sala, inicioLocal.toLocalDate(), inicioLocal.getDayOfWeek(), sede));
        }
        if (inicioLocal.toLocalTime().isBefore(APERTURA)
                || finLocal.toLocalTime().isAfter(CIERRE)
                || !inicioLocal.toLocalDate().equals(finLocal.toLocalDate())) {
            return Resultado.fallo(String.format(
                    "Fuera del horario de %s (%s-%s hora local): %s a %s",
                    sala, APERTURA, CIERRE,
                    inicioLocal.toLocalTime(), finLocal.toLocalTime()));
        }

        // 3. Solapes, comparando instantes
        Optional<Reserva> conflicto = reservas.stream()
                .filter(candidata::solapaCon)
                .findFirst();

        if (conflicto.isPresent()) {
            return Resultado.fallo("Solapa con " + conflicto.get().id()
                    + " (" + conflicto.get().empleado() + ")");
        }

        reservas.add(candidata);
        return Resultado.exito(candidata);
    }

    private boolean esFinDeSemana(ZonedDateTime z) {
        DayOfWeek d = z.getDayOfWeek();
        return d == DayOfWeek.SATURDAY || d == DayOfWeek.SUNDAY;
    }

    /** Agenda de un empleado en SU zona horaria. */
    public String agendaPara(String empleado, ZoneId zonaDelEmpleado) {
        List<Reserva> suyas = reservas.stream()
                .filter(r -> r.empleado().equals(empleado))
                .map(r -> r.vistaDesde(zonaDelEmpleado))
                .sorted(Comparator.comparing(r -> r.inicio().toInstant()))
                .toList();

        if (suyas.isEmpty()) {
            return empleado + " no tiene reservas.";
        }

        StringBuilder sb = new StringBuilder();
        sb.append("Agenda de ").append(empleado)
          .append(" (horario de ").append(zonaDelEmpleado).append(")\n");

        suyas.stream()
             .collect(Collectors.groupingBy(r -> r.inicio().toLocalDate(),
                      TreeMap::new, Collectors.toList()))
             .forEach((dia, delDia) -> {
                 sb.append("  ").append(dia).append(":\n");
                 delDia.forEach(r -> sb.append("    ").append(r.describir()).append('\n'));
             });

        return sb.toString();
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.servicio.*;

import java.time.*;

public class PruebaReservasMultizona {

    public static void main(String[] args) {

        ZoneId madrid = ZoneId.of("Europe/Madrid");
        ZoneId tokio  = ZoneId.of("Asia/Tokyo");
        ZoneId nyc    = ZoneId.of("America/New_York");

        Clock reloj = Clock.fixed(Instant.parse("2026-08-03T06:00:00Z"), madrid);
        GestorReservas gestor = new GestorReservas(reloj);

        System.out.println("Ahora: " + ZonedDateTime.now(reloj));
        System.out.println();

        // 1. Reserva normal en Madrid
        mostrar(gestor.reservar("R-001", "Madrid-A", "Marta Ruiz",
                ZonedDateTime.of(2026, 8, 5, 10, 0, 0, 0, madrid), Duration.ofHours(2)));

        // 2. Solape en la misma sala
        mostrar(gestor.reservar("R-002", "Madrid-A", "Diego Alonso",
                ZonedDateTime.of(2026, 8, 5, 11, 0, 0, 0, madrid), Duration.ofHours(1)));

        // 3. Otra sala a la misma hora: SIN solape
        mostrar(gestor.reservar("R-003", "Madrid-B", "Diego Alonso",
                ZonedDateTime.of(2026, 8, 5, 11, 0, 0, 0, madrid), Duration.ofHours(1)));

        // 4. Sala de Tokio reservada DESDE MADRID a las 3 de la mañana hora de Madrid
        //    = 10:00 hora de Tokio: horario laboral CORRECTO alli
        mostrar(gestor.reservar("R-004", "Tokio-1", "Nuria Vidal",
                ZonedDateTime.of(2026, 8, 6, 3, 0, 0, 0, madrid), Duration.ofHours(1)));

        // 5. Sala de Tokio a las 10:00 hora de MADRID = 17:00 en Tokio: aun abierto
        mostrar(gestor.reservar("R-005", "Tokio-1", "Marta Ruiz",
                ZonedDateTime.of(2026, 8, 6, 10, 0, 0, 0, madrid), Duration.ofHours(1)));

        // 6. Sala de Tokio a las 16:00 hora de Madrid = 23:00 en Tokio: CERRADO
        mostrar(gestor.reservar("R-006", "Tokio-1", "Diego Alonso",
                ZonedDateTime.of(2026, 8, 6, 16, 0, 0, 0, madrid), Duration.ofHours(1)));

        // 7. Nueva York en sabado hora local
        mostrar(gestor.reservar("R-007", "NuevaYork-1", "Marta Ruiz",
                ZonedDateTime.of(2026, 8, 8, 15, 0, 0, 0, madrid), Duration.ofHours(1)));

        // 8. En el pasado
        mostrar(gestor.reservar("R-008", "Madrid-A", "Nuria Vidal",
                ZonedDateTime.of(2026, 8, 1, 10, 0, 0, 0, madrid), Duration.ofHours(1)));

        System.out.println();
        System.out.println(gestor.agendaPara("Marta Ruiz", madrid));
        System.out.println(gestor.agendaPara("Marta Ruiz", tokio));

        // --- El caso del cambio de horario ---
        System.out.println("--- Reserva la noche del cambio de horario ---");
        ZonedDateTime nocheDelCambio = ZonedDateTime.of(2026, 10, 25, 1, 30, 0, 0, madrid);
        System.out.println("Inicio:  " + nocheDelCambio);
        System.out.println("+2 horas (Duration): " + nocheDelCambio.plus(Duration.ofHours(2)));
        System.out.println("Desfases válidos a las 02:30: "
                + madrid.getRules().getValidOffsets(LocalDateTime.of(2026, 10, 25, 2, 30)));
    }

    private static void mostrar(Resultado<com.nexussoftware.bibliotech.dominio.Reserva> r) {
        if (r.esExito()) {
            System.out.println("OK      " + r.valor().describir());
        } else {
            System.out.println("RECHAZO " + r.error());
        }
    }
}

Ahora: 2026-08-03T08:00+02:00[Europe/Madrid]

OK      R-001    Madrid-A     Marta Ruiz     mié 05/08 10:00 -- mié 05/08 12:00 (2h00m) [Europe/Madrid]
RECHAZO Solapa con R-001 (Marta Ruiz)
OK      R-003    Madrid-B     Diego Alonso   mié 05/08 11:00 -- mié 05/08 12:00 (1h00m) [Europe/Madrid]
OK      R-004    Tokio-1      Nuria Vidal    jue 06/08 03:00 -- jue 06/08 04:00 (1h00m) [Europe/Madrid]
OK      R-005    Tokio-1      Marta Ruiz     jue 06/08 10:00 -- jue 06/08 11:00 (1h00m) [Europe/Madrid]
RECHAZO Fuera del horario de Tokio-1 (08:00-20:00 hora local): 23:00 a 00:00
RECHAZO La sala NuevaYork-1 está cerrada: 2026-08-08 es SATURDAY en America/New_York
RECHAZO No se puede reservar en el pasado (2026-08-01T10:00+02:00[Europe/Madrid])

Agenda de Marta Ruiz (horario de Europe/Madrid)
  2026-08-05:
    R-001    Madrid-A     Marta Ruiz     mié 05/08 10:00 -- mié 05/08 12:00 (2h00m) [Europe/Madrid]
  2026-08-06:
    R-005    Tokio-1      Marta Ruiz     jue 06/08 10:00 -- jue 06/08 11:00 (1h00m) [Europe/Madrid]

Agenda de Marta Ruiz (horario de Asia/Tokyo)
  2026-08-05:
    R-001    Madrid-A     Marta Ruiz     mié 05/08 17:00 -- mié 05/08 19:00 (2h00m) [Asia/Tokyo]
  2026-08-06:
    R-005    Tokio-1      Marta Ruiz     jue 06/08 17:00 -- jue 06/08 18:00 (1h00m) [Asia/Tokyo]

--- Reserva la noche del cambio de horario ---
Inicio:  2026-10-25T01:30+02:00[Europe/Madrid]
+2 horas (Duration): 2026-10-25T02:30+01:00[Europe/Madrid]
Desfases válidos a las 02:30: [+02:00, +01:00]

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Prestamo;

import java.time.*;
import java.time.format.TextStyle;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Informe temporal de prestamos.
 * java.time (10-05) + streams (10-04) + Clock inyectado.
 */
public class InformeTemporal {

    private static final Locale ES = new Locale("es", "ES");

    private final Clock reloj;
    private final List<Prestamo> prestamos;

    public InformeTemporal(Clock reloj, List<Prestamo> prestamos) {
        this.reloj = Objects.requireNonNull(reloj);
        this.prestamos = List.copyOf(prestamos);
    }

    private LocalDate hoy() {
        return LocalDate.now(reloj);
    }

    // --- 1. Prestamos por mes ---
    public Map<YearMonth, Long> porMes() {
        return prestamos.stream()
                .collect(Collectors.groupingBy(
                        p -> YearMonth.from(p.getFechaPrestamo()),
                        TreeMap::new,                      // orden cronologico
                        Collectors.counting()));
    }

    // --- 2. Duracion media real de los devueltos ---
    public OptionalDouble duracionMediaDevueltos() {
        return prestamos.stream()
                .filter(p -> p.getFechaDevolucion().isPresent())
                .mapToLong(p -> ChronoUnit.DAYS.between(
                        p.getFechaPrestamo(), p.getFechaDevolucion().orElseThrow()))
                .average();
    }

    // --- 3. Distribucion por dia de la semana ---
    public Map<DayOfWeek, Long> porDiaDeLaSemana() {
        return prestamos.stream()
                .collect(Collectors.groupingBy(
                        p -> p.getFechaPrestamo().getDayOfWeek(),
                        () -> new EnumMap<>(DayOfWeek.class),
                        Collectors.counting()));
    }

    // --- 4. Los 5 con mas retraso ---
    public List<Prestamo> masRetrasados(int n) {
        LocalDate hoy = hoy();
        return prestamos.stream()
                .filter(p -> p.getFechaDevolucion().isEmpty())
                .filter(p -> p.tieneRetraso(hoy))
                .sorted(Comparator.comparingLong((Prestamo p) -> p.diasDeRetraso(hoy)).reversed())
                .limit(n)
                .toList();
    }

    // --- 5. Vencen esta semana (lunes a domingo) ---
    public List<Prestamo> vencenEstaSemana() {
        LocalDate lunes = hoy().with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
        LocalDate domingo = hoy().with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));

        return prestamos.stream()
                .filter(p -> p.getFechaDevolucion().isEmpty())
                .filter(p -> !p.getFechaVencimiento().isBefore(lunes))
                .filter(p -> !p.getFechaVencimiento().isAfter(domingo))
                .sorted(Comparator.comparing(Prestamo::getFechaVencimiento))
                .toList();
    }

    // --- 6. Mapa de calor mes x dia de la semana ---
    public Map<Month, Map<DayOfWeek, Long>> mapaDeCalor() {
        return prestamos.stream()
                .collect(Collectors.groupingBy(
                        p -> p.getFechaPrestamo().getMonth(),
                        () -> new EnumMap<>(Month.class),
                        Collectors.groupingBy(
                                p -> p.getFechaPrestamo().getDayOfWeek(),
                                () -> new EnumMap<>(DayOfWeek.class),
                                Collectors.counting())));
    }

    // --- 7. Puntualidad por trimestre ---
    public record Puntualidad(long puntuales, long totales) {
        public double porcentaje() {
            return totales == 0 ? 0.0 : puntuales * 100.0 / totales;
        }
    }

    public Map<String, Puntualidad> puntualidadPorTrimestre() {
        return prestamos.stream()
                .filter(p -> p.getFechaDevolucion().isPresent())
                .collect(Collectors.groupingBy(
                        this::trimestreDe,
                        TreeMap::new,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                lista -> new Puntualidad(
                                        lista.stream().filter(this::fueDevueltoAtiempo).count(),
                                        lista.size()))));
    }

    private String trimestreDe(Prestamo p) {
        LocalDate f = p.getFechaDevolucion().orElseThrow();
        return f.getYear() + "-T" + ((f.getMonthValue() - 1) / 3 + 1);
    }

    private boolean fueDevueltoAtiempo(Prestamo p) {
        return !p.getFechaDevolucion().orElseThrow().isAfter(p.getFechaVencimiento());
    }

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

    public String generar() {
        StringBuilder sb = new StringBuilder();
        LocalDate hoy = hoy();

        sb.append("=".repeat(64)).append('\n');
        sb.append("  INFORME TEMPORAL DE PRÉSTAMOS -- ")
          .append(hoy.format(java.time.format.DateTimeFormatter
                  .ofPattern("d 'de' MMMM 'de' yyyy", ES))).append('\n');
        sb.append("=".repeat(64)).append('\n');

        sb.append("\n1. PRÉSTAMOS POR MES\n");
        porMes().forEach((mes, n) -> sb.append(String.format("   %s  %3d  %s%n",
                mes, n, "▇".repeat(n.intValue()))));

        sb.append("\n2. DURACIÓN MEDIA DE LOS DEVUELTOS\n");
        duracionMediaDevueltos().ifPresentOrElse(
                d -> sb.append(String.format("   %.1f días%n", d)),
                () -> sb.append("   (aún no hay devoluciones)\n"));

        sb.append("\n3. DÍA DE LA SEMANA DEL PRÉSTAMO\n");
        Map<DayOfWeek, Long> porDia = porDiaDeLaSemana();
        long maximo = porDia.values().stream().mapToLong(Long::longValue).max().orElse(1);
        Arrays.stream(DayOfWeek.values()).forEach(d -> {
            long n = porDia.getOrDefault(d, 0L);
            sb.append(String.format("   %-11s %3d %s%n",
                    d.getDisplayName(TextStyle.FULL, ES), n,
                    "▇".repeat((int) (n * 24 / maximo))));
        });

        sb.append("\n4. LOS 5 CON MÁS RETRASO\n");
        List<Prestamo> retrasados = masRetrasados(5);
        if (retrasados.isEmpty()) {
            sb.append("   (ningún préstamo con retraso)\n");
        } else {
            retrasados.forEach(p -> sb.append(String.format("   %-14s %-14s venció %s  %3d días%n",
                    p.getId(), p.getEmpleado(), p.getFechaVencimiento(), p.diasDeRetraso(hoy))));
        }

        sb.append("\n5. VENCEN ESTA SEMANA\n");
        List<Prestamo> semana = vencenEstaSemana();
        if (semana.isEmpty()) {
            sb.append("   (ninguno)\n");
        } else {
            semana.forEach(p -> sb.append(String.format("   %-14s %-14s %s (%s)%n",
                    p.getId(), p.getEmpleado(), p.getFechaVencimiento(),
                    p.getFechaVencimiento().getDayOfWeek().getDisplayName(TextStyle.FULL, ES))));
        }

        sb.append("\n6. MAPA DE CALOR (mes x día)\n");
        sb.append("            Lu  Ma  Mi  Ju  Vi  Sá  Do\n");
        mapaDeCalor().forEach((mes, porDiaDelMes) -> {
            sb.append(String.format("   %-9s",
                    mes.getDisplayName(TextStyle.SHORT, ES)));
            Arrays.stream(DayOfWeek.values()).forEach(d ->
                    sb.append(String.format("%4d", porDiaDelMes.getOrDefault(d, 0L))));
            sb.append('\n');
        });

        sb.append("\n7. PUNTUALIDAD POR TRIMESTRE\n");
        puntualidadPorTrimestre().forEach((trimestre, p) ->
                sb.append(String.format("   %-9s %3d/%-3d  %5.1f %%  %s%n",
                        trimestre, p.puntuales(), p.totales(), p.porcentaje(),
                        "▇".repeat((int) (p.porcentaje() / 5)))));

        return sb.toString();
    }
}

================================================================
  INFORME TEMPORAL DE PRÉSTAMOS -- 5 de agosto de 2026
================================================================

1. PRÉSTAMOS POR MES
   2026-04    7  ▇▇▇▇▇▇▇
   2026-05   11  ▇▇▇▇▇▇▇▇▇▇▇
   2026-06    9  ▇▇▇▇▇▇▇▇▇
   2026-07   14  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   2026-08    4  ▇▇▇▇

2. DURACIÓN MEDIA DE LOS DEVUELTOS
   18,4 días

3. DÍA DE LA SEMANA DEL PRÉSTAMO
   lunes        12 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   martes        8 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   miércoles     9 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   jueves        7 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   viernes       9 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   sábado        0
   domingo       0

4. LOS 5 CON MÁS RETRASO
   PR-2026-0012   Diego Alonso   venció 2026-05-22   75 días
   PR-2026-0019   Marta Ruiz     venció 2026-06-15   51 días
   PR-2026-0027   Nuria Vidal    venció 2026-07-10   26 días
   PR-2026-0031   Diego Alonso   venció 2026-07-24   12 días
   PR-2026-0035   Marta Ruiz     venció 2026-08-03    2 días

5. VENCEN ESTA SEMANA
   PR-2026-0035   Marta Ruiz     2026-08-03 (lunes)
   PR-2026-0038   Nuria Vidal    2026-08-06 (jueves)
   PR-2026-0040   Diego Alonso   2026-08-07 (viernes)

6. MAPA DE CALOR (mes x día)
            Lu  Ma  Mi  Ju  Vi  Sá  Do
   abr         2   1   2   1   1   0   0
   may         3   2   2   2   2   0   0
   jun         2   2   2   1   2   0   0
   jul         4   2   2   2   4   0   0
   ago         1   1   1   1   0   0   0

7. PUNTUALIDAD POR TRIMESTRE
   2026-T2   14/18   77,8 %  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   2026-T3    9/13   69,2 %  ▇▇▇▇▇▇▇▇▇▇▇▇▇