// ===================================================================
// Machine à café — version avec async/await
// ===================================================================

/**
 * @typedef {object} CoffeeMachineConfig
 * @property {number} TEMPS_SELECTION - Temps en ms pour sélectionner le café.
 * @property {number} TEMPS_MOUTURE - Temps en ms pour moudre les grains.
 * @property {number} TEMPS_CHAUFFAGE - Temps en ms pour chauffer l'eau.
 * @property {number} TEMPS_PREPARATION - Temps en ms pour la préparation finale.
 * @property {number} CLEANING_TIME - Temps en ms pour laver la tasse.
 */

/** @type {CoffeeMachineConfig} */
const config = {
    TEMPS_SELECTION: 500,
    TEMPS_MOUTURE: 700,
    TEMPS_CHAUFFAGE: 1000,
    TEMPS_PREPARATION: 500,
    TEMPS_NETTOYER: 600,
};

// --- API de la machine à café (fonctions "promisifiées") ---
// Chaque fonction retourne une Promise, simulant une opération asynchrone.
// Cette encapsulation sépare la "logique métier" de son orchestration.

const coffeeApi = {
    /**
     * Simule la sélection d'un type de café.
     * @param {string} coffeeName - le nom du café à sélectionner.
     * @returns {Promise<string>} une promesse qui se résout avec le nom du café. Rejette si aucun nom n'est fourni.
     */
    selectionnerCafe(coffeeName) {
        return new Promise((resolve, reject) => {
            console.log(`  - Sélection du café : ${coffeeName}...`);
            setTimeout(() => {
                if (!coffeeName) {
                    return reject(new Error("Aucun type de café n'a été spécifié."));
                }
                console.log(`    -> Café "${coffeeName}" sélectionné.`);
                resolve(coffeeName);
            }, config.TEMPS_SELECTION);
        });
    },
    moudreGrains(coffeeName) {
        return new Promise((resolve) => {
            console.log(`  - Broyage des grains pour "${coffeeName}"...`);
            setTimeout(() => {
                console.log(`    -> Grains moulus.`);
                resolve('grains-moulus');
            }, config.TEMPS_MOUTURE);
        });
    },
    chaufferEau(temperature) {
        return new Promise((resolve) => {
            console.log(`  - Chauffage de l'eau à ${temperature}°C`);
            setTimeout(() => {
                console.log(`    -> Eau chaude prête`);
                resolve('eau-chaude');
            }, config.TEMPS_CHAUFFAGE);
        });
    },
    nettoyerTasse() {
        return new Promise((resolve) => {
            console.log(`  - Lavage de la tasse...`);
            setTimeout(() => {
                console.log(`    -> Tasse propre.`);
                resolve('tasse-propre');
            }, config.TEMPS_NETTOYER);
        });
    },
    preparerCafe(coffeeName) {
        return new Promise((resolve) => {
            console.log(`  - Préparation du café ${coffeeName}...`);
            setTimeout(() => {
                const finalCoffee = `café ${coffeeName} préparé`;
                console.log(`    -> ${finalCoffee.charAt(0).toUpperCase() + finalCoffee.slice(1)}.`);
                resolve(finalCoffee);
            }, config.TEMPS_PREPARATION);
        });
    }
};


// --- Orchestration des Scénarios ---

/**
 * Scénario 1 : préparation simple.
 * Les tâches s'exécutent les unes après les autres. Simple mais plus lent.
 */
async function runSequentialPreparation() {
    console.log("\n--- SCÉNARIO 1 : préparation simple ---");
    console.time("Temps total (séquentiel)");
    try {
        const coffeeName = 'Lungo';
        const selectedCoffee = await coffeeApi.selectionnerCafe(coffeeName);
        await coffeeApi.moudreGrains(selectedCoffee);
        await coffeeApi.chaufferEau(95);
        await coffeeApi.nettoyerTasse();
        const finalCoffee = await coffeeApi.preparerCafe(selectedCoffee);

        console.log(`\nSUCCÈS : votre ${finalCoffee} est servi !`);
    } catch (error) {
        console.error("ERREUR : la préparation a échoué.", error.message);
    } finally {
        console.timeEnd("Temps total (séquentiel)");
    }
}

/**
 * Scénario 2 : préparation optimisée avec exécution concurrente de certaines tâches.
 * Les tâches indépendantes (moudre, chauffer, laver) sont lancées en même temps.
 */
async function runOptimizedPreparation() {
    console.log("\n--- SCÉNARIO 2 : préparation optimisée, avec exécution concurrente de certaines tâches ---");
    console.time("Temps total (optimisé)");
    try {
        const coffeeName = 'Americano';
        const selectedCoffee = await coffeeApi.selectionnerCafe(coffeeName);
        console.log("-> Lancement en parallèle du broyage, du chauffage et du lavage...");
        await Promise.all([
            coffeeApi.moudreGrains(selectedCoffee), // Tâche 1
            coffeeApi.chaufferEau(92),   // Tâche 2
            coffeeApi.nettoyerTasse()               // Tâche 3
        ]);
        console.log("-> Tâches parallèles terminées.");
        const finalCoffee = await coffeeApi.preparerCafe(selectedCoffee);
        console.log(`\nSUCCÈS (optimisé) : votre ${finalCoffee} est servi !`);
    } catch (error) {
        console.error("ERREUR (optimisé) : la préparation a échoué.", error.message);
    } finally {
        console.timeEnd("Temps total (optimisé)");
    }
}

/**
 * Point d'entrée principal pour lancer les démonstrations.
 */
async function main() {
    console.log("=".repeat(50));
    console.log("Démonstration de la gestion asynchrone en JavaScript");
    console.log("=".repeat(50));
    await runSequentialPreparation();
    console.log("\n" + "-".repeat(50) + "\n");
    await runOptimizedPreparation();
}

// Lancement du script
main();