window.addEventListener("load", () => main());

const main = () => {

    let def = {
        a: true,
        b: false,
        c: 5
    };

    let exemple = "a && b || c"
    console.error(exemple, "\n=", parseLogicalExpression(def, exemple));
    console.log("vrai rep d'apres JS:", def.a && def.b || def.c);

    console.log("\n\n-----\n\n ");
    exemple = "!a && b || c && a || c && b && a"
    console.error(exemple, "\n=", parseLogicalExpression(def, exemple));
    console.log("vrai rep d'apres JS:", !def.a && def.b || def.c && def.a || def.c && def.b && def.a);

    console.log("\n\n-----\n\n ");
    exemple = "a || b || a && b && c || c"
    console.error(exemple, "\n=", parseLogicalExpression(def, exemple));
    console.log("vrai rep d'apres JS:", def.a || def.b || def.a && def.b && def.c || def.c);

    console.log("\n\n-----\n\n ");
    exemple = "a || a && !a && !b || !a"
    console.error(exemple, "\n=", parseLogicalExpression(def, exemple));
    console.log("vrai rep d'apres JS:", def.a || def.a && !def.a && !def.b || !def.a);

    console.log("\n\n-----\n\n ");
    exemple = "(a || b) || (a && b) && c"
    console.error(exemple, "\n=", parseLogicalExpression(def, exemple));
    console.log("vrai rep d'apres JS:", def.a || def.b || def.a && def.b && def.c || def.c);

};

const parseLogicalExpression = (subject = Object, expression = String) => {
    // on ajoute les portes non au subject
    Object.keys(subject).forEach(key => {
        subject["!" + key] = !subject[key];
    });

    /* ----------------------------------------------------------------------
    Explication regex pour pas oublier

    ( ... ) -> groupe
    | -> séparé les morceaux qu'on recherche
    [^)] -> récupérer le contenu entre ce qu'on a spécifié, ici ( et )
    + -> au moins un élément
    ---------------------------------------------------------------------- */

    const splitter = (expression = String) => expression.split(/(&&|\|\||\([^)]+\))/).map(str => str.trim());

    const replaceWithRightValues = (subject = Object, tableau = Array) => {
        let i = 0;
        tableau.forEach(expression => {
            Object.keys(subject).forEach(key => {
                if(key == expression) tableau[i] = subject[key];
            });
            i++;
        });
    }

    const gate = (gate = String, array = Array) => {
        let posGate = array.findIndex(element => typeof element == "string")
        if(array[posGate] == gate) {
            console.log("je vais travailler avec la porte", gate, "sur", array);
            console.log("je fais,", array[posGate - 1], gate, array[posGate + 1])
            if(gate == "&&")      array[posGate + 1] = array[posGate - 1] && array[posGate + 1];
            else if(gate == "||") array[posGate + 1] = array[posGate - 1] || array[posGate + 1];
            else return console.error("bad gate type");
            console.log("res:", array[posGate + 1]);
            array.splice(posGate - 1, 2);
            console.log("finit:", array);
        } else console.warn("la porte", gate, "n'a pas la priorité de calcule", array);

        console.log("\n ");
        return array;
    };

    const resolution = (problem = Array) => {
        while(problem.length > 1) ["&&", "||"].forEach(element => problem = gate(element, problem));
    };

    const bracketCalculator = (problem = Array) => {
        // on calcule les parenthèses
        let calculatedBrackets = [] // inialisation du tableau qui va recevoir les réponses des parenthese
        problem.forEach(element => {
            if(typeof element == "string") { // ajout de tous les éléments sauf les parentheses
                if(element.startsWith("(") == 0 || element.endsWith(")") == 0) calculatedBrackets.push(element);
            } else calculatedBrackets.push(element)
            if(typeof element == "string") if(element.startsWith("(") && element.endsWith(")")) {
                element = splitter(element.replace("(", "").replace(")", ""));
                replaceWithRightValues(subject, element);
                resolution(element);
                calculatedBrackets.push(element[0]) // ajout des réponses aux parenthèses
            };
        });

        return calculatedBrackets;
    }

    // expression propre
    let arrayLogicalExpression = splitter(expression);
    
    // -> on retire les string vide
    arrayLogicalExpression = arrayLogicalExpression.filter(element => element != "");

    console.log(arrayLogicalExpression);

    // on remplace par les valeurs de subject
    replaceWithRightValues(subject, arrayLogicalExpression);

    // on supprime les parenthèses
    console.log("avant bracket calculator:", arrayLogicalExpression);
    arrayLogicalExpression = bracketCalculator(arrayLogicalExpression);
    console.log("apres bracket calculator:", arrayLogicalExpression);

    // on résoud les problemes
    resolution(arrayLogicalExpression);

    console.log("resultat final:", arrayLogicalExpression);
    return arrayLogicalExpression[0];
};