const formula = "if( 1; round(10,2); 2*10)";
const formula = "round2(15.542 + 0.5)";
const formula1 = "max(2*15; 10; 20)";
const formula2 = "min(2; 10; 20)";
const formula3 = "random()";
const formula4 = "if ( max(0;10) ; 10*5 ; 15 ) ";
const formula5 = "sum(2*15; 10; 20)";
const calculator = new Calculator(null);
console.log(formula+" = "+calculator.calc(formula));
console.log(formula1+" = "+calculator.calc(formula1));
console.log(formula2+" = "+calculator.calc(formula2));
console.log(formula3+" = "+calculator.calc(formula3));
console.log(formula4+" = "+calculator.calc(formula4));
console.log(formula5+" = "+calculator.calc(formula5));

const Types = {
    Cell: "cell" ,
    Number: "number" ,
    Operator: "operator" ,
    Function: "function",
    LeftBracket: "left bracket" ,
    RightBracket: "right bracket",
    Semicolon: "semicolon",
    Text: "text"
};

const Operators = {
    ["+"]: { priority: 1, calc: (a, b) => a + b },  // сложение
    ["-"]: { priority: 1, calc: (a, b) => a - b },  //вычитание
    ["*"]: { priority: 2, calc: (a, b) => a * b },  // умножение
    ["/"]: { priority: 2, calc: (a, b) => a / b },  // деление
    ["^"]: { priority: 3, calc: (a, b) => Math.pow(a, b) }, // возведение в степень
};

const Functions = {
    ["random"]: {priority: 4, calc: () => Math.random() }, // случайное число
    ["round"]:  {priority: 4, calc: (a) => Math.round(a) },  // округление до целого
    ["round1"]: {priority: 4, calc: (a) => Math.round(a * 10) / 10 },
    ["round2"]: {priority: 4, calc: (a) => Math.round(a * 100) / 100 },
    ["round3"]: {priority: 4, calc: (a) => Math.round(a * 1000) / 1000 },
    ["round4"]: {priority: 4, calc: (a) => Math.round(a * 10000) / 10000 },
    ["sum"]:    {priority: 4, calc: (...args) => args.reduce( (sum, current) => sum + current, 0) },
    ["min"]:    {priority: 4, calc: (...args) => Math.min(...args) },
    ["max"]:    {priority: 4, calc: (...args) => Math.max(...args) },
    ["if"]:     {priority: 4, calc: (...args) => args[0] ? args[1] : (args[2] ? args[2] : 0) }
};

class Token {
    static separators = Object.keys(Operators).join("")+"();"; // запоминает строку разделителей вида "+-*/^();""
    static sepPattern = `[${Token.escape(Token.separators)}]`; // формирует шаблон разделитетей вида "[\+\-\*\/\^\(\)]"
    static funcPattern = new RegExp(`${Object.keys(Functions).join("|").toLowerCase()}`, "g");
    #type;
    #value;
    #calc;
    #priority;
    /**
     * Конструктор токена, которому передаются в качестве аргументов тип и значение токена,
     * а прочие параметры устанавливаются в зависимости от типа
     */
    constructor(type, value){
        this.#type = type;
        this.#value = value;
        if ( type === Types.Operator ) {
            this.#calc = Operators[value].calc;
            this.#priority = Operators[value].priority;
        }
        else if ( type === Types.Function ) {
            this.#calc = Functions[value].calc;
            this.#priority = Functions[value].priority;
        }
    }
    /**
     * Реализация геттеров для приватных полей класса
     */
    /**
     * Разбирает формулу на токены
     * @param {String} formula - строка с формулой
     */
    static getTokens(formula){
        let tokens = [];
        let tokenCodes = formula.replace(/\s+/g, "") // очистка от пробельных символов
            .replace(/(?<=\d+),(?=\d+)/g, ".") // заменяет запятую на точку (для чисел)
            .replace(/^\-/g, "0-") // подставляет отсутсующий 0 для знака "-" в начале строки
            .replace(/\(\-/g, "(0-") // подставляет отсутсующий 0 для знака "-" в середине строки
            .replace(new RegExp (Token.sepPattern, "g"), "&$&&") // вставка знака & перед разделителями
            .split("&")  // разбиение на токены по символу &
            .filter(item => item != ""); // удаление из массива пустых элементов
        tokenCodes.forEach(function (tokenCode){
            if ( tokenCode in Operators )
                tokens.push( new Token ( Types.Operator, tokenCode ));
            else if ( tokenCode === "(" )
                tokens.push ( new Token ( Types.LeftBracket, tokenCode ));
            else if ( tokenCode === ")" )
                tokens.push ( new Token ( Types.RightBracket, tokenCode ));
            else if ( tokenCode === ";" )
                tokens.push ( new Token ( Types.Semicolon, tokenCode ));
            else if ( tokenCode.toLowerCase().match( Token.funcPattern ) !== null  )
                tokens.push ( new Token ( Types.Function, tokenCode.toLowerCase() ));
            else if ( tokenCode.match(/^\d+[.]?\d*/g) !== null )
                tokens.push ( new Token ( Types.Number, Number(tokenCode) ));
            else if ( tokenCode.match(/^[A-Z]+[1-9]+/g) !== null )
                tokens.push ( new Token ( Types.Cell, tokenCode ));
        });
        return tokens;
    }
    /**
     * Экранирование обратным слешем специальных символов
     * @param {String} str
     */
    static escape(str) {
        return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
  }
}

class Calculator {
    #tdata;
    /**
     * Конструктор калькулятора
     * @param {Map} cells хеш ячеек, содержащих формулы или первичные значения
     */
    constructor(tableData) {
        this.#tdata = tableData;
    }
    /**
     * Расчет значения для формулы
     * @param {Array|String} formula - массив токенов или формула строки
     */
    calc(formula){
        let tokens = Array.isArray(formula) ? formula : Token.getTokens(formula);
        let operators = [];
        let operands = [];
        let funcs = [];
        let params = new Map();
        tokens.forEach( token => {
            switch(token.type) {
                case Types.Number :
                    operands.push(token);
                    break;
                case Types.Cell :
                    if ( this.#tdata.isNumber(token.value) ) {
                        operands.push(this.#tdata.getNumberToken(token));
                    }
                    else if ( this.#tdata.isFormula(token.value) ) {
                        let formula = this.#tdata.getTokens(token.value);
                        operands.push(new Token(Types.Number, this.calc(formula)));
                    }
                    else {
                        operands.push(new Token(Types.Number, 0));
                    }
                    break;
                case Types.Function :
                    funcs.push(token);
                    params.set(token, []);
                    operators.push(token);
                    break;
                case Types.Semicolon :
                    this.calcExpression(operands, operators, 1);
                    // получить имя функции из стека операторов
                    let funcToken = operators[operators.length-2];
                    // извлечь из стека последний операнд и добавить его в параметы функции
                    params.get(funcToken).push(operands.pop());
                    break;
                case Types.Operator :
                    this.calcExpression(operands, operators, token.priority);
                    operators.push(token);
                    break;
                case Types.LeftBracket :
                    operators.push(token);
                    break;
                case Types.RightBracket :
                    this.calcExpression(operands, operators, 1);
                    operators.pop();
                    // если последний оператор в стеке является функцией
                    if (operators.length && operators[operators.length-1].type == Types.Function ) {
                        // получить имя функции из стека операторов
                        let funcToken = operators.pop();
                        // получить массив токенов аргументов функции
                        let funcArgs = params.get(funcToken);
                        let paramValues = [];
                        if ( operands.length ) {
                            // добавить последний аргумент функции
                            funcArgs.push(operands.pop());
                            // получить массив значений всех аргументов функции
                            paramValues = funcArgs.map( item => item.value );
                        }
                        // вычислить значение функции и положить в стек операндов
                        operands.push(this.calcFunction(funcToken.calc, ...paramValues));
                    }
                    break;
            }
        });
        this.calcExpression(operands, operators, 0);
        return operands.pop().value;
    }
    /**
     * Вычисление подвыражения внутри (без) скобок
     * @param {Array} operands массив операндов
     * @param {Array} operators массив операторов
     * @param {Number} minPriority минимальный приоритет для вычисления выражения
     */
    calcExpression (operands, operators, minPriority) {
        while ( operators.length && ( operators[operators.length-1].priority ) >= minPriority ) {
            let rightOperand = operands.pop().value;
            let leftOperand = operands.pop().value;
            let operator = operators.pop();
            let result = operator.calc(leftOperand, rightOperand);
            if ( isNaN(result) || !isFinite(result) ) result = 0;
            operands.push(new Token ( Types.Number, result ));
        }
    }
    /**
     * Вычисление значений функции
     * @param {T} func - функция обработки аргументов
     * @param  {...Number} params - массив числовых значений аргументов
     */
    calcFunction(calc, ...params) {
        return new Token(Types.Number, calc(...params));
    }
}