// Calc
// ----
//
// A dumb/simple embeddable dsl for performing simple calculations in javascript
//
// e.g. ($area % 0.96) x 1.05 units 0.96
//      $area x 0.05
//      (2 x $centreline_length) x (2 x $width)
//
// calc     ::== exp 'units' unitlist
// unitlist ::== number ',' unitlist | number
// exp      ::== '(' exp ')'
//          ::== exp '%' exp
//          ::== exp 'x' exp
//          ::== exp '+' exp
//          ::== exp '-' exp
//          ::== value
// value    ::== number
//          ::== ref

var Calc = {};
(function () {
    var TokenTypes,
        SIMPLE_TOKENS,
        KEYWORDS,
        PATTERNS,
        tokenize,
        readToken;

    TokenTypes = {
        OPEN_PAREN: 'OPEN_PAREN',
        CLOSE_PAREN: 'CLOSE_PAREN',
        NUMBER: 'NUMBER',
        REFERENCE: 'REFERENCE',
        DIVIDE_OP: 'DIVIDE_OP',
        MULTIPLY_OP: 'MULTIPLY_OP',
        ADD_OP: 'ADD_OP',
        SUBTRACT_OP: 'SUBTRACT_OP',
        UNITS_KW: 'UNIT_KW',
        COMMA: 'COMMA'
    };

    SIMPLE_TOKENS = {
        '%': TokenTypes.DIVIDE_OP,
        'x': TokenTypes.MULTIPLY_OP,
        ',': TokenTypes.COMMA,
        '+': TokenTypes.ADD_OP,
        '-': TokenTypes.SUBTRACT_OP,
        '(': TokenTypes.OPEN_PAREN,
        ')': TokenTypes.CLOSE_PAREN
    };

    PATTERNS = {
        NUMBER: /^-?(0|([1-9]\d*))(\.\d+)?((e|E)(\+|\-)\d+)?/,
        REFERENCE: /^\$(\w+)/
    };

    KEYWORDS = {
        UNIT_KW: 'units'
    };

    Calc.tokenize = tokenize = function (str) {
        var tokens = [], i;
        for (i = 0; i < str.length; i = readToken(tokens, str, i)) { }
        return tokens;
    };

    readToken = function (tokens, str, i) {
        var char, head, match, key, end;
        char = str[i];

        if (char == ' ' || char == '\t' || char == '\n') {
            return i + 1;
        }

        if (char in SIMPLE_TOKENS) {
            tokens.push({ type: SIMPLE_TOKENS[char] });
            return i + 1;
        }

        head = str.slice(i);

        for (key in KEYWORDS) if (KEYWORDS.hasOwnProperty(key)) {
            end = i + KEYWORDS[key].length;
            match = str.slice(i, end);

            if (match === KEYWORDS[key]) {
                tokens.push({ type: TokenTypes[key] });
                return end;
            }
        }

        for (key in PATTERNS) if (PATTERNS.hasOwnProperty(key)) {
            match = PATTERNS[key].exec(head);

            if (match) {
                tokens.push({ type: TokenTypes[key], value: match[0]});
                return i + match[0].length;
            }
        }

        throw new Error("Couldn't tokenize " + str + " @ " + i + "'" + char + "'");
    };
}.call(null));
if (typeof module !== 'undefined' && module.exports) {
    module.exports = Calc;
}