// --- Probleme : JS est mono-thread, un calcul lourd BLOQUE tout le rendu de la page ---
function calculLourdBloquant(n) {
    let total = 0;
    for (let i = 0; i < n; i++) total += Math.sqrt(i);
    return total;
}
// calculLourdBloquant(1_000_000_000);   // gele l'UI pendant tout le calcul

// --- fichier worker.js : execute dans un thread SEPARE, sans acces au DOM ---
// self.onmessage = (event) => {
//     const { n } = event.data;
//     let total = 0;
//     for (let i = 0; i < n; i++) total += Math.sqrt(i);
//     self.postMessage({ resultat: total });
// };

// --- Cote page principale : creation et communication ---
const worker = new Worker("worker.js");

worker.postMessage({ n: 1_000_000_000 });    // envoie des donnees (clonees, pas partagees)

worker.onmessage = (event) => {
    console.log("Resultat recu du worker :", event.data.resultat);
};

worker.onerror = (erreur) => {
    console.error(`Erreur dans le worker : ${erreur.message} (${erreur.filename}:${erreur.lineno})`);
};

// La page reste totalement reactive pendant que le worker calcule en arriere-plan
console.log("L'UI continue de repondre immediatement");

// --- Terminer un worker devenu inutile (libere ses ressources) ---
function nettoyer() {
    worker.terminate();
}

// --- Worker avec Promise : pattern pour une API request/response propre ---
function creerWorkerAvecPromise(url) {
    const w = new Worker(url);
    let prochainId = 0;
    const requetesEnAttente = new Map();

    w.onmessage = (event) => {
        const { id, resultat, erreur } = event.data;
        const { resolve, reject } = requetesEnAttente.get(id);
        requetesEnAttente.delete(id);
        if (erreur) reject(new Error(erreur));
        else resolve(resultat);
    };

    return function appeler(donnees) {
        const id = prochainId++;
        return new Promise((resolve, reject) => {
            requetesEnAttente.set(id, { resolve, reject });
            w.postMessage({ id, ...donnees });
        });
    };
}
// const calculer = creerWorkerAvecPromise("worker.js");
// const resultat = await calculer({ n: 1_000_000 });

// --- Transferable objects : deplacer un ArrayBuffer SANS LE COPIER (zero-copy) ---
const gros_buffer = new ArrayBuffer(100 * 1024 * 1024);    // 100 Mo
// Par defaut, postMessage CLONE les donnees (structured clone) -- couteux pour un gros buffer.
// worker.postMessage({ buffer: gros_buffer });             // copie complete des 100 Mo

// Avec la liste de transfert : le buffer change de PROPRIETAIRE, aucune copie
worker.postMessage({ buffer: gros_buffer }, [gros_buffer]);
console.log(gros_buffer.byteLength);    // 0 -- le buffer est maintenant "neutre" (detache) cote appelant

// --- SharedArrayBuffer : memoire REELLEMENT partagee entre le thread principal et un worker ---
// (necessite les headers COOP/COEP pour des raisons de securite, cote serveur)
// const sab = new SharedArrayBuffer(1024);
// const vue = new Int32Array(sab);
// Atomics.add(vue, 0, 1);       // operation atomique, evite les races entre threads

// --- Pool de workers : repartir des taches sur plusieurs threads (imite un thread pool) ---
class PoolDeWorkers {
    #workers;
    #index = 0;

    constructor(url, taille = navigator.hardwareConcurrency || 4) {
        this.#workers = Array.from({ length: taille }, () => new Worker(url));
    }

    executer(donnees) {
        const w = this.#workers[this.#index];
        this.#index = (this.#index + 1) % this.#workers.length;   // round-robin
        return new Promise((resolve) => {
            w.onmessage = (e) => resolve(e.data);
            w.postMessage(donnees);
        });
    }

    detruire() {
        this.#workers.forEach((w) => w.terminate());
    }
}

// --- Ce qu'un Worker NE PEUT PAS faire ---
// Pas d'acces au DOM (document, window), mais acces a : fetch, setTimeout, IndexedDB,
// et importScripts() pour charger des scripts additionnels dans le worker.