[Script] JVChat Premium

function apposerNouveauBoutonCiterPourMessagesSupprimés(un_post) {
    if (un_post.dataset.leBoutonATIlEteAjoute) {
        return ;
    }
    un_post.dataset.leBoutonATIlEteAjoute = "oui" ;

    const ancien_bouton_citer = un_post.querySelector(".jvchat-picto.jvchat-quote") ;
    if (!ancien_bouton_citer) {
        return ;
    }
    const bouton_signaler = ancien_bouton_citer.nextSibling?.nextSibling ;
    if (!bouton_signaler || !bouton_signaler.parentNode) {
        return ;
    }
    const nouveau_bouton_citer = document.createElement("span") ;
    nouveau_bouton_citer.title = "Citer message supprimé" ;
    nouveau_bouton_citer.classList.add("jvchat-picto", "jvchat-quote") ;
    nouveau_bouton_citer.addEventListener("click", quoteDeleted) ;
    bouton_signaler.parentNode.insertBefore(nouveau_bouton_citer, bouton_signaler.previousSibling) ;
    ancien_bouton_citer.remove() ;
}

function quoteDeleted(targ) {
    const cible = targ.currentTarget ;
    const message = cible.closest(".jvchat-message") ; // ou ".jvchat-message-deleted"
    const citation = reverseQuote(message) ;
    const boîte_textuelle = document.querySelector("#message_topic") ;

    insertAtCursor(boîte_textuelle, citation) ;
    boîte_textuelle.focus() ;
}

const ID_CIBLE = "message_topic" ;
let zone_texte = document.getElementById(ID_CIBLE) ;
const PLACEHOLDER_JVCHAT = "Hop hop hop, le message ne va pas s'écrire tout seul !" ;

function est_ce_que_la_zone_texte_est_chargée() {
    return document.querySelector("#message_topic") !== null ; // plus sûr que return zone_texte !== null ; car zone_texte est fixe à ce stade
}

function est_ce_que_JVChat_est_activé() {
    if (!zone_texte) {
        return false ;
    }
    const placeholder = zone_texte.getAttribute("placeholder") || "" ;
    return placeholder === PLACEHOLDER_JVCHAT ;
}

let état_du_chargement = null ;

const détecteur_de_zone_texte = new MutationObserver(() => {
    const chargé = est_ce_que_la_zone_texte_est_chargée() ;
    if (chargé) {
        if (état_du_chargement !== chargé) {
            état_du_chargement = chargé ;
            console.log("ZONE CHARGÉE !") ;
        }

        zone_texte = document.getElementById(ID_CIBLE) ; // important car le premier document.getElementById(ID_CIBLE) (dans le let zone_texte) peut avoir foiré.

        const détecteur_de_jvchat = new MutationObserver(() => {
            if (!est_ce_que_JVChat_est_activé()) {
                console.log("Vous n'êtes pas encore en mode JVChat.") ;
            } else { // DÉBUT ELSE
                console.log("VOUS ÊTES BIEN EN MODE JVCHAT À PRÉSENT !") ;
                const container = document.getElementById("jvchat-main") ;

                function observeMessage(messageElem) {
                    const msgObserver = new MutationObserver(mutations => {
                        for (const mutation of mutations) {
                            if (mutation.type === "attributes" && mutation.attributeName === "class") {
                                if (messageElem.classList.contains("jvchat-message-deleted")) {
                                    apposerNouveauBoutonCiterPourMessagesSupprimés(messageElem) ;
                                }
                            }
                        }
                    }) ;
                    msgObserver.observe(messageElem, { attributes: true, attributeFilter: ["class"] }) ;
                }

                // Observer le container pour détecter les nouveaux messages
                const containerObserver = new MutationObserver(mutations => {
                    for (const mutation of mutations) {
                        if (mutation.type === "childList" && mutation.addedNodes.length) {
                            mutation.addedNodes.forEach(node => {
                                if (node.nodeType === 1 && node.classList.contains("jvchat-bloc-message")) {
                                    const msg = node.querySelector(".jvchat-message") ;
                                    if (msg) {
                                        observeMessage(msg) ;
                                        // Si déjà supprimé au moment de l'ajout
                                        if (msg.classList.contains("jvchat-message-deleted")) {
                                            apposerNouveauBoutonCiterPourMessagesSupprimés(msg) ;
                                        }
                                    }
                                }
                            }) ;
                        }
                    }
                }) ;

                // Démarrer observation sur container
                containerObserver.observe(container, { childList: true }) ;

                // Observer aussi tous les messages déjà existants
                container.querySelectorAll(".jvchat-message").forEach(msg => {
                    observeMessage(msg) ;
                    if (msg.classList.contains("jvchat-message-deleted")) {
                        apposerNouveauBoutonCiterPourMessagesSupprimés(msg) ;
                    }
                }) ;

            } // FIN ELSE
        }) ; // fin déclaration de la constante détecteur_de_jvchat

        détecteur_de_jvchat.observe(zone_texte, {
            attributes: true,
            attributeFilter: ["placeholder"]
        }) ;
    } // FIN if(chargé)
}) ;

const corps_de_page = document.body ;

détecteur_de_zone_texte.observe(corps_de_page, {
    childList: true,
    subtree: true
}) ;

function setTextAreaValue(textarea, value) {
    const prototype = Object.getPrototypeOf(textarea);
    const nativeSetter = Object.getOwnPropertyDescriptor(prototype, 'value').set;
    nativeSetter.call(textarea, value);
    textarea.dispatchEvent(new Event('input', { bubbles: true }));
}

function insertAtCursor(input, textToInsert) {
    const value = input.value;
    const start = input.selectionStart;
    const end = input.selectionEnd;
    const newValue = value.slice(0, start) + textToInsert + value.slice(end);
    setTextAreaValue(input, newValue);
    input.selectionStart = input.selectionEnd = start + textToInsert.length;
}

function reverseQuote(blocMessage) {
    let author = blocMessage.getElementsByClassName("jvchat-author")[0].textContent.trim();
    let date = blocMessage.getElementsByClassName("jvchat-date")[0].getAttribute("to-quote");
    let header = `> Le ${date} ${author} a écrit :\n`;
    let quoted = reverseMessage(blocMessage.getElementsByClassName("txt-msg")[0], true);
    return header + quoted + '\n\n';
}

function reverseMessage(node, isInit, isUl) {
    let quote = "";
    let prevIsP = false;
    let startsWithSpoil = false;

    for (let child of node.childNodes) {
        let name = child.nodeName;

        switch (name) {
            case "P": {
                quote += reverseMessage(child) + "\n\n";
                break;
            }
            case "STRONG": {
                quote += "'''" + reverseMessage(child) + "'''";
                break;
            }
            case "U": {
                quote += "<u>" + reverseMessage(child) + "</u>";
                break;
            }
            case "S": {
                quote += "<s>" + reverseMessage(child) + "</s>";
                break;
            }
            case "EM": {
                quote += "''" + reverseMessage(child) + "''";
                break;
            }
            case "BR": {
                quote += "\n";
                break;
            }
            case "UL": {
                quote += reverseMessage(child, false, true) + "\n\n";
                break;
            }
            case "OL": {
                quote += reverseMessage(child, false, false) + "\n\n";
                break;
            }
            case "LI": {
                if (isUl === true) {
                    quote += "* " + reverseMessage(child) + "\n";
                } else {
                    quote += "# " + reverseMessage(child) + "\n";
                }
                break;
            }
            case "DIV": {
                let classList = child.classList;
                if (classList.contains("bloc-spoil-jv")) {
                    if (quote === "") {
                        startsWithSpoil = true;
                    }
                    quote += "< spoil>" + reverseMessage(child) + "</ spoil>\n\n"
                } else if (classList.contains("contenu-spoil")) {
                    quote += reverseMessage(child);
                }
                break;
            }
            case "SPAN": {
                let classList = child.classList;
                if (classList.contains("bloc-spoil-jv")) {
                    quote += "< spoil>" + reverseMessage(child) + "</ spoil>";
                } else if (classList.contains("contenu-spoil")) {
                    quote += reverseMessage(child);
                }
                break;
            }
            case "LABEL": {
                break;
            }
            case "INPUT": {
                break;
            }
            case "IMG": {
                quote += child.alt;
                break;
            }
            case "A": {
                if (child.href) {
                    quote += child.href;
                } else {
                    quote += reverseMessage(child);
                }
                break;
            }
            case "PRE": {
                quote += reverseMessage(child) + "\n\n";
                break;
            }
            case "CODE": {
                quote += "< code>" + child.textContent + "</ code>";
                break;
            }
            case "BLOCKQUOTE": {
                if (prevIsP) {
                    quote = quote.trimEnd() + "\n" + reverseMessage(child).replace(/^/gm, '> ') + "\n\n";
                } else {
                    quote += reverseMessage(child).replace(/^/gm, '> ') + "\n\n";
                }

                break;
            }
            case "#text": {
                // The "isInit" check is to prevent the empty text surroudning message
                // However, it may happen that the root node contains valid text child, so it need to be added somehow
                // For some reason, an "new line" may be missing in this case, so just add it
                if (!isInit || child.textContent.trim() !== "") {
                    quote += child.textContent;
                    if (isInit && !quote.endsWith("\n")) {
                        quote += "\n";
                    }
                }
                break;
            }
            default: {
                break;
            }
        }

        if (name == "P") {
            prevIsP = true;
        } else {
            prevIsP = false;
        }
    }

    quote = quote.replace(/(\n){3,}/g, '\n\n');

    if (startsWithSpoil && isInit) {
        quote = "\n" + quote.trimEnd();
    } else {
        quote = quote.trim();
    }

    if (isInit) {
        quote = quote.replace(/^/gm, '> ');
    }

    return quote;
}