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