"use strict";

let ind = 0;
let expr = "";

function MyException(message) {
    this.message = message
}

function getFullByRegExp(reg) {
    // /\d/ - digits
    // /\s/ - blank space
    // /\S/ - not blank space
    // /[A-Za-z]/ - alphabetic
    let res = "";
    while (ind < expr.length && reg.test(expr[ind])) {
        res += expr[ind];
        ind++;
    }
    return res;
}

function skipWhiteSpaces() {
    while (ind < expr.length && /\s/.test(expr[ind])) {
        ind++;
    }
}

function isNumber(s) {
    if (s.length === 0) return false;
    let pos = 0;
    if (s[0] === '-' || s[0] === '+') {
        if (s.length > 1) {
            pos++;
        } else {
            return false;
        }
    }
    while (pos < s.length) {
        if (/\d/.test(s[pos])) {
            pos++;
        } else {
            return false;
        }
    }
    return true;
}

function readBrackets() {
    ind++; // вызывается всегда при '('
    let operation = getNextToken();
    if (!OPERATIONS.has(operation)) {
        throw new MyException("Unknown operation: " + operation);
    }
    let op = getOperands();
    if (OPERATIONS.get(operation)[1] !== 0 && OPERATIONS.get(operation)[1] !== op.length) {
        throw new MyException("Operation: " + operation + ". Expected " +
            OPERATIONS.get(operation)[1] + " arguments. Found: " + op);
    }
    return new (OPERATIONS.get(operation)[0])(...op);
}

function getNextToken() {
    skipWhiteSpaces();
    return getFullByRegExp(/[^\s()]/);
}

function getOperands() {
    let curStack = []; // аргументы - тоже функции (инвариант)
    while (true) {
        skipWhiteSpaces();
        let token = getNextToken();
        if (isNumber(token)) {
            curStack.push(new Const(parseInt(token, 10)));
        } else if (token.length !== 0) {
            if (!VARIABLES.has(token)) {
                throw new MyException("Unknown variable:" + token);
            }
            curStack.push(new Variable(token));
        } else if (expr[ind] === '(') {
            curStack.push(readBrackets());
        } else if (expr[ind] === ')') {
            ind++;
            return curStack;
        } else {
            console.log("Never see it again: " + expr);
            throw new MyException("Unexpected exception." + "Token: " + token + "Pos: " + ind + " Char: " + expr[ind]);
        }
    }
}

function parsePrefix(str) {
    expr = str;
    ind = 0;
    skipWhiteSpaces();
    if (expr[ind] === '(') {
        let res = readBrackets();
        skipWhiteSpaces();
        if (ind < expr.length) {
            throw new MyException("Cannot parse next. Stopped on position: " + ind);
        }
        return res;
    }
    let token = getFullByRegExp(/\S/);
    skipWhiteSpaces();
    if (ind < expr.length) {
        throw new MyException("Cannot parse next. Stopped on position: " + ind);
    }
    if (isNumber(token)) {
        return new Const(parseInt(token, 10));
    } else if (token.length !== 0) {
        if (!VARIABLES.has(token)) {
            throw new MyException("Unknown variable:" + token);
        }
        return new Variable(token);
    }
    console.log("Never see it again: " + expr);
    throw new MyException("Cannot start parse. Stopped on position: " + ind);
}

function newOperation(action, symbol) {
    function Operation(...args) {
        this.operands = args;
    }

    Operation.prototype.toString = function () {
        return this.operands.join(" ") + " " + symbol;
    };
    Operation.prototype.prefix = function () {
        return "(" + symbol + " " + this.operands.map(value => value.prefix()).join(" ") + ")";
    };
    Operation.prototype.evaluate = function (...args) {
        return action(...this.operands.map(operand => operand.evaluate(...args)));
    };

    return Operation;
}

function Const(x) {
    this.value = x;
}

Const.prototype.toString = function () {
    return this.value.toString();
};
Const.prototype.evaluate = function () {
    return this.value;
};
Const.prototype.prefix = Const.prototype.toString;

function Variable(s) {
    this.name = s;
    this.index = VARIABLES.get(s);
}

Variable.prototype.toString = function () {
    return this.name;
};
Variable.prototype.evaluate = function (...args) {
    return args[this.index];
};
Variable.prototype.prefix = Variable.prototype.toString;

const Add = newOperation((a, b) => a + b, "+");
const Subtract = newOperation((a, b) => a - b, "-");
const Multiply = newOperation((a, b) => a * b, "*");
const Divide = newOperation((a, b) => a / b, "/");
const Negate = newOperation(a => -a, "negate");
const Min3 = newOperation((a, b, c) => Math.min(a, b, c), "min3");
const Max5 = newOperation((a, b, c, d, e) => Math.max(a, b, c, d, e), "max5");
const Sum = newOperation((...args) => {
    let sum = 0;
    for (let k of args) {
        sum += k;
    }
    return sum;
}, "sum");
const Avg = newOperation((...args) => {
        let sum = 0;
        for (let k of args) {
            sum += k;
        }
        return sum / args.length; // Как поправить повтор?
    }, "avg"
);

const OPERATIONS = new Map([
    ['+', [Add, 2]],
    ['-', [Subtract, 2]],
    ['*', [Multiply, 2]],
    ['/', [Divide, 2]],
    ['negate', [Negate, 1]],
    ['min3', [Min3, 3]],
    ['max5', [Max5, 5]],
    ['sum', [Sum, 0]],
    ['avg', [Avg, 0]],

]);

const CONSTANTS = new Map([
    ['one', 1],
    ['two', 2],
    ['pi', Math.PI],
    ['e', Math.E]
]);

const VARIABLES = new Map([
    ["x", 0],
    ["y", 1],
    ["z", 2]
]);