/**
 * Surligne le texte correspondant à une recherche dans un élément DOM ou une classe CSS.
 * @param {HTMLElement|string} root - Élément DOM ou nom de classe CSS où effectuer la recherche.
 * @param {string} search - Terme à rechercher et surligner.
 */
function highlightText(root, search) {
    // Si aucun élément ou terme de recherche n'est fourni, on quitte la fonction
    if (!root || !search) return;

    // Si root est une chaîne de caractères, on l'interprète comme une classe CSS
    // et on applique le surlignement à toutes les div portant cette classe
    if (typeof root === "string") {
        const divs = document.querySelectorAll(`div.${root}`);
        divs.forEach(div => highlightText(div, search));
        return;
    }

    /**
     * Normalise un caractère en supprimant les accents et en le mettant en minuscule.
     * @param {string} char - Caractère à normaliser.
     * @returns {string} - Caractère normalisé.
     */
    function normalizeChar(char) {
        return char
            .normalize("NFD") // Décompose les caractères accentués
            .replace(/[\u0300-\u036f]/g, "") // Supprime les diacritiques
            .toLowerCase(); // Convertit en minuscules
    }

    /**
     * Construit une version normalisée d'une chaîne et une carte de correspondance
     * entre les indices des caractères originaux et normalisés.
     * @param {string} str - Chaîne à normaliser.
     * @returns {Object} - Objet contenant la chaîne normalisée et la carte de correspondance.
     */
    function buildNormalizedMap(str) {
        let normalized = "";
        const map = []; // Carte de correspondance entre indices

        for (let i = 0; i < str.length; i++) {
            const norm = normalizeChar(str[i]);
            normalized += norm;

            // Pour chaque caractère normalisé, on stocke l'index original
            for (let j = 0; j < norm.length; j++) {
                map.push(i);
            }
        }

        return { normalized, map };
    }

    /**
     * Récupère tous les nœuds texte dans un élément DOM.
     * @param {HTMLElement} node - Élément DOM à parcourir.
     * @param {Array} [acc=[]] - Accumulateur pour les nœuds texte.
     * @returns {Array} - Tableau des nœuds texte trouvés.
     */
    function getTextNodes(node, acc = []) {
        // Si le nœud est un nœud texte et non vide, on l'ajoute à l'accumulateur
        if (node.nodeType === Node.TEXT_NODE) {
            if (node.nodeValue.trim() !== "") {
                acc.push(node);
            }
            return acc;
        }

        // Si le nœud est un élément HTML, on parcourt ses enfants
        if (node.nodeType === Node.ELEMENT_NODE) {
            const tag = node.tagName.toLowerCase();
            // On ignore certains éléments comme script, style, etc.
            if (["script", "style", "noscript", "iframe"].includes(tag)) {
                return acc;
            }

            // On parcourt récursivement les enfants
            for (const child of node.childNodes) {
                getTextNodes(child, acc);
            }
        }

        return acc;
    }

    /**
     * Entoure les correspondances trouvées dans un nœud texte avec des balises <span>.
     * @param {Text} textNode - Nœud texte à analyser.
     * @param {string} normalizedSearch - Terme de recherche normalisé.
     */
    function wrapMatchesInTextNode(textNode, normalizedSearch) {
        const originalText = textNode.nodeValue;
        const { normalized, map } = buildNormalizedMap(originalText);

        const matches = []; // Tableau pour stocker les positions des correspondances
        let startIndex = 0;

        // Recherche toutes les occurrences du terme normalisé
        while (true) {
            const matchIndex = normalized.indexOf(normalizedSearch, startIndex);
            if (matchIndex === -1) break; // Si aucune correspondance n'est trouvée, on sort de la boucle

            // Convertit les indices normalisés en indices originaux
            const originalStart = map[matchIndex];
            const originalEnd = map[matchIndex + normalizedSearch.length - 1] + 1;

            matches.push([originalStart, originalEnd]);
            startIndex = matchIndex + normalizedSearch.length;
        }

        // Si aucune correspondance n'est trouvée, on quitte la fonction
        if (matches.length === 0) return;

        const fragment = document.createDocumentFragment(); // Fragment DOM pour construire le résultat
        let lastIndex = 0;

        // Parcourt les correspondances et construit le fragment DOM
        for (const [start, end] of matches) {
            // Ajoute le texte avant la correspondance
            if (start > lastIndex) {
                fragment.appendChild(
                    document.createTextNode(originalText.slice(lastIndex, start))
                );
            }

            // Crée un span pour la correspondance et l'ajoute au fragment
            const span = document.createElement("span");
            span.className = "highlight";
            span.textContent = originalText.slice(start, end);
            fragment.appendChild(span);

            lastIndex = end;
        }

        // Ajoute le texte restant après la dernière correspondance
        if (lastIndex < originalText.length) {
            fragment.appendChild(
                document.createTextNode(originalText.slice(lastIndex))
            );
        }

        // Remplace le nœud texte original par le fragment contenant les surlignements
        textNode.parentNode.replaceChild(fragment, textNode);
    }

    // Normalise le terme de recherche et quitte si le résultat est vide
    const normalizedSearch = buildNormalizedMap(search).normalized;
    if (!normalizedSearch) return;

    // Récupère tous les nœuds texte dans l'élément root et applique le surlignement
    const textNodes = getTextNodes(root);
    for (const textNode of textNodes) {
        wrapMatchesInTextNode(textNode, normalizedSearch);
    }
}

/**
 * Supprime tous les surlignements dans un élément DOM ou une classe CSS.
 * @param {HTMLElement|string} root - Élément DOM ou nom de classe CSS où supprimer les surlignements.
 */
function removeHighlight(root) {
    // Si aucun élément n'est fourni, on quitte la fonction
    if (!root) return;

    // Si root est une chaîne de caractères, on l'interprète comme une classe CSS
    // et on supprime les surlignements dans toutes les div portant cette classe
    if (typeof root === "string") {
        const divs = document.querySelectorAll(`div.${root}`);
        divs.forEach(div => removeHighlight(div));
        return;
    }

    // Récupère tous les éléments <span> avec la classe "highlight"
    const highlights = root.querySelectorAll("span.highlight");

    highlights.forEach(span => {
        const parent = span.parentNode;

        // Remplace le span par son contenu texte
        parent.replaceChild(document.createTextNode(span.textContent), span);

        // Fusionne les nœuds texte adjacents pour garder un DOM propre
        parent.normalize();
    });
}