Fx.Scroll = new Class({

	Extends: Fx,

	options: {
		offset: {x: 0, y: 0},
		wheelStops: true
	},

	initialize: function(element, options){
		this.element = this.subject = document.id(element);
		this.parent(options);

		if (typeOf(this.element) != 'element') this.element = document.id(this.element.getDocument().body);

		if (this.options.wheelStops){
			var stopper = this.element,
				cancel = this.cancel.pass(false, this);
			this.addEvent('start', function(){
				stopper.addEvent('mousewheel', cancel);
			}, true);
			this.addEvent('complete', function(){
				stopper.removeEvent('mousewheel', cancel);
			}, true);
		}
	},

	set: function(){
		var now = Array.flatten(arguments);
		if (Browser.firefox) now = [Math.round(now[0]), Math.round(now[1])]; // not needed anymore in newer firefox versions
		this.element.scrollTo(now[0], now[1]);
	},

	compute: function(from, to, delta){
		return [0, 1].map(function(i){
			return Fx.compute(from[i], to[i], delta);
		});
	},

	start: function(x, y){
		if (!this.check(x, y)) return this;
		var scroll = this.element.getScroll();
		return this.parent([scroll.x, scroll.y], [x, y]);
	},

	calculateScroll: function(x, y){
		var element = this.element,
			scrollSize = element.getScrollSize(),
			scroll = element.getScroll(),
			size = element.getSize(),
			offset = this.options.offset,
			values = {x: x, y: y};

		for (var z in values){
			if (!values[z] && values[z] !== 0) values[z] = scroll[z];
			if (typeOf(values[z]) != 'number') values[z] = scrollSize[z] - size[z];
			values[z] += offset[z];
		}

		return [values.x, values.y];
	},

	toTop: function(){
		return this.start.apply(this, this.calculateScroll(false, 0));
	},

	toLeft: function(){
		return this.start.apply(this, this.calculateScroll(0, false));
	},

	toRight: function(){
		return this.start.apply(this, this.calculateScroll('right', false));
	},

	toBottom: function(){
		return this.start.apply(this, this.calculateScroll(false, 'bottom'));
	},

	toElement: function(el, axes){
		axes = axes ? Array.from(axes) : ['x', 'y'];
		var scroll = isBody(this.element) ? {x: 0, y: 0} : this.element.getScroll();
		var position = Object.map(document.id(el).getPosition(this.element), function(value, axis){
			return axes.contains(axis) ? value + scroll[axis] : false;
		});
		return this.start.apply(this, this.calculateScroll(position.x, position.y));
	},

	toElementEdge: function(el, axes, offset){
		axes = axes ? Array.from(axes) : ['x', 'y'];
		el = document.id(el);
		var to = {},
			position = el.getPosition(this.element),
			size = el.getSize(),
			scroll = this.element.getScroll(),
			containerSize = this.element.getSize(),
			edge = {
				x: position.x + size.x,
				y: position.y + size.y
			};

		['x', 'y'].each(function(axis){
			if (axes.contains(axis)){
				if (edge[axis] > scroll[axis] + containerSize[axis]) to[axis] = edge[axis] - containerSize[axis];
				if (position[axis] < scroll[axis]) to[axis] = position[axis];
			}
			if (to[axis] == null) to[axis] = scroll[axis];
			if (offset && offset[axis]) to[axis] = to[axis] + offset[axis];
		}, this);

		if (to.x != scroll.x || to.y != scroll.y) this.start(to.x, to.y);
		return this;
	},

	toElementCenter: function(el, axes, offset){
		axes = axes ? Array.from(axes) : ['x', 'y'];
		el = document.id(el);
		var to = {},
			position = el.getPosition(this.element),
			size = el.getSize(),
			scroll = this.element.getScroll(),
			containerSize = this.element.getSize();

		['x', 'y'].each(function(axis){
			if (axes.contains(axis)){
				to[axis] = position[axis] - (containerSize[axis] - size[axis]) / 2;
			}
			if (to[axis] == null) to[axis] = scroll[axis];
			if (offset && offset[axis]) to[axis] = to[axis] + offset[axis];
		}, this);

		if (to.x != scroll.x || to.y != scroll.y) this.start(to.x, to.y);
		return this;
	}

});

//<1.2compat>
Fx.Scroll.implement({
	scrollToCenter: function(){
		return this.toElementCenter.apply(this, arguments);
	},
	scrollIntoView: function(){
		return this.toElementEdge.apply(this, arguments);
	}
});
//</1.2compat>

function isBody(element){
	return (/^(?:body|html)$/i).test(element.tagName);
}


window.addEvent('domready', function()
{ 
/*********************************************/
/** 			PARAMETRES	SCROLLER							**/
/*********************************************/		
	var container = $('actusListeContainer');
	var elementsClass = '.actuListe';
	var carLeft = $('actusScrollerPrev');
	var carRight = $('actusScrollerNext');
	var nbElementsDislayed = 1;
	var dureeScroll = 1500;
	var vertical = 1;
	
/*********************************************/
/** 			PARAMETRES	GALLERY								**/
/*********************************************/		
	
	
	var classContainersLiens = 'photosLiens';
	var classContainersPhotos = 'actuImages';
	
	
	var containersImages = $$('.'+classContainersPhotos);
	var currentContainer = containersImages[0];
	var classFirst = 'first';
	var classLast = 'last';
	var classActive = 'active';
	var showDuration = 4000;
	var interval;
	
	
	
	var createGallery = function(container,index){
		container.imagesArray = container.getElements('img');
		container.liensArray = new Array();
		
		// Récupère la classe du modèle de lien
		containerLien = container.getElement('.'+classContainersLiens);
		classModeleLien = containerLien.getElement('a').get('class');
		containerLien.set('html','');
		// définition de l'Index
		container.currentIndex = 0;
		
		if(container.imagesArray != null && container.imagesArray.length > 1){
			// Parcours des images
			container.imagesArray.each(function(img,i){
				// Création du lien pour chaque image
				classLien = classModeleLien;
				if(i==0) classLien = classFirst+' '+classActive+' '+classModeleLien;
				if(i==container.imagesArray.length - 1) classLien = classLast+' '+classModeleLien;
				container.liensArray[i] = new Element('a', {'class': classLien, 'href': '#', 'html': '&nbsp;'});
				
				activeLien(container.liensArray[i], i);
				container.liensArray[i].inject(containerLien);
				
				// Masque les images
				if(i > 0) {img.set('opacity',0);}
			});
		}
	}

	
	
	// fonction de fondu de la gallerie
	var blendGallerie = function(nextIndex){
		if(currentContainer == null) return false;
		if(nextIndex == null){
			nextIndex = currentContainer.currentIndex < currentContainer.imagesArray.length - 1 ? currentContainer.currentIndex+1 : 0;
		}
		currentContainer.liensArray[currentContainer.currentIndex].removeClass(classActive);
		currentContainer.liensArray[nextIndex].addClass(classActive);
		currentContainer.imagesArray[nextIndex].fade('in');
		currentContainer.imagesArray[currentContainer.currentIndex].fade('out');
		currentContainer.currentIndex = nextIndex;
	}
	
	var changeContainer = function(newContainer){
		// $clear(diaporama);
		// currentContainer = newContainer.getElement('.'+classContainersPhotos);
		// if(currentContainer.imagesArray.length > 1)diaporama = blendGallerie.periodical(showDuration);
	}


	// Active les boutons des images
	var activeLien = function(lien,index){
		lien.addEvents({
			'mouseenter' : function(){
				$clear(diaporama);
			},
			'mouseleave' : function(){
				diaporama = blendGallerie.periodical(showDuration);
			},
			'click' : function(event){ 
				blendGallerie(index);
				event.stop();
			}		  		  
		});
	};
	
	
//INITIALISATION
	/*
	containersImages.each(function(containerImages,index) {
		createGallery(containerImages,index);									
	});
	*/
	// diaporama = blendGallerie.periodical(showDuration);
	
/*********************************************/
/** 				SCROLLER												**/
/*********************************************/

// VARIABLES SCROLLER
	var elementsArray = container.getElements(elementsClass);
	var increment;
	if(vertical){
		increment = parseInt(container.getStyle('height').replace('px', ''));
	}else{
		increment = parseInt(container.getStyle('width').replace('px', ''));
	}
	var maxRightIncrement	= increment*(elementsArray.length - nbElementsDislayed);
	var totIncrement = 0;
	var currentElement = 0;
	var previousElement = null;
	var nextElement = 1;
	var sens = 0;
	var fxPos = 0;
	var notScrolling = 1;
	
// TRANSITIONS SCROLLER	
	// Définiton de l'effet Scroll
	var scrollEffect = new Fx.Scroll(container, {
		offset: {'x': 0, 'y': 0}, 
		duration: dureeScroll,
		transition: Fx.Transitions.Quad.easeInOut,
		wait: false
		}
	)
	.toLeft()
	.addEvents({ 
		'start' : function(event){ 
			notScrolling = 0;
		},
		'complete' : function(event){
			notScrolling = 1;
		}
	});	
	
	// Définition de la transition d'apparition/disparition des elements lors du scroll
	elementsArray.each(function(item, index){
		if(index >= nbElementsDislayed) item.setStyles({'opacity': 0.0});
		item.blendEffect = new Fx.Tween(item, {
			property : 'opacity',
			duration: parseInt(dureeScroll/2),
			transition: Fx.Transitions.Quad.easeInOut,
			wait: false
		});
	});

// BOUTONS DROITE/GAUCHE
	// Desactivation
	var desactiveButton = function(button){
		button.fade('.0');
		button.removeEvents();
		button.addEvents({ 
			'mouseenter' : function(){
			},
			'mouseleave' : function(){
			},
			'click' : function(event){ 
				event.stop();
			}		  		  
		});
	}

	// Activation
	var activeButton = function(button, sens){
		button.fade('1.0');
		button.removeEvents();
		button.addEvents({ 
			'mouseenter' : function(){
				
			},
			'mouseleave' : function(){
				
			},
			'click' : function(event){ 
				event.stop();
				// Bouton de Droite (+1)
				if( maxRightIncrement > totIncrement && notScrolling && sens == +1){
					activeButton(carLeft, -sens);
					
					totIncrement = (currentElement+sens)*increment;
					previousElement = currentElement;
					currentElement += sens; 
					if(vertical){
						scrollEffect.start(0,totIncrement);
					}else{
						scrollEffect.start(totIncrement ,0);
					}
					elementsArray[currentElement].blendEffect.start(1.0);
					elementsArray[previousElement].blendEffect.start(0.0);
					if( maxRightIncrement <= totIncrement) desactiveButton(this);
				}
				// Bouton de Gauche (-1)
				if( totIncrement > 0 && notScrolling && sens == -1){
					activeButton(carRight, -sens);
					totIncrement = (currentElement + sens )*increment;
					if( totIncrement <= 0) desactiveButton(this);
					previousElement = currentElement+nbElementsDislayed+sens;
					currentElement += sens;
		
					if(vertical){
						scrollEffect.start(0,totIncrement);
					}else{
						scrollEffect.start(totIncrement ,0);
					}
					elementsArray[currentElement].blendEffect.start(1.0)
					.chain(function(){elementsArray[previousElement].blendEffect.start(0.0);});
				}
				changeContainer(elementsArray[currentElement]);
			}		  		  
		});
	}

//INITIALISATION
	carLeft.set('opacity', 0);
	if(container.getElements(elementsClass).length > nbElementsDislayed){
		carRight.set('opacity', 1);
		activeButton(carRight, 1);
	}else{
		carRight.set('opacity', 0);
	}
	
});