/**
 * jQuery Templates
 *
 * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
 * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
 *
 * Written by: Stan Lemon <stanlemon@mac.com>
 *
 * Based off of the Ext.Template library, available at:
 * http://www.extjs.com
 *
 * This library provides basic templating functionality, allowing for macro-based
 * templates within jQuery.
 *
 * Basic Usage:
 *
 * var t = $.template('<div id="foo">Hello ${name}, how are you ${question}?  I am ${me:substr(0,10)}</div>');
 *
 * $(selector).append( t , {
 *     name: 'Stan',
 *     question: 'feeling',
 *     me: 'doing quite well myself, thank you very much!'
 * });
 *
 * Requires: jQuery 1.2+
 *
 *
 * @todo    Add callbacks to the DOM manipulation methods, so that events can be bound
 *          to template nodes after creation.
 */
(function($){
    
    /**
     * Create a New Template
     */
    $.template = function(html, options) {
        return new $.template.instance(html, options);
    };

    /**
     * Template constructor - Creates a new template instance.
     *
     * @param   html    The string of HTML to be used for the template.
     * @param   options An object of configurable options.  Currently
     *          you can toggle compile as a boolean value and set a custom
     *          template regular expression on the property regx by
     *          specifying the key of the regx to use from the regx object.
     */
    $.template.instance = function(html, options) {
        // If a custom regular expression has been set, grab it from the regx object
        if ( options && options['regx'] ) options.regx = this.regx[ options.regx ];

        this.options = $.extend({
            compile:        false,
            regx:           this.regx.standard
        }, options || {});

        this.html = html;

        if (this.options.compile) {
            this.compile();   
        }
        this.isTemplate = true;
    };

    /**
     * Regular Expression for Finding Variables
     *
     * The default pattern looks for variables in JSP style, the form of: ${variable}
     * There are also regular expressions available for ext-style variables and
     * jTemplate style variables.
     *
     * You can add your own regular expressions for variable ussage by doing.
     * $.extend({ $.template.re , {
     *     myvartype: /...../g
     * }
     *
     * Then when creating a template do:
     * var t = $.template("<div>...</div>", { regx: 'myvartype' });
     */
    $.template.regx = $.template.instance.prototype.regx = {
        jsp:        /\$\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
        ext:        /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
        jtemplates: /\{\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}\}/g
    };
    
    /**
     * Set the standard regular expression to be used.
     */
    $.template.regx.standard = $.template.regx.jsp;
    
    /**
     * Variable Helper Methods
     *
     * This is a collection of methods which can be used within the variable syntax, ie:
     * ${variable:substr(0,30)} Which would only print a substring, 30 characters in length
     * begining at the first character for the variable named "variable".
     *
     * A basic substring helper is provided as an example of how you can define helpers.
     * To add more helpers simply do:
     * $.extend( $.template.helpers , {
     *   sampleHelper: function() { ... }   
     * });
     */
    $.template.helpers = $.template.instance.prototype.helpers = {
        substr : function(value, start, length){
            return String(value).substr(start, length);
        }
    };


    /**
     * Template Instance Methods
     */
    $.extend( $.template.instance.prototype, {
        
        /**
         * Apply Values to a Template
         *
         * This is the macro-work horse of the library, it receives an object
         * and the properties of that objects are assigned to the template, where
         * the variables in the template represent keys within the object itself.
         *
         * @param   values  An object of properties mapped to template variables
         */
        apply: function(values) {
            if (this.options.compile) {
                return this.compiled(values);
            } else {
                var tpl = this;
                var fm = this.helpers;

                var fn = function(m, name, format, args) {
                    if (format) {
                        if (format.substr(0, 5) == "this."){
                            return tpl.call(format.substr(5), values[name], values);
                        } else {
                            if (args) {
                                // quoted values are required for strings in compiled templates, 
                                // but for non compiled we need to strip them
                                // quoted reversed for jsmin
                                var re = /^\s*['"](.*)["']\s*$/;
                                args = args.split(',');

                                for(var i = 0, len = args.length; i < len; i++) {
                                    args[i] = args[i].replace(re, "$1");
                                }
                                args = [values[name]].concat(args);
                            } else {
                                args = [values[name]];
                            }

                            return fm[format].apply(fm, args);
                        }
                    } else {
                        return values[name] !== undefined ? values[name] : "";
                    }
                };

                return this.html.replace(this.options.regx, fn);
            }
        },

        /**
         * Compile a template for speedier usage
         */
        compile: function() {
            var sep = $.browser.mozilla ? "+" : ",";
            var fm = this.helpers;

            var fn = function(m, name, format, args){
                if (format) {
                    args = args ? ',' + args : "";

                    if (format.substr(0, 5) != "this.") {
                        format = "fm." + format + '(';
                    } else {
                        format = 'this.call("'+ format.substr(5) + '", ';
                        args = ", values";
                    }
                } else {
                    args= ''; format = "(values['" + name + "'] == undefined ? '' : ";
                }
                return "'"+ sep + format + "values['" + name + "']" + args + ")"+sep+"'";
            };

            var body;

            if ($.browser.mozilla) {
                body = "this.compiled = function(values){ return '" +
                       this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.options.regx, fn) +
                        "';};";
            } else {
                body = ["this.compiled = function(values){ return ['"];
                body.push(this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.options.regx, fn));
                body.push("'].join('');};");
                body = body.join('');
            }
            eval(body);
            return this;
        }
    });


    /**
     * Save a reference in this local scope to the original methods which we're 
     * going to overload.
     **/
    var $_old = {
        domManip: $.fn.domManip,
        text: $.fn.text,
        html: $.fn.html
    };

    /**
     * Overwrite the domManip method so that we can use things like append() by passing a 
     * template object and macro parameters.
     */
    $.fn.domManip = function( args, table, reverse, callback ) {
        if (args[0].isTemplate) {
            // Apply the template and it's arguments...
            args[0] = args[0].apply( args[1] );
            // Get rid of the arguements, we don't want to pass them on
            delete args[1];
        }

        // Call the original method
        var r = $_old.domManip.apply(this, arguments);

        return r;
    };

    /**
     * Overwrite the html() method
     */
    $.fn.html = function( value , o ) {
        if (value && value.isTemplate) var value = value.apply( o );

        var r = $_old.html.apply(this, [value]);

        return r;
    };
    
    /**
     * Overwrite the text() method
     */
    $.fn.text = function( value , o ) {
        if (value && value.isTemplate) var value = value.apply( o );

        var r = $_old.text.apply(this, [value]);

        return r;
    };

})(jQuery);