@Service
public class GestorPrestecs {

    public void prestar(String isbn, Long idEmpleat, int dies) {
        // 1. Validacio d'entrada
        if (isbn == null || !isbn.matches("97[89]-\\d{10}")) {
            throw new IllegalArgumentException("ISBN invalid");
        }
        // 2. Acces a dades
        Material m = em.createQuery("select m from Material m where m.isbn = :i", Material.class)
                       .setParameter("i", isbn).getSingleResult();
        // 3. Regles de negoci
        long actius = em.createQuery("select count(p) from Prestec p where …").getSingleResult();
        if (actius >= 3) throw new LimitExceditException();
        // 4. Persistencia
        Prestec p = new Prestec(m, empleat, LocalDate.now(), LocalDate.now().plusDays(dies));
        em.persist(p);
        // 5. Notificacio
        smtp.enviar(empleat.getCorreu(), "Prestec confirmat", "Has agafat " + m.getTitol());
        // 6. Format de sortida
        System.out.printf("%-40s %s%n", m.getTitol(), p.getDataVenciment());
        // 7. Auditoria
        Files.writeString(Path.of("auditoria.log"), LocalDateTime.now() + " PRESTEC " + isbn + "\n",
                          StandardOpenOption.APPEND);
    }
}

// DOMINI: la regla, i nomes la regla
public class PoliticaPrestecs {
    private final int maximActius;

    public void verificarPotPrestar(Empleat empleat, List<Prestec> actius) {
        if (actius.size() >= maximActius) {
            throw new LimitPrestecsExceditException(empleat.getNom(), maximActius);
        }
        if (empleat.teMultesPendents()) {
            throw new MultesPendentsException(empleat.getNom());
        }
    }
}

// APLICACIO: orquestracio, i nomes orquestracio
public class GestorPrestecs implements GestionarPrestecs {

    private final RepositoriMaterials materials;
    private final RepositoriPrestecs prestecs;
    private final RepositoriEmpleats empleats;
    private final PoliticaPrestecs politica;
    private final NotificadorAvisos notificador;
    private final Clock rellotge;

    @Override
    public Prestec prestar(Isbn isbn, Long idEmpleat, int dies) {
        Material material = materials.cercarPerIsbn(isbn)
                .orElseThrow(() -> new MaterialNoTrobatException(isbn));
        Empleat empleat = empleats.cercarPerId(idEmpleat)
                .orElseThrow(() -> new EmpleatNoTrobatException(idEmpleat));

        politica.verificarPotPrestar(empleat, prestecs.actiusDe(empleat));

        Prestec prestec = Prestec.nou(material, empleat, LocalDate.now(rellotge), dies);
        prestecs.guardar(prestec);
        notificador.notificar(Avis.perPrestec(prestec));
        return prestec;
    }
}

public int diesDePrestec(Material material) {
    switch (material.getTipus()) {
        case LLIBRE:  return 15;
        case REVISTA: return 7;
        case DVD:     return 3;
        default: throw new IllegalStateException("Tipus desconegut: " + material.getTipus());
    }
}

public abstract class Material {
    // Cada subtipus respon per si mateix; la resta del sistema no canvia.
    public abstract int diesPrestecPerDefecte();
    public abstract Diner multaPerDia();
}

public class Llibre extends Material {
    @Override public int diesPrestecPerDefecte() { return 15; }
    @Override public Diner multaPerDia() { return Diner.euros("0.50"); }
}

public class Revista extends Material {
    @Override public int diesPrestecPerDefecte() { return 7; }
    @Override public Diner multaPerDia() { return Diner.euros("0.25"); }
}

public class Dvd extends Material {
    @Override public int diesPrestecPerDefecte() { return 3; }
    @Override public Diner multaPerDia() { return Diner.euros("1.00"); }
}

public class MaterialDeReferencia extends Llibre {

    @Override
    public Prestec prestarA(Empleat empleat, int dies) {
        throw new UnsupportedOperationException("Els materials de referencia no es presten");
    }
}

// Aquest metode era correcte. Ara peta en produccio quan en Diego Alonso
// afegeix un material de referencia al carret de prestec.
public void prestarTots(List<Material> materials, Empleat empleat) {
    for (Material m : materials) {
        m.prestarA(empleat, m.diesPrestecPerDefecte());   // UnsupportedOperationException
    }
}

/** No tot material es prestable. La capacitat es modela a part del tipus. */
public interface Prestable {
    Prestec prestarA(Empleat empleat, int dies);
    int diesPrestecPerDefecte();
}

public abstract class Material {                 // tots: titol, ISBN, ubicacio
    public abstract String getTitol();
    public abstract Isbn getIsbn();
}

public class Llibre extends Material implements Prestable { … }
public class MaterialDeReferencia extends Material { }   // simplement NO es Prestable

public void prestarTots(List<Prestable> materials, Empleat empleat) { … }
// Ja es IMPOSSIBLE passar-li un MaterialDeReferencia.

public interface GestioBiblioteca {
    Prestec prestar(Isbn isbn, Long idEmpleat, int dies);
    void retornar(Long idPrestec);
    void reservar(Isbn isbn, Long idEmpleat);
    void enviarAvis(Avis avis);
    InformeMensual generarInforme(YearMonth periode);
    void importarCataleg(Path fitxer);
    void exportarCataleg(Path desti);
}

public interface Prestable {
    Prestec prestarA(Empleat empleat, int dies);
}

public interface Notificable {
    String destiDeNotificacio();
}

public interface GestionarPrestecs {            // port d'entrada del cas d'us
    Prestec prestar(Isbn isbn, Long idEmpleat, int dies);
    void retornar(Long idPrestec);
}

public interface ConsultarCataleg {
    List<Material> cercar(CriteriCerca criteri);
    Optional<Material> perIsbn(Isbn isbn);
}

public class GestorPrestecs {
    // La politica d'alt nivell depen d'un detall de baix nivell.
    private final PrestecRepositoryJpa repositori = new PrestecRepositoryJpa();
    private final ClientMetadadesHttp metadades = new ClientMetadadesHttp();
}

public class GestorPrestecs {
    private final RepositoriPrestecs repositori;   // abstraccio definida al domini
    private final PassarelaMetadades metadades;

    public GestorPrestecs(RepositoriPrestecs repositori, PassarelaMetadades metadades) {
        this.repositori = repositori;
        this.metadades = metadades;
    }
}

// VIOLACIO: quatre nivells de profunditat. Coneixes tota l'estructura interna.
String ciutat = prestec.getEmpleat().getDepartament().getSeu().getAdreca().getCiutat();

// CORRECTE: cada objecte exposa el que li pregunten, i amaga com ho sap.
String ciutat = prestec.ciutatDeLempleat();

// a Prestec
public String ciutatDeLempleat() { return empleat.ciutat(); }
// a Empleat
public String ciutat() { return departament.ciutat(); }

public class ConfiguracioBiblioTech {

    private static final ConfiguracioBiblioTech INSTANCIA = new ConfiguracioBiblioTech();

    private ConfiguracioBiblioTech() { }           // ningu mes no la pot construir

    public static ConfiguracioBiblioTech getInstancia() { return INSTANCIA; }
}

public enum ConfiguracioBiblioTech {
    INSTANCIA;

    private final int diesPerDefecte = 15;
    public int diesPerDefecte() { return diesPerDefecte; }
}

public final class FabricaMaterials {

    private FabricaMaterials() { }

    public static Material desDe(RegistreImportacio registre) {
        return switch (registre.tipus()) {
            case LLIBRE  -> new Llibre(registre.titol(), new Isbn(registre.isbn()),
                                       registre.autor(), registre.pagines());
            case REVISTA -> new Revista(registre.titol(), new Isbn(registre.isbn()),
                                        registre.numero(), registre.periodicitat());
            case DVD     -> new Dvd(registre.titol(), new Isbn(registre.isbn()),
                                    registre.duracioMinuts());
        };
    }
}

public class Prestec {

    private Prestec(...) { }   // constructor privat: la creacio passa per les fabriques

    /** Prestec estandard, amb els dies per defecte del material. */
    public static Prestec nou(Material material, Empleat empleat, LocalDate avui) {
        return new Prestec(material, empleat, avui,
                           avui.plusDays(material.diesPrestecPerDefecte()),
                           EstatPrestec.ACTIU);
    }

    /** Prestec prorrogat per direccio: fins a 90 dies. */
    public static Prestec especial(Material material, Empleat empleat, LocalDate avui, int dies) {
        if (dies > 90) throw new IllegalArgumentException("Maxim 90 dies");
        return new Prestec(material, empleat, avui, avui.plusDays(dies), EstatPrestec.ACTIU);
    }
}

public interface FabricaExportacio {
    GeneradorInforme generador();
    FormatadorTaula formatadorTaula();
    String extensio();

    static FabricaExportacio per(Format format) {
        return switch (format) {
            case PDF  -> new FabricaPdf();
            case CSV  -> new FabricaCsv();
            case JSON -> new FabricaJson();
        };
    }
}

// Que significa el 15? I el true? I el segon null?
Prestec p = new Prestec(material, empleat, LocalDate.now(), 15, true, null, false, null, "Marta Ruiz");

public class Prestec {

    private final Material material;
    private final Empleat empleat;
    private final LocalDate dataPrestec;
    private final LocalDate dataVenciment;
    private final boolean renovable;
    private final String observacions;
    private final Empleat autoritzatPer;
    private final EstatPrestec estat;

    private Prestec(Builder b) {
        this.material = b.material;
        this.empleat = b.empleat;
        this.dataPrestec = b.dataPrestec;
        this.dataVenciment = b.dataVenciment;
        this.renovable = b.renovable;
        this.observacions = b.observacions;
        this.autoritzatPer = b.autoritzatPer;
        this.estat = EstatPrestec.ACTIU;
    }

    public static Builder de(Material material, Empleat empleat) {
        return new Builder(material, empleat);       // obligatoris a la fabrica del builder
    }

    public static class Builder {
        // Obligatoris: final, exigits al constructor del builder
        private final Material material;
        private final Empleat empleat;
        // Opcionals: amb valor per defecte sensat
        private LocalDate dataPrestec = LocalDate.now();
        private LocalDate dataVenciment;
        private boolean renovable = true;
        private String observacions = "";
        private Empleat autoritzatPer;

        private Builder(Material material, Empleat empleat) {
            this.material = Objects.requireNonNull(material, "material");
            this.empleat = Objects.requireNonNull(empleat, "empleat");
        }

        public Builder desDel(LocalDate data)      { this.dataPrestec = data; return this; }
        public Builder durant(int dies)            { this.dataVenciment = dataPrestec.plusDays(dies); return this; }
        public Builder finsA(LocalDate data)       { this.dataVenciment = data; return this; }
        public Builder noRenovable()               { this.renovable = false; return this; }
        public Builder ambObservacions(String o)   { this.observacions = o; return this; }
        public Builder autoritzatPer(Empleat e)    { this.autoritzatPer = e; return this; }

        public Prestec construir() {
            // La validacio de coherencia es fa UNA VEGADA, aqui:
            // aixi l'objecte construit es sempre valid.
            if (dataVenciment == null) {
                dataVenciment = dataPrestec.plusDays(material.diesPrestecPerDefecte());
            }
            if (dataVenciment.isBefore(dataPrestec)) {
                throw new IllegalStateException("El venciment no pot ser anterior al prestec");
            }
            if (!material.esPrestable() && autoritzatPer == null) {
                throw new IllegalStateException("Un material restringit requereix autoritzacio");
            }
            return new Prestec(this);
        }
    }
}

Prestec p = Prestec.de(javaEficac, martaRuiz)
        .desDel(LocalDate.of(2026, 3, 1))
        .durant(30)
        .noRenovable()
        .ambObservacions("Per al curs intern de Java")
        .autoritzatPer(nuriaVidal)
        .construir();

public record CriteriCerca(String titol, String autor, TipusMaterial tipus,
                           Integer anyInici, Integer anyFi, Boolean nomesDisponibles) {

    public static Builder builder() { return new Builder(); }

    public static class Builder {
        private String titol; private String autor; private TipusMaterial tipus;
        private Integer anyInici; private Integer anyFi;
        private Boolean nomesDisponibles = Boolean.FALSE;

        public Builder titol(String t) { this.titol = t; return this; }
        public Builder autor(String a) { this.autor = a; return this; }
        public Builder tipus(TipusMaterial t) { this.tipus = t; return this; }
        public Builder entre(int inici, int fi) { this.anyInici = inici; this.anyFi = fi; return this; }
        public Builder nomesDisponibles() { this.nomesDisponibles = true; return this; }

        public CriteriCerca construir() {
            return new CriteriCerca(titol, autor, tipus, anyInici, anyFi, nomesDisponibles);
        }
    }
}

public record CriteriCerca(String titol, String autor, TipusMaterial tipus, …) {

    public CriteriCerca ambTipus(TipusMaterial nou) {
        return new CriteriCerca(titol, autor, nou, anyInici, anyFi, nomesDisponibles);
    }
}

package com.nexussoftware.bibliotech.domini.cataleg.port;

public interface PassarelaMetadades {
    /** Buit si no hi ha metadades o si el servei no esta disponible. */
    Optional<MetadadesMaterial> cercar(Isbn isbn);
}

package com.nexussoftware.bibliotech.infraestructura.metadades;

@Component
class AdaptadorMetadadesHttp implements PassarelaMetadades {

    private static final Logger log = LoggerFactory.getLogger(AdaptadorMetadadesHttp.class);

    private final ClientMetadades client;     // l'"adaptee": la classe amb interficie incompatible

    AdaptadorMetadadesHttp(ClientMetadades client) { this.client = client; }

    @Override
    public Optional<MetadadesMaterial> cercar(Isbn isbn) {
        try {
            RespostaApiDto dto = client.consultarPerIsbn(isbn.valor());     // format extern

            // 1. Tradueix el model extern al del domini
            // 2. Tradueix les excepcions (frontera d'errors, 06-07)
            // 3. Aïlla el domini del fet que existeixin HTTP, JSON i aquesta API concreta
            return Optional.of(new MetadadesMaterial(
                    dto.title(),
                    dto.authors() == null ? List.of() : dto.authors(),
                    dto.publishedDate() == null ? null : Year.parse(dto.publishedDate().substring(0, 4)),
                    dto.pageCount()));

        } catch (RecursNoTrobatException e) {
            return Optional.empty();                     // "no hi ha dades" no es un error
        } catch (IOException | InterruptedException e) {
            if (e instanceof InterruptedException) Thread.currentThread().interrupt();
            log.warn("Metadades no disponibles per a {}: {}", isbn, e.getMessage());
            return Optional.empty();                     // degradacio elegant
        }
    }
}

// Cada embolcall AFEGEIX una capacitat a l'anterior, i tots son InputStream.
InputStream base       = Files.newInputStream(Path.of("cataleg.csv"));   // bytes crus
InputStream intermedi  = new BufferedInputStream(base);                  // + memoria intermedia
InputStream descomp    = new GZIPInputStream(intermedi);                 // + descompressio
Reader      lector     = new InputStreamReader(descomp, UTF_8);          // + codificacio
BufferedReader linies  = new BufferedReader(lector);                     // + readLine()

/**
 * Decorador: ES un RepositoriMaterials i TE un RepositoriMaterials.
 * Aquesta doble relacio es la signatura del patro.
 */
public class CatalegAmbCache implements RepositoriMaterials {

    private static final Logger log = LoggerFactory.getLogger(CatalegAmbCache.class);

    private final RepositoriMaterials delegat;
    private final Map<Isbn, Material> cache = new ConcurrentHashMap<>();   // modul 8

    public CatalegAmbCache(RepositoriMaterials delegat) {
        this.delegat = delegat;
    }

    @Override
    public Optional<Material> cercarPerIsbn(Isbn isbn) {
        Material enCache = cache.get(isbn);
        if (enCache != null) {
            log.debug("Encert de memoria cau per a {}", isbn);
            return Optional.of(enCache);
        }
        Optional<Material> resultat = delegat.cercarPerIsbn(isbn);
        resultat.ifPresent(m -> cache.put(isbn, m));
        return resultat;
    }

    @Override
    public List<Material> cercar(CriteriCerca criteri) {
        return delegat.cercar(criteri);        // les cerques no es desen: son variables
    }

    @Override
    public Material guardar(Material material) {
        cache.remove(material.getIsbn());      // invalidacio: el mes dificil d'una memoria cau
        return delegat.guardar(material);
    }
}

@Bean
RepositoriMaterials repositoriMaterials(RepositoriMaterialsJpa jpa, MeterRegistry registre) {
    return new CatalegAmbMetriques(          // 3r: mesura
             new CatalegAmbCache(            // 2n: desa a la memoria cau
               new CatalegAmbReintents(jpa, 3)));     // 1r: reintenta
}

// Proxy dinamic del modul 10-03: registra el temps de cada crida
@SuppressWarnings("unchecked")
public static <T> T ambCronometre(T objectiu, Class<T> interficie) {
    return (T) Proxy.newProxyInstance(
        interficie.getClassLoader(),
        new Class<?>[]{interficie},
        (proxy, metode, args) -> {
            long inici = System.nanoTime();
            try {
                return metode.invoke(objectiu, args);
            } finally {
                long ms = (System.nanoTime() - inici) / 1_000_000;
                LoggerFactory.getLogger(interficie).debug("{} ha trigat {} ms", metode.getName(), ms);
            }
        });
}

@Service
public class GestorPrestecs {
    @Transactional
    public Prestec prestar(Isbn isbn, Long idEmpleat, int dies) { … }
}

public interface ElementCataleg {
    String titol();
    int unitatsDisponibles();
}

public class Llibre implements ElementCataleg { … }               // fulla

public class ColleccioTematica implements ElementCataleg {        // compost
    private final String titol;
    private final List<ElementCataleg> elements;

    @Override
    public int unitatsDisponibles() {
        // Disponible si TOTS els seus elements ho estan: el minim mana
        return elements.stream().mapToInt(ElementCataleg::unitatsDisponibles).min().orElse(0);
    }
}

public Diner calcularMulta(Prestec p, LocalDate avui) {
    int retard = (int) ChronoUnit.DAYS.between(p.getDataVenciment(), avui);
    if (retard <= 0) return Diner.ZERO;

    if (p.getEmpleat().antiguitatEnMesos() < 6) {
        return Diner.euros("0.25").per(retard);
    } else if (p.getMaterial().esCritic()) {
        return Diner.euros("2.00").per(retard);
    } else if (p.getEmpleat().esDireccio()) {
        return Diner.ZERO;
    } else {
        return Diner.euros("0.50").per(retard);
    }
}

@FunctionalInterface
public interface ReglaTarifa {
    Diner calcular(int diesDeRetard, Prestec prestec);

    default boolean aplicaA(Prestec prestec) { return true; }
}

public class TarifaEstandard implements ReglaTarifa {
    @Override public Diner calcular(int dies, Prestec p) {
        return p.getMaterial().multaPerDia().per(dies).limitadaA(Diner.euros("20.00"));
    }
}

public class TarifaReduidaEmpleatNou implements ReglaTarifa {
    @Override public boolean aplicaA(Prestec p) { return p.getEmpleat().antiguitatEnMesos() < 6; }
    @Override public Diner calcular(int dies, Prestec p) { return Diner.euros("0.25").per(dies); }
}

public class TarifaExemptaDireccio implements ReglaTarifa {
    @Override public boolean aplicaA(Prestec p) { return p.getEmpleat().esDireccio(); }
    @Override public Diner calcular(int dies, Prestec p) { return Diner.ZERO; }
}

public class CalculadoraMultes {
    private final List<ReglaTarifa> regles;      // ordenades: la primera que aplica, guanya
    private final ReglaTarifa perDefecte = new TarifaEstandard();

    public CalculadoraMultes(List<ReglaTarifa> regles) { this.regles = List.copyOf(regles); }

    public Diner calcular(Prestec p, LocalDate avui) {
        int retard = (int) ChronoUnit.DAYS.between(p.getDataVenciment(), avui);
        if (retard <= 0) return Diner.ZERO;

        return regles.stream()
                .filter(r -> r.aplicaA(p))
                .findFirst()
                .orElse(perDefecte)
                .calcular(retard, p);
    }
}

@Component @Order(10) class TarifaExemptaDireccio implements ReglaTarifa { … }
@Component @Order(20) class TarifaReduidaEmpleatNou implements ReglaTarifa { … }

@Service
class CalculadoraMultes {
    private final List<ReglaTarifa> regles;
    CalculadoraMultes(List<ReglaTarifa> regles) { this.regles = regles; }   // Spring les injecta totes
}

public abstract class ImportadorCataleg {

    private static final Logger log = LoggerFactory.getLogger(ImportadorCataleg.class);

    private final RepositoriMaterials repositori;

    protected ImportadorCataleg(RepositoriMaterials repositori) {
        this.repositori = repositori;
    }

    /**
     * METODE PLANTILLA: defineix l'algorisme i es final perque ningu
     * no pugui alterar la sequencia. Nomes els passos son substituibles.
     */
    public final ResultatImportacio importar(Path origen) {
        log.info("Iniciant importacio des de {}", origen);
        long inici = System.nanoTime();

        int correctes = 0;
        List<ErrorImportacio> errors = new ArrayList<>();

        try (Origen o = obrir(origen)) {                        // PAS ABSTRACTE
            for (RegistreImportacio registre : llegirRegistres(o)) {   // PAS ABSTRACTE
                try {
                    if (!validar(registre)) {                   // GANXO amb implementacio per defecte
                        errors.add(ErrorImportacio.invalid(registre));
                        continue;
                    }
                    repositori.guardar(FabricaMaterials.desDe(registre));
                    correctes++;
                } catch (Exception e) {
                    errors.add(ErrorImportacio.de(registre, e));
                }
            }
        } catch (IOException e) {
            throw new ImportacioFallidaException(origen, e);
        }

        long ms = (System.nanoTime() - inici) / 1_000_000;
        enAcabar(correctes, errors);                            // GANXO opcional
        log.info("Importacio acabada: {} correctes, {} errors, {} ms",
                 correctes, errors.size(), ms);
        return new ResultatImportacio(correctes, errors, Duration.ofMillis(ms));
    }

    // --- Passos que cada subclasse HA d'aportar ---
    protected abstract Origen obrir(Path cami) throws IOException;
    protected abstract List<RegistreImportacio> llegirRegistres(Origen origen) throws IOException;

    // --- Ganxos: comportament per defecte, substituible ---
    protected boolean validar(RegistreImportacio r) {
        return r.isbn() != null && r.titol() != null && !r.titol().isBlank();
    }

    protected void enAcabar(int correctes, List<ErrorImportacio> errors) { }
}

public class ImportadorCsv extends ImportadorCataleg {

    private final char separador;

    @Override
    protected Origen obrir(Path cami) throws IOException {
        return new OrigenLector(Files.newBufferedReader(cami, StandardCharsets.UTF_8));
    }

    @Override
    protected List<RegistreImportacio> llegirRegistres(Origen origen) throws IOException {
        try (CSVReader csv = new CSVReaderBuilder(origen.lector())
                .withSkipLines(1)
                .withCSVParser(new CSVParserBuilder().withSeparator(separador).build())
                .build()) {
            return csv.readAll().stream().map(this::aRegistre).toList();
        }
    }
}

public interface OientDevolucio {
    void enRetornar(EsdevenimentDevolucio esdeveniment);
}

public class GestorPrestecs {
    private final List<OientDevolucio> oients = new CopyOnWriteArrayList<>();     // modul 8

    public void registrar(OientDevolucio oient) { oients.add(oient); }

    public void retornar(Long id) {
        Prestec p = …;
        p.registrarDevolucio(LocalDate.now(rellotge));
        prestecs.guardar(p);

        EsdevenimentDevolucio esdeveniment = new EsdevenimentDevolucio(p.getId(), p.getIsbn(), …);
        for (OientDevolucio oient : oients) {
            try {
                oient.enRetornar(esdeveniment);
            } catch (Exception e) {
                // Un oient que falla NO pot impedir que s'executin els altres
                log.error("L'oient {} ha fallat", oient.getClass().getSimpleName(), e);
            }
        }
    }
}

// L'esdeveniment: un record immutable
public record MaterialRetornat(Long idPrestec, Isbn isbn, Long idEmpleat,
                               LocalDate data, Diner multa) { }

// L'emissor: no coneix cap oient
@Service
public class GestorPrestecs {

    private final ApplicationEventPublisher esdeveniments;

    @Transactional
    public void retornar(Long id) {
        Prestec p = prestecs.cercarPerId(id).orElseThrow(…);
        Diner multa = p.registrarDevolucio(LocalDate.now(rellotge));
        prestecs.guardar(p);

        esdeveniments.publishEvent(new MaterialRetornat(p.getId(), p.getIsbn(),
                                                        p.getIdEmpleat(), LocalDate.now(rellotge), multa));
    }
}

// Els oients: independents, afegir-ne un no toca l'emissor
@Component
class ActivadorReserves {
    @EventListener
    void enRetornar(MaterialRetornat esdeveniment) {
        processadorReserves.activarSeguentReserva(esdeveniment.isbn());
    }
}

@Component
class ActualitzadorEstadistiques {
    // Nomes si la transaccio fa COMMIT: no volem comptar devolucions que es van desfer
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    void enRetornar(MaterialRetornat esdeveniment) {
        estadistiques.registrarDevolucio(esdeveniment);
    }
}

@Component
class NotificadorMultes {
    @Async                                     // en un altre fil: no bloqueja la resposta
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    void enRetornar(MaterialRetornat esdeveniment) {
        if (esdeveniment.multa().esPositiva()) {
            notificador.notificar(Avis.perMulta(esdeveniment));
        }
    }
}

public enum EstatPrestec {

    ACTIU {
        @Override public boolean permetRenovar()  { return true; }
        @Override public boolean permetRetornar() { return true; }
        @Override public EstatPrestec enRenovar() { return RENOVAT; }
    },
    RENOVAT {
        @Override public boolean permetRenovar()  { return false; }    // nomes una renovacio
        @Override public boolean permetRetornar() { return true; }
    },
    VENCUT {
        @Override public boolean permetRenovar()  { return false; }
        @Override public boolean permetRetornar() { return true; }
        @Override public boolean generaMulta()    { return true; }
    },
    RETORNAT {
        @Override public boolean esFinal() { return true; }
    },
    PERDUT {
        @Override public boolean esFinal() { return true; }
        @Override public boolean generaMulta() { return true; }
    };

    public boolean permetRenovar()  { return false; }
    public boolean permetRetornar() { return false; }
    public boolean generaMulta()    { return false; }
    public boolean esFinal()        { return false; }

    public EstatPrestec enRenovar() {
        throw new TransicioInvalidaException(this, "renovar");
    }
}

public void renovar(int dies) {
    if (!estat.permetRenovar()) {
        throw new TransicioInvalidaException(estat, "renovar");
    }
    this.dataVenciment = dataVenciment.plusDays(dies);
    this.estat = estat.enRenovar();
}

public interface Ordre {
    void executar();
    void desfer();
    String descripcio();
}

public class OrdrePrestar implements Ordre {

    private final GestionarPrestecs gestor;
    private final Isbn isbn;
    private final Long idEmpleat;
    private Long idPrestecCreat;        // estat necessari per desfer

    @Override
    public void executar() {
        this.idPrestecCreat = gestor.prestar(isbn, idEmpleat, 15).getId();
    }

    @Override
    public void desfer() {
        if (idPrestecCreat == null) throw new IllegalStateException("No executat");
        gestor.anullar(idPrestecCreat);
    }

    @Override
    public String descripcio() { return "Prestar " + isbn + " a l'empleat " + idEmpleat; }
}

public class HistorialOperacions {
    private final Deque<Ordre> pila = new ArrayDeque<>();        // 05-07/05-08

    public void executar(Ordre o) {
        o.executar();
        pila.push(o);
    }

    public void desferUltima() {
        if (pila.isEmpty()) throw new ResPerDesferException();
        pila.pop().desfer();
    }
}

public interface ValidadorImportacio {
    Optional<ErrorImportacio> validar(RegistreImportacio r);
}

@Service
class CadenaValidacio {
    private final List<ValidadorImportacio> validadors;     // Spring els injecta tots, ordenats

    public Optional<ErrorImportacio> validar(RegistreImportacio r) {
        return validadors.stream()
                .map(v -> v.validar(r))
                .flatMap(Optional::stream)
                .findFirst();               // el primer error talla la cadena
    }
}

public class CatalegPaginat implements Iterable<Material> {

    private final RepositoriMaterials repositori;
    private final int midaPagina;

    @Override
    public Iterator<Material> iterator() {
        return new Iterator<>() {
            private int pagina = 0;
            private Iterator<Material> actual = Collections.emptyIterator();

            @Override public boolean hasNext() {
                if (actual.hasNext()) return true;
                List<Material> seguent = repositori.pagina(pagina++, midaPagina);
                actual = seguent.iterator();
                return actual.hasNext();
            }

            @Override public Material next() {
                if (!hasNext()) throw new NoSuchElementException();
                return actual.next();
            }
        };
    }
}

// El client recorre 50.000 materials sense carregar-los tots a memoria
for (Material m : new CatalegPaginat(repositori, 500)) { … }

@Transactional
public void renovar(Long id, int dies) {
    Prestec p = prestecs.cercarPerId(id).orElseThrow(…);
    p.renovar(dies);
    // NO cal prestecs.guardar(p):
    // el context de persistencia (la unitat de treball) rastreja l'entitat
    // i fa l'UPDATE en fer flush, abans del commit.
}

public final class ConfigGlobal {
    public static int diesPrestec = 15;     // qualsevol el canvia, des de qualsevol fil
}

// MALAMENT: un gestor de prestecs NO ES una llista de prestecs.
public class GestorPrestecs extends ArrayList<Prestec> { … }

// ANEMIC: Prestec es una bossa de dades
public class Prestec {
    private LocalDate dataVenciment;
    private EstatPrestec estat;
    // 15 getters i 15 setters, zero comportament
}

@Service
public class GestorPrestecs {
    public void retornar(Prestec p, LocalDate avui) {
        // La regla de negoci viu FORA de l'objecte que la protegeix
        if (p.getEstat() == EstatPrestec.RETORNAT) throw new …;
        p.setDataDevolucio(avui);
        p.setEstat(EstatPrestec.RETORNAT);
    }
}

// RIC: l'objecte protegeix les seves propies regles
public class Prestec {
    public Diner registrarDevolucio(LocalDate data) {
        if (estat.esFinal()) throw new PrestecJaTancatException(id);
        if (data.isBefore(dataPrestec)) throw new DataInvalidaException(data);
        this.dataDevolucio = data;
        this.estat = EstatPrestec.RETORNAT;
        return multaFinsA(data);
    }
    // sense setters publics: es IMPOSSIBLE deixar l'objecte a mitges
}

@Service
public class ServeiExportacio {

    @Autowired private EntityManager em;
    @Autowired private JavaMailSender correu;

    public void exportar(String format, String desti, String correuDesti) throws Exception {
        List<Material> materials = em.createQuery("select m from Material m", Material.class)
                                     .getResultList();
        String contingut;

        if (format.equals("csv")) {
            StringBuilder sb = new StringBuilder("isbn;titol;tipus\n");
            for (Material m : materials) {
                sb.append(m.getIsbn()).append(';')
                  .append(m.getTitol()).append(';');
                if (m instanceof Llibre)       sb.append("LLIBRE");
                else if (m instanceof Revista) sb.append("REVISTA");
                else if (m instanceof Dvd)     sb.append("DVD");
                sb.append('\n');
            }
            contingut = sb.toString();
        } else if (format.equals("json")) {
            contingut = new ObjectMapper().writeValueAsString(materials);
        } else {
            throw new IllegalArgumentException("Format no suportat: " + format);
        }

        Files.writeString(Path.of(desti), contingut);

        if (correuDesti != null) {
            SimpleMailMessage m = new SimpleMailMessage();
            m.setTo(correuDesti);
            m.setSubject("Cataleg BiblioTech");
            m.setText("Adjunto el cataleg en format " + format);
            correu.send(m);
        }
        System.out.println("Exportats " + materials.size() + " materials");
    }
}

public abstract class Material {
    public abstract TipusMaterial tipus();   // adeu a l'instanceof
}
public class Llibre extends Material {
    @Override public TipusMaterial tipus() { return TipusMaterial.LLIBRE; }
}

public interface FormatadorCataleg {
    String formatar(List<Material> materials);
    Format format();
    String extensio();
}

@Component
class FormatadorCsv implements FormatadorCataleg {
    @Override public Format format()     { return Format.CSV; }
    @Override public String extensio()   { return "csv"; }

    @Override
    public String formatar(List<Material> materials) {
        return materials.stream()
                .map(m -> String.join(";", m.getIsbn().valor(), m.getTitol(), m.tipus().name()))
                .collect(Collectors.joining("\n", "isbn;titol;tipus\n", "\n"));
    }
}

@Component
class FormatadorJson implements FormatadorCataleg {
    private final ObjectMapper mapper;               // injectat: un de sol, reutilitzat

    FormatadorJson(ObjectMapper mapper) { this.mapper = mapper; }

    @Override public Format format()    { return Format.JSON; }
    @Override public String extensio()  { return "json"; }

    @Override
    public String formatar(List<Material> materials) {
        try {
            // DTO, no entitats (12-01)
            List<MaterialDto> dtos = materials.stream().map(MaterialDto::desDe).toList();
            return mapper.writeValueAsString(dtos);
        } catch (JsonProcessingException e) {
            throw new ExportacioFallidaException("No s'ha pogut serialitzar el cataleg", e);
        }
    }
}

public interface MagatzemExportacions {
    URI guardar(String nom, String contingut);
}

public interface NotificadorAvisos {
    void notificar(Avis avis);
}

@Service
public class ServeiExportacio {

    private static final Logger log = LoggerFactory.getLogger(ServeiExportacio.class);

    private final RepositoriMaterials materials;
    private final Map<Format, FormatadorCataleg> formatadors;
    private final MagatzemExportacions magatzem;
    private final NotificadorAvisos notificador;

    /** Spring injecta TOTS els formatadors; els indexem per format. */
    public ServeiExportacio(RepositoriMaterials materials,
                            List<FormatadorCataleg> formatadors,
                            MagatzemExportacions magatzem,
                            NotificadorAvisos notificador) {
        this.materials = materials;
        this.formatadors = formatadors.stream()
                .collect(Collectors.toUnmodifiableMap(FormatadorCataleg::format, f -> f));
        this.magatzem = magatzem;
        this.notificador = notificador;
    }

    public ResultatExportacio exportar(Format format, String nom, String correuDesti) {
        FormatadorCataleg formatador = formatadors.get(format);
        if (formatador == null) {
            throw new FormatNoSuportatException(format, formatadors.keySet());
        }

        List<Material> cataleg = materials.tots();
        String contingut = formatador.formatar(cataleg);
        URI ubicacio = magatzem.guardar(nom + "." + formatador.extensio(), contingut);

        if (correuDesti != null) {
            notificador.notificar(Avis.exportacioLlesta(correuDesti, format, ubicacio));
        }

        log.info("Exportats {} materials en format {} a {}", cataleg.size(), format, ubicacio);
        return new ResultatExportacio(cataleg.size(), ubicacio, format);
    }
}

/**
 * Decorador que limita la taxa de peticions a la passarela de metadades.
 *
 * Implementa una finestra lliscant: guarda la marca de temps de les
 * ultimes N peticions; si la mes antiga es dins de la finestra,
 * espera fins que en surti.
 *
 * ES una PassarelaMetadades i TE una PassarelaMetadades: decorador.
 */
public class PassarelaAmbLimitDeTaxa implements PassarelaMetadades {

    private static final Logger log = LoggerFactory.getLogger(PassarelaAmbLimitDeTaxa.class);

    private final PassarelaMetadades delegat;
    private final int maximPeticions;
    private final Duration finestra;
    private final Clock rellotge;                  // 10-05: injectable, per poder provar-ho

    /** Marques de temps de les ultimes peticions. Acces sempre sota el pany. */
    private final Deque<Instant> marques = new ArrayDeque<>();
    private final ReentrantLock pany = new ReentrantLock(true);   // just: ordre FIFO

    public PassarelaAmbLimitDeTaxa(PassarelaMetadades delegat, int maximPeticions,
                                   Duration finestra, Clock rellotge) {
        this.delegat = Objects.requireNonNull(delegat);
        if (maximPeticions < 1) throw new IllegalArgumentException("maximPeticions >= 1");
        this.maximPeticions = maximPeticions;
        this.finestra = Objects.requireNonNull(finestra);
        this.rellotge = Objects.requireNonNull(rellotge);
    }

    @Override
    public Optional<MetadadesMaterial> cercar(Isbn isbn) {
        adquirirPermis();                  // pot bloquejar
        return delegat.cercar(isbn);       // la crida real, ja fora del pany
    }

    private void adquirirPermis() {
        pany.lock();
        try {
            while (true) {
                Instant ara = Instant.now(rellotge);
                purgarAntigues(ara);

                if (marques.size() < maximPeticions) {
                    marques.addLast(ara);
                    return;
                }

                // La finestra esta plena: cal esperar que caduqui la mes antiga
                Instant mesAntiga = marques.peekFirst();
                Duration espera = Duration.between(ara, mesAntiga.plus(finestra));
                if (espera.isNegative() || espera.isZero()) continue;

                log.debug("Limit de taxa assolit; esperant {} ms", espera.toMillis());
                pany.unlock();                       // alliberar mentre dormim
                try {
                    Thread.sleep(espera.toMillis());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();     // regla del modul 8: restaurar la marca
                    throw new ConsultaInterrompudaException("Espera de limit de taxa interrompuda", e);
                } finally {
                    pany.lock();                     // recuperar abans de tornar al bucle
                }
            }
        } finally {
            pany.unlock();
        }
    }

    private void purgarAntigues(Instant ara) {
        Instant limit = ara.minus(finestra);
        while (!marques.isEmpty() && marques.peekFirst().isBefore(limit)) {
            marques.pollFirst();
        }
    }
}

@Bean
PassarelaMetadades passarelaMetadades(AdaptadorMetadadesHttp http, Clock rellotge, MeterRegistry registre) {
    return new PassarelaAmbMetriques(                    // 3r: mesura el temps total (inclosa l'espera)
             new PassarelaAmbLimitDeTaxa(                // 2n: no supera 10 per minut
               new PassarelaAmbCache(http, Duration.ofHours(24)),   // 1r: la memoria cau evita peticions
               10, Duration.ofMinutes(1), rellotge));
}

@Test
void esperaQuanSeSuperaElLimit() {
    var delegat = new PassarelaFalsa();
    var rellotge = Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), ZoneOffset.UTC);
    var passarela = new PassarelaAmbLimitDeTaxa(delegat, 2, Duration.ofSeconds(1), rellotge);

    long inici = System.nanoTime();
    passarela.cercar(Isbn.de("978-0000000001"));
    passarela.cercar(Isbn.de("978-0000000002"));
    passarela.cercar(Isbn.de("978-0000000003"));   // la tercera ha d'esperar ~1 s
    long ms = (System.nanoTime() - inici) / 1_000_000;

    assertThat(ms).isGreaterThanOrEqualTo(900);
    assertThat(delegat.crides()).isEqualTo(3);
}

public enum EstatReserva {

    /** A la cua, esperant que hi hagi un exemplar lliure. */
    PENDENT {
        @Override public boolean potCancellarse()     { return true; }
        @Override public boolean ocupaLlocACua()      { return true; }
        @Override public EstatReserva enHaverExemplar() { return DISPONIBLE; }
    },

    /** Hi ha exemplar apartat; l'empleat disposa de 48 hores. */
    DISPONIBLE {
        @Override public boolean potCancellarse()  { return true; }
        @Override public boolean potRecollirse()   { return true; }
        @Override public boolean potCaducar()      { return true; }
        @Override public boolean ocupaLlocACua()   { return true; }
        @Override public boolean teDataLimit()     { return true; }
        @Override public EstatReserva enRecollir() { return RECOLLIDA; }
        @Override public EstatReserva enCaducar()  { return CADUCADA; }
    },

    RECOLLIDA  { @Override public boolean esFinal() { return true; } },
    CADUCADA   { @Override public boolean esFinal() { return true; } },
    CANCELLADA { @Override public boolean esFinal() { return true; } };

    // --- Consultes: per defecte, res no esta permes ---
    public boolean potCancellarse() { return false; }
    public boolean potRecollirse()  { return false; }
    public boolean potCaducar()     { return false; }
    public boolean ocupaLlocACua()  { return false; }
    public boolean teDataLimit()    { return false; }
    public boolean esFinal()        { return false; }

    // --- Transicions: per defecte, invalides ---
    public EstatReserva enHaverExemplar() { throw new TransicioInvalidaException(this, "haver exemplar"); }
    public EstatReserva enRecollir()      { throw new TransicioInvalidaException(this, "recollir"); }
    public EstatReserva enCaducar()       { throw new TransicioInvalidaException(this, "caducar"); }

    /** Cancellar es l'unica transicio comuna a diversos estats. */
    public EstatReserva enCancellar() {
        if (!potCancellarse()) throw new TransicioInvalidaException(this, "cancellar");
        return CANCELLADA;
    }
}

@Entity
public class Reserva {

    private static final int HORES_PER_RECOLLIR = 48;

    @Id @GeneratedValue private Long id;
    @ManyToOne(fetch = FetchType.LAZY) private Material material;
    @ManyToOne(fetch = FetchType.LAZY) private Empleat empleat;
    @Enumerated(EnumType.STRING) private EstatReserva estat;
    private Instant dataSollicitud;
    private Instant dataLimitRecollida;       // nomes te sentit a DISPONIBLE
    @Version private long version;            // bloqueig optimista (11-03)

    protected Reserva() { }                   // exigit per JPA

    public static Reserva nova(Material material, Empleat empleat, Clock rellotge) {
        Reserva r = new Reserva();
        r.material = material;
        r.empleat = empleat;
        r.estat = EstatReserva.PENDENT;
        r.dataSollicitud = Instant.now(rellotge);
        return r;
    }

    public void assignarExemplar(Clock rellotge) {
        this.estat = estat.enHaverExemplar();         // valida i transita en una linia
        this.dataLimitRecollida = Instant.now(rellotge).plus(HORES_PER_RECOLLIR, ChronoUnit.HOURS);
    }

    public void recollir() {
        this.estat = estat.enRecollir();
        this.dataLimitRecollida = null;
    }

    public void cancellar() {
        this.estat = estat.enCancellar();
        this.dataLimitRecollida = null;
    }

    /** Retorna true si efectivament va caducar. Idempotent: si no escau, no fa res. */
    public boolean caducarSiEscau(Clock rellotge) {
        if (!estat.potCaducar()) return false;
        if (Instant.now(rellotge).isBefore(dataLimitRecollida)) return false;
        this.estat = estat.enCaducar();
        this.dataLimitRecollida = null;
        return true;
    }

    public boolean ocupaLlocACua() { return estat.ocupaLlocACua(); }
}

@Scheduled(cron = "0 */15 * * * *")     // cada 15 minuts
@Transactional
public void caducarReservesVencudes() {
    int caducades = 0;
    for (Reserva r : repositori.enEstat(EstatReserva.DISPONIBLE)) {
        if (r.caducarSiEscau(rellotge)) {
            caducades++;
            esdeveniments.publishEvent(new ReservaCaducada(r.getId()));   // Observador
        }
    }
    log.info("Reserves caducades: {}", caducades);
}