const ops = {
    '+': {Op: Add, Args: 2},
    '-': {Op: Subtract, Args: 2},
    '*': {Op: Multiply, Args: 2},
    '/': {Op: Divide, Args: 2},
    'negate': {Op: Negate, Args: 1},
};

function ParsePrefixError(msg) {
    this.message = msg;
    this.name = "ParsePrefixError";
}

ParsePrefixError.prototype = Error.prototype;

let expression = "";
let pos = 0;

const checkPos = () => pos < expression.length;

const isLetter = (c) => /\w/.test(c);

const isDigit = (c) => /\d/.test(c);

const isWhiteSpace = (c) => /\s/.test(c);

const next = () => {
    pos++;
};

const curChar = () => expression.charAt(pos);

function skipSpaces() {
    while (checkPos() && isWhiteSpace(curChar())) {
        next();
    }
}

function getNumber() {
    let number = "";
    while (checkPos() && (isDigit(curChar()) || curChar() === '-')) {
        number += curChar();
        next();
    }
    skipSpaces();
    return number;
}

function getConst(number) {
    try {
        return new Const(parseInt(number));
    } catch (Error) {
        throw new ParsePrefixError("Illegal constant at index " +
            (pos - number.length() + 1) + "\n" + number + "\n");
    }
}

function getVariable() {
    let identifier = "";
    while (checkPos() && isLetter(curChar())) {
        identifier += curChar();
        next();
    }
    if (!identifier in vars) {
        throw new ParsePrefixError("Unknown identifier name at pos : " +
            (pos - identifier.length) + " " + identifier);
    }
    skipSpaces();
    return Variable(identifier);
}

function getFunctionParam() {
    let functionName = "";
    while (!(/\(/.test(curChar()) || isWhiteSpace(curChar()))) {
        functionName += curChar();
        next();
    }
    if (!functionName in ops) {
        throw new ParsePrefixError("Unknown function name at pos : " +
            (pos - functionName.length) + " " + functionName);
    }
    skipSpaces();
    const func = ops[functionName]["Op"];
    const argsCnt = ops[functionName]["Args"];
    return [func, argsCnt];
}

function parseInBrackets() {
    if (checkPos()) {
        next();
        skipSpaces();
        if (isDigit(curChar())) {
            return getConst(getNumber());
        } else if (isLetter(curChar())) {
            return getVariable();
        } else {
            let curOperands = [];
            const params = getFunctionParam();
            const func = params[0];
            const argsCnt = params[1];
            if (curChar() === ')') {
                throw new ParsePrefixError("Missing operands at pos : " + pos);
            } else if (isDigit(curChar())) {
                curOperands.push(getConst(getNumber()));
            } else if (isLetter(curChar())) {
                curOperands.push(getVariable());
            } else if (/\(/.test(curChar())) {
                curOperands.push(parseInBrackets());
            }
            if (curOperands.length !== argsCnt) {
                throw new ParsePrefixError("Unexpected number of arguments");
            } else {
                return func(curOperands);
            }
        }
    }
}

const parsePrefix = function (expr) {
    expression = expr;
    return parseInBrackets();
};