/*
* 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: 11
* Version: 0.4.07
*
* Revision History
* v0.4.07
* - Added trim to parseNumber to fix issue with whitespace in elements
* 
* v0.4.06
* - Added support for calc() "format" callback so that if return value
*   is null, then value is not updated
* - Added jQuery.isFunction() check for calc() callbacks
* 
* v0.4.05
* - Added support to the sum() & calc() method for automatically fixing precision
*   issues (will detect the max decimal spot in the number and fix to that
*   depth)
* 
* v0.4.04
* - Fixed bug #5420 by adding the defaults.cleanseNumber handler; you can
*   override this function to handle stripping number of extra digits
* 
* v0.4.02
* - Fixed bug where bind parameter was not being detecting if you specified
*   a string in method like sum(), avg(), etc.
* 
* 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
        // this function is used in the parseNumber() to cleanse up any found numbers
        // the function is intended to remove extra information found in a number such
        // as extra commas and dollar signs. override this function to strip European values
		, cleanseNumber: function (v) {
		    // cleanse the number one more time to remove extra data (like commas and dollar signs)
		    // use this for European numbers: v.replace(/[^0-9,\-]/g, "").replace(/,/g, ".")
		    return v.replace(/[^0-9.\-]/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.4.07",
        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 = $.trim($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 = options.cleanseNumber.apply(this, [v[0]]);
			        // 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 = ""
        // track the precision to use
			, precision = 0
        // 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
			, _
        // 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) {
            // replace the keys in the expression
            expr = expr.replace((new RegExp("(" + k + ")", "g")), "_.$1");
            if (!!vars[k] && !!vars[k].jquery) {
                parsedVars[k] = vars[k].parseNumber();
            } else {
                parsedVars[k] = vars[k];
            }
        }

        this.each(
			function (i, el) {
			    var p, len;
			    // 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
			    _ = {};
			    for (var k in parsedVars) {
			        if (typeof parsedVars[k] == "number") {
			            _[k] = parsedVars[k];
			        } else if (typeof parsedVars[k] == "string") {
			            _[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;
			            _[k] = parsedVars[k][tmp];
			        }

			        // if we're not a number, make it 0
			        if (isNaN(_[k])) _[k] = 0;

			        // check for decimals and check the precision
			        p = _[k].toString().match(/\.\d+$/gi);
			        len = (p) ? p[0].length - 1 : 0;

			        // track the highest level of precision
			        if (len > precision) precision = len;
			    }


			    // try the calculation
			    try {
			        exprValue = eval(expr);

			        // fix any the precision errors
			        if (precision) exprValue = Number(exprValue.toFixed(Math.max(precision, 4)));

			        // if there's a format callback, call it now
			        if (jQuery.isFunction(cbFormat)) {
			            // get return value
			            var tmp = cbFormat.apply(this, [exprValue])
			            // if we have a returned value (it's null null) use it
			            if (!!tmp) exprValue = tmp;
			        }

			        // 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 (jQuery.isFunction(cbDone)) cbDone.apply(this, [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: 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, precision = 0;

            // loop through the value and total them
            $.each(a, function (i, v) {
                // check for decimals and check the precision
                var p = v.toString().match(/\.\d+$/gi), len = (p) ? p[0].length - 1 : 0;
                // track the highest level of precision
                if (len > precision) precision = len;
                // we add 0 to the value to ensure we get a numberic value
                total += v;
            });

            // fix any the precision errors
            if (precision) total = Number(total.toFixed(precision));

            // 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);