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

public class ApiAntiga {

    public static void main(String[] args) {

        // Crear el 15 de marc de 2026
        Calendar c = Calendar.getInstance();
        c.set(2026, 2, 15);          // 2 es MARC! Els mesos comencen a 0
        Date data = c.getTime();

        System.out.println(data);

        // Sumar 30 dies: MUTA l objecte
        c.add(Calendar.DAY_OF_MONTH, 30);
        System.out.println(c.getTime());

        // I l objecte original ha canviat tambe, perque es el mateix
        Date altraReferencia = data;
        System.out.println(altraReferencia);
    }
}

package com.nexussoftware.bibliotech;

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

public class BugDeSimpleDateFormat {

    // Sembla raonable: un formatador reutilitzable, per no crear ne un per crida
    private static final SimpleDateFormat FORMAT = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

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

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

        for (int i = 0; i < 20; i++) {
            pool.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName()
                            + " -> " + FORMAT.format(data));
                } catch (Exception e) {
                    System.out.println("EXCEPCIO: " + 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     <-- any incorrecte
EXCEPCIO: java.lang.NumberFormatException: multiple points
pool-1-thread-4 -> 05/08/2026 14:32:07

// DateTimeFormatter es IMMUTABLE i SEGUR entre fils.
// Compartir lo com a constant static final es el CORRECTE.
private static final DateTimeFormatter FORMAT =
        DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");

LocalDate avui = LocalDate.of(2026, 8, 5);
LocalDate futur = avui.plusDays(30);

System.out.println(avui);     // 2026-08-05   sense canvis
System.out.println(futur);    // 2026-09-04

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

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

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

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

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

// El MATEIX LocalDateTime en dues zones son dos INSTANTS diferents
ZonedDateTime aMadrid = local.atZone(ZoneId.of("Europe/Madrid"));
ZonedDateTime aToquio = local.atZone(ZoneId.of("Asia/Tokyo"));

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

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

// Set hores de diferencia entre dues "mateixes" hores
System.out.println(Duration.between(aToquio.toInstant(), aMadrid.toInstant()));  // PT7H

// --- now(): el moment actual ---
LocalDate avui = LocalDate.now();
LocalTime ara = LocalTime.now();
LocalDateTime araComplet = LocalDateTime.now();
ZonedDateTime aMadrid = ZonedDateTime.now(ZoneId.of("Europe/Madrid"));
Instant instant = Instant.now();

// --- of(): construir amb valors explicits ---
LocalDate data = LocalDate.of(2026, 8, 5);
LocalDate data2 = LocalDate.of(2026, Month.AUGUST, 5);       // amb l enum: mes llegible
LocalTime hora = LocalTime.of(9, 30);
LocalTime horaAmbSegons = LocalTime.of(9, 30, 45);
LocalDateTime completa = LocalDateTime.of(2026, 8, 5, 9, 30);
LocalDateTime combinada = LocalDateTime.of(data, hora);       // combinant

// --- parse(): des de text 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");

// --- Conversions entre tipus ---
LocalDateTime deData = data.atTime(9, 30);
LocalDateTime deData2 = data.atStartOfDay();                 // 2026-08-05T00:00
LocalDate nomesData = completa.toLocalDate();
LocalTime nomesHora = completa.toLocalTime();
ZonedDateTime ambZona = completa.atZone(ZoneId.of("Europe/Madrid"));
Instant aInstant = ambZona.toInstant();

LocalDate.of(2026, 2, 30);

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

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

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

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

System.out.println(data.lengthOfMonth());       // 31
System.out.println(data.lengthOfYear());        // 365
System.out.println(data.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 = data.getDayOfWeek();

// switch d expressio (02-03, i el veuras modern a 10-06)
String tipus = switch (dia) {
    case SATURDAY, SUNDAY -> "cap de setmana";
    default -> "dia laborable";
};

// Nom localitzat
System.out.println(dia.getDisplayName(TextStyle.FULL, new Locale("ca", "ES")));  // dimecres

// Aritmetica de dies
System.out.println(dia.plus(3));                // SATURDAY
System.out.println(dia.getValue());             // 3 (1=dilluns ... 7=diumenge, ISO)

Month mes = data.getMonth();
System.out.println(mes.length(false));          // 31 (false = no de traspas)
System.out.println(mes.getDisplayName(TextStyle.FULL, new Locale("ca", "ES")));  // agost

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

// Numero de setmana ISO (la que fan servir els sistemes europeus)
System.out.println(data.get(WeekFields.ISO.weekOfWeekBasedYear()));  // 32

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

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

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

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

LocalDate venciment = LocalDate.of(2026, 8, 5);
venciment.plusDays(21);                          // NO FA RES!
System.out.println(venciment);                   // 2026-08-05

String s = "hola";
s.toUpperCase();                                 // no fa res
System.out.println(s);                           // hola

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

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

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

LocalDate deTraspas = LocalDate.of(2024, 2, 29);
System.out.println(deTraspas.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

// Tambe son Comparable (05-09), aixi que s ordenen
List<LocalDate> dates = new ArrayList<>(List.of(b, a));
Collections.sort(dates);
System.out.println(dates);                       // [2026-08-05, 2026-08-26]

// I amb streams (10-04)
Optional<LocalDate> mesRecent = dates.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 MATEIX instant
System.out.println(madrid.equals(londres));      // false: zona i hora local diferents

// DURATION: temps 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: temps huma
Period p1 = Period.ofDays(21);
Period p2 = Period.of(1, 2, 3);                  // 1 any, 2 mesos, 3 dies
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 anys, %d mesos, %d dies%n",
        p3.getYears(), p3.getMonths(), p3.getDays());   // 0 anys, 6 mesos, 21 dies

LocalDate gener = LocalDate.of(2026, 1, 1);
LocalDate febrer = LocalDate.of(2026, 2, 1);

System.out.println(ChronoUnit.DAYS.between(gener, febrer));       // 31

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

// I en un any de traspas
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 hi ha dies en aquest periode

// Per saber quants dies son, cal una data concreta
LocalDate des = LocalDate.of(2026, 1, 31);
LocalDate fins = des.plus(unMes);
System.out.println(ChronoUnit.DAYS.between(des, fins));           // 28

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

// La nit del canvi a horari d estiu: 29 de marc de 2026
ZonedDateTime abans = ZonedDateTime.of(2026, 3, 28, 12, 0, 0, 0, madrid);

ZonedDateTime ambPeriod = abans.plus(Period.ofDays(1));
ZonedDateTime ambDuration = abans.plus(Duration.ofDays(1));

System.out.println("Origen:        " + abans);
System.out.println("+ Period 1D:   " + ambPeriod);
System.out.println("+ Duration 1D: " + ambDuration);

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 prestec = LocalDate.of(2026, 8, 5);
LocalDate venciment = LocalDate.of(2026, 8, 26);
LocalDate avui = LocalDate.of(2026, 9, 3);

System.out.println(ChronoUnit.DAYS.between(prestec, venciment));      // 21
System.out.println(ChronoUnit.DAYS.between(venciment, avui));         // 8  (retard)
System.out.println(ChronoUnit.WEEKS.between(prestec, avui));          // 4
System.out.println(ChronoUnit.MONTHS.between(prestec, avui));         // 0
System.out.println(ChronoUnit.YEARS.between(prestec, avui));          // 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(avui, prestec));       // -29 (negatiu)

Instant inici = Instant.now();
Instant fi = inici.plusSeconds(9_045);

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

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

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

// Period: DESCOMPOSAT en anys, mesos i dies
Period p = Period.between(a, b);
System.out.printf("%d anys, %d mesos, %d dies%n",
        p.getYears(), p.getMonths(), p.getDays());      // 1 anys, 2 mesos, 5 dies

LocalDate avui = LocalDate.of(2026, 8, 5);       // dimecres

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

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

// El primer i ultim dia concret del mes
System.out.println(avui.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY))); // 2026-08-03
System.out.println(avui.with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY)));  // 2026-08-28
System.out.println(avui.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.TUESDAY))); // 2026-08-11

package com.nexussoftware.bibliotech.servei;

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

/**
 * Ajustadors de calendari de Nexus Software.
 */
public final class AjustadorsBiblioTech {

    private AjustadorsBiblioTech() { }

    /** Festius fixos de la biblioteca (MonthDay: es repeteixen cada any). */
    private static final Set<MonthDay> FESTIUS = Set.of(
            MonthDay.of(1, 1),     // Cap d Any
            MonthDay.of(1, 6),     // Reis
            MonthDay.of(5, 1),     // Treball
            MonthDay.of(8, 15),    // Assumpcio
            MonthDay.of(10, 12),   // Festa Nacional
            MonthDay.of(11, 1),    // Tots Sants
            MonthDay.of(12, 6),    // Constitucio
            MonthDay.of(12, 8),    // Immaculada
            MonthDay.of(12, 25));  // Nadal

    public static boolean esFestiu(LocalDate data) {
        return FESTIUS.contains(MonthDay.from(data));
    }

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

    /**
     * Ajustador: mou la data al seguent dia habil si no ho es.
     * TemporalAdjuster es funcional: es pot escriure com a lambda.
     */
    public static TemporalAdjuster seguentDiaHabil() {
        return temporal -> {
            LocalDate data = LocalDate.from(temporal);
            while (!esHabil(data)) {
                data = data.plusDays(1);
            }
            return temporal.with(data);
        };
    }

    /** Suma N dies HABILS, saltant caps de setmana i festius. */
    public static TemporalAdjuster mesDiesHabils(int dies) {
        return temporal -> {
            LocalDate data = LocalDate.from(temporal);
            int restants = dies;
            while (restants > 0) {
                data = data.plusDays(1);
                if (esHabil(data)) {
                    restants--;
                }
            }
            return temporal.with(data);
        };
    }

    /** Compta dies habils entre dues dates (per a multes justes). */
    public static long diesHabilsEntre(LocalDate des, LocalDate fins) {
        return des.datesUntil(fins)                     // Stream<LocalDate> (Java 9)
                  .filter(AjustadorsBiblioTech::esHabil)
                  .count();
    }
}

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

System.out.println("Divendres 14:          " + divendres);
System.out.println("+ 1 dia natural:       " + divendres.plusDays(1));
System.out.println("Ajustat a habil:       "
        + divendres.plusDays(1).with(AjustadorsBiblioTech.seguentDiaHabil()));
System.out.println("+ 5 dies habils:       "
        + divendres.with(AjustadorsBiblioTech.mesDiesHabils(5)));
System.out.println("Dies habils d agost:   "
        + AjustadorsBiblioTech.diesHabilsEntre(
                LocalDate.of(2026, 8, 1), LocalDate.of(2026, 9, 1)));

Divendres 14:          2026-08-14
+ 1 dia natural:       2026-08-15
Ajustat a habil:       2026-08-17
+ 5 dies habils:       2026-08-24
Dies habils d agost:   20

// ZoneId: identificador IANA "Regio/Ciutat"
ZoneId madrid = ZoneId.of("Europe/Madrid");
ZoneId toquio = ZoneId.of("Asia/Tokyo");
ZoneId novaYork = ZoneId.of("America/New_York");
ZoneId utc = ZoneId.of("UTC");
ZoneId perDefecte = ZoneId.systemDefault();

// ZoneOffset: desfasament fix
ZoneOffset mesDos = ZoneOffset.ofHours(2);
ZoneOffset zero = ZoneOffset.UTC;

// Quantes zones hi ha
System.out.println(ZoneId.getAvailableZoneIds().size());   // unes 600

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

// MATEIX instant, altra zona: l hora local CANVIA
ZonedDateTime aToquio = aMadrid.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));

// MATEIXA hora local, altra zona: l instant CANVIA
ZonedDateTime altreInstant = aMadrid.withZoneSameLocal(ZoneId.of("Asia/Tokyo"));

System.out.println("Madrid:              " + aMadrid);
System.out.println("Mateix instant:      " + aToquio);
System.out.println("Mateixa hora local:  " + altreInstant);
System.out.println("Mateix instant?      " + aMadrid.isEqual(aToquio));
System.out.println("Mateix instant?      " + aMadrid.isEqual(altreInstant));

Madrid:              2026-08-05T09:30+02:00[Europe/Madrid]
Mateix instant:      2026-08-05T16:30+09:00[Asia/Tokyo]
Mateixa hora local:  2026-08-05T09:30+09:00[Asia/Tokyo]
Mateix instant?      true
Mateix instant?      false

package com.nexussoftware.bibliotech.presentacio;

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

public class RellotgeMundialBiblioTech {

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

    public static void main(String[] args) {

        Instant ara = Instant.now();

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

        System.out.println("Seus de Nexus Software -- instant: " + ara);
        System.out.println("-".repeat(62));

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

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

package com.nexussoftware.bibliotech;

import java.time.*;

public class HoraQueNoExisteix {

    public static void main(String[] args) {

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

        // 29 de marc de 2026: canvi a horari d estiu
        LocalDateTime inexistent = LocalDateTime.of(2026, 3, 29, 2, 30);

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

        ZonedDateTime resultat = inexistent.atZone(madrid);
        System.out.println("atZone():       " + resultat);
        System.out.println("Desfasament:    " + resultat.getOffset());

        // Comprovar ho explicitament
        var regles = madrid.getRules();
        System.out.println("Es un forat?    " + (regles.getTransition(inexistent) != null));
        System.out.println("Durada salt:    "
                + regles.getTransition(inexistent).getDuration());
    }
}

LocalDateTime:  2026-03-29T02:30
atZone():       2026-03-29T03:30+02:00[Europe/Madrid]
Desfasament:    +02:00
Es un forat?    true
Durada salt:    PT1H

package com.nexussoftware.bibliotech;

import java.time.*;

public class HoraDuplicada {

    public static void main(String[] args) {

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

        // 25 d octubre de 2026: tornada a l horari d hivern
        LocalDateTime ambigua = LocalDateTime.of(2026, 10, 25, 2, 30);

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

        // Per defecte tria la PRIMERA ocurrencia (estiu, +02:00)
        ZonedDateTime perDefecte = ambigua.atZone(madrid);
        System.out.println("atZone() per defecte: " + perDefecte);

        // Eleccio explicita
        ZonedDateTime primera = ambigua.atZone(madrid).withEarlierOffsetAtOverlap();
        ZonedDateTime segona = ambigua.atZone(madrid).withLaterOffsetAtOverlap();

        System.out.println("Primera (estiu):      " + primera);
        System.out.println("Segona (hivern):      " + segona);
        System.out.println("Diferencia real:      "
                + Duration.between(primera.toInstant(), segona.toInstant()));

        var regles = madrid.getRules();
        System.out.println("Desfasaments valids:  " + regles.getValidOffsets(ambigua));
    }
}

LocalDateTime:        2026-10-25T02:30
atZone() per defecte: 2026-10-25T02:30+02:00[Europe/Madrid]
Primera (estiu):      2026-10-25T02:30+02:00[Europe/Madrid]
Segona (hivern):      2026-10-25T02:30+01:00[Europe/Madrid]
Diferencia real:      PT1H
Desfasaments valids:  [+02:00, +01:00]

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

System.out.println(data.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(ambZona.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
// 2026-08-05T09:30:45+02:00[Europe/Madrid]
System.out.println(ambZona.format(DateTimeFormatter.ISO_INSTANT));      // 2026-08-05T07:30:45Z
System.out.println(data.format(DateTimeFormatter.BASIC_ISO_DATE));      // 20260805

DateTimeFormatter catala = DateTimeFormatter.ofPattern("dd/MM/yyyy");
DateTimeFormatter ambHora = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");
DateTimeFormatter llegible = DateTimeFormatter.ofPattern("EEEE, d 'de' MMMM 'de' yyyy",
                                                         new Locale("ca", "ES"));

System.out.println(data.format(catala));         // 05/08/2026
System.out.println(completa.format(ambHora));    // 05/08/2026 09:30:45
System.out.println(data.format(llegible));       // dimecres, 5 de agost de 2026

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

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

// Sense formatador: s espera ISO-8601
LocalDate iso = LocalDate.parse("2026-08-05");

package com.nexussoftware.bibliotech.presentacio;

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

public class LectorDeDates {

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

    /** Retorna Optional en lloc de llancar: l entrada dolenta de l usuari es esperable (10-04). */
    public static Optional<LocalDate> llegir(String text) {
        if (text == null || text.isBlank()) {
            return Optional.empty();
        }
        try {
            return Optional.of(LocalDate.parse(text.strip(), ENTRADA));
        } catch (DateTimeParseException e) {
            System.out.printf("  Data no valida: \"%s\" (posicio %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", "cinc d agost", "  05/08/2026  " }) {

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

Entrada: "05/08/2026"
  -> 2026-08-05 (WEDNESDAY)
Entrada: "31/02/2026"
  Data no valida: "31/02/2026" (posicio 0: Text '31/02/2026' could not be parsed:
    Invalid date 'FEBRUARY 31')
  -> descartada
Entrada: "2026-08-05"
  Data no valida: "2026-08-05" (posicio 0: Text '2026-08-05' could not be parsed at index 2)
  -> descartada
Entrada: "cinc d agost"
  Data no valida: "cinc d agost" (posicio 0: ...)
  -> descartada
Entrada: "  05/08/2026  "
  -> 2026-08-05 (WEDNESDAY)

DateTimeFormatter tolerant = new DateTimeFormatterBuilder()
        .parseCaseInsensitive()                       // accepta "AG" i "ag"
        .appendPattern("dd/MM/yyyy")
        .optionalStart()                              // l hora es opcional
        .appendPattern(" HH:mm")
        .optionalEnd()
        .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)  // si falta, mitjanit
        .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
        .toFormatter(new Locale("ca", "ES"));

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

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

DateTimeFormatter senseLocale = DateTimeFormatter.ofPattern("EEEE d 'de' MMMM");
DateTimeFormatter ambCatala = DateTimeFormatter.ofPattern("EEEE d 'de' MMMM",
                                                          new Locale("ca", "ES"));
DateTimeFormatter ambCastella = DateTimeFormatter.ofPattern("EEEE d 'de' MMMM",
                                                            new Locale("es", "ES"));

System.out.println(data.format(senseLocale));    // Wednesday 5 de August  (si la JVM es en angles)
System.out.println(data.format(ambCatala));      // dimecres 5 de agost
System.out.println(data.format(ambCastella));    // miercoles 5 de agosto

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

System.out.println(data.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT).withLocale(ca)));
// 5/8/26
System.out.println(data.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(ca)));
// 5 d ag. 2026
System.out.println(data.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).withLocale(ca)));
// 5 d agost de 2026
System.out.println(data.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(ca)));
// dimecres, 5 d agost de 2026

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

System.out.println(DayOfWeek.WEDNESDAY.getDisplayName(TextStyle.FULL, ca));    // dimecres
System.out.println(DayOfWeek.WEDNESDAY.getDisplayName(TextStyle.SHORT, ca));   // dc.
System.out.println(Month.AUGUST.getDisplayName(TextStyle.FULL, ca));           // agost
System.out.println(Month.AUGUST.getDisplayName(TextStyle.SHORT, ca));          // ag.

// Date -> Instant -> java.time
Date dataAntiga = new Date();
Instant instant = dataAntiga.toInstant();
LocalDateTime local = instant.atZone(ZoneId.systemDefault()).toLocalDateTime();
LocalDate nomesData = instant.atZone(ZoneId.systemDefault()).toLocalDate();

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

// 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 InventariDeResguards {

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

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

    public record Resguard(Path cami, LocalDateTime modificat, long bytes) {

        public long diesAntiguitat(LocalDate avui) {
            return java.time.temporal.ChronoUnit.DAYS.between(modificat.toLocalDate(), avui);
        }
    }

    /** Llista els resguards amb la seva data real, no amb un FileTime opac. */
    public List<Resguard> inventariar(Path directori) throws IOException {
        try (Stream<Path> camins = Files.list(directori)) {
            return camins
                    .filter(Files::isRegularFile)
                    .filter(p -> p.getFileName().toString().endsWith(".bak"))
                    .map(this::descriure)
                    .sorted(java.util.Comparator.comparing(Resguard::modificat).reversed())
                    .toList();
        }
    }

    private Resguard descriure(Path cami) {
        try {
            BasicFileAttributes atributs = Files.readAttributes(cami, BasicFileAttributes.class);

            // FileTime -> Instant -> LocalDateTime a la zona de la biblioteca
            FileTime modificat = atributs.lastModifiedTime();
            LocalDateTime data = modificat.toInstant().atZone(ZONA).toLocalDateTime();

            return new Resguard(cami, data, atributs.size());

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

    /** Marca un fitxer amb una data concreta: java.time -> FileTime. */
    public void datarCom(Path fitxer, LocalDateTime quan) throws IOException {
        Instant instant = quan.atZone(ZONA).toInstant();
        Files.setLastModifiedTime(fitxer, FileTime.from(instant));
    }

    /** Esborra els resguards anteriors a la data de tall. */
    public int purgarAnteriorsA(Path directori, LocalDate tall) throws IOException {
        List<Resguard> caducats = inventariar(directori).stream()
                .filter(r -> r.modificat().toLocalDate().isBefore(tall))
                .toList();

        for (Resguard r : caducats) {
            Files.delete(r.cami());
        }
        return caducats.size();
    }

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

        InventariDeResguards inventari = new InventariDeResguards();
        LocalDate avui = LocalDate.now(ZONA);

        System.out.printf("%-28s %-18s %10s %8s%n",
                "FITXER", "MODIFICAT", "MIDA", "DIES");
        System.out.println("-".repeat(68));

        inventari.inventariar(Path.of("resguards")).forEach(r ->
                System.out.printf("%-28s %-18s %8d KB %8d%n",
                        r.cami().getFileName(),
                        r.modificat().format(FORMAT),
                        r.bytes() / 1024,
                        r.diesAntiguitat(avui)));

        LocalDate tall = avui.minusMonths(3).with(
                java.time.temporal.TemporalAdjusters.firstDayOfMonth());
        System.out.println("\nPurgant resguards anteriors a " + tall + "...");
        System.out.println("Eliminats: " + inventari.purgarAnteriorsA(Path.of("resguards"), tall));
    }
}

FITXER                       MODIFICAT                MIDA     DIES
--------------------------------------------------------------------
cataleg-20260804.bak         04/08/2026 03:00        1284 KB        1
cataleg-20260728.bak         28/07/2026 03:00        1271 KB        8
cataleg-20260630.bak         30/06/2026 03:00        1198 KB       36
cataleg-20260401.bak         01/04/2026 03:00        1044 KB      126

Purgant resguards anteriors a 2026-05-01...
Eliminats: 1

public class CalculadoraMultes {

    public double calcular(Prestec prestec) {
        LocalDate avui = LocalDate.now();                    // <-- el problema
        long retard = ChronoUnit.DAYS.between(prestec.getDataVenciment(), avui);
        return retard <= 0 ? 0.0 : retard * 0.25;
    }
}

// Rellotge del sistema a la zona per defecte
Clock sistema = Clock.systemDefaultZone();

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

// Rellotge FIX: sempre retorna el mateix instant
Clock fix = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"), ZoneId.of("Europe/Madrid"));

// Rellotge desplacat respecte a un altre
Clock dAqui30Dies = Clock.offset(sistema, Duration.ofDays(30));

// Rellotge amb granularitat reduida (util per a proves deterministes)
Clock perSegons = Clock.tickSeconds(ZoneId.of("Europe/Madrid"));

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

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Prestec;

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

/**
 * Calculadora de multes amb rellotge INJECTAT.
 * En produccio rep el rellotge del sistema; en proves, un de fix.
 */
public class CalculadoraMultes {

    private static final double EURO_PER_DIA = 0.25;
    private static final double SOSTRE = 20.0;
    private static final int DIES_DE_CORTESIA = 2;

    private final Clock rellotge;

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

    /** Constructor per a proves i per a escenaris amb zona explicita. */
    public CalculadoraMultes(Clock rellotge) {
        this.rellotge = java.util.Objects.requireNonNull(rellotge, "rellotge");
    }

    public LocalDate avui() {
        return LocalDate.now(rellotge);     // mai LocalDate.now() a seques
    }

    public long diesDeRetard(Prestec prestec) {
        long dies = ChronoUnit.DAYS.between(prestec.getDataVenciment(), avui());
        return Math.max(0, dies);
    }

    public double calcular(Prestec prestec) {
        long retard = diesDeRetard(prestec);
        if (retard <= DIES_DE_CORTESIA) {
            return 0.0;
        }
        return Math.min((retard - DIES_DE_CORTESIA) * EURO_PER_DIA, SOSTRE);
    }

    public boolean estaVencut(Prestec prestec) {
        return avui().isAfter(prestec.getDataVenciment());
    }

    public boolean venceEnElsProxims(Prestec prestec, int dies) {
        LocalDate limit = avui().plusDays(dies);
        LocalDate venciment = prestec.getDataVenciment();
        return !venciment.isBefore(avui()) && !venciment.isAfter(limit);
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.Prestec;
import com.nexussoftware.bibliotech.servei.CalculadoraMultes;

import java.time.*;

public class ProvaCalculadoraMultes {

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

    public static void main(String[] args) {

        // L "avui" de la prova es FIX: 5 d agost de 2026
        Clock avuiFix = Clock.fixed(Instant.parse("2026-08-05T10:00:00Z"), MADRID);
        CalculadoraMultes calculadora = new CalculadoraMultes(avuiFix);

        System.out.printf("%-24s %-12s %8s %10s%n",
                "CAS", "VENCIMENT", "RETARD", "MULTA");
        System.out.println("-".repeat(58));

        comprovar(calculadora, "Sense vencer",             LocalDate.of(2026, 8, 20));
        comprovar(calculadora, "Venc avui",                LocalDate.of(2026, 8,  5));
        comprovar(calculadora, "1 dia (cortesia)",         LocalDate.of(2026, 8,  4));
        comprovar(calculadora, "2 dies (cortesia)",        LocalDate.of(2026, 8,  3));
        comprovar(calculadora, "3 dies (primera multa)",   LocalDate.of(2026, 8,  2));
        comprovar(calculadora, "30 dies",                  LocalDate.of(2026, 7,  6));
        comprovar(calculadora, "1 any (sostre)",           LocalDate.of(2025, 8,  5));

        // I ara "viatgem" 100 dies al futur sense tocar el rellotge del sistema
        System.out.println("\n--- El mateix prestec, 100 dies despres ---");
        Clock futur = Clock.offset(avuiFix, Duration.ofDays(100));
        CalculadoraMultes enElFutur = new CalculadoraMultes(futur);
        System.out.println("Avui per a la calculadora: " + enElFutur.avui());
        comprovar(enElFutur, "Sense vencer (abans)", LocalDate.of(2026, 8, 20));
    }

    private static void comprovar(CalculadoraMultes c, String cas, LocalDate venciment) {
        Prestec p = new Prestec("PR-TEST", "978-0000000001", "Marta Ruiz",
                                venciment.minusDays(21), venciment);
        System.out.printf("%-24s %-12s %8d %8.2f €%n",
                cas, venciment, c.diesDeRetard(p), c.calcular(p));
    }
}

CAS                        VENCIMENT     RETARD      MULTA
----------------------------------------------------------
Sense vencer             2026-08-20          0     0,00 €
Venc avui                2026-08-05          0     0,00 €
1 dia (cortesia)         2026-08-04          1     0,00 €
2 dies (cortesia)        2026-08-03          2     0,00 €
3 dies (primera multa)   2026-08-02          3     0,25 €
30 dies                  2026-07-06         30     7,00 €
1 any (sostre)           2025-08-05        365    20,00 €

--- El mateix prestec, 100 dies despres ---
Avui per a la calculadora: 2026-11-13
Sense vencer (abans)     2026-08-20         85    20,00 €

package com.nexussoftware.bibliotech.domini;

import com.nexussoftware.bibliotech.anotacions.CampCsv;

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

/**
 * Prestec amb dates REALS.
 *
 * ABANS: private final int diaPrestec;
 *        private final int diaVenciment;
 * ARA:   LocalDate, perque un prestec es un fet de CALENDARI,
 *        no un instant: no l afecta l horari d estiu.
 */
public class Prestec implements Identificable {

    /** Termini estandard de prestec a Nexus Software. */
    public static final Period TERMINI_ESTANDARD = Period.ofDays(21);

    /** ISO-8601 per persistir: inequivoc a qualsevol pais i sistema. */
    private static final DateTimeFormatter ISO = DateTimeFormatter.ISO_LOCAL_DATE;

    @CampCsv(nom = "Referencia", ordre = 1)
    private final String referencia;

    @CampCsv(nom = "ISBN", ordre = 2)
    private final String isbn;

    @CampCsv(nom = "Empleat", ordre = 3, sensible = true)
    private final String empleat;

    @CampCsv(nom = "Data prestec", ordre = 4)
    private final LocalDate dataPrestec;

    @CampCsv(nom = "Data venciment", ordre = 5)
    private final LocalDate dataVenciment;

    /** Instant EXACTE del registre: per a auditoria es guarda Instant, no LocalDate. */
    private final Instant registratEl;

    private LocalDate dataDevolucio;                // null mentre continui prestat

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

    public Prestec(String referencia, String isbn, String empleat,
                   LocalDate dataPrestec, LocalDate dataVenciment) {
        this.referencia = Objects.requireNonNull(referencia, "referencia");
        this.isbn = Objects.requireNonNull(isbn, "isbn");
        this.empleat = Objects.requireNonNull(empleat, "empleat");
        this.dataPrestec = Objects.requireNonNull(dataPrestec, "dataPrestec");
        this.dataVenciment = Objects.requireNonNull(dataVenciment, "dataVenciment");

        if (dataVenciment.isBefore(dataPrestec)) {
            throw new IllegalArgumentException(
                    "El venciment (" + dataVenciment + ") no pot ser anterior "
                    + "al prestec (" + dataPrestec + ")");
        }
        this.registratEl = Instant.now();
    }

    /** Fabrica que aplica el termini estandard en dies HABILS. */
    public static Prestec ambTerminiEstandard(String referencia, String isbn,
                                              String empleat, LocalDate dataPrestec) {
        LocalDate venciment = dataPrestec.plus(TERMINI_ESTANDARD)
                .with(com.nexussoftware.bibliotech.servei
                        .AjustadorsBiblioTech.seguentDiaHabil());
        return new Prestec(referencia, isbn, empleat, dataPrestec, venciment);
    }

    // --- Consultes dependents de l "avui": SEMPRE reben la data ---

    /** Dies de retard. 0 si encara no ha vencut. */
    public long diesDeRetard(LocalDate avui) {
        LocalDate referencia = dataDevolucio != null ? dataDevolucio : avui;
        return Math.max(0, ChronoUnit.DAYS.between(dataVenciment, referencia));
    }

    public boolean teRetard(LocalDate avui) {
        return diesDeRetard(avui) > 0;
    }

    public boolean venceEn(LocalDate avui, int dies) {
        LocalDate limit = avui.plusDays(dies);
        return !dataVenciment.isBefore(avui) && !dataVenciment.isAfter(limit);
    }

    /** Descomposicio humana del temps transcorregut. */
    public Period antiguitat(LocalDate avui) {
        return Period.between(dataPrestec, avui);
    }

    public void retornar(LocalDate quan) {
        if (dataDevolucio != null) {
            throw new IllegalStateException(
                    "El prestec " + referencia + " ja es va retornar el " + dataDevolucio);
        }
        if (quan.isBefore(dataPrestec)) {
            throw new IllegalArgumentException("No es pot retornar abans de prestar");
        }
        this.dataDevolucio = quan;
    }

    // --- Serialitzacio: SEMPRE ISO-8601 ---

    public String aLiniaCsv() {
        return String.join(";",
                referencia, isbn, empleat,
                dataPrestec.format(ISO),
                dataVenciment.format(ISO),
                dataDevolucio == null ? "" : dataDevolucio.format(ISO),
                registratEl.toString());           // Instant.toString() ja es ISO
    }

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

    // --- Getters ---
    @Override public String getId() { return referencia; }
    public String getIsbn() { return isbn; }
    public String getEmpleat() { return empleat; }
    public LocalDate getDataPrestec() { return dataPrestec; }
    public LocalDate getDataVenciment() { return dataVenciment; }
    public Optional<LocalDate> getDataDevolucio() { return Optional.ofNullable(dataDevolucio); }
    public Instant getRegistratEl() { return registratEl; }
    public List<Incidencia> getIncidencies() { return List.copyOf(incidencies); }

    public record Incidencia(String descripcio, Gravetat gravetat, LocalDate quan) { }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Prestec;

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

public class ServeiAvisos {

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

    private final Clock rellotge;

    public ServeiAvisos(Clock rellotge) {
        this.rellotge = Objects.requireNonNull(rellotge);
    }

    private LocalDate avui() {
        return LocalDate.now(rellotge);
    }

    /** Prestecs que vencen els proxims N dies, agrupats per empleat. */
    public Map<String, List<Prestec>> avisosDeVenciment(List<Prestec> prestecs, int dies) {
        LocalDate limit = avui().plusDays(dies);
        return prestecs.stream()
                .filter(p -> p.getDataDevolucio().isEmpty())
                .filter(p -> !p.getDataVenciment().isBefore(avui()))
                .filter(p -> !p.getDataVenciment().isAfter(limit))
                .collect(Collectors.groupingBy(Prestec::getEmpleat, TreeMap::new,
                         Collectors.toList()));
    }

    /** L avis s envia el seguent dia HABIL: ningu no llegeix correus el diumenge. */
    public LocalDate quanEnviarAvis(Prestec prestec, int diesDAntelacio) {
        return prestec.getDataVenciment()
                .minusDays(diesDAntelacio)
                .with(AjustadorsBiblioTech.seguentDiaHabil());
    }

    /** Data de l informe mensual: ultim divendres del mes. */
    public LocalDate dataInformeMensual() {
        return avui().with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY));
    }

    /** Data de l inventari trimestral: primer dilluns del proxim trimestre. */
    public LocalDate dataInventariTrimestral() {
        LocalDate avui = avui();
        int mesActual = avui.getMonthValue();
        int primerMesDelProximTrimestre = ((mesActual - 1) / 3 + 1) * 3 + 1;

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

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

    public String redactarAvis(String empleat, List<Prestec> prestecs) {
        StringBuilder sb = new StringBuilder();
        sb.append("Benvolgut/da ").append(empleat).append(":\n\n");
        sb.append("Us recordem que teniu ").append(prestecs.size())
          .append(prestecs.size() == 1 ? " material pendent" : " materials pendents")
          .append(" de devolucio:\n\n");

        prestecs.stream()
                .sorted(Comparator.comparing(Prestec::getDataVenciment))
                .forEach(p -> {
                    long dies = java.time.temporal.ChronoUnit.DAYS
                            .between(avui(), p.getDataVenciment());
                    sb.append(String.format("  - %s   venc el %s (%s)%n",
                            p.getIsbn(),
                            p.getDataVenciment().format(LLEGIBLE),
                            dies == 0 ? "avui" : "d aqui a " + dies + (dies == 1 ? " dia" : " dies")));
                });

        sb.append("\nBiblioTech -- Nexus Software\n");
        sb.append("Generat el ").append(avui().format(LLEGIBLE)).append('\n');
        return sb.toString();
    }
}

package com.nexussoftware.bibliotech.persistencia;

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

/**
 * Configuracio (07-07) amb la zona horaria de la biblioteca EXPLICITA.
 * Dependre de ZoneId.systemDefault() significa que el comportament
 * canvia en desplegar en un servidor configurat en UTC.
 */
public class ConfiguracioTemporal {

    private final ZoneId zona;
    private final Clock rellotge;
    private final LocalTime oberturaBiblioteca;
    private final LocalTime tancamentBiblioteca;
    private final Period terminiDePrestec;

    public ConfiguracioTemporal(Properties propietats) {
        this.zona = ZoneId.of(propietats.getProperty("bibliotech.zona", "Europe/Madrid"));
        this.rellotge = Clock.system(zona);
        this.oberturaBiblioteca = LocalTime.parse(
                propietats.getProperty("bibliotech.obertura", "09:00"));
        this.tancamentBiblioteca = LocalTime.parse(
                propietats.getProperty("bibliotech.tancament", "20:00"));
        this.terminiDePrestec = Period.parse(
                propietats.getProperty("bibliotech.termini", "P21D"));
    }

    public ZoneId zona() { return zona; }
    public Clock rellotge() { return rellotge; }
    public Period terminiDePrestec() { return terminiDePrestec; }

    public boolean estaOberta(LocalDateTime quan) {
        DayOfWeek dia = quan.getDayOfWeek();
        if (dia == DayOfWeek.SATURDAY || dia == DayOfWeek.SUNDAY) {
            return false;
        }
        LocalTime hora = quan.toLocalTime();
        return !hora.isBefore(oberturaBiblioteca) && hora.isBefore(tancamentBiblioteca);
    }

    public boolean estaObertaAra() {
        return estaOberta(LocalDateTime.now(rellotge));
    }
}

# bibliotech.properties
bibliotech.zona=Europe/Madrid
bibliotech.obertura=09:00
bibliotech.tancament=20:00
bibliotech.termini=P21D

Referencia;ISBN;Empleat;Data prestec;Data venciment;Data devolucio;Registrat el
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.servei;

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;

/**
 * Calendari laboral de la biblioteca de Nexus Software.
 * Rellotge injectat: provable de manera determinista.
 */
public class CalendariBiblioTech {

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

    /** Festius de data FIXA: MonthDay, perque es repeteixen cada any. */
    private static final Map<MonthDay, String> FESTIUS_FIXOS = Map.ofEntries(
            Map.entry(MonthDay.of(1, 1),   "Cap d Any"),
            Map.entry(MonthDay.of(1, 6),   "Reis"),
            Map.entry(MonthDay.of(5, 1),   "Dia del Treball"),
            Map.entry(MonthDay.of(8, 15),  "Assumpcio"),
            Map.entry(MonthDay.of(10, 12), "Festa Nacional"),
            Map.entry(MonthDay.of(11, 1),  "Tots Sants"),
            Map.entry(MonthDay.of(12, 6),  "Constitucio"),
            Map.entry(MonthDay.of(12, 8),  "Immaculada"),
            Map.entry(MonthDay.of(12, 25), "Nadal"));

    private final Clock rellotge;

    /** Cache de festius mobils per any: el calcul no canvia mai. */
    private final Map<Integer, Map<LocalDate, String>> mobilsPerAny = new HashMap<>();

    public CalendariBiblioTech(Clock rellotge) {
        this.rellotge = Objects.requireNonNull(rellotge, "rellotge");
    }

    public LocalDate avui() {
        return LocalDate.now(rellotge);
    }

    // ------------------------------------------------------------------
    // 1. Dies habils i festius
    // ------------------------------------------------------------------

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

    public Optional<String> nomDelFestiu(LocalDate data) {
        String fix = FESTIUS_FIXOS.get(MonthDay.from(data));
        if (fix != null) {
            return Optional.of(fix);
        }
        return Optional.ofNullable(festiusMobils(data.getYear()).get(data));
    }

    public boolean esFestiu(LocalDate data) {
        return nomDelFestiu(data).isPresent();
    }

    public boolean esHabil(LocalDate data) {
        return !esCapDeSetmana(data) && !esFestiu(data);
    }

    /**
     * Algorisme de Butcher (o de Meeus/Jones/Butcher) per al diumenge de Pasqua
     * al calendari gregoria. A partir d ell se n deriven els altres.
     */
    private Map<LocalDate, String> festiusMobils(int any) {
        return mobilsPerAny.computeIfAbsent(any, y -> {
            LocalDate pasqua = diumengeDePasqua(y);
            Map<LocalDate, String> mobils = new LinkedHashMap<>();
            mobils.put(pasqua.minusDays(3), "Dijous Sant");
            mobils.put(pasqua.minusDays(2), "Divendres Sant");
            mobils.put(pasqua.plusDays(1),  "Dilluns de Pasqua");
            return mobils;
        });
    }

    public static LocalDate diumengeDePasqua(int any) {
        int a = any % 19;
        int b = any / 100;
        int c = any % 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(any, mes, dia);
    }

    // ------------------------------------------------------------------
    // 2. Navegacio per dies habils
    // ------------------------------------------------------------------

    public LocalDate seguentHabil(LocalDate des) {
        LocalDate data = des;
        while (!esHabil(data)) {
            data = data.plusDays(1);
        }
        return data;
    }

    public LocalDate sumarDiesHabils(LocalDate des, int dies) {
        if (dies < 0) {
            throw new IllegalArgumentException("Dies negatius: " + dies);
        }
        LocalDate data = des;
        int restants = dies;
        while (restants > 0) {
            data = data.plusDays(1);
            if (esHabil(data)) {
                restants--;
            }
        }
        return data;
    }

    // ------------------------------------------------------------------
    // 3-5. Consultes agregades amb streams (10-04)
    // ------------------------------------------------------------------

    /** datesUntil (Java 9) retorna un Stream<LocalDate>: el pont amb 10-04. */
    public long diesHabilsEntre(LocalDate des, LocalDate finsExclusiu) {
        return des.datesUntil(finsExclusiu)
                  .filter(this::esHabil)
                  .count();
    }

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

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

    // ------------------------------------------------------------------
    // 6. Calendari visual
    // ------------------------------------------------------------------

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

        String titol = mes.getMonth().getDisplayName(TextStyle.FULL, CA).toUpperCase()
                + " " + mes.getYear();
        sb.append(String.format("%s%n", centrar(titol, 28)));
        sb.append(" Dl  Dt  Dc  Dj  Dv  Ds  Dg\n");

        LocalDate primer = mes.atDay(1);
        // getValue(): 1 = dilluns ... 7 = diumenge (ISO)
        int foratInicial = primer.getDayOfWeek().getValue() - 1;
        sb.append("    ".repeat(foratInicial));

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

            String marca;
            if (esFestiu(data))              marca = "*";     // festiu
            else if (esCapDeSetmana(data))   marca = ".";     // cap de setmana
            else                             marca = " ";     // habil

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

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

        long habils = diesHabilsEntre(mes.atDay(1), mes.plusMonths(1).atDay(1));
        sb.append(String.format("%nDies habils: %d de %d   (* festiu, . cap de setmana)%n",
                habils, mes.lengthOfMonth()));

        festiusDe(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 text, int amplada) {
        int esquerra = Math.max(0, (amplada - text.length()) / 2);
        return " ".repeat(esquerra) + text;
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.servei.CalendariBiblioTech;

import java.time.*;

public class ProvaCalendari {

    public static void main(String[] args) {

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

        System.out.println("Avui: " + calendari.avui() + " ("
                + calendari.avui().getDayOfWeek() + "), habil: "
                + calendari.esHabil(calendari.avui()));

        System.out.println("\nPasqua 2026: " + CalendariBiblioTech.diumengeDePasqua(2026));
        System.out.println("Pasqua 2027: " + CalendariBiblioTech.diumengeDePasqua(2027));

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

        System.out.println("\n--- Dies habils per mes el 2026 ---");
        calendari.habilsPerMes(2026).forEach((mes, n) ->
                System.out.printf("  %-12s %2d %s%n", mes, n, "#".repeat(n.intValue())));

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

        System.out.println("--- Navegacio ---");
        LocalDate divendres = LocalDate.of(2026, 8, 14);
        System.out.println("Divendres 14/08:          " + divendres);
        System.out.println("Seguent habil des del 15: "
                + calendari.seguentHabil(divendres.plusDays(1)));
        System.out.println("+10 dies habils:          "
                + calendari.sumarDiesHabils(divendres, 10));
    }
}

Avui: 2026-08-05 (WEDNESDAY), habil: true

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

--- Festius de 2026 ---
  2026-01-01  Cap d Any          (THURSDAY)
  2026-01-06  Reis               (TUESDAY)
  2026-04-02  Dijous Sant        (THURSDAY)
  2026-04-03  Divendres Sant     (FRIDAY)
  2026-04-06  Dilluns de Pasqua  (MONDAY)
  2026-05-01  Dia del Treball    (FRIDAY)
  2026-08-15  Assumpcio          (SATURDAY)
  2026-10-12  Festa Nacional     (MONDAY)
  2026-11-01  Tots Sants         (SUNDAY)
  2026-12-06  Constitucio        (SUNDAY)
  2026-12-08  Immaculada         (TUESDAY)
  2026-12-25  Nadal              (FRIDAY)

--- Dies habils per mes el 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
 Dl  Dt  Dc  Dj  Dv  Ds  Dg
              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

Dies habils: 19 de 30   (* festiu, . cap de setmana)
  2  Dijous Sant
  3  Divendres Sant
  6  Dilluns de Pasqua

            AGOST 2026
 Dl  Dt  Dc  Dj  Dv  Ds  Dg
                  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

Dies habils: 21 de 31   (* festiu, . cap de setmana)
  15  Assumpcio

--- Navegacio ---
Divendres 14/08:          2026-08-14
Seguent habil des del 15: 2026-08-17
+10 dies habils:          2026-08-31

package com.nexussoftware.bibliotech.domini;

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

/**
 * Reserva de sala amb zona horaria explicita.
 * ZonedDateTime perque cal respectar l horari laboral LOCAL
 * de cada seu i el canvi d hora.
 */
public record Reserva(String id, String sala, String empleat,
                      ZonedDateTime inici, Duration durada) {

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

    public Reserva {
        Objects.requireNonNull(id, "id");
        Objects.requireNonNull(sala, "sala");
        Objects.requireNonNull(empleat, "empleat");
        Objects.requireNonNull(inici, "inici");
        Objects.requireNonNull(durada, "durada");
        if (durada.isNegative() || durada.isZero()) {
            throw new IllegalArgumentException("La durada ha de ser positiva: " + durada);
        }
        if (durada.toHours() > 8) {
            throw new IllegalArgumentException("Una reserva no pot durar mes de 8 hores");
        }
    }

    public ZonedDateTime fi() {
        return inici.plus(durada);
    }

    /**
     * Compara INSTANTS, no hores locals.
     * Aixi funciona encara que les dues reserves siguin en zones diferents
     * i encara que hi hagi canvi d horari pel mig.
     */
    public boolean solapaAmb(Reserva altra) {
        if (!sala.equals(altra.sala)) {
            return false;
        }
        Instant elMeuInici = inici.toInstant();
        Instant elMeuFi = fi().toInstant();
        Instant elSeuInici = altra.inici.toInstant();
        Instant elSeuFi = altra.fi().toInstant();

        return elMeuInici.isBefore(elSeuFi) && elSeuInici.isBefore(elMeuFi);
    }

    /** La mateixa reserva vista des d una altra zona: MATEIX instant, altre rellotge. */
    public Reserva vistaDes(ZoneId zona) {
        return new Reserva(id, sala, empleat, inici.withZoneSameInstant(zona), durada);
    }

    public String descriure() {
        return String.format("%-8s %-12s %-14s %s -- %s (%dh%02dm) [%s]",
                id, sala, empleat,
                inici.format(LLEGIBLE), fi().format(LLEGIBLE),
                durada.toHours(), durada.toMinutesPart(),
                inici.getZone());
    }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Reserva;

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

public class GestorReserves {

    /** Seu de cada sala: defineix el seu horari laboral local. */
    private static final Map<String, ZoneId> SEU_DE_LA_SALA = Map.of(
            "Madrid-A",  ZoneId.of("Europe/Madrid"),
            "Madrid-B",  ZoneId.of("Europe/Madrid"),
            "NovaYork-1", ZoneId.of("America/New_York"),
            "Toquio-1",  ZoneId.of("Asia/Tokyo"));

    private static final LocalTime OBERTURA  = LocalTime.of(8, 0);
    private static final LocalTime TANCAMENT = LocalTime.of(20, 0);

    private final List<Reserva> reserves = new ArrayList<>();
    private final Clock rellotge;

    public GestorReserves(Clock rellotge) {
        this.rellotge = Objects.requireNonNull(rellotge);
    }

    public Resultat<Reserva> reservar(String id, String sala, String empleat,
                                      ZonedDateTime inici, Duration durada) {

        ZoneId seu = SEU_DE_LA_SALA.get(sala);
        if (seu == null) {
            return Resultat.fallada("No existeix la sala '" + sala + "'");
        }

        // 1. No es reserva al passat: comparacio d INSTANTS
        if (inici.toInstant().isBefore(Instant.now(rellotge))) {
            return Resultat.fallada("No es pot reservar al passat (" + inici + ")");
        }

        Reserva candidata;
        try {
            candidata = new Reserva(id, sala, empleat, inici, durada);
        } catch (IllegalArgumentException e) {
            return Resultat.fallada(e.getMessage());
        }

        // 2. Horari laboral A LA ZONA DE LA SALA, no a la de qui reserva
        ZonedDateTime iniciLocal = inici.withZoneSameInstant(seu);
        ZonedDateTime fiLocal = candidata.fi().withZoneSameInstant(seu);

        if (esCapDeSetmana(iniciLocal)) {
            return Resultat.fallada(String.format(
                    "La sala %s esta tancada: %s es %s a %s",
                    sala, iniciLocal.toLocalDate(), iniciLocal.getDayOfWeek(), seu));
        }
        if (iniciLocal.toLocalTime().isBefore(OBERTURA)
                || fiLocal.toLocalTime().isAfter(TANCAMENT)
                || !iniciLocal.toLocalDate().equals(fiLocal.toLocalDate())) {
            return Resultat.fallada(String.format(
                    "Fora de l horari de %s (%s-%s hora local): %s a %s",
                    sala, OBERTURA, TANCAMENT,
                    iniciLocal.toLocalTime(), fiLocal.toLocalTime()));
        }

        // 3. Solapaments, comparant instants
        Optional<Reserva> conflicte = reserves.stream()
                .filter(candidata::solapaAmb)
                .findFirst();

        if (conflicte.isPresent()) {
            return Resultat.fallada("Solapa amb " + conflicte.get().id()
                    + " (" + conflicte.get().empleat() + ")");
        }

        reserves.add(candidata);
        return Resultat.exit(candidata);
    }

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

    /** Agenda d un empleat a LA SEVA zona horaria. */
    public String agendaPer(String empleat, ZoneId zonaDeLEmpleat) {
        List<Reserva> seves = reserves.stream()
                .filter(r -> r.empleat().equals(empleat))
                .map(r -> r.vistaDes(zonaDeLEmpleat))
                .sorted(Comparator.comparing(r -> r.inici().toInstant()))
                .toList();

        if (seves.isEmpty()) {
            return empleat + " no te reserves.";
        }

        StringBuilder sb = new StringBuilder();
        sb.append("Agenda de ").append(empleat)
          .append(" (horari de ").append(zonaDeLEmpleat).append(")\n");

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

        return sb.toString();
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.servei.*;

import java.time.*;

public class ProvaReservesMultizona {

    public static void main(String[] args) {

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

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

        System.out.println("Ara: " + ZonedDateTime.now(rellotge));
        System.out.println();

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

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

        // 3. Altra sala a la mateixa hora: SENSE solapament
        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 Toquio reservada DES DE MADRID a les 3 de la matinada hora de Madrid
        //    = 10:00 hora de Toquio: horari laboral CORRECTE alla
        mostrar(gestor.reservar("R-004", "Toquio-1", "Nuria Vidal",
                ZonedDateTime.of(2026, 8, 6, 3, 0, 0, 0, madrid), Duration.ofHours(1)));

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

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

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

        // 8. Al passat
        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.agendaPer("Marta Ruiz", madrid));
        System.out.println(gestor.agendaPer("Marta Ruiz", toquio));

        // --- El cas del canvi d horari ---
        System.out.println("--- Reserva la nit del canvi d horari ---");
        ZonedDateTime nitDelCanvi = ZonedDateTime.of(2026, 10, 25, 1, 30, 0, 0, madrid);
        System.out.println("Inici:   " + nitDelCanvi);
        System.out.println("+2 hores (Duration): " + nitDelCanvi.plus(Duration.ofHours(2)));
        System.out.println("Desfasaments valids a les 02:30: "
                + madrid.getRules().getValidOffsets(LocalDateTime.of(2026, 10, 25, 2, 30)));
    }

    private static void mostrar(Resultat<com.nexussoftware.bibliotech.domini.Reserva> r) {
        if (r.esExit()) {
            System.out.println("OK      " + r.valor().descriure());
        } else {
            System.out.println("REBUIG  " + r.error());
        }
    }
}

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

OK      R-001    Madrid-A     Marta Ruiz     dc. 05/08 10:00 -- dc. 05/08 12:00 (2h00m) [Europe/Madrid]
REBUIG  Solapa amb R-001 (Marta Ruiz)
OK      R-003    Madrid-B     Diego Alonso   dc. 05/08 11:00 -- dc. 05/08 12:00 (1h00m) [Europe/Madrid]
OK      R-004    Toquio-1     Nuria Vidal    dj. 06/08 03:00 -- dj. 06/08 04:00 (1h00m) [Europe/Madrid]
OK      R-005    Toquio-1     Marta Ruiz     dj. 06/08 10:00 -- dj. 06/08 11:00 (1h00m) [Europe/Madrid]
REBUIG  Fora de l horari de Toquio-1 (08:00-20:00 hora local): 23:00 a 00:00
REBUIG  La sala NovaYork-1 esta tancada: 2026-08-08 es SATURDAY a America/New_York
REBUIG  No es pot reservar al passat (2026-08-01T10:00+02:00[Europe/Madrid])

Agenda de Marta Ruiz (horari de Europe/Madrid)
  2026-08-05:
    R-001    Madrid-A     Marta Ruiz     dc. 05/08 10:00 -- dc. 05/08 12:00 (2h00m) [Europe/Madrid]
  2026-08-06:
    R-005    Toquio-1     Marta Ruiz     dj. 06/08 10:00 -- dj. 06/08 11:00 (1h00m) [Europe/Madrid]

Agenda de Marta Ruiz (horari de Asia/Tokyo)
  2026-08-05:
    R-001    Madrid-A     Marta Ruiz     dc. 05/08 17:00 -- dc. 05/08 19:00 (2h00m) [Asia/Tokyo]
  2026-08-06:
    R-005    Toquio-1     Marta Ruiz     dj. 06/08 17:00 -- dj. 06/08 18:00 (1h00m) [Asia/Tokyo]

--- Reserva la nit del canvi d horari ---
Inici:   2026-10-25T01:30+02:00[Europe/Madrid]
+2 hores (Duration): 2026-10-25T02:30+01:00[Europe/Madrid]
Desfasaments valids a les 02:30: [+02:00, +01:00]

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Prestec;

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 prestecs.
 * java.time (10-05) + streams (10-04) + Clock injectat.
 */
public class InformeTemporal {

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

    private final Clock rellotge;
    private final List<Prestec> prestecs;

    public InformeTemporal(Clock rellotge, List<Prestec> prestecs) {
        this.rellotge = Objects.requireNonNull(rellotge);
        this.prestecs = List.copyOf(prestecs);
    }

    private LocalDate avui() {
        return LocalDate.now(rellotge);
    }

    // --- 1. Prestecs per mes ---
    public Map<YearMonth, Long> perMes() {
        return prestecs.stream()
                .collect(Collectors.groupingBy(
                        p -> YearMonth.from(p.getDataPrestec()),
                        TreeMap::new,                      // ordre cronologic
                        Collectors.counting()));
    }

    // --- 2. Durada mitjana real dels retornats ---
    public OptionalDouble duradaMitjanaRetornats() {
        return prestecs.stream()
                .filter(p -> p.getDataDevolucio().isPresent())
                .mapToLong(p -> ChronoUnit.DAYS.between(
                        p.getDataPrestec(), p.getDataDevolucio().orElseThrow()))
                .average();
    }

    // --- 3. Distribucio per dia de la setmana ---
    public Map<DayOfWeek, Long> perDiaDeLaSetmana() {
        return prestecs.stream()
                .collect(Collectors.groupingBy(
                        p -> p.getDataPrestec().getDayOfWeek(),
                        () -> new EnumMap<>(DayOfWeek.class),
                        Collectors.counting()));
    }

    // --- 4. Els 5 amb mes retard ---
    public List<Prestec> mesRetardats(int n) {
        LocalDate avui = avui();
        return prestecs.stream()
                .filter(p -> p.getDataDevolucio().isEmpty())
                .filter(p -> p.teRetard(avui))
                .sorted(Comparator.comparingLong((Prestec p) -> p.diesDeRetard(avui)).reversed())
                .limit(n)
                .toList();
    }

    // --- 5. Vencen aquesta setmana (dilluns a diumenge) ---
    public List<Prestec> vencenAquestaSetmana() {
        LocalDate dilluns = avui().with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
        LocalDate diumenge = avui().with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));

        return prestecs.stream()
                .filter(p -> p.getDataDevolucio().isEmpty())
                .filter(p -> !p.getDataVenciment().isBefore(dilluns))
                .filter(p -> !p.getDataVenciment().isAfter(diumenge))
                .sorted(Comparator.comparing(Prestec::getDataVenciment))
                .toList();
    }

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

    // --- 7. Puntualitat per trimestre ---
    public record Puntualitat(long puntuals, long totals) {
        public double percentatge() {
            return totals == 0 ? 0.0 : puntuals * 100.0 / totals;
        }
    }

    public Map<String, Puntualitat> puntualitatPerTrimestre() {
        return prestecs.stream()
                .filter(p -> p.getDataDevolucio().isPresent())
                .collect(Collectors.groupingBy(
                        this::trimestreDe,
                        TreeMap::new,
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                llista -> new Puntualitat(
                                        llista.stream().filter(this::fouRetornatATemps).count(),
                                        llista.size()))));
    }

    private String trimestreDe(Prestec p) {
        LocalDate d = p.getDataDevolucio().orElseThrow();
        return d.getYear() + "-T" + ((d.getMonthValue() - 1) / 3 + 1);
    }

    private boolean fouRetornatATemps(Prestec p) {
        return !p.getDataDevolucio().orElseThrow().isAfter(p.getDataVenciment());
    }

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

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

        sb.append("=".repeat(64)).append('\n');
        sb.append("  INFORME TEMPORAL DE PRESTECS -- ")
          .append(avui.format(java.time.format.DateTimeFormatter
                  .ofPattern("d 'de' MMMM 'de' yyyy", CA))).append('\n');
        sb.append("=".repeat(64)).append('\n');

        sb.append("\n1. PRESTECS PER MES\n");
        perMes().forEach((mes, n) -> sb.append(String.format("   %s  %3d  %s%n",
                mes, n, "▇".repeat(n.intValue()))));

        sb.append("\n2. DURADA MITJANA DELS RETORNATS\n");
        duradaMitjanaRetornats().ifPresentOrElse(
                d -> sb.append(String.format("   %.1f dies%n", d)),
                () -> sb.append("   (encara no hi ha devolucions)\n"));

        sb.append("\n3. DIA DE LA SETMANA DEL PRESTEC\n");
        Map<DayOfWeek, Long> perDia = perDiaDeLaSetmana();
        long maxim = perDia.values().stream().mapToLong(Long::longValue).max().orElse(1);
        Arrays.stream(DayOfWeek.values()).forEach(d -> {
            long n = perDia.getOrDefault(d, 0L);
            sb.append(String.format("   %-11s %3d %s%n",
                    d.getDisplayName(TextStyle.FULL, CA), n,
                    "▇".repeat((int) (n * 24 / maxim))));
        });

        sb.append("\n4. ELS 5 AMB MES RETARD\n");
        List<Prestec> retardats = mesRetardats(5);
        if (retardats.isEmpty()) {
            sb.append("   (cap prestec amb retard)\n");
        } else {
            retardats.forEach(p -> sb.append(String.format("   %-14s %-14s venc %s  %3d dies%n",
                    p.getId(), p.getEmpleat(), p.getDataVenciment(), p.diesDeRetard(avui))));
        }

        sb.append("\n5. VENCEN AQUESTA SETMANA\n");
        List<Prestec> setmana = vencenAquestaSetmana();
        if (setmana.isEmpty()) {
            sb.append("   (cap)\n");
        } else {
            setmana.forEach(p -> sb.append(String.format("   %-14s %-14s %s (%s)%n",
                    p.getId(), p.getEmpleat(), p.getDataVenciment(),
                    p.getDataVenciment().getDayOfWeek().getDisplayName(TextStyle.FULL, CA))));
        }

        sb.append("\n6. MAPA DE CALOR (mes x dia)\n");
        sb.append("            Dl  Dt  Dc  Dj  Dv  Ds  Dg\n");
        mapaDeCalor().forEach((mes, perDiaDelMes) -> {
            sb.append(String.format("   %-9s",
                    mes.getDisplayName(TextStyle.SHORT, CA)));
            Arrays.stream(DayOfWeek.values()).forEach(d ->
                    sb.append(String.format("%4d", perDiaDelMes.getOrDefault(d, 0L))));
            sb.append('\n');
        });

        sb.append("\n7. PUNTUALITAT PER TRIMESTRE\n");
        puntualitatPerTrimestre().forEach((trimestre, p) ->
                sb.append(String.format("   %-9s %3d/%-3d  %5.1f %%  %s%n",
                        trimestre, p.puntuals(), p.totals(), p.percentatge(),
                        "▇".repeat((int) (p.percentatge() / 5)))));

        return sb.toString();
    }
}

================================================================
  INFORME TEMPORAL DE PRESTECS -- 5 de agost de 2026
================================================================

1. PRESTECS PER MES
   2026-04    7  ▇▇▇▇▇▇▇
   2026-05   11  ▇▇▇▇▇▇▇▇▇▇▇
   2026-06    9  ▇▇▇▇▇▇▇▇▇
   2026-07   14  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   2026-08    4  ▇▇▇▇

2. DURADA MITJANA DELS RETORNATS
   18,4 dies

3. DIA DE LA SETMANA DEL PRESTEC
   dilluns      12 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   dimarts       8 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   dimecres      9 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   dijous        7 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   divendres     9 ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇
   dissabte      0
   diumenge      0

4. ELS 5 AMB MES RETARD
   PR-2026-0012   Diego Alonso   venc 2026-05-22   75 dies
   PR-2026-0019   Marta Ruiz     venc 2026-06-15   51 dies
   PR-2026-0027   Nuria Vidal    venc 2026-07-10   26 dies
   PR-2026-0031   Diego Alonso   venc 2026-07-24   12 dies
   PR-2026-0035   Marta Ruiz     venc 2026-08-03    2 dies

5. VENCEN AQUESTA SETMANA
   PR-2026-0035   Marta Ruiz     2026-08-03 (dilluns)
   PR-2026-0038   Nuria Vidal    2026-08-06 (dijous)
   PR-2026-0040   Diego Alonso   2026-08-07 (divendres)

6. MAPA DE CALOR (mes x dia)
            Dl  Dt  Dc  Dj  Dv  Ds  Dg
   abr.        2   1   2   1   1   0   0
   maig        3   2   2   2   2   0   0
   juny        2   2   2   1   2   0   0
   jul.        4   2   2   2   4   0   0
   ag.         1   1   1   1   0   0   0

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