// --- Proxy de base : un objet "enveloppe" qui intercepte les operations ---
const cible = { nom: "Alice", age: 30 };

const gestionnaire = {
    get(objetCible, propriete, recepteur) {
        console.log(`Lecture de "${String(propriete)}"`);
        return Reflect.get(objetCible, propriete, recepteur);   // delegue au comportement par defaut
    },
    set(objetCible, propriete, valeur, recepteur) {
        console.log(`Ecriture de "${String(propriete)}" = ${valeur}`);
        return Reflect.set(objetCible, propriete, valeur, recepteur);
    },
};

const proxy = new Proxy(cible, gestionnaire);
proxy.nom;              // "Lecture de nom"
proxy.age = 31;           // "Ecriture de age = 31"
console.log(cible.age);    // 31 -- le proxy modifie bien l'objet cible sous-jacent

// --- Reflect : pendant "fonctionnel" des operateurs du langage, API coherente avec les traps ---
console.log(Reflect.has(cible, "nom"));            // equivalent a "nom" in cible
console.log(Reflect.ownKeys(cible));                  // equivalent a Object.getOwnPropertyNames + Symbols
console.log(Reflect.deleteProperty(cible, "age"));      // equivalent a delete cible.age

// --- Validation transparente : refuser certaines valeurs a l'ecriture ---
function creerObjetValide(schema) {
    return new Proxy({}, {
        set(objetCible, propriete, valeur) {
            const validateur = schema[propriete];
            if (validateur && !validateur(valeur)) {
                throw new TypeError(`Valeur invalide pour "${String(propriete)}" : ${valeur}`);
            }
            return Reflect.set(objetCible, propriete, valeur);
        },
    });
}
const utilisateur = creerObjetValide({
    age: (v) => typeof v === "number" && v >= 0,
    email: (v) => typeof v === "string" && v.includes("@"),
});
utilisateur.age = 25;             // OK
try {
    utilisateur.age = -5;
} catch (e) {
    console.error(e.message);
}

// --- has trap : proteger contre les fautes de frappe sur des proprietes "privees" par convention ---
const configurationSecurisee = new Proxy(
    { apiUrl: "https://api.example.com" },
    {
        has(objetCible, propriete) {
            if (typeof propriete === "string" && propriete.startsWith("_")) {
                return false;      // masque les proprietes internes du "in"
            }
            return Reflect.has(objetCible, propriete);
        },
        get(objetCible, propriete) {
            if (!(propriete in objetCible)) {
                throw new ReferenceError(`Propriete inconnue : "${String(propriete)}"`);
            }
            return Reflect.get(objetCible, propriete);
        },
    }
);
console.log(configurationSecurisee.apiUrl);
// console.log(configurationSecurisee.apiUrll);   // ReferenceError immediate, pas juste "undefined"

// --- Valeurs par defaut transparentes ---
function avecValeurParDefaut(objetSource, valeurDefaut) {
    return new Proxy(objetSource, {
        get(objetCible, propriete) {
            return propriete in objetCible ? objetCible[propriete] : valeurDefaut;
        },
    });
}
const compteurs = avecValeurParDefaut({}, 0);
console.log(compteurs.visites);       // 0, sans avoir jamais ete initialise

// --- apply trap : intercepter l'APPEL d'une fonction ---
function fonctionOriginale(a, b) {
    return a + b;
}
const fonctionTracee = new Proxy(fonctionOriginale, {
    apply(cibleFn, thisArg, args) {
        console.log(`Appel avec les arguments : ${args}`);
        const resultat = Reflect.apply(cibleFn, thisArg, args);
        console.log(`Resultat : ${resultat}`);
        return resultat;
    },
});
fonctionTracee(2, 3);

// --- construct trap : intercepter "new" sur une classe/fonction ---
class Produit {
    constructor(nom, prix) {
        this.nom = nom;
        this.prix = prix;
    }
}
const ProduitTrace = new Proxy(Produit, {
    construct(ClasseCible, args) {
        console.log(`Creation d'un Produit avec : ${args}`);
        return Reflect.construct(ClasseCible, args);
    },
});
const p = new ProduitTrace("Clavier", 49.99);

// --- deleteProperty trap : proteger certaines proprietes contre "delete" ---
const objetProtege = new Proxy(
    { id: 1, nom: "essentiel" },
    {
        deleteProperty(objetCible, propriete) {
            if (propriete === "id") {
                throw new Error("Impossible de supprimer la propriete 'id'");
            }
            return Reflect.deleteProperty(objetCible, propriete);
        },
    }
);
try {
    delete objetProtege.id;
} catch (e) {
    console.error(e.message);
}

// --- Proxy revocable : desactiver l'acces a un objet a la demande ---
const { proxy: acces, revoke } = Proxy.revocable({ secret: 42 }, {});
console.log(acces.secret);      // 42
revoke();
try {
    acces.secret;                  // TypeError : impossible d'utiliser un proxy revoque
} catch (e) {
    console.error(e.constructor.name);
}

// --- Cas d'usage reel : etat reactif minimal (base des frameworks type Vue) ---
function reactif(donnees, surChangement) {
    return new Proxy(donnees, {
        set(objetCible, propriete, valeur) {
            const ancienne = objetCible[propriete];
            const resultat = Reflect.set(objetCible, propriete, valeur);
            if (ancienne !== valeur) surChangement(propriete, valeur, ancienne);
            return resultat;
        },
    });
}
const etat = reactif({ compteur: 0 }, (prop, val, ancien) => {
    console.log(`"${prop}" change de ${ancien} a ${val} -- re-render declenche`);
});
etat.compteur++;