// ---------- Carousel ----------

RHG.Classes.Carousel = new RHG.Class();
RHG.Classes.Carousel.selectors = {
	"tabsSelector": ".carousel-dots a",
	"panelsContainerSelector": ".carousel-panels",
	"panelsScrollSelector": ".carousel-panel-scroll",
	"panelsSelector": ".carousel-panel",
	"controlsContainerSelector": ".carousel-overlay"
};
RHG.Classes.Carousel.getState = function(classFunctionInstance) {
	return {
		"defaultTab": classFunctionInstance.currentTabIndex,
		"autoplay": classFunctionInstance.autoplaying
	};
}
RHG.Classes.Carousel.classFunction = function(configObject) {
	var classFunctionPub = {};
	var thisClass = RHG.Classes.Carousel;

	var targetJq;
	var panelsContainerJq;
	var panelsScrollJq
	var PanelArray = [];
	var TabArray = [];
	var currentPanelIndex;
	var currentTabIndex;
	var nextTabIndex;	
	var prevControlButton;
	var nextControlButton;
	var pauseControlButton;
	var playControlButton;
	var playpauseToggleButton;
	var paused;
	var forward = "FORWARD";
	var backward = "BACKWARD";
	var autoplayInterval;
	var autoplayIntervalTime = 5010;
	var autoplayAnimationFrames = 43;
	var autoplayAnimationCount = 0;
	var autoplayBackgroundStartPosition = -400;
	var dotAnimationOnPosition = -200
	
	var defaultTab = (configObject.defaultTab == undefined) ? 0 : parseInt(configObject.defaultTab);	
	var autoplay = (configObject.autoplay != "false" && configObject.autoplay != false) ? true : false;
	
	classFunctionPub.autoplaying = autoplay;
	
	//CLASSES		
	var Tab = function(enabledElemJq, index) {
		var TabPub = {};
		var disabledElemJq = jQuery("<strong></strong>");
		disabledElemJq.append(enabledElemJq.contents().clone());
		TabPub.currentElemJq = enabledElemJq;
		TabPub.elemsJq = jQuery([ TabPub.currentElemJq[0], disabledElemJq[0] ]);

		TabPub.enable = function(animate) {
			if (TabPub.enabled == false) { 
				disabledElemJq.replaceWith(enabledElemJq);
				TabPub.currentElemJq = enabledElemJq;
				TabPub.currentElemJq.parent().removeClass("current");				
				TabPub.enabled = true;
				enabledElemJq.click(function(evt){
					pause();
					showPanel(index);
					return false
				});
			}
		}
		TabPub.disable = function(animate) {
			if (TabPub.enabled == true) {	
				enabledElemJq.replaceWith(disabledElemJq);
				TabPub.currentElemJq = disabledElemJq;
				TabPub.currentElemJq.parent().addClass("current");				
				TabPub.enabled = false;
			}	
		}
		
		TabPub.setBackgroundPosition = function(newPos) {
			if (newPos) {
				TabPub.elemsJq.css({
					backgroundPosition: newPos
				});	
			} else {
				// TabPub.elemsJq.css({
				// 	backgroundPosition: ""
				// });
				TabPub.elemsJq.removeAttr('style');
			}
		}
			
		TabPub.enabled = true;
		enabledElemJq.click(function(evt){
			pause();
			showPanel(index);
			return false
		});

		return TabPub;
	}	
			
	var Panel = function(panelJq) {
		var PanelPub = {};
		PanelPub.panelJq = panelJq;
		PanelPub.leftPos;
		
		var showAll = function() {
			jQuery.each(PanelArray, function(i){
				PanelArray[i].enable();
			});				
		}
		
		PanelPub.position = function(newLeftPos) {
			newLeftPos = (newLeftPos == undefined) ? PanelPub.leftPos : newLeftPos;
						
			PanelPub.leftPos = newLeftPos;
			PanelPub.panelJq.css({
				"position": "absolute",
				"left": newLeftPos
			});
		}
					
		PanelPub.enable = function() {
			PanelPub.panelJq.removeClass('hidden')
		}
		PanelPub.disable = function() {
			PanelPub.panelJq.addClass('hidden')
		}
		
		PanelPub.leftPos = PanelPub.panelJq.position().left;
		
		return PanelPub;			
	}
			

	
	var orderPanels = function(indexFrom, indexTo, direction) {
		// Line 'em up
				
		if (direction !== forward && direction !== backward) {
			if (indexTo > indexFrom) {
				direction = forward;
			} else {
				direction = backward;
			}								
		}			
					
		// Gets the correct panel from an index outsied the range
		// (so panel '12' in a range of 10 would return panel 2)
		var loopIndex = function(indexToLoop) {
			if (indexToLoop > PanelArray.length-1) {
				indexToLoop = indexToLoop - PanelArray.length;
			} else if (indexToLoop < 0) {
				indexToLoop = PanelArray.length + indexToLoop;
			}
			return indexToLoop;
		}
		
		var panelIndexsToPositionArray = []
		for(var i = 0; i < PanelArray.length; i++) {
			var index;

			if (direction == forward) {
				index = loopIndex(indexFrom + i)
			} else if (direction == backward) {
				index = loopIndex(indexFrom - i)
			}

			panelIndexsToPositionArray[i] = index;
		}
		
		// Position all panels between From and To
		var panelPosArray = [];
		panelPosArray[panelIndexsToPositionArray[0]] = PanelArray[panelIndexsToPositionArray[0]].leftPos;
		for(var i = 1; i <= panelIndexsToPositionArray.length; i++) {
			if (direction == forward) {
				panelPosArray[panelIndexsToPositionArray[i]] = panelPosArray[panelIndexsToPositionArray[i-1]] + PanelArray[panelIndexsToPositionArray[i-1]].panelJq.width();
			} else if (direction == backward) {
				panelPosArray[panelIndexsToPositionArray[i]] = panelPosArray[panelIndexsToPositionArray[i-1]] - PanelArray[panelIndexsToPositionArray[i-1]].panelJq.width();
			}
		}

		// Set positions
		for(var i = 0; i <= PanelArray.length-1; i++) {
			if (typeof panelPosArray[i] == 'number') {
				PanelArray[i].position(panelPosArray[i]);
			}
		}
	}		
	
	var getNextPanel = function() {
		if (currentTabIndex == PanelArray.length-1) {
			return 0;
		} else {
			return currentTabIndex + 1;
		}		
	}
	
	var showPreviousPanel = function() {
		if (currentTabIndex == 0) {
			showPanel(PanelArray.length - 1, true, backward);				
		} else {
			showPanel(currentTabIndex - 1, true, backward);
		}
	}
	var showNextPanel = function() {
		showPanel(getNextPanel(), true, forward);
	}
	var showPanel = function(panelIndex, animate, direction) {
		animate = (animate == undefined) ? true : animate

		var showAll = function() {
			jQuery.each(PanelArray, function(i){
				PanelArray[i].enable();
			});				
		}
		var hideOthers = function() {
			jQuery.each(PanelArray, function(i){
				if(i != panelIndex) {
					PanelArray[i].disable();
				}
			});				
		}

		TabArray[panelIndex].disable(animate);
		
		//PanelArray[panelIndex].position()
		if (animate) {
			orderPanels(currentPanelIndex, panelIndex, direction);
		}
		var scrollTo = -PanelArray[panelIndex].leftPos;
		var startIndex = currentTabIndex;
		var endIndex = panelIndex;

		if (animate) {
			showAll();
			
			panelsScrollJq.stop().animate({
				"left": scrollTo
			}, {
				duration: 400,
				easing: "swing",
				complete: function() {
					currentPanelIndex = panelIndex;
					hideOthers();
				}
			});		

			if (paused == false) {
				autoplayInterval = setInterval(autoplayAnimationFunction, autoplayIntervalTime/autoplayAnimationFrames);
			}
						
		} else {
			panelsScrollJq.css({
				"left":scrollTo
			})
			hideOthers();
		}
		
		
		if (currentTabIndex != null) {
			TabArray[currentTabIndex].enable();
		}
					
		previousTabIndex = currentTabIndex;
		currentTabIndex = panelIndex;
		classFunctionPub.currentTabIndex = currentTabIndex;
	}
	
	var autoplayAnimationFunction = function() {
		if (autoplayAnimationCount < autoplayAnimationFrames) {
			var bgpos = "-4px "+(-104-(autoplayAnimationCount*20))+"px";
			TabArray[currentTabIndex].setBackgroundPosition(bgpos);			
		} else {
			TabArray[currentTabIndex].setBackgroundPosition();
		}
		
		var animationOverlap = autoplayAnimationCount - autoplayAnimationFrames + 4;
		
		if (animationOverlap >= 0) {
			var bgpos = "-4px "+(-4-(animationOverlap*20))+"px";
			TabArray[getNextPanel()].setBackgroundPosition(bgpos);				
		}
		
		if (autoplayAnimationCount < autoplayAnimationFrames) {
			autoplayAnimationCount++
		} else {
			clearInterval(autoplayInterval);				
			showNextPanel();
			autoplayAnimationCount = 0;
		}
	}
	
	var play = function() {
		if (paused == true) {
			playpauseToggleButton.setState(pauseControlButton);
			autoplayInterval = setInterval(autoplayAnimationFunction, autoplayIntervalTime/autoplayAnimationFrames);
			paused = false;
			classFunctionPub.autoplaying = true;
		}
	}
	var pause = function() {
		if (paused == false) {
			playpauseToggleButton.setState(playControlButton);
			clearInterval(autoplayInterval);
			jQuery.each(TabArray, function(i){
				this.setBackgroundPosition();
			})
			autoplayAnimationCount = 0;				
			paused = true;
			classFunctionPub.autoplaying = false;
		}
	}

	prevControlButton = new RHG.Utilities.ControlButton("Previous", "carousel-previous", function(){
		pause();
		showPreviousPanel();
	});
	nextControlButton = new RHG.Utilities.ControlButton("Next", "carousel-next", function(){
		pause();
		showNextPanel();
	});


	playControlButton = new RHG.Utilities.ControlButton("Play", "carousel-play");
	pauseControlButton = new RHG.Utilities.ControlButton("Pause", "carousel-pause");
	playpauseToggleButton = new RHG.Utilities.ToggleButton([playControlButton, pauseControlButton])
	pauseControlButton.setActionFunction(function(){
		pause();
		return false;
	});
	playControlButton.setActionFunction(function(){
		play();
		return false;
	});

	
	
	// INIT	
	classFunctionPub.init = function() {
		var selectors = thisClass.selectors;
		targetJq = jQuery(configObject.uniqueTargetNodeOrSelector)
		
		var tabsJq = targetJq.find(selectors.tabsSelector)
		
		if (tabsJq.length > 1) {
			tabsJq.each(function(i){
				TabArray.push(new Tab(jQuery(this), i));
			});

			var panelsJq = targetJq.find(selectors.panelsSelector);
			panelsContainerJq = targetJq.find(selectors.panelsContainerSelector);
			panelsScrollJq = targetJq.find(selectors.panelsScrollSelector)
			panelsContainerJq.height(panelsContainerJq.height());

			panelsJq.each(function(i){
				PanelArray.push(new Panel(jQuery(this)));
			});

			var controlsContainerJq = targetJq.find(selectors.controlsContainerSelector);

			controlsContainerJq.prepend(prevControlButton.elemJq);
			controlsContainerJq.append(nextControlButton.elemJq);
			prevControlButton.enable();
			nextControlButton.enable();
			
			controlsContainerJq.append(playpauseToggleButton.currentControlButton.elemJq);

			PanelArray[defaultTab].position()
			currentPanelIndex = defaultTab;
			showPanel(defaultTab, false);

			if (autoplay == false) {
				playpauseToggleButton.setState(pauseControlButton);	
				paused = false;
				classFunctionPub.autoplaying = true;
				pause()
			} else {
				playpauseToggleButton.setState(playControlButton);	
				paused = true;
				classFunctionPub.autoplaying = false;
				play();				
			}

		}
	}

	classFunctionPub.play = play;
	classFunctionPub.pause = pause;

	return classFunctionPub;
}