// --- WeakRef : contient une reference qui NE MAINTIENT PAS l'objet en vie ---
let utilisateur = { nom: "Alice" };
const referenceFaible = new WeakRef(utilisateur);

console.log(referenceFaible.deref());      // { nom: "Alice" } -- tant que "utilisateur" existe encore

utilisateur = null;      // plus aucune reference FORTE vers l'objet
// A un moment INDETERMINE (decide par le moteur), le GC peut collecter l'objet.
// console.log(referenceFaible.deref());   // peut devenir "undefined", sans garantie de delai

// --- Difference avec WeakMap/WeakSet : WeakRef s'utilise sur UNE valeur isolee ---
// WeakMap/WeakSet exigent des CLES objets ; WeakRef enveloppe directement UNE reference.

// --- Cas d'usage n°1 : cache qui n'empeche pas la collecte des entrees non utilisees ---
class CacheFaible {
    #cache = new Map();      // cle -> WeakRef(valeur)

    obtenir(cle, fabrique) {
        const ref = this.#cache.get(cle);
        const valeurExistante = ref?.deref();
        if (valeurExistante !== undefined) {
            return valeurExistante;      // reutilise l'objet encore vivant
        }
        const nouvelleValeur = fabrique();
        this.#cache.set(cle, new WeakRef(nouvelleValeur));
        return nouvelleValeur;
    }
}
const cacheImages = new CacheFaible();
// Si plus personne d'autre ne retient l'image decodee, le GC peut la liberer :
// le cache ne provoque alors AUCUNE fuite memoire, contrairement a une Map classique.

// --- FinalizationRegistry : etre notifie APRES la collecte d'un objet ---
const registre = new FinalizationRegistry((valeurNettoyage) => {
    console.log(`Objet collecte, nettoyage associe : ${valeurNettoyage}`);
});

function creerRessource(id) {
    const ressource = { id, gros_buffer: new ArrayBuffer(1024 * 1024) };
    registre.register(ressource, `ressource-${id}`);      // 2e argument : donnee passee au callback
    return ressource;
}

let r = creerRessource(1);
r = null;
// Le callback peut s'executer plus tard, voire JAMAIS si le programme se termine avant --
// AUCUNE garantie de timing. Ne JAMAIS baser une logique metier dessus.

// --- unregister : annuler l'enregistrement si l'objet est nettoye manuellement avant ---
const jetonDesenregistrement = {};
function creerRessourceAvecNettoyageManuel(id) {
    const ressource = { id };
    registre.register(ressource, `ressource-${id}`, jetonDesenregistrement);
    return {
        ressource,
        fermer() {
            registre.unregister(jetonDesenregistrement);      // evite un double-nettoyage
            console.log(`Ressource ${id} fermee explicitement`);
        },
    };
}

// --- Regle absolue : WeakRef/FinalizationRegistry ne sont PAS un remplacement de try/finally ---
// MAUVAIS : compter sur le GC pour liberer une ressource critique (fichier, connexion, verrou)
class ConnexionMauvaisePratique {
    constructor() {
        this.ouverte = true;
        registre.register(this, "connexion-non-fermee", this);
        // Le GC pourrait ne JAMAIS passer avant la fin du programme : fuite de ressource garantie
    }
}

// BON : liberer explicitement via un pattern deterministe (voir la lecon Debounce/Throttle,
// ou "using" -- explicit resource management, ES2024)
class ConnexionCorrecte {
    #ouverte = true;
    constructor() { this.#ouverte = true; }
    fermer() {
        this.#ouverte = false;
        console.log("Connexion fermee de facon deterministe");
    }
    [Symbol.dispose]() {
        this.fermer();          // integration avec "using" (ES2024, cf. TC39 stage 4)
    }
}
// using connexion = new ConnexionCorrecte();
// -- fermer() est appele AUTOMATIQUEMENT et IMMEDIATEMENT a la sortie du bloc, sans GC

// --- Observer une structure DOM sans empecher sa collecte (cas d'usage reel) ---
function observerSansRetenir(element, callback) {
    const ref = new WeakRef(element);
    const intervalId = setInterval(() => {
        const el = ref.deref();
        if (!el || !document.contains(el)) {
            clearInterval(intervalId);      // l'element a disparu du DOM (ou a ete collecte)
            return;
        }
        callback(el);
    }, 1000);
}