/**************************************************
				*** jQuery-Powered Slider for Internet Specials *** 
				**************************************************/
	

/* ******************************************************************************* */
/* ******************************************************************************* */
function setDefaults() {
	
	/* *************** */
	/*  Configuration  */
	/* *************** */
	
	// Speed of each slide
	speed = 2000;			// 		an integer in milliseconds; or "slow", "normal", "fast"
	
	// Autorotate?
	autoRotate = true;		//		true or false;
	
	// Pause between slides
	pauseTime = 6000; 		// 		pause between slide movements, in milliseconds - recommended between 5000 - 10000.
	
	
	// Easing
	easeStyle = "swing";	// 		either "linear" or "swing" - use jQuery 'Easing' plugin for more easing types
	
	// Initial Slide Direction
	direction = -1; 		// 		1 = slide right				-1 = slide left
							// 		(can be changed at runtime with any element that is using classes .sliderLeft and .sliderRight)
	

/* ******************************************************************************* */
/* ******************************************************************************* */	


	/* ************************************************* */
	/* more initialization - ignore these next few items */
	/* ************************************************* */
	
	// How far does it move each time?  Total width of each unit.
	distance = parseFloat($(".unit:first-child").outerWidth(true));
	
	//adds Pause-Time to the transition-time of each slide, to account for the way the timer works, which starts each pause when the slide *begins*, not ends.
	pauseTime = speed + pauseTime;
}


/* ******************************************************************************* */
/* ******************************************************************************* */

/* 
	Debugging Tool - browser selects whether to use Alerts or Print to Firebug Console
		usage:
		$.log(string); 
*/
jQuery.log = function(message) {
  if(window.console) {
     console.debug(message);
  } else {
     //alert(message);
  }
};


/* **************************************************************************************** */
/* **************************************************************************************** */

/* *********************** */
/* Declaring the Variables */
/* *********************** */

var speed; // set in configuration above
var pauseTime; // set in configuration above
var autoRotate; // set in configuration above
var direction; // set in configuration above or by 'Next' or 'Prev' buttons
var distance; // figured out in the initialization process
var nextPos; // figured out in the initialization process
var easeStyle; // set in configuration above
var slideBlocker = false; // set while sliding, to stop buttons from working and messing things up


/* **************************************************************************************** */
/* **************************************************************************************** */

/* ***************************************** */
/* General Functions of Movement and Whatnot */
/* ***************************************** */

function slideIt() { //moves the whole .slider over one 'distance' in the correct direction	
	if (slideBlocker==false) {
		
		// copy the unit from the leading end to the trailing end
		passOneAround(); 
			
		// slide the .slider over, then removes the unit at the leading end]
		$(".slider").animate({
			left : nextPos() + "px"
		},speed,easeStyle,takeOneDown);
	}
}

function nextPos() {
	//What's the next move's position during slideIt()?
	return Math.round((parseFloat($(".slider").css("left"))) + (distance * parseFloat(direction)));
}


function reversePos() {
	//determine the adjustment to the css.left of the .slider during takeOneDown() or passItAround()
	return Math.round((parseFloat($(".slider").css("left"))) + (distance * parseFloat(direction*-1)));
}

function passOneAround() {
	//stop buttons from working and messing things up
	unclickable();  
	// copy the unit from the leading end to the trailing end, adjust if needed
	if (direction == -1) {
		//$.log('passing one around - moving left');
		$(".slider .unit:first-child").clone(true).appendTo(".slider");
	} else {
		//$.log('passing one around - moving right');
		$(".slider .unit:last-child").clone(true).prependTo(".slider");
		$(".slider").css("left", reversePos());
	}
	setSliderWidth();
}

function takeOneDown() {
	// removes the unit at the leading end, adjusts, makes buttons clickable again
	if (direction == -1) {
		//$.log('taking one down - from the left');
		$(".slider .unit:first-child").remove();
		$(".slider").css("left", reversePos());
	} else {
		//$.log('taking one down - from the right');
		$(".slider .unit:last-child").remove();
	}
	setSliderWidth();
	clickable();
}

function autoRotateIt(){
	// starts continuous rotation
	if (autoRotate == true) {
		// the initial slide
		slideIt();
		// all subsequent slides
		$(document).everyTime(pauseTime, "autoRotate", function(){slideIt()});
	}
}


function clickable() {
	// makes the buttons clickable
	slideBlocker=false;
}

function unclickable() {	
	// makes the buttons UNclickable
	slideBlocker=true;
}


function initBtns() {
	// Initialize Buttons
	
	// Slide One Unit Left
	$(".sliderLeft").click(function() {
		if (slideBlocker==false) {
			direction = 1;
			slideIt();
		}
	});
	
	//Slide One Unit Right
	$(".sliderRight").click(function() {
		if (slideBlocker==false) {
			direction = -1;
			slideIt();
		}
	});
	
	// Pause/Stop Rotation (upon completion of any current sliding)
	$(".sliderPause").click(function() {
		sliderPause();
	});
	
	// Play - Begin Rotation when paused/stopped
	$(".sliderPlay").click(function() {
		sliderPlay();
	});
	
	// Toggle *functionality* of a combined play/pause button
		// determines starting state and sets  initial toggle-state accordingly
		// must add any visual/graphical toggle on a case-by-case basis, but is not built-in by default
	if (autoRotate == true) {
		$(".sliderPlayPause").toggle(
			function() {
				sliderPause();
			},
			function() {
				sliderPlay();
			}
		);
	} else {
		$(".sliderPlayPause").toggle(
			function() {
				sliderPlay();
			},
			function() {
				sliderPause();
			}
		);
	}
}

// Pause/Stop the Slider
function sliderPause() {
	$(document).stopTime("autoRotate");
}

//Play the slider - auto-rotate
function sliderPlay() {
	autoRotate = true;
	autoRotateIt();
}

//determine the width of the .slider so the units all sit in a nice straight row.
function setSliderWidth() {
	var total = ($(".slider .unit").length)*distance;
	//$.log(total);
	$(".slider").width(total);
}

function initHoverState() {
	$('.unit').hover(
		function() {
			$(this).addClass('hovering');
			//$.log("hovering");
		},
		function() {
			$(this).removeClass('hovering');
			//$.log("not-hovering");
		}
	);
}


/* **************************************************************************************** */
/* **************************************************************************************** */


/* ************************ */
/* Doc.Ready Initialization */
/* ************************ */
$(document).ready(function() {
	// let's get it going...
	setDefaults();
	initBtns();	
	setSliderWidth();
	initHoverState();
	autoRotateIt();
 });


/* **************************************************************************************** */
/* **************************************************************************************** */

/**
 * jQuery.timers - Timer abstractions for jQuery
 * Written by Blair Mitchelmore (blair DOT mitchelmore AT gmail DOT com)
 * Licensed under the WTFPL (http://sam.zoy.org/wtfpl/).
 * Date: 2009/10/16
 *
 * @author Blair Mitchelmore
 * @version 1.2
 * Usage: http://plugins.jquery.com/project/timers
 *
 **/

jQuery.fn.extend({
	everyTime: function(interval, label, fn, times) {
		return this.each(function() {
			jQuery.timer.add(this, interval, label, fn, times);
		});
	},
	oneTime: function(interval, label, fn) {
		return this.each(function() {
			jQuery.timer.add(this, interval, label, fn, 1);
		});
	},
	stopTime: function(label, fn) {
		return this.each(function() {
			jQuery.timer.remove(this, label, fn);
		});
	}
});

jQuery.extend({
	timer: {
		global: [],
		guid: 1,
		dataKey: "jQuery.timer",
		regex: /^([0-9]+(?:\.[0-9]*)?)\s*(.*s)?$/,
		powers: {
			// Yeah this is major overkill...
			'ms': 1,
			'cs': 10,
			'ds': 100,
			's': 1000,
			'das': 10000,
			'hs': 100000,
			'ks': 1000000
		},
		timeParse: function(value) {
			if (value == undefined || value == null)
				return null;
			var result = this.regex.exec(jQuery.trim(value.toString()));
			if (result[2]) {
				var num = parseFloat(result[1]);
				var mult = this.powers[result[2]] || 1;
				return num * mult;
			} else {
				return value;
			}
		},
		add: function(element, interval, label, fn, times) {
			var counter = 0;
			
			if (jQuery.isFunction(label)) {
				if (!times) 
					times = fn;
				fn = label;
				label = interval;
			}
			
			interval = jQuery.timer.timeParse(interval);

			if (typeof interval != 'number' || isNaN(interval) || interval < 0)
				return;

			if (typeof times != 'number' || isNaN(times) || times < 0) 
				times = 0;
			
			times = times || 0;
			
			var timers = jQuery.data(element, this.dataKey) || jQuery.data(element, this.dataKey, {});
			
			if (!timers[label])
				timers[label] = {};
			
			fn.timerID = fn.timerID || this.guid++;
			
			var handler = function() {
				if ((++counter > times && times !== 0) || fn.call(element, counter) === false)
					jQuery.timer.remove(element, label, fn);
			};
			
			handler.timerID = fn.timerID;
			
			if (!timers[label][fn.timerID])
				timers[label][fn.timerID] = window.setInterval(handler,interval);
			
			this.global.push( element );
			
		},
		remove: function(element, label, fn) {
			var timers = jQuery.data(element, this.dataKey), ret;
			
			if ( timers ) {
				
				if (!label) {
					for ( label in timers )
						this.remove(element, label, fn);
				} else if ( timers[label] ) {
					if ( fn ) {
						if ( fn.timerID ) {
							window.clearInterval(timers[label][fn.timerID]);
							delete timers[label][fn.timerID];
						}
					} else {
						for ( var fn in timers[label] ) {
							window.clearInterval(timers[label][fn]);
							delete timers[label][fn];
						}
					}
					
					for ( ret in timers[label] ) break;
					if ( !ret ) {
						ret = null;
						delete timers[label];
					}
				}
				
				for ( ret in timers ) break;
				if ( !ret ) 
					jQuery.removeData(element, this.dataKey);
			}
		}
	}
});

jQuery(window).bind("unload", function() {
	jQuery.each(jQuery.timer.global, function(index, item) {
		jQuery.timer.remove(item);
	});
});