File f = new File("/dades/cataleg.txt");
if (!f.delete()) {
    // Per que? No existia? No tinc permis? Estava obert?
    // Era un directori no buit? L'API no ho diu.
}

File[] fills = directori.listFiles();
for (File f : fills) {          // NullPointerException si el directori no existeix
    // ...
}

// java.io: copiar un fitxer
try (InputStream in = new BufferedInputStream(new FileInputStream(origen));
     OutputStream out = new BufferedOutputStream(new FileOutputStream(desti))) {
    byte[] bloc = new byte[8192];
    int llegits;
    while ((llegits = in.read(bloc)) != -1) {
        out.write(bloc, 0, llegits);
    }
}

// NIO.2: el mateix
Files.copy(origen, desti, StandardCopyOption.REPLACE_EXISTING);

import java.nio.file.Path;
import java.nio.file.Paths;

public class ConstruirCamins {

    public static void main(String[] args) {
        // Java 11+: la forma recomanada
        Path p1 = Path.of("dades", "cataleg.txt");

        // Java 7-10: equivalent, encara molt comu en codi existent
        Path p2 = Paths.get("dades", "cataleg.txt");

        // Cami complet en una cadena
        Path p3 = Path.of("dades/informes/2026/gener.txt");

        // Cami absolut
        Path p4 = Path.of("/home/marta/bibliotech/dades/cataleg.txt");

        // Des d'un URI
        Path p5 = Path.of(java.net.URI.create("file:///home/marta/cataleg.txt"));

        System.out.println(p1);      // dades/cataleg.txt
        System.out.println(p1.equals(p2));   // true
    }
}

import java.nio.file.Path;

public class ConsultarCamins {

    public static void main(String[] args) {
        Path p = Path.of("/home/marta/bibliotech/dades/cataleg.txt");

        System.out.println("Cami complet   : " + p);
        System.out.println("Nom            : " + p.getFileName());      // cataleg.txt
        System.out.println("Directori      : " + p.getParent());        // .../dades
        System.out.println("Arrel          : " + p.getRoot());          // /
        System.out.println("Es absolut?    : " + p.isAbsolute());       // true
        System.out.println("Segments       : " + p.getNameCount());     // 5

        // Iterar els segments: Path es Iterable<Path>
        System.out.println("  Recorregut:");
        for (Path segment : p) {
            System.out.println("    " + segment);
        }

        // Acces per index
        System.out.println("Segment 0      : " + p.getName(0));         // home
        System.out.println("Segment 3      : " + p.getName(3));         // dades

        // Subcami [inici, fi)
        System.out.println("Subcami 1..3   : " + p.subpath(1, 3));      // marta/bibliotech

        // Comprovacions
        System.out.println("Comenca per /home? " + p.startsWith("/home"));   // true
        System.out.println("Acaba en .txt?     "
                + p.getFileName().toString().endsWith(".txt"));              // true
    }
}

Path p = Path.of("/home/marta/dades");
p.startsWith("/home/mar");      // false: "mar" no es un segment complet
p.startsWith("/home/marta");    // true

Path base = Path.of("/home/marta/bibliotech");

base.resolve("dades/cataleg.txt");
// /home/marta/bibliotech/dades/cataleg.txt

base.resolve("/etc/config");
// /etc/config   <-- si l'argument es ABSOLUT, substitueix la base

base.resolve("");
// /home/marta/bibliotech

Path cataleg = Path.of("/home/marta/bibliotech/dades/cataleg.txt");

cataleg.resolveSibling("cataleg.txt.tmp");
// /home/marta/bibliotech/dades/cataleg.txt.tmp

cataleg.resolveSibling("cataleg.bak");
// /home/marta/bibliotech/dades/cataleg.bak

Path base    = Path.of("/home/marta/bibliotech");
Path informe = Path.of("/home/marta/bibliotech/dades/informes/gener.txt");

base.relativize(informe);
// dades/informes/gener.txt

informe.relativize(base);
// ../../..

Path lleig = Path.of("/home/marta/./bibliotech/../bibliotech/dades/../dades/cataleg.txt");
lleig.normalize();
// /home/marta/bibliotech/dades/cataleg.txt

/**
 * Comprova que un cami demanat per l'usuari queda DINS del directori
 * de dades.
 *
 * Sense aquesta comprovacio, un nom com "../../etc/passwd" permetria sortir
 * del directori permes. Es la vulnerabilitat coneguda com a "path
 * traversal", i es de les mes frequents en aplicacions que accepten noms
 * de fitxer de l'usuari. La seguretat d'aplicacions es tracta a 12-07.
 */
public static Path resoldreSegur(Path directoriBase, String nomDemanat) {
    Path base = directoriBase.toAbsolutePath().normalize();
    Path candidat = base.resolve(nomDemanat).normalize();

    if (!candidat.startsWith(base)) {
        throw new IllegalArgumentException(
                "Cami fora del directori permes: " + nomDemanat);
    }
    return candidat;
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.LinkOption;

Path p = Path.of("dades/cataleg.txt");

Files.exists(p);            // true si existeix i es pot comprovar
Files.notExists(p);         // true si NO existeix i es pot comprovar
Files.isRegularFile(p);     // fitxer normal (no directori, no enllac)
Files.isDirectory(p);
Files.isSymbolicLink(p);
Files.isReadable(p);
Files.isWritable(p);
Files.isExecutable(p);
Files.isHidden(p);          // llanca IOException

// Sense seguir enllacos simbolics
Files.exists(p, LinkOption.NOFOLLOW_LINKS);

// Un fitxer buit. Llanca FileAlreadyExistsException si ja existeix.
Files.createFile(Path.of("dades/nou.txt"));

// Un directori. Llanca NoSuchFileException si falta el pare.
Files.createDirectory(Path.of("dades"));

// Un directori I TOTS ELS SEUS PARES. No falla si ja existeixen.
Files.createDirectories(Path.of("dades/informes/2026/gener"));

// java.io (07-02)
File pare = desti.getAbsoluteFile().getParentFile();
if (pare != null && !pare.exists() && !pare.mkdirs()) {
    throw new IOException("No s'ha pogut crear el directori " + pare.getAbsolutePath());
}

// NIO.2: una linia, idempotent, i amb excepcio informativa si falla
Files.createDirectories(desti.getParent());

// Esborra. Llanca NoSuchFileException si no existeix.
Files.delete(p);

// Esborra si existeix. Retorna true si ha esborrat alguna cosa. NO llanca.
boolean esborrat = Files.deleteIfExists(p);

// java.io: saps que ha fallat, no per que
if (!fitxer.delete()) {
    System.err.println("No s'ha pogut esborrar");
}

// NIO.2: saps exactament que ha passat i pots actuar en consequencia
try {
    Files.delete(cami);
} catch (NoSuchFileException e) {
    LOG.fine(() -> "Ja no hi era: " + cami);              // no es un problema
} catch (DirectoryNotEmptyException e) {
    LOG.warning(() -> "El directori te contingut: " + cami);
} catch (AccessDeniedException e) {
    LOG.severe(() -> "Sense permis per esborrar " + cami); // aixo si que cal mirar-ho
} catch (IOException e) {
    LOG.log(Level.SEVERE, "Fallada esborrant " + cami, e);
}

import java.nio.file.StandardCopyOption;

// Copia. Llanca FileAlreadyExistsException si el desti existeix.
Files.copy(origen, desti);

// Sobreescriu el desti
Files.copy(origen, desti, StandardCopyOption.REPLACE_EXISTING);

// Conserva data de modificacio, propietari i permisos
Files.copy(origen, desti,
        StandardCopyOption.REPLACE_EXISTING,
        StandardCopyOption.COPY_ATTRIBUTES);

// Des d'un InputStream a un fitxer (07-03)
Files.copy(entrada, desti, StandardCopyOption.REPLACE_EXISTING);

// Des d'un fitxer a un OutputStream
Files.copy(origen, sortida);

// Mou o reanomena
Files.move(origen, desti);

// Sobreescrivint el desti
Files.move(origen, desti, StandardCopyOption.REPLACE_EXISTING);

// ATOMIC: o hi es sencer o no hi es. Mai a mitges.
Files.move(temporal, desti,
        StandardCopyOption.REPLACE_EXISTING,
        StandardCopyOption.ATOMIC_MOVE);

// 07-02, amb java.io: DUES operacions, amb un buit perillos entre elles
if (desti.exists() && !desti.delete()) {        // 1. esborrar
    return false;
}
return temporal.renameTo(desti);                // 2. reanomenar
// Entre 1 i 2, el fitxer desti NO EXISTEIX. Si el proces mor alla,
// et quedes sense res. I un altre proces que llegeixi en aquell instant
// no troba el fitxer.

// NIO.2: UNA operacio atomica. No hi ha buit.
Files.move(temporal, desti, REPLACE_EXISTING, ATOMIC_MOVE);

package com.nexussoftware.bibliotech.infraestructura;

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.logging.Logger;

/**
 * Escriptura atomica amb NIO.2.
 *
 * Substitueix la versio de 07-02 escrita amb java.io. Mateixa garantia
 * —el desti no queda mai a mitges— en una fraccio del codi, i amb
 * una atomicitat REAL en lloc de la sequencia esborrar-mes-reanomenar.
 */
public final class EscripturaAtomica {

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

    private EscripturaAtomica() { }

    @FunctionalInterface
    public interface Contingut {
        void escriureA(BufferedWriter sortida) throws IOException;
    }

    public static void escriure(Path desti, Contingut contingut) throws IOException {
        // 1. Crear el directori si falta. Idempotent.
        Path directori = desti.toAbsolutePath().getParent();
        Files.createDirectories(directori);

        // 2. El temporal, AL MATEIX DIRECTORI: ATOMIC_MOVE ho exigeix.
        //    resolveSibling fa exactament aixo (apartat 3).
        Path temporal = desti.resolveSibling(desti.getFileName() + ".tmp");

        boolean completat = false;
        try {
            // 3. Escriure-ho tot al temporal. BufferedWriter, no PrintWriter:
            //    els seus metodes SI que llancen IOException (07-04).
            try (BufferedWriter sortida = Files.newBufferedWriter(
                    temporal, StandardCharsets.UTF_8,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.TRUNCATE_EXISTING,
                    StandardOpenOption.WRITE)) {

                contingut.escriureA(sortida);
            }

            // 4. Substituir de forma ATOMICA. Una sola operacio.
            Files.move(temporal, desti,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.ATOMIC_MOVE);

            completat = true;
            LOG.fine(() -> "Escriptura atomica completada: " + desti);

        } catch (AtomicMoveNotSupportedException e) {
            // Pot passar si el temporal i el desti son en sistemes de
            // fitxers diferents. Es degrada a un move no atomic, avisant.
            LOG.warning(() -> "El sistema de fitxers no suporta ATOMIC_MOVE; "
                    + "se substitueix de forma no atomica: " + desti);
            Files.move(temporal, desti, StandardCopyOption.REPLACE_EXISTING);
            completat = true;

        } finally {
            // 5. Compensacio (06-05): sense brossa si alguna cosa ha fallat.
            if (!completat) {
                Files.deleteIfExists(temporal);       // no llanca si ja no hi es
            }
        }
    }
}

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

Path p = Path.of("dades/cataleg.txt");

// Java 11+: el fitxer sencer com a String
String tot = Files.readString(p, StandardCharsets.UTF_8);

// Totes les linies en una llista
List<String> linies = Files.readAllLines(p, StandardCharsets.UTF_8);

// Tots els bytes (per a binari)
byte[] bytes = Files.readAllBytes(p);

// Un BufferedReader ja construit (07-04)
try (java.io.BufferedReader lector =
             Files.newBufferedReader(p, StandardCharsets.UTF_8)) {
    String linia;
    while ((linia = lector.readLine()) != null) {
        processar(linia);
    }
}

// Un InputStream (07-03)
try (java.io.InputStream entrada = Files.newInputStream(p)) {
    // ...
}

// Java 11+: escriure una cadena
Files.writeString(p, "contingut", StandardCharsets.UTF_8);

// Afegint al final
Files.writeString(p, "una linia mes\n", StandardCharsets.UTF_8,
        StandardOpenOption.CREATE, StandardOpenOption.APPEND);

// Escriure una colleccio de linies (afegeix el salt a cadascuna)
Files.write(p, linies, StandardCharsets.UTF_8);

// Escriure bytes
Files.write(p, bytes);

// Un BufferedWriter ja construit
try (java.io.BufferedWriter sortida =
             Files.newBufferedWriter(p, StandardCharsets.UTF_8)) {
    sortida.write("...");
    sortida.newLine();
}

// 07-02, amb java.io
try (PrintWriter sortida = new PrintWriter(
        new BufferedWriter(new FileWriter(cami, StandardCharsets.UTF_8)))) {
    for (String linia : linies) {
        sortida.println(linia);
    }
    if (sortida.checkError()) {
        throw new IOException("Fallada en escriure");
    }
}

// NIO.2
Files.write(Path.of(cami), linies, StandardCharsets.UTF_8);

// SOBREESCRIURE: crear si falta, buidar si existeix
Files.newBufferedWriter(p, UTF_8,
        StandardOpenOption.CREATE,
        StandardOpenOption.TRUNCATE_EXISTING,
        StandardOpenOption.WRITE);

// AFEGIR: crear si falta, escriure al final
Files.newBufferedWriter(p, UTF_8,
        StandardOpenOption.CREATE,
        StandardOpenOption.APPEND);

// CREAR NOU: fallar si ja existeix. Util com a bloqueig (07-02)
Files.newBufferedWriter(p, UTF_8,
        StandardOpenOption.CREATE_NEW,
        StandardOpenOption.WRITE);

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class LlegirAmbLines {

    public static void mostrar(Path fitxer) throws IOException {
        // try-with-resources OBLIGATORI: el flux mante el fitxer obert
        try (Stream<String> linies = Files.lines(fitxer, StandardCharsets.UTF_8)) {

            // forEach: processa cada linia. L'API completa, a 10-04.
            linies.forEach(System.out::println);
        }
    }
}

public static void comptar(Path fitxer) throws IOException {
    // Els comptadors han de ser efectivament finals per fer-los servir en
    // una lambda (04-05). Un array d'un element es el truc classic;
    // a 10-04 veuras formes millors.
    int[] comptadors = new int[2];      // [0] = linies, [1] = amb dades

    try (Stream<String> linies = Files.lines(fitxer, StandardCharsets.UTF_8)) {
        linies.forEach(linia -> {
            comptadors[0]++;
            if (!linia.isBlank() && !linia.startsWith("#")) {
                comptadors[1]++;
            }
        });
    }
    System.out.printf("%d linies, %d amb dades%n", comptadors[0], comptadors[1]);
}

public static void llistar(Path directori) throws IOException {
    try (Stream<Path> fills = Files.list(directori)) {
        fills.forEach(fill -> System.out.println("  " + fill.getFileName()));
    }
}

public static void recorrer(Path arrel) throws IOException {
    try (Stream<Path> arbre = Files.walk(arrel)) {
        arbre.forEach(p -> System.out.println("  " + p));
    }
}

/** Limitant la profunditat. */
public static void recorrerFinsA(Path arrel, int profunditat) throws IOException {
    try (Stream<Path> arbre = Files.walk(arrel, profunditat)) {
        arbre.forEach(System.out::println);
    }
}

/** Localitza tots els informes d'un arbre de directoris. */
public static void localitzarInformes(Path arrel) throws IOException {
    try (Stream<Path> arbre = Files.walk(arrel)) {
        arbre.forEach(p -> {
            if (Files.isRegularFile(p) && p.getFileName().toString().endsWith(".informe")) {
                System.out.println("  " + arrel.relativize(p));
            }
        });
    }
}

package com.nexussoftware.bibliotech.util;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.logging.Logger;

/**
 * Recorregut d'arbres amb control complet, fent servir walkFileTree.
 *
 * Avantatge decisiu sobre Files.walk: pot DECIDIR que fer davant de cada
 * element i davant de cada fallada, en lloc d'avortar el recorregut sencer
 * quan un sol directori no es accessible.
 */
public class RecorregutControlat {

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

    /** Calcula la mida total d'un arbre, saltant-se el que es inaccessible. */
    public static Resultat calcularMida(Path arrel) throws IOException {
        Resultat resultat = new Resultat();

        Files.walkFileTree(arrel, new SimpleFileVisitor<Path>() {

            /** Abans d'entrar en un directori. */
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                // Saltar directoris ocults i de treball sense entrar-hi
                String nom = dir.getFileName().toString();
                if (nom.startsWith(".") || nom.equals("tmp")) {
                    return FileVisitResult.SKIP_SUBTREE;
                }
                resultat.directoris++;
                return FileVisitResult.CONTINUE;
            }

            /** Per cada fitxer. */
            @Override
            public FileVisitResult visitFile(Path fitxer, BasicFileAttributes attrs) {
                resultat.fitxers++;
                resultat.bytes += attrs.size();

                if (attrs.size() > resultat.midaMesGran) {
                    resultat.midaMesGran = attrs.size();
                    resultat.fitxerMesGran = fitxer;
                }
                return FileVisitResult.CONTINUE;
            }

            /**
             * Quan un fitxer o directori NO es pot visitar.
             *
             * AQUEST es el metode que fa superior walkFileTree: retornant
             * CONTINUE, el recorregut SEGUEIX. Amb Files.walk, un sol directori
             * sense permisos ho avorta tot.
             */
            @Override
            public FileVisitResult visitFileFailed(Path fitxer, IOException e) {
                resultat.inaccessibles++;
                LOG.fine(() -> "No accessible: " + fitxer + " (" + e.getMessage() + ")");
                return FileVisitResult.CONTINUE;
            }

            /** En sortir d'un directori, despres de visitar-ne tot el contingut. */
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException e) {
                return FileVisitResult.CONTINUE;
            }
        });

        return resultat;
    }

    public static class Resultat {
        int directoris = 0;
        int fitxers = 0;
        int inaccessibles = 0;
        long bytes = 0;
        long midaMesGran = 0;
        Path fitxerMesGran = null;

        public String informe() {
            return String.format(
                    "%d directoris, %d fitxers, %.2f MB, %d inaccessibles.%n"
                            + "  Mes gran: %s (%.2f MB)",
                    directoris, fitxers, bytes / 1024.0 / 1024.0, inaccessibles,
                    fitxerMesGran == null ? "(cap)" : fitxerMesGran.getFileName(),
                    midaMesGran / 1024.0 / 1024.0);
        }
    }
}

/** Esborra un directori i tot el seu contingut. FER SERVIR AMB MOLT DE COMPTE. */
public static void esborrarArbre(Path arrel) throws IOException {
    if (Files.notExists(arrel)) {
        return;
    }
    Files.walkFileTree(arrel, new SimpleFileVisitor<Path>() {

        @Override
        public FileVisitResult visitFile(Path f, BasicFileAttributes attrs)
                throws IOException {
            Files.delete(f);
            return FileVisitResult.CONTINUE;
        }

        /**
         * El directori s'esborra DESPRES del seu contingut: per aixo va a
         * postVisitDirectory i no a pre. A l'inreves, Files.delete llancaria
         * DirectoryNotEmptyException.
         */
        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException e)
                throws IOException {
            if (e != null) {
                throw e;                  // no esborrar si el recorregut ha fallat
            }
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;

Path p = Path.of("dades/cataleg.txt");

// D'un en un: cada crida consulta el sistema de fitxers
long mida = Files.size(p);
FileTime modificat = Files.getLastModifiedTime(p);

// TOTS DE COP: una sola consulta. Mes eficient i CONSISTENT.
BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);

System.out.println("Mida          : " + attrs.size());
System.out.println("Creat         : " + attrs.creationTime());
System.out.println("Modificat     : " + attrs.lastModifiedTime());
System.out.println("Ultim acces   : " + attrs.lastAccessTime());
System.out.println("Es fitxer?    : " + attrs.isRegularFile());
System.out.println("Es directori? : " + attrs.isDirectory());
System.out.println("Es enllac?    : " + attrs.isSymbolicLink());

FileTime moment = Files.getLastModifiedTime(p);

System.out.println(moment);               // 2026-08-05T14:23:11.482Z
System.out.println(moment.toMillis());    // 1785943391482

// Comparar dos fitxers
FileTime a = Files.getLastModifiedTime(camiA);
FileTime b = Files.getLastModifiedTime(camiB);
if (a.compareTo(b) > 0) {
    System.out.println("A es mes recent que B");
}

// Antiguitat en dies, amb aritmetica de millisegons
long diesDAntiguitat = (System.currentTimeMillis() - moment.toMillis())
        / (1000L * 60 * 60 * 24);

// Canviar la data de modificacio
Files.setLastModifiedTime(p, FileTime.fromMillis(System.currentTimeMillis()));

import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;

try {
    Set<PosixFilePermission> permisos = Files.getPosixFilePermissions(p);
    System.out.println(PosixFilePermissions.toString(permisos));   // rw-r--r--

    // Establir permisos: nomes el propietari pot llegir i escriure
    Files.setPosixFilePermissions(p,
            PosixFilePermissions.fromString("rw-------"));

} catch (UnsupportedOperationException e) {
    // A Windows el model POSIX no existeix: cal fer servir ACL
    LOG.fine("Sistema sense permisos POSIX");
}

// Crear el fitxer JA amb permisos restringits, en una sola operacio
Files.createFile(p, PosixFilePermissions.asFileAttribute(
        PosixFilePermissions.fromString("rw-------")));

// Fitxer temporal al directori temporal del sistema
Path temporal = Files.createTempFile("bibliotech-", ".tmp");

// En un directori concret: necessari si despres faras ATOMIC_MOVE
Path temporalLocal = Files.createTempFile(Path.of("dades"), "cataleg-", ".tmp");

// Directori temporal
Path dirTemporal = Files.createTempDirectory("bibliotech-import-");

Path temporal = Files.createTempFile("bibliotech-", ".tmp");

try (var sortida = Files.newBufferedWriter(temporal, StandardCharsets.UTF_8,
        StandardOpenOption.WRITE,
        StandardOpenOption.DELETE_ON_CLOSE)) {    // s'esborra en tancar

    sortida.write("dades de treball");
}
// Aqui el fitxer JA NO EXISTEIX

import java.nio.file.*;

/**
 * Vigilancia d'un directori.
 *
 * NOTA: aquest bucle es BLOQUEJANT. En una aplicacio real s'executa en un
 * fil a part, i aixo es el modul 8. Aqui queda com a demostracio del
 * mecanisme, no com a codi que ficaries al teu main.
 */
public static void vigilar(Path directori) throws IOException, InterruptedException {

    try (WatchService vigilant = FileSystems.getDefault().newWatchService()) {

        directori.register(vigilant,
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_MODIFY,
                StandardWatchEventKinds.ENTRY_DELETE);

        System.out.println("Vigilant " + directori + "...");

        while (true) {
            WatchKey clau = vigilant.take();          // BLOQUEJA fins que passi res

            for (WatchEvent<?> ev : clau.pollEvents()) {
                System.out.printf("  %s: %s%n", ev.kind().name(), ev.context());
            }

            if (!clau.reset()) {                      // el directori ja no existeix
                break;
            }
        }
    }
}

// De File a Path
File f = new File("dades/cataleg.txt");
Path p = f.toPath();

// De Path a File
Path p2 = Path.of("dades/cataleg.txt");
File f2 = p2.toFile();

package com.nexussoftware.bibliotech.infraestructura;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;

/**
 * Capa de persistencia de BiblioTech sobre NIO.2.
 *
 * Substitueix tot el codi de java.io de 07-01 a 07-05:
 *   - creacio de directoris       -> Files.createDirectories
 *   - escriptura atomica          -> Files.move amb ATOMIC_MOVE
 *   - copies rotatives            -> Files.move i Files.deleteIfExists
 *   - localitzacio d'informes     -> Files.walk
 *   - fallades                    -> excepcions especifiques, no boolean muts
 *
 * Estructura de directoris que gestiona:
 *   dades/
 *     cataleg.txt
 *     auditoria.txt
 *     copies/
 *       cataleg.bak.1  (la mes recent)
 *       cataleg.bak.2
 *       cataleg.bak.3
 *     informes/
 *       2026/
 *         01/ *.informe
 *     sessions/
 */
public class MagatzemBiblioTech {

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

    private static final java.nio.charset.Charset CHARSET = StandardCharsets.UTF_8;

    private static final String CATALEG    = "cataleg.txt";
    private static final String AUDITORIA  = "auditoria.txt";
    private static final String EXT_INFORME = ".informe";

    private static final int COPIES_CONSERVADES = 3;

    private final Path arrel;
    private final Path copies;
    private final Path informes;
    private final Path sessions;

    /**
     * Prepara l'estructura de directoris.
     *
     * createDirectories es IDEMPOTENT: si ja existeixen, no fa res i no
     * falla. S'ha acabat el "if (!existeix) crear" amb el seu boolean mut.
     */
    public MagatzemBiblioTech(String directoriArrel) throws IOException {
        this.arrel = Path.of(Objects.requireNonNull(directoriArrel,
                "El directori no pot ser nul")).toAbsolutePath().normalize();

        this.copies   = arrel.resolve("copies");
        this.informes = arrel.resolve("informes");
        this.sessions = arrel.resolve("sessions");

        Files.createDirectories(copies);
        Files.createDirectories(informes);
        Files.createDirectories(sessions);

        LOG.config(() -> "Magatzem de BiblioTech preparat a " + arrel);
    }

    // ---------------------- ESCRIPTURA ATOMICA ----------------------

    @FunctionalInterface
    public interface Contingut {
        void escriureA(BufferedWriter sortida) throws IOException;
    }

    /**
     * Escriu un fitxer de forma atomica, despres de fer copia de seguretat.
     *
     * Sequencia:
     *   1. rotar les copies de seguretat existents
     *   2. copiar el fitxer actual a copies/nom.bak.1
     *   3. escriure el contingut nou en un temporal GERMA del desti
     *   4. moure'l sobre el desti amb ATOMIC_MOVE
     */
    public void escriureAmbCopia(String nom, Contingut contingut) throws IOException {
        Path desti = arrel.resolve(nom);

        // 1 i 2: copia de seguretat rotativa
        if (Files.exists(desti)) {
            rotarCopies(nom);
            Files.copy(desti, copies.resolve(nom + ".bak.1"),
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.COPY_ATTRIBUTES);
        }

        // 3: temporal GERMA. ATOMIC_MOVE exigeix el mateix sistema de fitxers.
        Path temporal = desti.resolveSibling(desti.getFileName() + ".tmp");
        boolean completat = false;

        try {
            try (BufferedWriter sortida = Files.newBufferedWriter(temporal, CHARSET,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.TRUNCATE_EXISTING,
                    StandardOpenOption.WRITE)) {

                contingut.escriureA(sortida);
            }

            // 4: substitucio atomica de veritat
            Files.move(temporal, desti,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.ATOMIC_MOVE);
            completat = true;

            LOG.info(() -> String.format("Escrit %s (%d bytes)",
                    desti.getFileName(), midaSegura(desti)));

        } catch (AtomicMoveNotSupportedException e) {
            LOG.warning(() -> "Sense suport d'ATOMIC_MOVE; substitucio no atomica");
            Files.move(temporal, desti, StandardCopyOption.REPLACE_EXISTING);
            completat = true;

        } finally {
            if (!completat) {
                Files.deleteIfExists(temporal);      // compensacio (06-05)
            }
        }
    }

    /**
     * Rotacio de copies: .bak.2 passa a .bak.3, .bak.1 a .bak.2, i la mes
     * antiga es perd.
     *
     * De MAJOR a MENOR, com a 07-02: a l'inreves, cada reanomenat matxucaria
     * la copia seguent abans d'haver-la desplacat.
     */
    private void rotarCopies(String nom) throws IOException {
        Files.deleteIfExists(copies.resolve(nom + ".bak." + COPIES_CONSERVADES));

        for (int i = COPIES_CONSERVADES - 1; i >= 1; i--) {
            Path origen = copies.resolve(nom + ".bak." + i);
            Path desti  = copies.resolve(nom + ".bak." + (i + 1));

            if (Files.exists(origen)) {
                Files.move(origen, desti, StandardCopyOption.REPLACE_EXISTING);
            }
        }
    }

    // ---------------------- LECTURA ----------------------

    /**
     * Llegeix el cataleg linia a linia, amb memoria constant.
     *
     * Files.newBufferedReader retorna el BufferedReader de 07-04, amb el
     * charset obligatori i una excepcio especifica si el fitxer falta.
     */
    public List<String> llegirCataleg() throws IOException {
        Path fitxer = arrel.resolve(CATALEG);
        List<String> linies = new ArrayList<>();

        if (Files.notExists(fitxer)) {
            // DEGRADACIO ELEGANT (06-07, 07-01): la primera execucio no
            // te cataleg, i aixo es normal, no una fallada.
            LOG.warning(() -> "No hi ha cataleg a " + fitxer
                    + "; s'arrenca amb el cataleg buit");
            return linies;
        }

        try (BufferedReader lector = Files.newBufferedReader(fitxer, CHARSET)) {
            String linia;
            while ((linia = lector.readLine()) != null) {       // bucle canonic (07-04)
                String neta = linia.trim();
                if (!neta.isEmpty() && !neta.startsWith("#")) {
                    linies.add(neta);
                }
            }
        }

        LOG.info(() -> "Cataleg llegit: " + linies.size() + " linies de " + fitxer);
        return linies;
    }

    /** Afegeix una linia a l'auditoria. APPEND explicit: el fitxer CREIX. */
    public void auditar(String linia) {
        Path fitxer = arrel.resolve(AUDITORIA);

        try (BufferedWriter sortida = Files.newBufferedWriter(fitxer, CHARSET,
                StandardOpenOption.CREATE,
                StandardOpenOption.APPEND)) {          // impossible de confondre

            sortida.write(linia);
            sortida.write('\n');                       // fitxer de dades: '\n' fix

        } catch (IOException e) {
            // L'auditoria no tomba l'operacio de negoci (07-02)
            LOG.log(Level.WARNING, "No s'ha pogut auditar: " + linia, e);
        }
    }

    // ---------------------- INFORMES ----------------------

    /** Desa un informe a informes/AAAA/MM/nom.informe. */
    public Path desarInforme(String any, String mes, String nom, String contingut)
            throws IOException {

        Path directori = informes.resolve(any).resolve(mes);
        Files.createDirectories(directori);

        Path fitxer = directori.resolve(nom + EXT_INFORME);
        Files.writeString(fitxer, contingut, CHARSET,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING,
                StandardOpenOption.WRITE);

        LOG.info(() -> "Informe desat: " + arrel.relativize(fitxer));
        return fitxer;
    }

    /**
     * Localitza tots els informes de l'arbre, ordenats del mes recent al
     * mes antic.
     *
     * Files.walk retorna un flux MANDROS que S'HA DE TANCAR: mante
     * descriptors de directori oberts. D'aqui el try-with-resources.
     * Es fa servir nomes forEach; l'API completa de Streams es 10-04.
     */
    public List<InfoInforme> localitzarInformes() throws IOException {
        List<InfoInforme> trobats = new ArrayList<>();

        try (Stream<Path> arbre = Files.walk(informes)) {
            arbre.forEach(p -> {
                if (!Files.isRegularFile(p)
                        || !p.getFileName().toString().endsWith(EXT_INFORME)) {
                    return;
                }
                try {
                    // readAttributes: UNA consulta per a tots els atributs,
                    // en lloc de tres crides independents (apartat 10)
                    BasicFileAttributes attrs =
                            Files.readAttributes(p, BasicFileAttributes.class);

                    trobats.add(new InfoInforme(
                            informes.relativize(p).toString(),
                            attrs.size(),
                            attrs.lastModifiedTime()));

                } catch (IOException e) {
                    LOG.fine(() -> "No s'han pogut llegir els atributs de " + p);
                }
            });
        }

        // Mes recent primer (05-09)
        trobats.sort(Comparator.comparing(InfoInforme::modificat).reversed());
        return trobats;
    }

    /**
     * Informacio d'un informe localitzat.
     *
     * FileTime es mostra amb toString() i es compara amb compareTo().
     * La seva conversio a dates llegibles es java.time, que es 10-05.
     */
    public record InfoInforme(String camiRelatiu, long bytes, FileTime modificat) {

        public String linia() {
            return String.format("%-40s %8d bytes  %s",
                    camiRelatiu, bytes, modificat);
        }

        /** Antiguitat en dies, amb aritmetica de millisegons (10-05 ho fara millor). */
        public long diesDAntiguitat() {
            return (System.currentTimeMillis() - modificat.toMillis())
                    / (1000L * 60 * 60 * 24);
        }
    }

    // ---------------------- MANTENIMENT ----------------------

    /**
     * Esborra els informes amb mes de N dies.
     *
     * @return quants se n'han esborrat
     */
    public int netejarInformesAntics(int diesMaxims) throws IOException {
        int esborrats = 0;

        for (InfoInforme info : localitzarInformes()) {
            if (info.diesDAntiguitat() > diesMaxims) {
                Path fitxer = informes.resolve(info.camiRelatiu());
                if (Files.deleteIfExists(fitxer)) {
                    esborrats++;
                    LOG.fine(() -> "Informe antic esborrat: " + info.camiRelatiu());
                }
            }
        }

        final int total = esborrats;
        LOG.info(() -> "Neteja: " + total + " informes amb mes de "
                + diesMaxims + " dies");
        return esborrats;
    }

    /** Resum de l'espai ocupat, amb walkFileTree per no avortar per una fallada. */
    public String informeDEspai() throws IOException {
        long[] dades = new long[2];      // [0] bytes, [1] fitxers

        Files.walkFileTree(arrel, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path f, BasicFileAttributes attrs) {
                dades[0] += attrs.size();
                dades[1]++;
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path f, IOException e) {
                LOG.fine(() -> "No accessible: " + f);
                return FileVisitResult.CONTINUE;      // no avorta el recorregut
            }
        });

        return String.format("%s: %d fitxers, %.2f MB",
                arrel.getFileName(), dades[1], dades[0] / 1024.0 / 1024.0);
    }

    private long midaSegura(Path p) {
        try {
            return Files.size(p);
        } catch (IOException e) {
            return -1;
        }
    }

    public Path getArrel()    { return arrel; }
    public Path getSessions() { return sessions; }
}

package com.nexussoftware.bibliotech.presentacio;

import java.io.IOException;
import com.nexussoftware.bibliotech.infraestructura.MagatzemBiblioTech;

public class DemoMagatzem {

    public static void main(String[] args) throws IOException {
        MagatzemBiblioTech magatzem = new MagatzemBiblioTech("dades");

        // 1. Escriure el cataleg amb copia de seguretat i atomicitat
        magatzem.escriureAmbCopia("cataleg.txt", sortida -> {
            sortida.write("# Cataleg de BiblioTech - Nexus Software");
            sortida.newLine();
            sortida.write("LLIBRE;978-0000000001;Java Eficac;Bloch;2018");
            sortida.newLine();
            sortida.write("LLIBRE;978-0000000002;Patrons de Disseny;Gamma;1994");
            sortida.newLine();
            sortida.write("LLIBRE;978-0000000003;Refactoritzacio;Fowler;1999");
            sortida.newLine();
        });

        // 2. Llegir
        System.out.println("=== CATALEG ===");
        for (String linia : magatzem.llegirCataleg()) {
            System.out.println("  " + linia);
        }

        // 3. Auditoria (mode APPEND)
        magatzem.auditar("PRESTEC;PR-0001;978-0000000001;E-001");
        magatzem.auditar("DEVOLUCIO;PR-0001;978-0000000001;E-001");

        // 4. Informes en un arbre de directoris
        magatzem.desarInforme("2026", "01", "multes-gener", "Total: 142,50 EUR");
        magatzem.desarInforme("2026", "02", "multes-febrer", "Total: 98,25 EUR");
        magatzem.desarInforme("2026", "08", "multes-agost", "Total: 210,00 EUR");

        System.out.println();
        System.out.println("=== INFORMES LOCALITZATS ===");
        for (MagatzemBiblioTech.InfoInforme info : magatzem.localitzarInformes()) {
            System.out.println("  " + info.linia());
        }

        // 5. Espai ocupat
        System.out.println();
        System.out.println("=== ESPAI ===");
        System.out.println("  " + magatzem.informeDEspai());
    }
}

=== CATALEG ===
  LLIBRE;978-0000000001;Java Eficac;Bloch;2018
  LLIBRE;978-0000000002;Patrons de Disseny;Gamma;1994
  LLIBRE;978-0000000003;Refactoritzacio;Fowler;1999

=== INFORMES LOCALITZATS ===
  2026/08/multes-agost.informe                   17 bytes  2026-08-05T09:14:22.331Z
  2026/02/multes-febrer.informe                  16 bytes  2026-08-05T09:14:22.329Z
  2026/01/multes-gener.informe                   17 bytes  2026-08-05T09:14:22.327Z

=== ESPAI ===
  dades: 9 fitxers, 0,01 MB

package com.nexussoftware.bibliotech.util;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.PosixFilePermissions;

/**
 * Informe complet d'un cami fent servir nomes NIO.2.
 *
 * Substitueix el DiagnosticCami de 07-01, que feia servir java.io: aqui cada
 * fallada diu PER QUE, en lloc de retornar un boolean mut.
 */
public class ExploradorCamins {

    public static void analitzar(String cami) {
        Path p = Path.of(cami);

        System.out.println("========================================");
        System.out.println("ANALISI DE: " + cami);
        System.out.println("========================================");

        // ---- 1. Formes del cami ----
        System.out.println("  Tal qual        : " + p);
        System.out.println("  Absoluta        : " + p.toAbsolutePath());
        System.out.println("  Normalitzada    : " + p.toAbsolutePath().normalize());

        try {
            // toRealPath SI que consulta el disc i resol enllacos simbolics
            System.out.println("  Real            : " + p.toRealPath());
        } catch (NoSuchFileException e) {
            System.out.println("  Real            : (no existeix, no es pot resoldre)");
        } catch (IOException e) {
            System.out.println("  Real            : (error: " + e.getMessage() + ")");
        }

        // ---- 2. Estructura ----
        System.out.println("  Nom             : " + p.getFileName());
        System.out.println("  Pare            : " + p.getParent());
        System.out.println("  Arrel           : " + p.getRoot());
        System.out.println("  Absolut?        : " + p.isAbsolute());
        System.out.println("  Segments        : " + p.getNameCount());

        StringBuilder segments = new StringBuilder();
        for (Path s : p) {                       // Path es Iterable<Path>
            segments.append('[').append(s).append(']');
        }
        System.out.println("  Recorregut      : " + segments);

        // ---- 5. exists / notExists ----
        boolean existeix = Files.exists(p);
        boolean noExisteix = Files.notExists(p);

        System.out.println("  ----");
        System.out.println("  exists()        : " + existeix);
        System.out.println("  notExists()     : " + noExisteix);
        System.out.println("  Interpretacio   : " + interpretar(existeix, noExisteix));

        if (!existeix) {
            System.out.println();
            return;
        }

        // ---- 3. Atributs: UNA sola consulta ----
        try {
            BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);

            System.out.println("  ----");
            System.out.println("  Tipus           : " + tipus(attrs));
            System.out.println("  Mida            : " + attrs.size() + " bytes");
            System.out.println("  Creat           : " + attrs.creationTime());
            System.out.println("  Modificat       : " + attrs.lastModifiedTime());
            System.out.println("  Ultim acces     : " + attrs.lastAccessTime());
            System.out.println("  Llegible?       : " + Files.isReadable(p));
            System.out.println("  Escrivible?     : " + Files.isWritable(p));

            // ---- 4. Antiguitat ----
            long dies = (System.currentTimeMillis() - attrs.lastModifiedTime().toMillis())
                    / (1000L * 60 * 60 * 24);
            System.out.println("  Antiguitat      : " + dies + " dies");

            // Permisos POSIX si el sistema els te
            try {
                System.out.println("  Permisos POSIX  : " + PosixFilePermissions.toString(
                        Files.getPosixFilePermissions(p)));
            } catch (UnsupportedOperationException e) {
                System.out.println("  Permisos POSIX  : (sistema sense suport, p.ex. Windows)");
            }

        } catch (IOException e) {
            System.out.println("  ERROR llegint atributs: " + e.getMessage());
        }

        System.out.println();
    }

    private static String tipus(BasicFileAttributes a) {
        if (a.isDirectory())     { return "directori"; }
        if (a.isRegularFile())   { return "fitxer"; }
        if (a.isSymbolicLink())  { return "enllac simbolic"; }
        return "altre";
    }

    /** Els TRES estats possibles, no dos. */
    private static String interpretar(boolean existeix, boolean noExisteix) {
        if (existeix && !noExisteix) {
            return "EXISTEIX, i s'ha pogut comprovar";
        }
        if (!existeix && noExisteix) {
            return "NO EXISTEIX, i s'ha pogut comprovar";
        }
        if (!existeix && !noExisteix) {
            return "NO ES POT DETERMINAR (probablement sense permis sobre "
                    + "el directori que el conte). Per aixo !exists() NO "
                    + "significa 'no existeix'.";
        }
        return "estat impossible";
    }

    public static void main(String[] args) {
        analitzar("dades/cataleg.txt");
        analitzar("dades");
        analitzar("dades/no-existeix.txt");
        analitzar("dades/../dades/./informes/../cataleg.txt");   // sense normalitzar
    }
}

========================================
ANALISI DE: dades/../dades/./informes/../cataleg.txt
========================================
  Tal qual        : dades/../dades/./informes/../cataleg.txt
  Absoluta        : /home/marta/bibliotech/dades/../dades/./informes/../cataleg.txt
  Normalitzada    : /home/marta/bibliotech/dades/cataleg.txt
  Real            : /home/marta/bibliotech/dades/cataleg.txt
  Nom             : cataleg.txt
  Segments        : 7
  Recorregut      : [dades][..][dades][.][informes][..][cataleg.txt]
  ----
  exists()        : true
  notExists()     : false
  Interpretacio   : EXISTEIX, i s'ha pogut comprovar

package com.nexussoftware.bibliotech.util;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Logger;

/**
 * Sincronitza un directori desti amb un origen, copiant nomes el necessari.
 *
 * Es el nucli de qualsevol eina de copia incremental: no copiar el
 * que ja esta igual estalvia la major part de la feina.
 */
public class SincronitzadorDirectoris {

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

    public record Resultat(int copiats, int actualitzats, int senseCanvis,
                           int nomesAlDesti, int errors,
                           List<String> detallNomesAlDesti) {

        public String informe() {
            StringBuilder sb = new StringBuilder();
            sb.append("=== SINCRONITZACIO ===\n");
            sb.append(String.format("  Copiats (nous)    : %d%n", copiats));
            sb.append(String.format("  Actualitzats      : %d%n", actualitzats));
            sb.append(String.format("  Sense canvis      : %d%n", senseCanvis));
            sb.append(String.format("  Nomes al desti    : %d%n", nomesAlDesti));
            sb.append(String.format("  Errors            : %d%n", errors));

            if (!detallNomesAlDesti.isEmpty()) {
                sb.append("  --- Nomes al desti (candidats a esborrar) ---\n");
                int n = Math.min(10, detallNomesAlDesti.size());
                for (int i = 0; i < n; i++) {
                    sb.append("    ").append(detallNomesAlDesti.get(i)).append('\n');
                }
                if (detallNomesAlDesti.size() > n) {
                    sb.append(String.format("    ... i %d mes%n",
                            detallNomesAlDesti.size() - n));
                }
            }
            return sb.toString();
        }
    }

    /** Sincronitza origen cap a desti. NO esborra MAI res del desti. */
    public Resultat sincronitzar(Path origen, Path desti) throws IOException {
        Path arrelOrigen = origen.toAbsolutePath().normalize();
        Path arrelDesti  = desti.toAbsolutePath().normalize();

        if (!Files.isDirectory(arrelOrigen)) {
            throw new NotDirectoryException(arrelOrigen.toString());
        }
        Files.createDirectories(arrelDesti);

        int[] comptadors = new int[4];        // copiats, actualitzats, iguals, errors
        Set<Path> vistosAOrigen = new HashSet<>();

        // ---- FASE 1: recorrer l'origen i sincronitzar ----
        Files.walkFileTree(arrelOrigen, new SimpleFileVisitor<Path>() {

            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                    throws IOException {

                // relativize dona el cami equivalent al desti (apartat 3)
                Path equivalent = arrelDesti.resolve(arrelOrigen.relativize(dir));
                Files.createDirectories(equivalent);        // idempotent
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path fitxer, BasicFileAttributes attrsOrigen) {
                Path relatiu = arrelOrigen.relativize(fitxer);
                Path equivalent = arrelDesti.resolve(relatiu);

                vistosAOrigen.add(relatiu);

                try {
                    if (Files.notExists(equivalent)) {
                        // NOU: copiar conservant els atributs
                        Files.copy(fitxer, equivalent,
                                StandardCopyOption.COPY_ATTRIBUTES);
                        comptadors[0]++;
                        LOG.fine(() -> "Nou: " + relatiu);
                        return FileVisitResult.CONTINUE;
                    }

                    BasicFileAttributes attrsDesti =
                            Files.readAttributes(equivalent, BasicFileAttributes.class);

                    FileTime tOrigen = attrsOrigen.lastModifiedTime();
                    FileTime tDesti  = attrsDesti.lastModifiedTime();

                    // compareTo > 0 significa que l'origen es MES RECENT.
                    // Es compara tambe la mida: un fitxer amb la mateixa
                    // data pero mida diferent tambe cal copiar-lo.
                    if (tOrigen.compareTo(tDesti) > 0
                            || attrsOrigen.size() != attrsDesti.size()) {

                        Files.copy(fitxer, equivalent,
                                StandardCopyOption.REPLACE_EXISTING,
                                StandardCopyOption.COPY_ATTRIBUTES);
                        comptadors[1]++;
                        LOG.fine(() -> "Actualitzat: " + relatiu);
                    } else {
                        comptadors[2]++;
                    }

                } catch (IOException e) {
                    comptadors[3]++;
                    LOG.warning(() -> "Error sincronitzant " + relatiu
                            + ": " + e.getMessage());
                }
                return FileVisitResult.CONTINUE;
            }

            /**
             * CLAU: un fitxer inaccessible NO avorta la sincronitzacio.
             * Amb Files.walk aixo no seria possible.
             */
            @Override
            public FileVisitResult visitFileFailed(Path fitxer, IOException e) {
                comptadors[3]++;
                LOG.warning(() -> "No accessible a l'origen: " + fitxer);
                return FileVisitResult.CONTINUE;
            }
        });

        // ---- FASE 2: detectar el que nomes es al desti ----
        List<String> nomesDesti = new ArrayList<>();

        Files.walkFileTree(arrelDesti, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path fitxer, BasicFileAttributes attrs) {
                Path relatiu = arrelDesti.relativize(fitxer);
                if (!vistosAOrigen.contains(relatiu)) {
                    nomesDesti.add(relatiu.toString());
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path f, IOException e) {
                return FileVisitResult.CONTINUE;
            }
        });

        nomesDesti.sort(null);

        return new Resultat(comptadors[0], comptadors[1], comptadors[2],
                nomesDesti.size(), comptadors[3], nomesDesti);
    }

    public static void main(String[] args) throws IOException {
        Resultat r = new SincronitzadorDirectoris()
                .sincronitzar(Path.of("dades"), Path.of("copia-seguretat/dades"));
        System.out.println(r.informe());
    }
}

=== SINCRONITZACIO ===
  Copiats (nous)    : 0
  Actualitzats      : 1
  Sense canvis      : 11
  Nomes al desti    : 2
  Errors            : 0
  --- Nomes al desti (candidats a esborrar) ---
    cataleg-antic.txt
    informes/2025/12/multes-desembre.informe

package com.nexussoftware.bibliotech.infraestructura;

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.logging.Logger;
import java.util.stream.Stream;

/**
 * Copies de seguretat rotatives amb marca de temps, sobre NIO.2.
 *
 * Cada copia s'anomena fitxer.AAAAMMDD-HHMMSS.bak. Es conserven les N mes
 * recents; les altres s'esborren.
 *
 * NOTA: el nom amb data es compon amb SimpleDateFormat perque java.time
 * es la llico 10-05. Amb LocalDateTime i DateTimeFormatter aixo queda
 * bastant millor, i alla ho veuras.
 */
public class GestorCopies {

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

    private static final String SUFIX = ".bak";
    private static final int MAX_COPIES_DEFECTE = 3;

    private final Path directoriCopies;
    private final int maxCopies;

    public GestorCopies(Path directoriCopies) throws IOException {
        this(directoriCopies, MAX_COPIES_DEFECTE);
    }

    public GestorCopies(Path directoriCopies, int maxCopies) throws IOException {
        this.directoriCopies = Objects.requireNonNull(directoriCopies)
                .toAbsolutePath().normalize();

        if (maxCopies < 1) {
            throw new IllegalArgumentException(
                    "Cal conservar com a minim una copia, i se n'han demanat: " + maxCopies);
        }
        this.maxCopies = maxCopies;

        Files.createDirectories(this.directoriCopies);
    }

    /** Informacio d'una copia existent. */
    public record InfoCopia(Path cami, String nom, long bytes, FileTime creada) {

        public String linia() {
            return String.format("%-45s %8d bytes  %s", nom, bytes, creada);
        }
    }

    // ---------------------- CREAR ----------------------

    /**
     * Crea una copia amb marca de temps i aplica la rotacio.
     *
     * @return el cami de la copia creada
     */
    public Path crearCopia(Path fitxer) throws IOException {
        Objects.requireNonNull(fitxer, "El fitxer no pot ser nul");

        if (Files.notExists(fitxer)) {
            throw new NoSuchFileException(fitxer.toString(),
                    null, "No es pot copiar un fitxer que no existeix");
        }

        String nomBase = fitxer.getFileName().toString();
        String marca = new java.text.SimpleDateFormat("yyyyMMdd-HHmmss")
                .format(new Date(System.currentTimeMillis()));

        Path copia = directoriCopies.resolve(nomBase + "." + marca + SUFIX);

        // Si al mateix segon es demana una altra copia, s'afegeix un sufix
        int intent = 1;
        while (Files.exists(copia)) {
            copia = directoriCopies.resolve(
                    nomBase + "." + marca + "-" + intent + SUFIX);
            intent++;
        }

        // COPY_ATTRIBUTES conserva la data original del fitxer copiat
        Files.copy(fitxer, copia, StandardCopyOption.COPY_ATTRIBUTES);

        final Path creada = copia;
        LOG.info(() -> "Copia creada: " + creada.getFileName());

        aplicarRotacio(nomBase);
        return copia;
    }

    /** Esborra les copies que sobren, comencant per les mes antigues. */
    private void aplicarRotacio(String nomBase) throws IOException {
        List<InfoCopia> copies = llistarCopies(nomBase);

        for (int i = maxCopies; i < copies.size(); i++) {
            InfoCopia sobrant = copies.get(i);         // ja venen de nova a vella
            if (Files.deleteIfExists(sobrant.cami())) {
                LOG.fine(() -> "Copia antiga esborrada: " + sobrant.nom());
            }
        }
    }

    // ---------------------- LLISTAR ----------------------

    /** Copies d'un fitxer, de la MES RECENT a la mes antiga. */
    public List<InfoCopia> llistarCopies(String nomBase) throws IOException {
        List<InfoCopia> trobades = new ArrayList<>();
        String prefix = nomBase + ".";

        // Files.list retorna un flux MANDROS: try-with-resources obligatori
        try (Stream<Path> fills = Files.list(directoriCopies)) {
            fills.forEach(p -> {
                String nom = p.getFileName().toString();
                if (!nom.startsWith(prefix) || !nom.endsWith(SUFIX)) {
                    return;
                }
                try {
                    BasicFileAttributes attrs =
                            Files.readAttributes(p, BasicFileAttributes.class);
                    trobades.add(new InfoCopia(p, nom, attrs.size(),
                            attrs.lastModifiedTime()));
                } catch (IOException e) {
                    LOG.fine(() -> "No s'ha pogut llegir " + p);
                }
            });
        }

        // Mes recent primer (05-09)
        trobades.sort(Comparator.comparing(InfoCopia::creada).reversed());
        return trobades;
    }

    public List<InfoCopia> llistarCopies(Path fitxer) throws IOException {
        return llistarCopies(fitxer.getFileName().toString());
    }

    // ---------------------- RESTAURAR ----------------------

    /**
     * Restaura la copia numero 'index' (0 = la mes recent).
     *
     * ABANS de restaurar, fa una copia de l'estat ACTUAL: si la
     * restauracio resulta ser un error, es pot desfer. Restaurar sense
     * aquesta xarxa es una forma habitual de perdre la feina del dia.
     *
     * La substitucio es ATOMICA: el fitxer no queda mai a mitges.
     */
    public void restaurar(Path fitxer, int index) throws IOException {
        List<InfoCopia> copies = llistarCopies(fitxer);

        if (copies.isEmpty()) {
            throw new NoSuchFileException(fitxer.toString(),
                    null, "No hi ha cap copia de seguretat d'aquest fitxer");
        }
        if (index < 0 || index >= copies.size()) {
            throw new IllegalArgumentException(String.format(
                    "Index %d fora de rang: hi ha %d copies (0..%d)",
                    index, copies.size(), copies.size() - 1));
        }

        InfoCopia triada = copies.get(index);

        // 1. Xarxa de seguretat: copiar l'estat actual abans de trepitjar-lo
        if (Files.exists(fitxer)) {
            crearCopia(fitxer);
        }

        // 2. Temporal GERMA del desti: ATOMIC_MOVE ho exigeix
        Path temporal = fitxer.resolveSibling(fitxer.getFileName() + ".restaurant");
        boolean completat = false;

        try {
            Files.copy(triada.cami(), temporal,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.COPY_ATTRIBUTES);

            Files.move(temporal, fitxer,
                    StandardCopyOption.REPLACE_EXISTING,
                    StandardCopyOption.ATOMIC_MOVE);
            completat = true;

            LOG.info(() -> "Restaurat " + fitxer.getFileName()
                    + " des de " + triada.nom());

        } catch (AtomicMoveNotSupportedException e) {
            LOG.warning(() -> "Sense ATOMIC_MOVE; restauracio no atomica");
            Files.move(temporal, fitxer, StandardCopyOption.REPLACE_EXISTING);
            completat = true;

        } finally {
            if (!completat) {
                Files.deleteIfExists(temporal);        // compensacio (06-05)
            }
        }
    }

    // ---------------------- ESPAI ----------------------

    /** Espai total ocupat per les copies. */
    public long espaiOcupat() throws IOException {
        long[] total = new long[1];

        Files.walkFileTree(directoriCopies, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path f, BasicFileAttributes attrs) {
                if (f.getFileName().toString().endsWith(SUFIX)) {
                    total[0] += attrs.size();
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path f, IOException e) {
                return FileVisitResult.CONTINUE;       // no avortar per una fallada
            }
        });
        return total[0];
    }

    // ---------------------- DEMOSTRACIO ----------------------

    public static void main(String[] args) throws IOException, InterruptedException {
        Path fitxer = Path.of("dades/cataleg.txt");
        Files.createDirectories(fitxer.getParent());

        GestorCopies gestor = new GestorCopies(Path.of("dades/copies"), 3);

        // 1. Cinc versions diferents, amb maxim de 3 copies
        System.out.println("=== CREANT 5 COPIES (maxim 3) ===");
        for (int v = 1; v <= 5; v++) {
            Files.writeString(fitxer,
                    "# Cataleg versio " + v + "\n"
                            + "LLIBRE;978-000000000" + v + ";Llibre " + v + ";Autor;2020\n",
                    java.nio.charset.StandardCharsets.UTF_8,
                    StandardOpenOption.CREATE,
                    StandardOpenOption.TRUNCATE_EXISTING,
                    StandardOpenOption.WRITE);

            Path copia = gestor.crearCopia(fitxer);
            System.out.println("  v" + v + " -> " + copia.getFileName());

            Thread.sleep(1100);        // perque la marca de temps canvii
        }

        // 2. Llistar: nomes han de quedar les 3 ultimes
        System.out.println();
        System.out.println("=== COPIES CONSERVADES ===");
        List<InfoCopia> copies = gestor.llistarCopies(fitxer);
        for (int i = 0; i < copies.size(); i++) {
            System.out.printf("  [%d] %s%n", i, copies.get(i).linia());
        }

        // 3. Contingut actual
        System.out.println();
        System.out.println("=== CONTINGUT ACTUAL ===");
        System.out.print(Files.readString(fitxer));

        // 4. Restaurar la copia [1] (la penultima, es a dir, la versio 4)
        System.out.println();
        System.out.println("=== RESTAURANT LA COPIA [1] ===");
        gestor.restaurar(fitxer, 1);
        System.out.print(Files.readString(fitxer));

        // 5. Espai
        System.out.println();
        System.out.printf("=== ESPAI OCUPAT: %.2f KB en %d copies ===%n",
                gestor.espaiOcupat() / 1024.0,
                gestor.llistarCopies(fitxer).size());
    }
}

=== CREANT 5 COPIES (maxim 3) ===
  v1 -> cataleg.txt.20260805-091422.bak
  v2 -> cataleg.txt.20260805-091423.bak
  v3 -> cataleg.txt.20260805-091424.bak
  v4 -> cataleg.txt.20260805-091425.bak
  v5 -> cataleg.txt.20260805-091426.bak

=== COPIES CONSERVADES ===
  [0] cataleg.txt.20260805-091426.bak                     61 bytes  2026-08-05T09:14:26.118Z
  [1] cataleg.txt.20260805-091425.bak                     61 bytes  2026-08-05T09:14:25.012Z
  [2] cataleg.txt.20260805-091424.bak                     61 bytes  2026-08-05T09:14:23.907Z

=== CONTINGUT ACTUAL ===
# Cataleg versio 5
LLIBRE;978-0000000005;Llibre 5;Autor;2020

=== RESTAURANT LA COPIA [1] ===
# Cataleg versio 4
LLIBRE;978-0000000004;Llibre 4;Autor;2020

=== ESPAI OCUPAT: 0,18 KB en 3 copies ===