// --- Les limites de JSON.stringify/parse pour cloner ---
const original = {
    date: new Date(),
    ensemble: new Set([1, 2, 3]),
    carte: new Map([["a", 1]]),
    fonction: () => 42,
    indefini: undefined,
    grandEntier: 123n,
    tableau: new Uint8Array([1, 2, 3]),
};

const clonJSON = JSON.parse(JSON.stringify(original));
console.log(clonJSON.date);            // string, PAS un objet Date
console.log(clonJSON.ensemble);          // undefined -- Set totalement perdu
console.log(clonJSON.carte);              // undefined -- Map totalement perdue
console.log(clonJSON.fonction);            // undefined -- les fonctions sont ignorees
console.log("grandEntier" in clonJSON);      // JSON.stringify LEVE une TypeError sur un BigInt

// --- structuredClone() : l'algorithme natif du navigateur, bien plus complet ---
const clone = structuredClone(original);
console.log(clone.date instanceof Date);        // true -- type preserve
console.log(clone.ensemble instanceof Set);       // true
console.log(clone.carte instanceof Map);           // true
console.log(clone.tableau instanceof Uint8Array);    // true
// console.log(structuredClone({ f: () => {} }));   // DataCloneError : les fonctions ne sont PAS clonables

// --- structuredClone gere les references CIRCULAIRES, contrairement a JSON ---
const objetCirculaire = { nom: "noeud" };
objetCirculaire.self = objetCirculaire;
// JSON.stringify(objetCirculaire);          // TypeError : Converting circular structure to JSON
const cloneCirculaire = structuredClone(objetCirculaire);
console.log(cloneCirculaire.self === cloneCirculaire);      // true -- la circularite est preservee

// --- Ce que structuredClone ne peut PAS cloner ---
// Fonctions, Symbols, prototypes personnalises (perd la classe -- devient un objet simple),
// descripteurs de proprietes (getters/setters), et certains objets DOM specifiques.
class Point {
    constructor(x, y) { this.x = x; this.y = y; }
    distance() { return Math.sqrt(this.x ** 2 + this.y ** 2); }
}
const pointOriginal = new Point(3, 4);
const pointClone = structuredClone(pointOriginal);
console.log(pointClone instanceof Point);       // false -- redevient un objet litteral simple
console.log(pointClone.x, pointClone.y);          // donnees preservees, methodes perdues

// --- JSON avec replacer/reviver : serialisation CUSTOM pour des types non supportes ---
function remplacer(cle, valeur) {
    if (valeur instanceof Map) {
        return { __type: "Map", donnees: Array.from(valeur.entries()) };
    }
    if (typeof valeur === "bigint") {
        return { __type: "BigInt", donnees: valeur.toString() };
    }
    return valeur;
}
function reviveur(cle, valeur) {
    if (valeur && valeur.__type === "Map") return new Map(valeur.donnees);
    if (valeur && valeur.__type === "BigInt") return BigInt(valeur.donnees);
    return valeur;
}
const donnees = { carte: new Map([["x", 1]]), id: 9007199254740993n };
const json = JSON.stringify(donnees, remplacer);
const relu = JSON.parse(json, reviveur);
console.log(relu.carte instanceof Map, relu.id);

// --- toJSON() : personnaliser automatiquement la serialisation d'une classe ---
class Argent {
    constructor(montant, devise) {
        this.montant = montant;
        this.devise = devise;
    }
    toJSON() {
        // appele AUTOMATIQUEMENT par JSON.stringify, sans passer de replacer
        return `${this.montant} ${this.devise}`;
    }
}
console.log(JSON.stringify({ prix: new Argent(49.99, "EUR") }));

// --- postMessage entre iframes/workers : utilise structuredClone en interne ---
// worker.postMessage({ carte: new Map([["cle", "valeur"]]) });    // fonctionne nativement,
// contrairement a JSON.stringify qui perdrait la Map avant l'envoi

// --- Transferable objects : deplacer plutot que cloner (voir lecon Web Workers) ---
function envoyerSansCopie(worker, buffer) {
    worker.postMessage({ buffer }, [buffer]);      // transfert de propriete, zero copie
}

// --- Comparaison structurelle profonde (utile pour des tests, du memoization) ---
function egaliteProfonde(a, b) {
    if (a === b) return true;
    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
    const clesA = Object.keys(a);
    const clesB = Object.keys(b);
    if (clesA.length !== clesB.length) return false;
    return clesA.every((cle) => egaliteProfonde(a[cle], b[cle]));
}
console.log(egaliteProfonde({ a: { b: 1 } }, { a: { b: 1 } }));    // true