var nxblender = {




	fadeDuration: 2.5,
	displayDuration: 7,




	init: function() {

		var sourcePool = nxblender.getSourcePool();
		nxblender.createContentReplacements(sourcePool);
		nxblender.addRotationOrder(sourcePool);

		nxblender.showFirstElement(sourcePool);

	},




	showFirstElement: function(sourcePool) {

		var startIndex = nxblender.findCurrentElementIndex(sourcePool);

		sourcePool.targetIdentifiers.each(function(targetIdentifier) {

			switch(sourcePool.sourcePools[targetIdentifier][startIndex].effectIdentifier) {
				case 'resize':
					nxblender.createContentReplacements_resize(sourcePool.sourcePools[targetIdentifier][startIndex].sourceElement, 'first');
					break;
				default:
					nxblender.createContentReplacements_opacity(sourcePool.sourcePools[targetIdentifier][startIndex].sourceElement, 'first');
					break;
			}

		});

		nxblender.fade(sourcePool, startIndex, true);

	},




	findCurrentElementIndex: function(sourcePool) {

		var index = 0;

		sourcePool.targetIdentifiers.each(function(targetIdentifier) {
			var counter = 0;
			sourcePool.sourcePools[targetIdentifier].each(function(sourceElement) {

				var lastChild = $$(targetIdentifier).first().select(':last-child').last();
				var srcArray = [];
				if(lastChild.tagName.toLowerCase() == 'img' && lastChild.getAttribute('src')) {
					srcArray.push(lastChild.getAttribute('src'));
				}
				lastChild.select('img').each(function(img) {
					srcArray.push[img.getAttribute('src')];
				});

				sourceElement.sourceElement.select('img').each(function(srcImage) {
					srcArray.each(function(src) {
						if (src === srcImage.getAttribute('src')) {
							index = counter;
						}
					});
				});

				counter++;

			});
		});

		return index;

	},




	getSourcePool: function() {

		var sourcePool = {
			sourcePools: {},
			targetIdentifiers: []
		};

		var defaultTargetIdentifier = 'body';

		$$('.nxblender-sourcepool').each(function(sourceElement) {
			var targetIdentifierInput = false;
			var targetIdentifier = defaultTargetIdentifier;
			if (targetIdentifierInput = sourceElement.select('input.nxblender-targetelement').first()) {
				targetIdentifier = targetIdentifierInput.getAttribute('value');
			}
			else {
				targetIdentifier = $$(defaultTargetIdentifier).first();
			}

			var effectIdentifier = 'opacity';
			if (effectIdentifierInput = sourceElement.select('input.nxblender-effect').first()) {
				effectIdentifier = effectIdentifierInput.getAttribute('value');
			}

			if (targetIdentifier) {
				if (!sourcePool.sourcePools[targetIdentifier]) {
					sourcePool.targetIdentifiers.push(targetIdentifier);
					sourcePool.sourcePools[targetIdentifier] = [];
				}
				sourcePool.sourcePools[targetIdentifier].push({
					targetIdentifier: targetIdentifier,
					targetIdentifierInput: targetIdentifierInput,
					sourceElement: sourceElement,
					effectIdentifier: effectIdentifier,
					originalHeight: 0,
					originalWidth: 0
				});
			}
		});

		//TODO: Hier evtl. sourcePool[$i][] auf gleiche Längen trimmen

		return sourcePool;

	},




	createContentReplacements: function(sourcePool) {

		sourcePool.targetIdentifiers.each(function(targetIdentifier) {

			var targetElement = ($$(targetIdentifier).first());

			var height = 0;
			var width = 0;
			targetElement.childElements().each(function(element) {
				element.setStyle({visibility: 'hidden'});
				height += element.getHeight();
				width += element.getWidth();
			});
			targetElement.setStyle({
				position: targetElement.getStyle('position')
			});

			maxWidth = width;
			maxHeight = height;

			var replacementBox = new Element('div');

			targetElement.insert({top: replacementBox});

			replacementBox.addClassName('nxblender-replacementbox');

			replacementBox.setStyle({
				display: 'block',
				overflow: 'hidden',
				position: 'absolute',
				width: maxWidth+'px',
				height: maxHeight+'px'
			});

			sourcePool.sourcePools[targetIdentifier].each(function(sourceElement) {
				sourceElement.targetElement = replacementBox;
				replacementBox.insert(sourceElement.sourceElement);
				sourceElement.sourceElement.setStyle({
					position: 'absolute'
				});
				sourceElement.originalHeight = sourceElement.sourceElement.getHeight();
				sourceElement.originalWidth = sourceElement.sourceElement.getWidth();

				switch(sourceElement.effectIdentifier) {
					case 'resize':
						nxblender.createContentReplacements_resize(sourceElement.sourceElement, 'all');
						break;
					default:
						nxblender.createContentReplacements_opacity(sourceElement.sourceElement, 'all');
						break;
				}
			});

		});

	},




	createContentReplacements_resize: function(sourceElement, first) {

		switch (first) {

			case 'first':
				sourceElement.setStyle({
					width: 'auto',
					height: 'auto'
				});
				break;
	
			default: 
				sourceElement.setStyle({
					width: '0px',
					height: '0px'
				});
				break;

		}

	},




	createContentReplacements_opacity: function(sourceElement, first) {

		switch (first) {

			case 'first':
				sourceElement.setStyle({
					opacity: 1.0
				});
				break;
	
			default: 
				sourceElement.setStyle({
					opacity: 0.0
				});
				break;

		}

	},




	addRotationOrder: function(sourcePool) {

		var size = 0;

		sourcePool.targetIdentifiers.each(function(targetIdentifier) {
			if (
				size === 0
				||
				sourcePool.sourcePools[targetIdentifier].length < size
			) {
				size = sourcePool.sourcePools[targetIdentifier].length;
			}
		});

		sourcePool.targetIdentifiers.each(function(targetIdentifier) {
			var nextItem = 0;
			sourcePool.sourcePools[targetIdentifier].each(function(sourceElement) {
				nextItem++;
				if (nextItem >= size) {
					nextItem = 0;
				}
				sourceElement.nextItemIndex = nextItem;
				sourceElement.nextItem = sourcePool.sourcePools[targetIdentifier][nextItem];
			});
		});

	},




	fade: function(sourcePool, currentIndex, firstCall) {

		var nextIndex = currentIndex;

		if (!firstCall) {

			sourcePool.targetIdentifiers.each(function(targetIdentifier) {
				var currentElement = sourcePool.sourcePools[targetIdentifier][currentIndex];
				nextIndex = currentElement.nextItemIndex;
				var nextElement = currentElement.nextItem;

				switch (currentElement.effectIdentifier) {

					case 'resize':
						nxblender.fade_resize(currentElement, nextElement);
						break;

					default:
						nxblender.fade_opacity(currentElement, nextElement);
						break;

				}

			});

		}

		nxblender.fade.delay(nxblender.displayDuration, sourcePool, nextIndex, false);

	},




	fade_resize: function(currentElement, nextElement) {

		currentElement.sourceElement.setStyle({opacity: 1});
		nextElement.sourceElement.setStyle({opacity: 1});

		// fade out current element immediately
		new Effect.Scale(
			currentElement.sourceElement,
			0,
			{
			scaleMode: {
				originalHeight: nextElement.originalHeight,
				originalWidth: nextElement.originalWidth
			},
			scaleFrom: 100
			}
		);

		// fade in next element with a delay of 1.5 seconds to wait for the first element being faded out
		(function() {
			new Effect.Scale(
				nextElement.sourceElement,
				100,
				{
					scaleMode: {
						originalHeight: nextElement.originalHeight,
						originalWidth: nextElement.originalWidth
					},
					scaleFrom: 0
				}
			);
		}).delay(1.5);

	},




	fade_opacity: function(currentElement, nextElement) {

		new Effect.Opacity(currentElement.sourceElement, {
			duration: nxblender.fadeDuration,
			from: 1.0,
			to: 0.0
		});

		new Effect.Opacity(nextElement.sourceElement, {
			duration: nxblender.fadeDuration,
			from: 0.0,
			to: 1.0
		});

	}




};




Event.observe(window, 'load', function() {
	nxblender.init();
});