// --- Le garbage collector de V8 : generationnel, avec Mark-and-Sweep ---
// Heap divise en "young generation" (Scavenger, GC frequent et rapide) et
// "old generation" (Mark-Compact, GC moins frequent mais plus couteux).
// Un objet qui survit a plusieurs cycles de jeune generation est "promu" en vieille generation.

// Un objet devient eligible au GC quand il n'est plus ACCESSIBLE depuis les racines
// (variables globales, pile d'appel, closures actives) -- pas juste "non utilise".

// --- Fuite memoire n°1 : variables globales accidentelles ---
function fuiteGlobale() {
    donneesOubliees = new Array(1_000_000).fill("x");    // pas de let/const : devient globale !
}
// "use strict" empeche ce piege en levant une erreur explicite

// --- Fuite memoire n°2 : timers/listeners jamais nettoyes ---
class ComposantAvecFuite {
    constructor() {
        this.donnees = new Array(100_000).fill("data");
        setInterval(() => {
            console.log(this.donnees.length);     // la closure retient "this" indefiniment
        }, 1000);
        // Le composant ne sera JAMAIS collecte tant que l'intervalle tourne, meme si "detruit"
    }
}

class ComposantSansFuite {
    #intervalId;
    constructor() {
        this.donnees = new Array(100_000).fill("data");
        this.#intervalId = setInterval(() => console.log(this.donnees.length), 1000);
    }
    detruire() {
        clearInterval(this.#intervalId);    // libere la reference explicitement
    }
}

// --- Fuite memoire n°3 : closures qui retiennent des objets volumineux inutilement ---
function creerGestionnaireEvenement() {
    const grosseDonnee = new Array(1_000_000).fill("x");     // gros objet
    const idNecessaire = grosseDonnee[0];                       // on n'a besoin que d'UNE valeur

    // MAUVAIS : la closure capture TOUTE la variable grosseDonnee, meme si seul idNecessaire compte
    return function () {
        console.log(grosseDonnee[0]);
    };
    // BON : n'extraire QUE ce qui est necessaire avant de retourner la closure
    // return function () { console.log(idNecessaire); };
}

// --- Fuite memoire n°4 : caches non bornes ---
const cacheNonBorne = new Map();
function memoiserSansLimite(cle, calcul) {
    if (!cacheNonBorne.has(cle)) {
        cacheNonBorne.set(cle, calcul());       // grandit indefiniment, jamais purge
    }
    return cacheNonBorne.get(cle);
}

// Solution : cache LRU borne, ou WeakMap si les cles sont des objets
class CacheLRU {
    #capacite;
    #cache = new Map();
    constructor(capacite) {
        this.#capacite = capacite;
    }
    obtenir(cle) {
        if (!this.#cache.has(cle)) return undefined;
        const valeur = this.#cache.get(cle);
        this.#cache.delete(cle);
        this.#cache.set(cle, valeur);       // remet en fin (le plus recemment utilise)
        return valeur;
    }
    definir(cle, valeur) {
        if (this.#cache.has(cle)) this.#cache.delete(cle);
        else if (this.#cache.size >= this.#capacite) {
            this.#cache.delete(this.#cache.keys().next().value);   // supprime le plus ancien
        }
        this.#cache.set(cle, valeur);
    }
}

// --- WeakMap/WeakSet : references qui n'empechent PAS le GC ---
const metadonneesParObjet = new WeakMap();     // les cles doivent etre des objets
function associerMetadonnees(objet, meta) {
    metadonneesParObjet.set(objet, meta);
    // si "objet" n'a plus d'autre reference ailleurs, il PEUT etre collecte,
    // et son entree dans la WeakMap disparait automatiquement -- pas de fuite
}

// --- Optimisations V8 : shapes / hidden classes (voir lecon internals pour le detail) ---
// Garder une structure d'objet STABLE (memes proprietes, meme ordre) permet a V8
// d'optimiser fortement l'acces aux proprietes.
function CreerPointOptimal(x, y) {
    this.x = x;      // toujours dans le meme ordre -> meme "shape" -> code optimise reutilise
    this.y = y;
}
function creerPointSousOptimal(x, y, ajouterZ) {
    const p = { x, y };
    if (ajouterZ) p.z = 0;      // shape DIFFERENTE selon les appels -> deoptimisation possible
    return p;
}

// --- Mesurer la memoire : performance.memory (Chrome) ou --inspect (Node) ---
// console.log(performance.memory.usedJSHeapSize);