/*!
 * Auto Complete 5.0
 * November 22, 2009
 * Corey Hart @ http://www.codenothing.com
 */ 
(function($, undefined){
	// Expose autoComplete to the jQuery chain
	$.fn.autoComplete = function(){
		// Force array of arguments
		var args = Slice.call(arguments),
			self = this, 
			first = args.shift(),
			isMethod = (typeof first === 'string');

		// Deep namespacing is not supported in jQuery, a mistake I made in v4.1
		if (isMethod) first = first.replace('.', '-');
		
		// Allow for passing array of arguments, or multiple arguments
		// Eg: .autoComplete('trigger', [arg1, arg2, arg3...]) or .autoComplete('trigger', arg1, arg2, arg3...)
		// Mainly to allow for .autoComplete('trigger', arguments) to work
		// Note*: button.supply passes an array as the first param, so check against that first
		args = first === 'button-supply' || first === 'direct-supply' ? $.isArray(args[0]) && $.isArray(args[0][0]) ? args[0] : args :
			args[1] === undefined && $.isArray(args[0]) ? args[0] : args;

		// Autocomplete special triggers
		return isMethod ?
			// The only chain breaking operation is option, which gets passed back the
			// settings/value it requested, otherwise trigger the event and don't break the chain!
			$(self)[ first === 'option' && args.length < 2 ? 'triggerHandler' : 'trigger' ]('autoComplete.'+first, args) :

			// Allow passing a jquery event special object {from $.Event()}
			first && first[$.expando] ? $(self).trigger(first, args) :

			// Initiate the autocomplete (Only takes a single argument, the options object)
			AutoCompleteFunction.call(self, first);
	};

	// bgiframe is needed to fix z-index problem for IE6 users.
	$.fn.bgiframe = $.fn.bgiframe ? $.fn.bgiframe : $.fn.bgIframe ? $.fn.bgIframe : function(){
		// For applications that don't have bgiframe plugin installed, create a useless 
		// function that doesn't break the chain
		return this;
	};

	// The expando won't get attached to the jQuery object until 1.4 release(or so it seems in the nightlies)
	// To get the expando, we must create an event through jQuery, and filter it out.
	$.expando = $.expando !== undefined ? $.expando : (function(){
		var event = $.Event('keyup'), i;
		for (i in event)
			if (i.indexOf('jQuery') === 0)
				return i;
		// Use the event's timestamp on instances where 
		// expando isn't attached to the event object
		// (is it ever not?)
		return 'jQuery'+event.timeStamp;
	})();

	// Current timestamp
	function now(){
		return (new Date).getTime();
	}



// Internals
var
	// Munging
	TRUE = true,
	FALSE = false,

	// Copy of the slice prototype
	Slice = Array.prototype.slice,

	// Attach global aspects to jQuery itself
	AutoComplete = $.autoComplete = {
		// Index Counter
		counter: 0,

		// Attach length of stack to object
		length: 0,

		// Storage of elements
		stack: {},

		// Storage order of uid's
		order: [],

		// Global access to elements in use
		hasFocus: FALSE,

		// Callback methods for getting focus element
		getFocus: function(){
			return this.order[0] ? this.stack[ this.order[0] ] : undefined;
		},
		getPrevious: function(){
			// Removing elements cause some indexs on the order stack
			// to become undefined, so loop until one is found
			for ( var i=1, l=this.order.length; i < l; i++ )
				if (this.order[i])
					return this.stack[ this.order[i] ];
			// If none are found, return undefined
			return undefined;
		},

		// Attempts to remove element from the stack
		remove: function(i){
			for ( var k=0, l=this.order.length; k < l; k++ )
				if (this.order[k] === i)
					this.order[k] = undefined;
			this.stack[i] = undefined;
			this.length--;
			delete this.stack[i];
		},

		// Returns full stack in jQuery form
		getAll: function(){
			for ( var i = 0, l = this.counter, stack = []; i < l; i++ )
				if (this.stack[i])
					stack.push(this.stack[i]);
			return $(stack);
		},

		defaults: {
			// To smooth upgrade process to 5.0, set backwardsCompatible to true
			backwardsCompatible: FALSE,
			// Server Script Path
			ajax: 'ajax.php',
			ajaxCache: $.ajaxSettings.cache,
			// Data Configuration
			dataSupply: [],
			dataFn: undefined,
			dataName: 'ac-data',
			// Drop List CSS
			list: 'auto-complete-list',
			rollover: 'auto-complete-list-rollover',
			width: undefined, // Defined as inputs width when extended (can be overridden with this global/options/meta)
			striped: undefined,
			maxHeight: undefined,
			newList: FALSE,
			// Post Data
			postVar: 'value',
			postData: {},
			// Limitations
			minChars: 1,
			maxItems: -1,
			maxRequests: 0,
			requestType: 'POST',
			// Input
			inputControl: undefined,
			autoFill: FALSE,
			nonInput: undefined,
			multiple: FALSE,
			multipleSeparator: ' ',
			// Events
			onBlur: undefined,
			onFocus: undefined,
			onHide: undefined,
			onLoad: undefined,
			onMaxRequest: function(){},
			onRollover: undefined,
			onSelect: undefined,
			onShow: undefined,
			onSubmit: function(){return TRUE;},
			spinner: undefined,
			preventEnterSubmit: TRUE,
			delay: 0,
			// Caching Options
			useCache: TRUE,
			cacheLimit: 50
		}
	},

	// Autocomplete function
	AutoCompleteFunction = function(options){
		return this.each(function(){
		var
			// Cache a copy of the input element
			self = this,
			// Cache Input Object
			$input = $(self).attr('autocomplete', 'off'),
			// autoComplete enabled/disabled
			Active = TRUE,
			// Track every event triggered
			LastEvent = {},
			// String of current input value
			inputval = '',
			// Place holder for all list elements
			$elems = {length:0},
			// Place holder for the list element in focus
			$li,
			// View and heights for scrolling
			view, ulHeight, liHeight, liPerView,
			// Harcoded value for ul visiblity
			ulOpen = FALSE,
			// Timer for delay
			timeid,
			// Ajax requests holder
			xhr,
			// li element in focus during key up/down, and its data
			liFocus = -1, liData,
			// For multiple selections
			separator,
			// Index of current input
			inputIndex = (function(){ AutoComplete.length++; return ++AutoComplete.counter; })(),
			// Number of requests made
			requests = 0,
			// Internal Per Input Cache
			cache = {
				length: 0,
				val: undefined,
				list: {}
			},

			// Merge defaults with passed options and metadata options
			settings = $.extend(
				{ width: $input.outerWidth() },
				AutoComplete.defaults, 
				options||{},
				$.metadata ? $input.metadata() : {}
			),

			// Create the drop list (Use an existing one if possible)
			$ul = !settings.newList && $('ul.'+settings.list)[0] ?
				$('ul.'+settings.list).eq(0).bgiframe().data('autoComplete', TRUE) :
				$('<ul/>').appendTo('body').addClass(settings.list).bgiframe().hide().data('ac-selfmade', TRUE).data('autoComplete', TRUE),

			// Attach document click to force blur event
			$doc = $(document).bind('click.autoComplete-'+inputIndex, function(event){
				var $elem;
				// Make sure input is active and list is open
				if (Active && ulOpen &&
					// Double check the event timestamps to ensure there isn't
					// a delayed reaction from a button
					(!LastEvent || event.timeStamp - LastEvent.timeStamp > 200) && 
					// Check the target after all other checks are passed (less processing)
					( $elem = $(event.target) ).closest('ul').data('ac-input-index') !== inputIndex &&
					// Also ensure that the input it's being clicked on either
					$elem.data('ac-input-index') !== inputIndex){
						$ul.hide(event);
						// We want to trigger all blur events, so don't
						// pass special autoComplete flags here through the
						// trigger function
						$input.blur();
				}
				LastEvent = event;
			});

			// Attach special fn's to ul
			newUl();
			// Upper case requestType now instead of on every call
			settings.requestType = settings.requestType.toUpperCase();
			// Set separator to local variable for munging
			separator = settings.multiple ? settings.multipleSeparator : undefined;
			// Add input to stack
			AutoComplete.stack[inputIndex] = self;

			/**
			 * Input Central
			 */ 
			// Show autocomplete has been initialized on this element
			$input.data('autoComplete', TRUE)
			// Attach input index and initial settings
			.data('ac-input-index', inputIndex)
			// autoComplete Activity
			.data('ac-active', Active)
			// Attach settings to initail and current states
			.data('ac-initial-settings', $.extend(TRUE, {}, settings)).data('ac-settings', settings)
			// Central autoComplete specific function
			// Opera uses keypress as it has problems with keydown
			.bind(window.opera ? 'keypress.autoComplete' : 'keydown.autoComplete', function(event){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Track last event and store code for munging
				var key = (LastEvent = event).keyCode, enter = FALSE;

				// Tab Key
				if (key == 9 && ulOpen){
					select(event);
				}
				// Enter Key
				else if (key == 13 && $li){
					// IE needs keydown to return false on 'enter' so the element doesn't
					// lose focus. The problem with returning false is that it prevents bubbling,
					// and most importantly, form submission. To allow for most flexibility,
					// preventEnterSubmit is used along with activity of drop down UL list to
					// determine whether focus is on the drop list or is just on the input.
					//
					// Furthermore, preventEnterSubmit will now be defaulted to true, so as
					// to affect as few implementations as possible, and the ones that need
					// form submission on 'enter' can just set this flag to false for it to
					// work as needed.
					enter = settings.preventEnterSubmit && ulOpen ? FALSE : TRUE;
					select(event);
				}
				// Up Arrow
				else if (key == 38){
					if (liFocus > 0){
						liFocus--;
						up(event);
					}else{
						liFocus = -1;
						$input.val(inputval);
						$ul.hide(event);
					}
				}
				// Down Arrow
				else if (key == 40){
					if (liFocus < $elems.length-1){
						liFocus++;
						down(event);
					}
				}
				// Page Up
				else if (key == 33){
					if (liFocus > 0){
						liFocus -= liPerView;
						if (liFocus < 0) liFocus = 0;
						up(event);
					}
				}
				// Page Down
				else if (key == 34){
					if (liFocus < $elems.length-1){
						liFocus += liPerView;
						if (liFocus > $elems.length-1) liFocus = $elems.length-1;
						down(event);
					}
				}
				// Check for non input values defined by user
				else if (settings.nonInput && $.inArray(key, settings.nonInput)){
					$ul.html('').hide(event);
				}
				// Everything else is considered possible input, so
				// return before keyup prevention flag is set
				else{
					return TRUE;
				}

				// Prevent autoComplete keyup event's from triggering by
				// attaching a flag to the last event
				LastEvent[$.expando + '_autoComplete_keydown'] = TRUE;
				return enter;
			})
			// Run a keydown event to specifically catch the tab key
			.bind('keyup.autoComplete', function(event){
				// If autoComplete has been disabled or keyup prevention 
				// flag has be set, prevent input events
				if (!Active || LastEvent[$.expando + '_autoComplete_keydown']) return TRUE;

				/**
				 * If no special operations were run on keydown,
				 * allow for regular text searching
				 */
				inputval = $input.val();
				var key = (LastEvent = event).keyCode,
					val = separator ? inputval.split(separator).pop() : inputval;
				// Still check to make sure 'enter' wasn't pressed
				if (key != 13){
					// Caching key value
					cache.val = settings.inputControl === undefined ? val : 
						settings.inputControl.apply(self, settings.backwardsCompatible ? 
							[val, key, $ul, event] : [event, {val: val, key: key, ul: $ul}]);
					// Only send request if character length passes
					if (cache.val.length >= settings.minChars)
						sendRequest(event, settings, cache, (key==8||key==32));
					// Remove list on backspace of small string
					else if (key == 8)
						$ul.html('').hide(event);
				}
			})
			// Bind specific Blur Actions
			.bind('blur.autoComplete', function(event){
				// If autoComplete has been disabled or the drop list
				// is still open, prevent input events
				if (!Active || ulOpen) return TRUE;
				// Store event
				LastEvent = event;
				$input.data('ac-hasFocus', FALSE);
				liFocus = -1;
				// Only push undefined index onto order stack
				// if not already there (incase multiple blur events occur)
				if (AutoComplete.order[0] !== undefined)
					AutoComplete.order.unshift(undefined);
				// Expose focus
				AutoComplete.hasFocus = FALSE;
				$ul.hide(event);
				// Trigger blur callback last
				if (settings.onBlur) settings.onBlur.apply(self, settings.backwardsCompatible ?
					[inputval, $ul, event] : [event, {val: inputval, ul: $ul}]);
			})
			// Bind specific focus actions
			.bind('focus.autoComplete', function(event, flag){
				// If autoComplete has been disabled but not destoyed, just return true 
				if (!Active || 
					// Prevent inner focus events if caused by autoComplete inner functionality
					(AutoComplete.focus === inputIndex && flag === $.expando + '_autoComplete') || 
					// Because IE triggers focus AND closes the drop list before form submission,
					// prevent inner function focus functionality & pass on the select flag
					LastEvent[$.expando + '_autoComplete_enter'])
						return TRUE;
				// Store event
				LastEvent = event;
				// If ul is not associated with current input, clear it
				if (inputIndex != $ul.data('ac-input-index'))
					$ul.html('').hide(event);
				// Store focus into input
				$input.data('ac-hasFocus', TRUE);
				// Overwrite undefined index pushed on by the blur event
				if (AutoComplete.order[0] === undefined){
					if (AutoComplete.order[1] === inputIndex)
						AutoComplete.order.shift();
					else
						AutoComplete.order[0] = inputIndex;
				}
				// Only push another uid if it's not the current one
				else if (AutoComplete.order[0] != inputIndex && AutoComplete.order[1] != inputIndex)
					AutoComplete.order.unshift(inputIndex);
				// Keep the order array to within the global cacheLimit size
				if (AutoComplete.order.length > AutoComplete.defaults.cacheLimit)
					AutoComplete.order.pop();
				// Expose focus
				AutoComplete.hasFocus = TRUE;
				// Trigger focus callback last
				if (settings.onFocus) settings.onFocus.apply(self, settings.backwardsCompatible ? [$ul, event] : [event, {ul: $ul}]);
			})

			/**
			 * Autocomplete Methods
			 * -Extensions off autoComplete event
			 */ 
			// Allows for change of settings at any point
			.bind('autoComplete.settings', function(event, newSettings){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Give access to current settings and cache
				if ($.isFunction(newSettings)){
					var ret = newSettings.apply(self, settings.backwardsCompatible ? 
						[settings, cache, $ul, event] : [event, {settings: settings, cache: cache, ul: $ul}]);
					// Allow for extending of settings/cache based off function return values
					if ($.isArray(ret) && ret[0] !== undefined){
						settings = $.extend(TRUE, {}, settings, ret[0]||settings);
						cache = $.extend(TRUE, {}, cache, ret[1]||cache);
					}
				}else{
					// Extend deep so settings are kept
					settings = $.extend(TRUE, {}, settings, newSettings||{});
				}
				// Upper case requestType now instead of on every call
				settings.requestType = settings.requestType.toUpperCase();
				// Reassign local separator
				separator = settings.multiple ? settings.multipleSeparator : undefined;
				// Restablish current settings onto the inputs data
				$input.data('ac-settings', settings);
				// Change the drop down if user want's a differen't class attached
				$ul = !settings.newList && $ul.hasClass(settings.list) ? $ul : 
					!settings.newList && $('ul.'+settings.list)[0] ? $('ul.'+settings.list).bgiframe().data('autoComplete', TRUE) : 
					$('<ul/>').appendTo('body').addClass(settings.list).bgiframe().hide()
						.data('ac-selfmade', TRUE).data('autoComplete', TRUE);
				// Attach special ul fn's
				newUl();
				// Return & Store event
				return LastEvent = event;
			})
			// Clears the Cache & requests (requests can be blocked on request)
			.bind('autoComplete.flush', function(event, cacheOnly){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				cache = {length:0, val:undefined, list:{}};
				if (!cacheOnly) requests = 0;
				// Store & return event
				return LastEvent = event;
			})
			// External button trigger for ajax requests
			.bind('autoComplete.button-ajax', function(event, postData, cacheName){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Store event
				LastEvent = event;
				// Refocus the input box and pass flag to prevent inner focus events
				$input.trigger('focus', [$.expando + '_autoComplete']);
				// Allow for just passing the cache name
				if (typeof postData === 'string'){
					cacheName = postData;
					postData = {};
				}
				// If no cache name is given, supply a non-common word
				cache.val = cacheName||'NON_404_<>!@$^&';
				// Timer is done within sendRequest
				return sendRequest(
					event, 
					$.extend(TRUE, {}, settings, {maxItems: -1, postData: postData||{}}), 
					cache
				);
			})
			// External button trigger for supplied data
			.bind('autoComplete.button-supply', function(event, data, cacheName){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Store event
				LastEvent = event;
				// Refocus the input box and pass flag to prevent inner focus events
				$input.trigger('focus', [$.expando + '_autoComplete']);
				// Allow for just passing of cacheName
				if (typeof data === 'string'){
					cacheName = data;
					data = undefined;
				}
				// If no cache name is given, supply a non-common word
				cache.val = cacheName||'NON_404_SUPPLY_<>!@$^&';
				// If no data is supplied, use data in settings
				data = $.isArray(data) && data.length ? data : settings.dataSupply;
				// Timer done within sendRequest
				return sendRequest(
					event,
					$.extend(TRUE, {}, settings, {maxItems: -1, dataSupply: data, dataFn: function(){ return TRUE; } }), 
					cache
				);
			})
			// Supply list directly into the result function
			.bind('autoComplete.direct-supply', function(event, data, cacheName){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Store event
				LastEvent = event;
				// Refocus the input box and pass flag to prevent inner focus events
				$input.trigger('focus', [$.expando + '_autoComplete']);
				// Allow for just passing of cacheName
				if (typeof data === 'string'){
					cacheName = data;
					data = undefined;
				}
				// If no cache name is given, supply a non-common word
				cache.val = cacheName||'NON_404_SUPPLY_<>!@$^&';
				// If no data is supplied, use data in settings
				data = $.isArray(data) && data.length ? data : settings.dataSupply;
				// Load the results directly into the results function
				// bypassing error checks (Only do)
				return loadResults(
					event,
					data,
					$.extend(TRUE, {}, settings, {maxItems: -1, dataSupply: data, dataFn: function(){ return TRUE; } }), 
					cache
				);
			})
			// Triggering autocomplete programatically
			.bind('autoComplete.search', function(event, value){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				cache.val = value||'';
				// Timer done within sendRequest
				return sendRequest(LastEvent = event, settings, cache);
			})
			// Add jquery-ui like option access
			.bind('autoComplete.option', function(event){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Store event
				LastEvent = event;
				var args = Slice.call(arguments), length = args.length;
				return length == 3 ? (function(){settings[ args[1] ] = args[2]; $input.data('ac-settings', settings); return args[2];})() :
					length == 2 ? (function(){ 
						switch (args[1]){
							case 'ul': return $ul;
							case 'cache': return cache;
							case 'xhr': return xhr;
							case 'input': return $input;
							default: return settings[ args[1] ] || undefined;
						}
					})() :
					settings;
			})
			// Add enabling event (only applicable after disable)
			.bind('autoComplete.enable', function(event){
				$input.data('ac-active', Active = TRUE);
				// Store & return event
				return LastEvent = event;
			})
			// Add disable event
			.bind('autoComplete.disable', function(event){
				// Store event
				$input.data('ac-active', Active = FALSE);
				$ul.html('').hide(event);
				// Store & return event
				return LastEvent = event;
			})
			// Add a destruction function
			.bind('autoComplete.destroy', function(event){
				// Break down the input
				$input
					// Remove all autoComplete Specific Data
					.removeData('autoComplete')
					.removeData('ac-input-index')
					.removeData('ac-initial-settings')
					.removeData('ac-settings')
					.removeData('ac-active')
					// Remove all autoComplete specific events
					.unbind('.autoComplete')
					// jQuery requires every namespace attached to
					// a made up event to be removed separately
					.unbind( 'autoComplete.' + [
							'settings',
							'flush',
							'button-ajax',
							'button-supply',
							'direct-supply',
							'search',
							'option',
							'enable',
							'disable',
							'destroy'
						].join(' autoComplete.') )
					// Unbind the form submission event
					.parents('form').eq(0).unbind('submit.autoComplete-'+inputIndex);
				// Remove document click event
				$doc.unbind('click.autoComplete-'+inputIndex);
				// Remove from stack
				AutoComplete.remove(inputIndex);
				// Disable Activity
				Active = FALSE;
				// Clean the UL
				var list = $ul.html('').hide(event).data('ac-inputs'), i;
				list[inputIndex] = undefined;
				for (i in list)
					if (list[i] === TRUE)
						return LastEvent = event;
				// Remove the element from the DOM if self created no other input is using it
				if ($ul.data('ac-selfmade') === TRUE) $ul.remove();
				// Store & return event
				return LastEvent = event;
			})

			// Back to normal events
			// Prevent form submission if defined in settings
			.parents('form').eq(0).bind('submit.autoComplete-'+inputIndex, function(event){
				// If autoComplete has been disabled, prevent input events
				if (!Active) return TRUE;
				// Because IE triggers focus AND closes the drop list before form submission, store the flag if any
				var flag = LastEvent[$.expando + '_autoComplete_enter']||FALSE;
				// Store event
				LastEvent = event;
				return settings.preventEnterSubmit ?
					(ulOpen || flag) ? FALSE : settings.onSubmit.call(self, event, {form: this, ul: $ul}) :
					settings.onSubmit.call(self, event, {form: this, ul: $ul});
			});
	
			// Ajax/Cache Request
			function sendRequest(event, settings, cache, backSpace, timeout){
				// Pass spinner enabler
				if (settings.spinner) settings.spinner.call(self, event, {active: TRUE, ul: $ul});
				// Centralize the timer request
				if (timeid) timeid = clearTimeout(timeid);
				// Call send request again with timeout flag if on delay
				if (settings.delay > 0 && timeout === undefined) return timeid = setTimeout(function(){
						sendRequest(event, settings, cache, backSpace, TRUE);
						timeid = clearTimeout(timeid);
					}, settings.delay);

				// Abort previous request incase it's still running
				if (xhr) xhr.abort();

				// Load from cache if possible
				if (settings.useCache && cache.list[cache.val])
					return loadResults(event, cache.list[cache.val], settings, cache, backSpace);

				// Use user supplied data when defined
				if (settings.dataSupply.length)
					return userSuppliedData(event, settings, cache, backSpace);

				// Check Max requests first before sending request
				if (settings.maxRequests && ++requests >= settings.maxRequests){
					$ul.html('').hide(event);
					if (settings.spinner) settings.spinner.call(self, event, {active: FALSE, ul: $ul});
					return requests > settings.maxRequests ?
						FALSE : settings.onMaxRequest.apply(self, settings.backwardsCompatible ? 
								[cache.val, $ul, event, inputval] : [event, {search: cache.val, val: inputval, ul: $ul}]);
				}

				// Send request server side
				settings.postData[settings.postVar] = cache.val
				// Switched to base ajax request to remove list on errors
				return xhr = $.ajax({
					type: settings.requestType,
					url: settings.ajax,
					data: settings.postData,
					dataType: 'json',
					cache: settings.ajaxCache,
					success: function(list){
						loadResults(event, list, settings, cache, backSpace);
					},
					error: function(){
						$ul.html('').hide(event);
						if (settings.spinner) settings.spinner.call(self, event, {active: FALSE, ul: $ul});
					}
				});
			}

			// Parse User Supplied Data
			function userSuppliedData(event, settings, cache, backSpace){
				var list = [], // Result list
					args = [], // Backwards Compatibility
					fn = $.isFunction(settings.dataFn), // User supplied function
					regex = fn ? undefined : new RegExp('^'+cache.val, 'i'), // Only compile regex if needed
					k = 0, entry, i=0, l=settings.dataSupply.length; // Looping vars

				// Loop through each entry and find matches
				for ( ; i < l; i++ ){
					entry = settings.dataSupply[i];
					// Force object
					entry = typeof entry === 'object' && entry.value ? entry : {value: entry};
					// Setup arguments for dataFn in a backwards compatible way if needed
					args = settings.backwardsCompatible ? 
						[cache.val, entry.value, list, i, settings.dataSupply, $ul, event] :
						[event, {val: cache.val, entry: entry.value, list: list, i: i, supply: settings.dataSupply, ul: $ul}];
					// If user supplied function, use that, otherwise test with default regex
					if ((fn && settings.dataFn.apply(self, args)) || (!fn && entry.value.match(regex))){
						// Reduce browser load by breaking on limit if it exists
						if (settings.maxItems > -1 && ++k > settings.maxItems)
							break;
						list.push(entry);
					}
				}
				// Use normal load functionality
				return loadResults(event, list, settings, cache, backSpace);
			}

			// Key element Selection
			function select(event){
				// Ensure the select function only gets fired when list of open
				if (ulOpen){
					if (settings.onSelect) settings.onSelect.apply(self, settings.backwardsCompatible ? 
						[liData, $li, $ul, event] : [event, {data: liData, li: $li, ul: $ul}]);
					autoFill(undefined);
					inputval = $input.val();
					// Because IE triggers focus AND closes the drop list before form submission
					// attach a flag on 'enter' selection
					if (LastEvent.type=='keydown') LastEvent[$.expando + '_autoComplete_enter'] = TRUE;
				}
				$ul.hide(event);
				return $li;
			}

			// Key direction up
			function up(event){
				if ($li) $li.removeClass(settings.rollover);
				$ul.show(event);
				$li = $elems.eq(liFocus).addClass(settings.rollover);
				liData = $li.data(settings.dataName);
				if (!$li.length || !liData) return FALSE;
				autoFill( liData.value||'' );
				if (settings.onRollover) settings.onRollover.apply(self, settings.backwardsCompatible ? 
					[liData, $li, $ul, event] : [event, {data: liData, li: $li, ul: $ul}]);
				// Scrolling
				var v = liFocus*liHeight;
				if (v < view-ulHeight){
					view = v+ulHeight
					$ul.scrollTop( v );
				}
				return $li;
			}

			// Key direction down
			function down(event){
				if ($li) $li.removeClass(settings.rollover);
				$ul.show(event);
				$li = $elems.eq( liFocus ).addClass( settings.rollover );
				liData = $li.data( settings.dataName );
				if (!$li.length || !liData) return FALSE;
				autoFill( liData.value||'' );
				// Scrolling
				var v = (liFocus+1)*liHeight;
				if (v > view)
					$ul.scrollTop( (view = v) - ulHeight );
				// Callback
				if (settings.onRollover) settings.onRollover.apply(self, settings.backwardsCompatible ? 
					[liData, $li, $ul, event] : [event, {data: liData, li: $li, ul: $ul}]);
				return $li;
			}

			// Attach new show/hide functionality to only the
			// ul object (so not to infect all of jQuery)
			function newUl(){
				if (! $ul[$.expando + '_autoComplete']){
					// Make a copy of the old show/hide
					var hide = $ul.hide, show = $ul.show;
					$ul.hide = function(event, speed, callback){
						if (settings.onHide && ulOpen){
							settings.onHide.call(self, event, {ul: $ul});
							LastEvent[$.expando + '_autoComplete_hide'] = TRUE;
						}
						ulOpen = FALSE;
						return hide.call($ul, speed, callback);
					};
					$ul.show = function(event, speed, callback){
						if (settings.onShow && !ulOpen) settings.onShow.call(self, event, {ul: $ul});
						ulOpen = TRUE;
						return show.call($ul, speed, callback);
					};
					// A flag must be attached to the $ul cached object
					$ul[$.expando + '_autoComplete'] = TRUE;
				}
				var list = $ul.data('ac-inputs')||{};
				list[inputIndex] = TRUE;
				return $ul.data('ac-inputs', list);
			}

			// Auto-fill the input
			// Credit to Jörn Zaefferer @ http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/
			// and http://www.pengoworks.com/workshop/jquery/autocomplete.htm for this functionality
			function autoFill(val){
				// Set starting and ending points based on values
				if (val === undefined){
					var start, end; start = end = $input.val().length;
				}else{
					if (separator) val = inputval.substr( 0, inputval.length-inputval.split(separator).pop().length ) + val + separator;
					var start = inputval.length, end = val.length;
					$input.val(val);
				}

				// Create selection if allowed
				if (! settings.autoFill || start > end){
					return FALSE;
				}
				else if (self.createTextRange){
					var range = self.createTextRange();
					if (val === undefined) {
						range.move('character', start);
						range.select();
					}else{
						range.collapse(TRUE);
						range.moveStart("character", start);
						range.moveEnd("character", end);
						range.select();
					}
				}
				else if (self.setSelectionRange){
					self.setSelectionRange(start, end);
				}
				else if (self.selectionStart){
					self.selectionStart = start;
					self.selectionEnd = end;
				}
				return TRUE;
			}

			// List Functionality
			function loadResults(event, list, settings, cache, backSpace){
				// Allow another level of result handling
				if (settings.onLoad) list = settings.onLoad.call(self, event, {list: list, settings: settings, cache: cache, ul: $ul});
				// Pass spinner killer as wait time is done in javascript processing
				if (settings.spinner) settings.spinner.call(self, event, {active: FALSE, ul: $ul});
				// Store results into the cache if allowed
				if (settings.useCache && cache.list[cache.val] === undefined){
					cache.length++;
					cache.list[cache.val] = list;
					// Clear cache if necessary
					if (cache.length > settings.cacheLimit){
						cache.list = {};
						cache.length = 0;
					}
				}

				// Ensure there is a list
				if (!list || list.length < 1)
					return $ul.html('').hide(event);

				// Refocus list element
				liFocus = -1;

				// Initialize Vars together (save bytes)
				var offset = $input.offset(), // Input position
				    container = [], // Container for list elements
				    aci=0,k=0,i=0,even=FALSE,length=list.length; // Loop Items

				// Push items onto container
				for (; i < length; i++){
					if (list[i].value){
						if (settings.maxItems > -1 && ++aci > settings.maxItems)
							break;
						container.push(
							settings.striped && even ? '<li class="'+settings.striped+'">' : '<li>',
							list[i].display||list[i].value,
							'</li>'
						);
						even = !even;
					}
				}

				// Load items into list
				$elems = $ul.html( container.join('') ).children('li');
				for ( length = $elems.length; k < length; k++ ){
					$.data( $elems[k], settings.dataName, list[k] );
					$.data( $elems[k], 'ac-index', k );
				}


				// Autofill input with first entry
				if (settings.autoFill && ! backSpace){
					liFocus = 0;
					liData = list[0];
					autoFill( liData.value||'' );
					$li = $elems.eq(0).addClass( settings.rollover );
				}

				// Clear off old events and attach new ones
				$ul.unbind('.autoComplete')
				// Attach input index in focus
				.data('ac-input-index', inputIndex)
				// Remove focus elements hover class
				.bind('mouseout.autoComplete', function(){
					$li.removeClass(settings.rollover);
				})
				// Mouseover using event delegation
				.bind('mouseover.autoComplete', function(event){
					$li = $(event.target).closest('li');
					// Ensure 'li' mouseover
					if ($li.length < 1) return FALSE;
					// Remove hover class from last rollover
					$elems.filter('.'+settings.rollover).removeClass(settings.rollover);
					liFocus = $li.addClass(settings.rollover).data('ac-index');
					liData = $li.data( settings.dataName );
					if (settings.onRollover) settings.onRollover.apply(self, settings.backwardsCompatible ? 
						[liData, $li, $ul, event] : [event, {data: liData, li: $li, ul: $ul}]);
				})
				// Click event using target from mouseover
				.bind('click.autoComplete', function(event){
					// Refocus the input box and pass flag to prevent inner focus events
					$input.trigger('focus', [$.expando + '_autoComplete']);
					liData = $li.data(settings.dataName);
					// Check against separator for input value
					$input.val( inputval = separator ? 
						inputval.substr( 0, inputval.length-inputval.split(separator).pop().length ) + liData.value + separator :
						liData.value 
					);
					$ul.hide(event);
					autoFill(undefined);
					if (settings.onSelect) settings.onSelect.apply(self, settings.backwardsCompatible ? 
						[liData, $li, $ul, event] : [event, {data: liData, li: $li, ul: $ul}]);
				})
				// Reposition list
				.css({
					top: offset.top + $input.outerHeight(),
					left: offset.left,
					width: settings.width
				})
				// Scroll to the top
				.scrollTop(0);

				// If Max Height specified, control it
				if (settings.maxHeight) $ul.css({
					height: liHeight*$elems.length > settings.maxHeight ? settings.maxHeight : 'auto', 
					overflow: 'auto'
				});

				// Apply list height to view for inital value,
				// and show the list now so no jerkiness from css
				// changes are shown to the user
				ulHeight = $ul.show(event).outerHeight();
				view = ulHeight;
				// Log li height for less computation
				liHeight = $elems.eq(0).outerHeight();
				// Number of elements per viewport
				liPerView = Math.floor(view/liHeight);

				// Include amount of time it took
				// to load the list
				LastEvent.timeStamp = now();

				// Every function needs to return something
				return $ul;
			}
		});
	};
})(jQuery);