// Le protocole iterateur : un objet avec une methode next() retournant { value, done }
function creerIterateur(max) {
    let actuel = 0;
    return {
        next() {
            if (actuel < max) {
                return { value: actuel++, done: false };
            }
            return { value: undefined, done: true };
        },
    };
}
const it = creerIterateur(3);
console.log(it.next(), it.next(), it.next(), it.next());

// Symbol.iterator : rendre un objet ITERABLE (utilisable avec for...of, spread, destructuring)
class Plage {
    constructor(debut, fin) {
        this.debut = debut;
        this.fin = fin;
    }
    [Symbol.iterator]() {
        let actuel = this.debut;
        const fin = this.fin;
        return {
            next() {
                return actuel < fin
                    ? { value: actuel++, done: false }
                    : { value: undefined, done: true };
            },
        };
    }
}

for (const n of new Plage(0, 5)) {
    console.log(n);
}
console.log([...new Plage(0, 3)]);          // le spread utilise aussi Symbol.iterator

// --- Generateurs : sucre syntaxique bien plus simple pour ecrire un iterateur ---
function* plageGen(debut, fin) {
    for (let i = debut; i < fin; i++) {
        yield i;             // suspend l'execution, renvoie une valeur
    }
}

for (const n of plageGen(0, 5)) {
    console.log(n);
}

// Un generateur EST un iterateur : consommable manuellement
const gen = plageGen(0, 3);
console.log(gen.next());       // { value: 0, done: false }
console.log(gen.next());        // { value: 1, done: false }

// Generateur infini, consomme a la demande
function* nombresInfinis() {
    let n = 0;
    while (true) yield n++;
}
function prendre(iterable, n) {
    const resultat = [];
    for (const valeur of iterable) {
        if (resultat.length >= n) break;
        resultat.push(valeur);
    }
    return resultat;
}
console.log(prendre(nombresInfinis(), 5));    // [0, 1, 2, 3, 4]

// yield* : delegation vers un sous-generateur
function* interne() {
    yield "a";
    yield "b";
}
function* externe() {
    yield 1;
    yield* interne();          // delegue a "interne"
    yield 2;
}
console.log([...externe()]);    // [1, "a", "b", 2]

// Generateurs pour implementer un iterateur d'arbre (parcours en profondeur)
class Noeud {
    constructor(valeur, enfants = []) {
        this.valeur = valeur;
        this.enfants = enfants;
    }
    *[Symbol.iterator]() {
        yield this.valeur;
        for (const enfant of this.enfants) {
            yield* enfant;              // recursion via delegation
        }
    }
}
const arbre = new Noeud(1, [new Noeud(2, [new Noeud(4)]), new Noeud(3)]);
console.log([...arbre]);    // [1, 2, 4, 3]

// Communication bidirectionnelle avec generator.next(valeur)
function* dialogue() {
    const nom = yield "Quel est ton nom ?";
    const age = yield `Bonjour ${nom}, quel age as-tu ?`;
    return `${nom} a ${age} ans`;
}
const conv = dialogue();
console.log(conv.next());              // demarre, ignore la 1ere valeur envoyee
console.log(conv.next("Alice"));         // envoie "Alice" comme valeur de "yield" precedent
console.log(conv.next(30));               // envoie 30

// Symbol : valeurs uniques, utilisees comme cles de proprietes non-collisionnables
const ID_UNIQUE = Symbol("id");
const objet = { [ID_UNIQUE]: 42, nom: "test" };
console.log(Object.keys(objet));           // ["nom"] -- les Symbols n'apparaissent pas ici
console.log(objet[ID_UNIQUE]);               // 42