/*
 * jQuery Calculation Plug-in
 *
 * Copyright (c) 2007 Dan G. Switzer, II
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 *
 * Revision: 6
 * Version: 0.4
 *
 * Revision History
 * v0.4a
 * - Fixed bug in aggregate functions so that a string is passed to jQuery's
 *   text() method (since numeric zero is interpetted as false)
 * 
 * v0.4
 * - Added support for -$.99 values
 * - Fixed regex so that decimal values without leading zeros are correctly
 *   parsed
 * - Removed defaults.comma setting
 * - Changed secondary regex that cleans additional formatting from parsed
 *   number
 * 
 * v0.3
 * - Refactored the aggregate methods (since they all use the same core logic)
 *   to use the $.extend() method
 * - Added support for negative numbers in the regex)
 * - Added min/max aggregate methods
 * - Added defaults.onParseError and defaults.onParseClear methods to add logic for
 *   parsing errors
 * 
 * v0.2
 * - Fixed bug in sMethod in calc() (was using getValue, should have been setValue)
 * - Added arguments for sum() to allow auto-binding with callbacks
 * - Added arguments for avg() to allow auto-binding with callbacks
 * 
 * v0.1a
 * - Added semi-colons after object declaration (for min protection)
 * 
 * v0.1
 * - First public release
 *
*/
(function($){

    // set the defaults
    var defaults = {
        // regular expression used to detect numbers, if you want to force the field to contain
        // numbers, you can add a ^ to the beginning or $ to the end of the regex to force the
        // the regex to match the entire string: /^(-|-\$)?(\d+(,\d{3})*(\.\d{1,})?|\.\d{1,})$/g
        reNumbers: /(-|-\$)?(\d+(,\d{3})*(\.\d{1,})?|\.\d{1,})/g
        // should the Field plug-in be used for getting values of :input elements?
        , useFieldPlugin: (!!$.fn.getValue)
        // a callback function to run when an parsing error occurs
        , onParseError: null
        // a callback function to run once a parsing error has cleared
        , onParseClear: null
    };
    
    // set default options
    $.Calculation = {
        version: "0.4a",
        setDefaults: function(options){
            $.extend(defaults, options);
        }
    };


    /*
     * jQuery.fn.parseNumber()
     *
     * returns Array - detects the DOM element and returns it's value. input
     *                 elements return the field value, other DOM objects
     *                 return their text node
     *
     * NOTE: Breaks the jQuery chain, since it returns a Number.
     *
     * Examples:
     * $("input[@name^='price']").parseNumber();
     * > This would return an array of potential number for every match in the selector
     *
     */
    // the parseNumber() method -- break the chain
    $.fn.parseNumber = function(options){
        var aValues = [];
        options = $.extend(options, defaults);
        
        this.each(
            function (){
                var
                    // get a pointer to the current element
                    $el = $(this),
                    // determine what method to get it's value
                    sMethod = ($el.is(":input") ? (defaults.useFieldPlugin ? "getValue" : "val") : "text"),
                    // parse the string and get the first number we find
                    v = $el[sMethod]().match(defaults.reNumbers, "");

                // if the value is null, use 0
                if( v == null ){
                    v = 0; // update value
                    // if there's a error callback, execute it
                    if( jQuery.isFunction(options.onParseError) ) options.onParseError.apply($el, [sMethod]);
                    $.data($el[0], "calcParseError", true);
                // otherwise we take the number we found and remove any commas
                } else {
                    // clense the number one more time to remove extra data (like commas and dollar signs)
                    v = v[0].replace(/[^0-9.\-]/g, "");
                    // if there's a clear callback, execute it
                    if( $.data($el[0], "calcParseError") && jQuery.isFunction(options.onParseClear) ){
                        options.onParseClear.apply($el, [sMethod]);
                        // clear the error flag
                        $.data($el[0], "calcParseError", false);
                    } 
                }
                aValues.push(parseFloat(v, 10));
            }
        );

        // return an array of values
        return aValues;
    };

    /*
     * jQuery.fn.calc()
     *
     * returns Number - performance a calculation and updates the field
     *
     * Examples:
     * $("input[@name='price']").calc();
     * > This would return the sum of all the fields named price
     *
     */
    // the calc() method
    $.fn.calc = function(expr, vars, cbFormat, cbDone){
        var
            // create a pointer to the jQuery object
            $this = this,
            // the value determine from the expression
            exprValue = "",
            // a pointer to the current jQuery element
            $el,
            // store an altered copy of the vars
            parsedVars = {},
            // temp variable
            tmp,
            // the current method to use for updating the value
            sMethod,
            // a hash to store the local variables
            hVars,
            // track whether an error occured in the calculation
            bIsError = false;

        // look for any jQuery objects and parse the results into numbers           
        for( var k in vars ){
            if( !!vars[k] && !!vars[k].jquery ){
                parsedVars[k] = vars[k].parseNumber();
            } else {
                parsedVars[k] = vars[k];
            }
        }
        
        this.each(
            function (i, el){
                // get a pointer to the current element
                $el = $(this);
                // determine what method to get it's value
                sMethod = ($el.is(":input") ? (defaults.useFieldPlugin ? "setValue" : "val") : "text");

                // initialize the hash vars
                hVars = {};
                for( var k in parsedVars ){
                    if( typeof parsedVars[k] == "number" ){
                        hVars[k] = parsedVars[k];
                    } else if( typeof parsedVars[k] == "string" ){
                        hVars[k] = parseFloat(parsedVars[k], 10);
                    } else if( !!parsedVars[k] && (parsedVars[k] instanceof Array) ) {
                        // if the length of the array is the same as number of objects in the jQuery
                        // object we're attaching to, use the matching array value, otherwise use the
                        // value from the first array item
                        tmp = (parsedVars[k].length == $this.length) ? i : 0;
                        hVars[k] = parsedVars[k][tmp];
                    }
                    
                    // if we're not a number, make it 0
                    if( isNaN(hVars[k]) ) hVars[k] = 0;
                }

                // try the calculation
                try {
                    exprValue = eval( expr.replace(/([A-Za-z]+)/g, "hVars.$1") );
                    
                    // if there's a format callback, call it now
                    if( !!cbFormat ) exprValue = cbFormat(exprValue);
        
                // if there's an error, capture the error output
                } catch(e){
                    exprValue = e;
                    bIsError = true;
                }
                
                // update the value
                $el[sMethod](exprValue.toString());
            }
        );
        
        // if there's a format callback, call it now
        if( !!cbDone ) cbDone(this);

        return this;
    };

    /*
     * Define all the core aggregate functions. All of the following methods
     * have the same functionality, but they perform different aggregate 
     * functions.
     * 
     * If this methods are called without any arguments, they will simple
     * perform the specified aggregate function and return the value. This
     * will break the jQuery chain. 
     * 
     * However, if you invoke the method with any arguments then a jQuery
     * object is returned, which leaves the chain intact.
     * 
     * 
     * jQuery.fn.sum()
     * returns Number - the sum of all fields
     *
     * jQuery.fn.avg()
     * returns Number - the avg of all fields
     *
     * jQuery.fn.min()
     * returns Number - the minimum value in the field
     *
     * jQuery.fn.max()
     * returns Number - the maximum value in the field
     * 
     * Examples:
     * $("input[@name='price']").sum();
     * > This would return the sum of all the fields named price
     *
     * $("input[@name='price1'], input[@name='price2'], input[@name='price3']").sum();
     * > This would return the sum of all the fields named price1, price2 or price3
     *
     * $("input[@name^=sum]").sum("keyup", "#totalSum");
     * > This would update the element with the id "totalSum" with the sum of all the 
     * > fields whose name started with "sum" anytime the keyup event is triggered on
     * > those field.
     *
     * NOTE: The syntax above is valid for any of the aggregate functions
     *
     */
    $.each(["sum", "avg", "min", "max"], function (i, method){
        $.fn[method] = function (bind, selector){
            // if no arguments, then return the result of the aggregate function
            if( arguments.length == 0 )
                return math[method](this.parseNumber());
    
            // if the selector is an options object, get the options
            var bSelOpt = selector && selector.constructor == Object && !(selector instanceof jQuery);
            
            // configure the options for this method
            var opt = bind && bind.constructor == Object ? bind : {
                  bind: "keyup"
                , selector: (!bSelOpt) ? selector : null
                , oncalc: null
            };
    
            // if the selector is an options object, extend the options
            if( bSelOpt ) opt = jQuery.extend(opt, selector);
            
            // if the selector exists, make sure it's a jQuery object
            if( !!opt.selector ) opt.selector = $(opt.selector);
            
            var self = this
                , sMethod
                , doCalc = function (){
                    // preform the aggregate function
                    var value = math[method](self.parseNumber(opt));
                    // check to make sure we have a selector                
                    if( !!opt.selector ){
                        // determine how to set the value for the selector
                        sMethod = (opt.selector.is(":input") ? (defaults.useFieldPlugin ? "setValue" : "val") : "text");
                        // update the value
                        opt.selector[sMethod](value.toString());
                    }
                    // if there's a callback, run it now
                    if( jQuery.isFunction(opt.oncalc) ) opt.oncalc.apply(self, [value, opt]);
                };
            
            // perform the aggregate function now, to ensure init values are updated
            doCalc();
            
            // bind the doCalc function to run each time a key is pressed
            return self.bind(opt.bind, doCalc);
        }
    });
    
    /*
     * Mathmatical functions
     */
    var math = {
        // sum an array
        sum: function (a){
            var total = 0;
            
            // loop through the value and total them
            $.each(a, function (i, v){
                // we add 0 to the value to ensure we get a numberic value
                total += v;
            });
    
            // return the values as a comma-delimited string
            return total;
        },
        // average an array
        avg: function (a){
            // return the values as a comma-delimited string
            return math.sum(a)/a.length;
        },
        // lowest number in array
        min: function (a){
            return Math.min.apply(Math, a);
        },
        // highest number in array
        max: function (a){
            return Math.max.apply(Math, a);
        }
    };
    

})(jQuery);