// --- Debounce : n'execute la fonction qu'apres une PERIODE D'INACTIVITE ---
// Usage typique : champ de recherche, redimensionnement de fenetre, validation de formulaire
function debounce(fonction, delai) {
    let timeoutId;
    return function (...args) {
        clearTimeout(timeoutId);                 // annule l'appel precedent en attente
        timeoutId = setTimeout(() => fonction.apply(this, args), delai);
    };
}

const rechercherDebounced = debounce((terme) => {
    console.log(`Recherche lancee pour : "${terme}"`);
    // appel API reel ici
}, 300);

// Simule une saisie rapide au clavier : seul le DERNIER appel (apres 300ms d'inactivite) s'execute
document.querySelector("#recherche")?.addEventListener("input", (e) => {
    rechercherDebounced(e.target.value);
});

// --- Throttle : limite l'execution a AU PLUS une fois par intervalle regulier ---
// Usage typique : scroll, mousemove, resize -- garantir un flux constant, pas juste la fin
function throttle(fonction, intervalle) {
    let enAttente = false;
    let dernierArgs = null;
    return function (...args) {
        dernierArgs = args;
        if (!enAttente) {
            fonction.apply(this, dernierArgs);
            enAttente = true;
            setTimeout(() => {
                enAttente = false;
            }, intervalle);
        }
    };
}

const gererScrollThrottled = throttle(() => {
    console.log(`Position de scroll : ${window.scrollY}`);
}, 200);

window.addEventListener("scroll", gererScrollThrottled);

// --- Version throttle "leading + trailing" : execute au debut ET a la fin de la periode ---
function throttleAvance(fonction, intervalle) {
    let dernierAppel = 0;
    let timeoutId = null;
    return function (...args) {
        const maintenant = Date.now();
        const tempsRestant = intervalle - (maintenant - dernierAppel);
        if (tempsRestant <= 0) {
            clearTimeout(timeoutId);
            dernierAppel = maintenant;
            fonction.apply(this, args);
        } else if (!timeoutId) {
            timeoutId = setTimeout(() => {
                dernierAppel = Date.now();
                timeoutId = null;
                fonction.apply(this, args);
            }, tempsRestant);
        }
    };
}

// --- Debounce avec execution immediate (leading edge) ---
function debounceImmediat(fonction, delai) {
    let timeoutId;
    return function (...args) {
        const appelImmediat = !timeoutId;
        clearTimeout(timeoutId);
        timeoutId = setTimeout(() => {
            timeoutId = null;
        }, delai);
        if (appelImmediat) fonction.apply(this, args);   // execute au PREMIER appel, pas au dernier
    };
}

// --- Debounce annulable (pattern utile en production) ---
function debounceAnnulable(fonction, delai) {
    let timeoutId;
    const debounced = function (...args) {
        clearTimeout(timeoutId);
        timeoutId = setTimeout(() => fonction.apply(this, args), delai);
    };
    debounced.annuler = () => clearTimeout(timeoutId);
    return debounced;
}

const sauvegardeAuto = debounceAnnulable(() => console.log("Sauvegarde automatique"), 1000);
sauvegardeAuto();
sauvegardeAuto.annuler();       // annule la sauvegarde en attente (ex: si l'utilisateur quitte la page)

// --- requestAnimationFrame : throttle naturel pour les animations (aligne sur le rafraichissement ecran) ---
function gererMouseMoveOptimise() {
    let ticking = false;
    window.addEventListener("mousemove", (event) => {
        if (!ticking) {
            requestAnimationFrame(() => {
                console.log(event.clientX, event.clientY);
                ticking = false;
            });
            ticking = true;
        }
    });
}