/***************************************************************
*  Copyright notice
*
*  (c) 2009 Stephan Schuler <stephan.schuler@netlogix.de>
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/




/**
 * Formular Validator
 *
 * $Id$
 */
var nxformvalidation = {




	validationRules: [],




	groupingAttribute: '.nx-tabform-tab',




	init: function(_param) {

		var param = jQuery.extend({
			performAddingEvents: true,
			validateOnChange: true
		}, _param);

		jQuery(nxformvalidation.onInitFunction).each(function(initFunctionKey, initFunction) {
			initFunction();
		});

		jQuery('form.nx-formvalidation').each(function(formKey, form) {
			nxformvalidation.addValidationHandlerToFormInputs(jQuery(form), param);
		});
		jQuery('.nx-formvalidation-wrapper').find('form').each(function(formKey, form) {
			nxformvalidation.addValidationHandlerToFormInputs(jQuery(form), param);
		});

		if (param.performAddingEvents) {
			nxformvalidation.performAddingEvents();
		}

	},




	performAddingEvents: function() {

		while (addEventFunction = nxformvalidation.addEventStack.pop()) {
			if (typeof addEventFunction == 'function') {
				addEventFunction();
			}
		};

	},




	addValidationGroupHandlers: function() {

		jQuery('.nx-formvalidation-validategroupNew').each(function(i, Button) {
			var button = jQuery(Button);
			var groupId = '';
			var formId = '';
			jQuery.each(button.attr('class').split(/\s/), function(j, className) {
				if (className.substr(0, 'nx-formvalidation-validategroup-'.length) == 'nx-formvalidation-validategroup-') {
					groupId = className.substr('nx-formvalidation-validategroup-'.length);
				}
				if (className.substr(0, 'nx-formvalidation-validateform-'.length) == 'nx-formvalidation-validateform-') {
					formId = className.substr('nx-formvalidation-validateform-'.length);
				}
			});

			nxformvalidation.addEventStack.push(function() {
				button.click(function(event) {
					var counter = 0;
					var invalidResultsList = nxformvalidation.validateForms(formId, groupId);
					jQuery.each(invalidResultsList, function(group, invalidResults) {
						jQuery.each(invalidResults, function(t) {
							counter++;
						});
					});
					if (counter !== 0) {
						event.stopPropagation();
						event.stopImmediatePropagation();
						event.preventDefault();
					}
				});
			});

		});

	},




	onInit: function(onInitFunction) {
		nxformvalidation.onInitFunction.push(onInitFunction);
	},




	onValidate: function(onValidateFunction) {
		nxformvalidation.onValidateFunction.push(onValidateFunction);
	},




	addValidationHandlerToFormInputs: function(form, param) {

		if (form.hasClass('nx-formvalidation-validated')) {
			return false;
		}
		form.addClass('nx-formvalidation-validated');

		nxformvalidation.addVirtualId(jQuery(form));


		var e = jQuery.Event('nxformvalidationPreInit');
		e.restrictToSingleForm = jQuery(form).attr('id');
		jQuery('body').trigger(e);

		form.find('.nx-formvalidation-input').each(function(inputKey, input) {
			inputField = jQuery(input);
			nxformvalidation.addVirtualId(inputField);
			var validationRules = nxformvalidation.getValidationRules(inputField, form, param);
		});

		form.find(nxformvalidation.groupingAttribute).each(function(i, group) {
			nxformvalidation.addGroupValidationHandler(form, jQuery(group));
		});

		form.submit(function(e) {
			return nxformvalidation.formSubmit(e, form);
		});

	},




	addGroupValidationHandler: function(form, group) {
		group.find('.nx-formvalidation-validategroup').each(function(i, button) {
			nxformvalidation.addVirtualId(jQuery(button));
			jQuery(button).addClass('nx-formvalidation-validategroup-'+group.attr('id'));
			jQuery(button).addClass('nx-formvalidation-validateform-'+form.attr('id'));
			jQuery(button).addClass('nx-formvalidation-validategroupNew');
		});
	},




	addVirtualId: function(element) {

		if(!element.attr('id')) {
			nxformvalidation.virtualIdCounter++;
			element.attr('id', 'nx-formvalidation-virtualid-'+nxformvalidation.virtualIdCounter);
		}

	},




	formSubmit: function(e, form) {

		var invalidInputs = nxformvalidation.validateForms(form.attr('id'));

		var formInvalidInputs = [];
		if (invalidInputs[form.attr('id')]) {
			while (invalidInput = invalidInputs[form.attr('id')].pop()) {
				var formChild = form.find('*').each(function (formChildKey, formChild) {
					if(invalidInput[0] == formChild) {
						formInvalidInputs.push(invalidInput);
					}
				});
			};
		}

		if (formInvalidInputs.length == 0) {
			return true;
		}
		else {
			e.stopImmediatePropagation();
			e.stopPropagation();
			return false;
		}

		return false;

	},




	getValidationRules: function(inputField, containingForm, param) {

		var responsibleRules = [];
		jQuery((inputField.attr('class').split(' '))).each(function(classNameKey, className) {
			jQuery(nxformvalidation.validationRules).each(function(ruleObjectKey, ruleObject) {
				if (ruleObject.responsible(className)) {
					responsibleRules.push({
						className: className,
						ruleObject: ruleObject
					});
				}
			});
		});
		if(responsibleRules.length > 0) {
			nxformvalidation.validationJobs.push({
				inputField: inputField,
				containingForm: containingForm,
				responsibleRules: responsibleRules,
				overruled: false
			});
			if (param.validateOnChange) {
				inputField.change(function() {
					nxformvalidation.validateForms(containingForm.attr('id'));
				});
			}
		}

	},




	validateRules: function(inputField, responsibleRules) {
		/*
		if (inputField.hasClass('nx-formvalidation-empty') && inputField.val()=='') {
			return false;
		}
		*/
		var errorFound = false;
		jQuery(responsibleRules).each(function(ruleObjectKey, ruleObject) {

			if (!errorFound) {
				var className = ruleObject.className;
				var parameters = ruleObject.ruleObject.parameters(className);
				var currentValidationState = ruleObject.ruleObject.valid(inputField, parameters, className);
				if (!currentValidationState) {
					errorFound = ruleObject;
				}
			}

		});

		var errorClassNames = new Array();
		if(errorFound) {
			errorFound = false;
			var regExp = new RegExp('nx-formvalidation-error-(.+)');
			jQuery(inputField.attr('class').split(/\s/)).each(function(classNameKey, className) {
				var match = (className.match(regExp));
				if (match) {
					errorClassNames.push('nx-formvalidation-errorfield-'+match[1]);
					errorFound = 'nx-formvalidation-errorfield-'+match[1];
				}
			});
		}
		if (errorFound) {
			return errorClassNames;
		}
		else {
			return false;
		}

		return errorFound;

	},




	validateForms: function(restrictToSingleForm, restrictToSingleGroup) {

		var errorBlockClassNames = {};
		var validationAnyGroups = {};

		var responsibleLabelFields = {};
		var responsibleErrorBlocks = {};

		jQuery(nxformvalidation.validationJobs).each(function(validationJobKey, validationJob) {
			var anyGroupName = nxformvalidation.getAnyGroupName(validationJob.inputField);
			var formId = validationJob.containingForm.attr('id');
			if (!validationAnyGroups[formId]) {
				validationAnyGroups[formId] = [];
			}
			if (!validationAnyGroups[formId][anyGroupName]) {
				validationAnyGroups[formId][anyGroupName] = [];
			}
			validationAnyGroups[formId][anyGroupName].push(validationJob);
		});

		var invalidInputs = {};
		jQuery(nxformvalidation.onValidateFunction).each(function(validationFunctionKey, validationFunction) {
			validationFunction(restrictToSingleForm, validationAnyGroups);
		});

		for (var formId in validationAnyGroups) {
			if (!restrictToSingleForm || restrictToSingleForm==formId) {

				if (typeof invalidInputs[formId] == 'undefined') {
					invalidInputs[formId] = [];
				}

				for (var anyGroupKey in validationAnyGroups[formId]) {

					if(typeof validationAnyGroups[formId][anyGroupKey] != 'object') {
						continue;
					}

					var anyGroup = validationAnyGroups[formId][anyGroupKey];
					var anyInputFalid = false;
					var anyErrorBlockClassNames = [];

					var invalidGroupInputs = [];
					jQuery(anyGroup).each(function(validationJobKey, validationJob) {

						if(!validationJob.overruled) {

							var errorBlockClassName = nxformvalidation.validateRules(validationJob.inputField, validationJob.responsibleRules);
							responsibleErrorBlocks[validationJob.inputField.attr('id')] = jQuery('form#'+validationJob.containingForm.attr('id')).find('.' + errorBlockClassName);
							responsibleLabelFields[validationJob.inputField.attr('id')] = jQuery('form#'+validationJob.containingForm.attr('id')).find('label[for='+validationJob.inputField.attr('id')+']');

							var errorBlockClassNames = nxformvalidation.validateRules(validationJob.inputField, validationJob.responsibleRules);
							if(errorBlockClassNames) {
								jQuery.each(errorBlockClassNames, function(errorBlockClassNameCounter, errorBlockClassName) {
									anyErrorBlockClassNames.push(errorBlockClassName);
								});
								invalidGroupInputs.push(validationJob.inputField);
							}
							else {
								anyInputFalid = true;
							}

						}
						else {
							validationJob.overruled = false;
						}

					});
					if (!anyInputFalid) {
						while (invalidGroupInput = invalidGroupInputs.pop()) {
							invalidInputs[formId].push(invalidGroupInput);
						}
						while(errorBlockClassName = anyErrorBlockClassNames.pop()) {
							errorBlockClassNames[errorBlockClassName] = errorBlockClassName;
							nxformvalidation.errorBlockClassNames[errorBlockClassName] = errorBlockClassName;
						}
					}

				};

			};
		};

		var groupedInvalidInputs = nxformvalidation.groupInvalidInputs(invalidInputs, restrictToSingleForm, restrictToSingleGroup);
		nxformvalidation.changeCssClasses(errorBlockClassNames, groupedInvalidInputs, restrictToSingleForm, responsibleErrorBlocks, responsibleLabelFields);


		var e = jQuery.Event('nxformvalidationPostValidation');
		e.restrictToSingleForm = restrictToSingleForm;
		jQuery('body').trigger(e);


		return groupedInvalidInputs;

	},




	groupInvalidInputs: function(invalidInputs, restrictToSingleForm, restrictToSingleGroup) {

		if (!restrictToSingleForm) {
			return invalidInputs;
		}

		if (!restrictToSingleGroup) {
			return invalidInputs;
		}

		if (typeof invalidInputs[restrictToSingleForm] == 'undefined') {
			return invalidInputs;
		}

		var groupedInvalidInputs = {};

		jQuery.each(invalidInputs[restrictToSingleForm], function(i, input) {
			var targetGroup = '---';
			jQuery(nxformvalidation.groupingAttribute).each(function(j, groupBlock) {
				jQuery(groupBlock).find('#'+input.attr('id')).each(function() {
					targetGroup = jQuery(groupBlock).attr('id');
				});
			});
			if (typeof groupedInvalidInputs[targetGroup] == 'undefined') {
				groupedInvalidInputs[targetGroup] = [];
			}
			groupedInvalidInputs[targetGroup].push(input);
		});

		if (typeof groupedInvalidInputs[restrictToSingleGroup] == 'undefined') {
			return [];
		}
		else {
			var result = {};
			result[restrictToSingleForm] = groupedInvalidInputs[restrictToSingleGroup];
			return result;
		}

	},




	getAnyGroupName: function(inputField) {
		if (!nxformvalidation.anyGroupCounter) {
			nxformvalidation.anyGroupCounter = 0;
		}
		nxformvalidation.anyGroupCounter++;
		var anyGroupName = 'default-'+nxformvalidation.anyGroupCounter;
		jQuery(inputField.attr('class').split(' ')).each(function(classNameKey, className) {
			if(className.substr(0, 22) == 'nx-formvalidation-any-') {
				anyGroupName = className.substr(22);
			}
		});
		return anyGroupName;
	},




	changeCssClasses: function(errorBlockClassNames, invalidInputs, restrictToSingleForm, responsibleErrorBlocks, responsibleLabelFields) {

		for (var className in nxformvalidation.errorBlockClassNames) {
			if (typeof nxformvalidation.errorBlockClassNames[className] == 'string') {
				jQuery('.'+className)
					.addClass('nx-formvalidation-errorfield-errorblock-noerrorsfound')
					.removeClass('nx-formvalidation-errorfield-errorblock-errorsfound')
					;
			}
		};

		for (var validationJobKey in nxformvalidation.validationJobs) {
			var validationJob = nxformvalidation.validationJobs[validationJobKey];
			if (typeof validationJob == 'object') {
				if (!restrictToSingleForm || restrictToSingleForm == validationJob.containingForm.attr('id')) {
					validationJob.inputField
						.removeClass('nx-formvalidation-inputfield-errorsfound')
						.addClass('nx-formvalidation-inputfield-noerrorsfound')
					;
					if(validationJob.inputField.attr('id')) {
						var labelQuery = 'label[for='+validationJob.inputField.attr('id')+']';
						jQuery('form#'+validationJob.containingForm.attr('id')).find(labelQuery).each(function(labelKey, label) {
							jQuery(label)
								.removeClass('nx-formvalidation-inputlabel-errorsfound')
								.addClass('nx-formvalidation-inputlabel-noerrorsfound')
							;
						});
					}
				}
			}
		}

		for (var formKey in invalidInputs) {
			if(typeof invalidInputs[formKey] == 'object') {
				if (!restrictToSingleForm || restrictToSingleForm == formKey) {
					for (var invalidInputKey in invalidInputs[formKey]) {
						var invalidInput = invalidInputs[formKey][invalidInputKey];
						if (typeof invalidInput == 'object') {
							invalidInput
								.removeClass('nx-formvalidation-inputfield-noerrorsfound')
								.addClass('nx-formvalidation-inputfield-errorsfound')
							;
							if (invalidInput.attr('id')) {
								if (responsibleLabelFields[invalidInput.attr('id')]) {
									responsibleLabelFields[invalidInput.attr('id')]
										.removeClass('nx-formvalidation-inputlabel-noerrorsfound')
										.addClass('nx-formvalidation-inputlabel-errorsfound')
									;
								}
								if (responsibleErrorBlocks[invalidInput.attr('id')]) {
									responsibleErrorBlocks[invalidInput.attr('id')]
										.removeClass('nx-formvalidation-errorfield-errorblock-noerrorsfound')
										.addClass('nx-formvalidation-errorfield-errorblock-errorsfound')
									;
								}
							}
						}
					}
				}
			}
		}

	},




	validationJobs: [],




	errorBlockClassNames: {},




	onInitFunction: [],




	onValidateFunction: [],




	virtualIdCounter: 0,




	addEventStack: []




};




/**
 * Validation rule for min length
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 28) == 'nx-formvalidation-minlength-')
			return true;
		return false;
	},

	parameters: function(className) {
		var returnValue = {
				minLength: 10
		};
		var minLength = (parseInt(className.substr(28)));
		if (minLength != 0) {
			returnValue.minLength = minLength;
		}
		return returnValue;

	},

	valid: function(inputObject, parameters, className) {
		if (inputObject.val().length < parameters.minLength) {
			return false;
		}
		else {
			return true;
		}
	}

});




/**
 * Validation rule for max length
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 28) == 'nx-formvalidation-maxlength-')
			return true;
		return false;
	},

	parameters: function(className) {
		var returnValue = {
				maxLength: 10
		};
		var maxLength = (parseInt(className.substr(28)));
		if (maxLength != 0) {
			returnValue.maxLength = maxLength;
		}
		return returnValue;
	},

	valid: function(inputObject, parameters, className) {
		if (inputObject.val().length > parameters.maxLength) {
			return false;
		}
		else {
			return true;
		}
	}

});




/**
 * Validation rule for integers having a minimum value
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 27) == 'nx-formvalidation-minvalue-')
			return true;
		return false;
	},

	parameters: function(className) {
		var returnValue = {
				minValue: 0
		};
		var minValue = (parseInt(className.substr(27)));
		if (minValue != 0) {
			returnValue.minValue = minValue;
		}
		return returnValue;
	},

	valid: function(inputObject, parameters, className) {
		if (parseInt(inputObject.val()) >= parameters.minValue) {
			return true;
		}
		else {
			return false;
		}
	}

});




/**
 * Validation rule for integers having a maximum value
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 27) == 'nx-formvalidation-maxvalue-')
			return true;
		return false;
	},

	parameters: function(className) {
		var returnValue = {
				maxValue: 100000000
		};
		var maxValue = (parseInt(className.substr(27)));
		if (maxValue != 0) {
			returnValue.maxValue = maxValue;
		}
		return returnValue;
	},

	valid: function(inputObject, parameters, className) {
		if (parseInt(inputObject.val()) <= parameters.maxValue) {
			return true;
		}
		else {
			return false;
		}
	}

});




/**
 * Validation rule for email adresses
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 23) == 'nx-formvalidation-email')
			return true;
		return false;
	},

	parameters: function(className) {
		return {};
	},

	valid: function(inputObject, parameters, className) {
//		var matchingExpression = new RegExp("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$", 'i');
		var matchingExpression = new RegExp("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|gov|mil|biz|info|mobi|name|aero|jobs|museum)$", 'i');
		if (!matchingExpression.test(inputObject.val())) {
			return false;
		}
		else {
			return true;
		}
	}

});




/**
 * Validation rule unchecked checkboxes
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 25) == 'nx-formvalidation-checked')
			return true;
		return false;
	},

	parameters: function(className) {
		return {};
	},

	valid: function(inputObject, parameters, className) {

		return (inputObject.attr('checked'));

	}

});




/**
 * Validation rule for unchecked checkboxes
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 27) == 'nx-formvalidation-unchecked')
			return true;
		return false;
	},

	parameters: function(className) {
		return {};
	},

	valid: function(inputObject, parameters, className) {

		return !(inputObject.attr('checked'));

	}

});




/**
 * Validation rule for integers
 */
nxformvalidation.validationRules.push({

	responsible: function(className) {
		if(className.substr(0, 25) == 'nx-formvalidation-integer')
			return true;
		return false;
	},

	parameters: function(className) {
		var returnValue = {
				intLength: 0
		};
		var intLength = (parseInt(className.substr(26)));
		if (intLength != 0) {
			returnValue.intLength = intLength;
		}
		if (returnValue.intLength == 0) {
			returnValue.minLength = 0;
			returnValue.maxLength = 10000;
		}
		else {
			returnValue.minLength = intLength;
			returnValue.maxLength = intLength;
		}
		return returnValue;
	},

	valid: function(inputObject, parameters, className) {
		var matchingExpression = new RegExp('^\\d{'+(parameters.minLength)+','+(parameters.maxLength)+'}$');
		if (!matchingExpression.test(inputObject.val())) {
			return false;
		}
		else {
			return true;
		}
	}

});




/**
 * Example form validation onInit hook
 */
nxformvalidation.onInit(function() {
	// noop();
});


if (typeof checkbox != 'function') {
	checkbox = function() {};
}/***************************************************************
*  Copyright notice
*
*  (c) 2009 Stephan Schuler <stephan.schuler@netlogix.de>
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/




/**
 * Formular Validator
 *
 * $Id$
 */
var nxformvalidation_conditionalRequirement = {




	init: function() {
		nxformvalidation.onValidate(nxformvalidation_conditionalRequirement.onValidate);
	},




	overruleSplitter: '_',




	onValidate: function(restrictToSingleForm, validationAnyGroups) {

		for (var formId in validationAnyGroups) {
			if (!restrictToSingleForm || restrictToSingleForm==formId) {
				for (var anyBoxIdentifier in validationAnyGroups[formId]) {
					for (var i in validationAnyGroups[formId][anyBoxIdentifier]) {
						if(typeof validationAnyGroups[formId][anyBoxIdentifier][i] != 'function') {
							var overrule = nxformvalidation_conditionalRequirement.overruleElement(validationAnyGroups[formId][anyBoxIdentifier][i], anyBoxIdentifier);
							if (overrule) {
								validationAnyGroups[formId][anyBoxIdentifier][i]['overruled'] = true;
							}
						}
					};
				}
			}
		}

	},




	overruleElement: function(inputElement, anyBoxIdentifier) {

		var dependencyFound = false;
		var dependencySatisfied = false;
		if(typeof inputElement.inputField == 'undefined') {
			return false;
		}

		jQuery(inputElement.inputField.attr('class').split(' ')).each(function(classNameKey, className) {
			if (className.substr(0, 30) == 'nx-formvalidation-dependingon-') {
				dependencyFound = true;
				var dependingClass = className.substr(30).split(nxformvalidation_conditionalRequirement.overruleSplitter);
				var requiredValue = dependingClass.pop();
				dependingClass = dependingClass.join(nxformvalidation_conditionalRequirement.overruleSplitter);
				jQuery('input.'+dependingClass+':checked').each(function(dependingInputKey, dependingInput) {
					if (
						jQuery(dependingInput).val().toLowerCase() == requiredValue.toLowerCase()
					) {
						dependencySatisfied = true;
					}
				});
			}
		});

		return (dependencyFound && !dependencySatisfied);

	}




};




nxformvalidation.onInit(nxformvalidation_conditionalRequirement.init);




jQuery(function(){




	var config = {
		general: {
			form 							: 'nx-formvalidation',
			input 							: 'nx-formvalidation-input',
			errorMsg						: 'nx-formvalidation-errormsg',
			errorText 						: 'nx-formvalidation-error-powermail',
			errorField 						: 'nx-formvalidation-errorfield-powermail',
			classToAppendTheErrorTextTo		: new Array(
												'tx_powermail_pi1_fieldwrap_html_submitgraphic',
												'tx_powermail_pi1_fieldwrap_html_submit'
											 ),
			errorMessageConfiguration		: {
				underneathTheErrorInput 			: 0,
				globalErrorBoxWithAllErrors			: 0,
				globalErrorBoxWithOneErrorMessage	: 1
			},
			globalErrorMessage				: 'Bitte alle Pflichtfelder ausfüllen.',
			counter							: 0
		},
		inputClasses: {
			required 						: {
				'nx-formvalidation-minlength-1' 	: 'Bitte füllen Sie das Feld aus.'
			},
			'validate-email'				: {
				'nx-formvalidation-email' 			: 'Bitte geben Sie eine korrekte E-Mailadresse ein.'
			}
		}
	};





	/**
	 * Is triggerd before a form is being validated by nxformvalidation to ensure that with
	 * powermail we have the classes we need to validate the form without user interaction
	 * for usability reasons
	 */
	jQuery('body').bind('nxformvalidationPreInit', function(nxPreValidationEventObject) {

		// Adds a Class to the Form
		addClass('.nx-formvalidation-wrapper', '#' + nxPreValidationEventObject.restrictToSingleForm, config.general.form);

		// Get all Powermail Wrapper divs
		jQuery('#' + nxPreValidationEventObject.restrictToSingleForm + ' .tx_powermail_pi1_fieldwrap_html').each(function(wrapperCounter, wrapperObject){

			config.general.counter ++;
			var errorText = config.general.errorText + '-' + config.general.counter;
			var errorField = config.general.errorField + '-' + config.general.counter;

			/**
			 * Adds a class to each element with the given class
			 *
			 * This is the mapping from powermail to nxformvalidation
			 */
			jQuery.each(config.inputClasses, function(oldClassName, newClassConfigs) {

				jQuery(wrapperObject).find('.' + oldClassName).each(function(foundInputCounter, foundInput) {

					/**
					 * Validate the current input field
					 */
					jQuery(foundInput).addClass(config.general.input);

					/**
					 * Connect the current input field with its wrapper div as error message box
					 */
					jQuery.each(newClassConfigs, function(newClassName, errorMessage) {

						// Errormessages for each input
						if(config.general.errorMessageConfiguration.underneathTheErrorInput){
							var newErrorBox = jQuery('<div />');
							newErrorBox.html(errorMessage);
							newErrorBox.addClass(config.general.errorMsg);
							newErrorBox.addClass(errorField);
							jQuery(wrapperObject).append(newErrorBox);

						}else{
						// One global Errormessagebox

							// Errormessages
							if(config.general.errorMessageConfiguration.globalErrorBoxWithAllErrors){
								for(var i = 0; i < config.general.classToAppendTheErrorTextTo.length; i++){
									if(jQuery('.' + config.general.classToAppendTheErrorTextTo[i]).length){

										// Add an errormessage
										var newErrorBox = jQuery('<div />');
										newErrorBox.html(errorMessage);
										newErrorBox.addClass(config.general.errorMsg);
										newErrorBox.addClass(errorField);
										jQuery('.' + config.general.classToAppendTheErrorTextTo[i]).append(newErrorBox);

									}
								}
							}
							// Errormessage
							if(config.general.errorMessageConfiguration.globalErrorBoxWithOneErrorMessage){
								for(var i = 0; i < config.general.classToAppendTheErrorTextTo.length; i++){
									if(jQuery('.' + config.general.classToAppendTheErrorTextTo[i]).length){

										// If there is no errormessage
										if(!jQuery('.' + config.general.classToAppendTheErrorTextTo[i] + ' .' + config.general.errorMsg).length){
											var newErrorBox = jQuery('<div />');
											newErrorBox.html(config.general.globalErrorMessage);
											newErrorBox.addClass(config.general.errorMsg);
											newErrorBox.addClass(errorField);
											jQuery('.' + config.general.classToAppendTheErrorTextTo[i]).append(newErrorBox);
										}else{
											jQuery('#' + nxPreValidationEventObject.restrictToSingleForm).find('.' + config.general.errorMsg).addClass(errorField);
										}

									}
								}
							}
						}

						jQuery(foundInput).addClass(newClassName);
					});
					jQuery(wrapperObject).addClass(errorField);

					/**
					 * Validate by a single rule
					 */
					jQuery(foundInput).addClass(errorText);

				});
			});


		});

		/*
//		nx-formvalidation-error-required nx-formvalidation-input nx-formvalidation-minlength-1

		// Creates a container for the Error Message
		var errorDiv = jQuery('<div/>');
		jQuery(errorDiv).addClass(config.errorField);

		// Apends the Error Message Container
		for(var i = 0; i < config.classToAppendTheErrorTextTo.length; i++){
			if(jQuery('.' + config.classToAppendTheErrorTextTo[i]).length){
				jQuery('.' + config.classToAppendTheErrorTextTo[i]).append(errorDiv);
			}
		}
		*/



	});





	// Adds the class nxformvalidations needs to check if the input is not empty
	var addClass = function(wrapperDomElement, classToAddAClassTo, newClass){

		jQuery(wrapperDomElement).find(classToAddAClassTo).each(function(){

			if(!jQuery(this).hasClass(newClass)){
				jQuery(this).addClass(newClass);
			}
		});
	};






	// Adds the class nxformvalidations needs to check if the input is not empty
	var addClassToParent = function(classToAddToTheParent, inputId){

		console.log(inputId);

		jQuery('.' + classToAddToTheParent).parent().each(function(){

			if(!jQuery(this).hasClass(classToAddToTheParent)){
				jQuery(this).addClass(classToAddToTheParent);
			}
		});
	};


});

var nxfancymailbox = {

	init: function(){

		jQuery('#fancybox-inner').each(function(fancyBoxCounter, fancyBoxObject) {

			jQuery(fancyBoxObject).find('form.tx_powermail_pi1_form').each(function(formCounter, formElement) {

				if (jQuery(formElement).hasClass('nxfancymailbox-performed')) {
					return false;
				}
				jQuery(formElement).addClass('nxfancymailbox-performed');

				jQuery(formElement).submit(function(){

					var postData = jQuery(formElement).serializeArray();
					postData.push({
						name: 'removeHtmlHeader',
						value: 1
					});

					jQuery(fancyBoxObject).addClass('nxformvalidation_nxfancymailboxWorking');
					$.fancybox.resize();
					jQuery.ajax({
						url		:	jQuery(formElement).attr('action'),
						data	:	postData,
						type	: 	"POST",
						success	:	function(data) {
							jQuery(fancyBoxObject).html(data);
							jQuery(fancyBoxObject).removeClass('nxformvalidation_nxfancymailboxWorking');
							$.fancybox.resize();
						}
					});
					return false;

				});

			});

		});

	}

};jQuery(function(){



	jQuery('.roundedbox-accordion-wrapper').accordion({
			header : 'h1',
			collapsible : true,
			autoHeight : false
		});


});jQuery(function(){



	jQuery("a.fancybox").fancybox({
		'transitionIn'	: 'elastic',
		'transitionOut'	: 'elastic',
		'easingIn'	: 'easeOutBack',
		'easingOut'	: 'easeInBack',
		'titlePosition'	: 'inside'
		/*'titlePosition'	: 'over',
		'titleFormat'	: function(title, currentArray, currentIndex, currentOpts) {
			return '<span id="fancybox-title-over">Bild ' +  (currentIndex + 1) + ' / ' + currentArray.length + ' - ' + title + '</span>';
		}*/
	});


	jQuery("a.fancybox-form").fancybox({
		'titleShow'	: false,
		'hideOnOverlayClick' : false,
		 'onComplete' : function(){
			// Enables the JS-Validation on Fancybox ready
			nxformvalidation.init();
			// Makes all ajax interaction within a fancybox powermail form
			nxfancymailbox.init();
		}
	});


});var swapImages = {

	animationDuration : 2.5 * 1000,
	delay : 10 * 1000,
	mousehover : false,
	focus : false,

	swap : function(domElements, cssClass){
		var show;
		var next;

		// Gets the element that is shown
		domElements.each(function(){
			if(jQuery(this).hasClass(cssClass)){
				show = jQuery(this);
			}
		});

		/* If there is a next element, we will show that.
		 * If there is no next element, we will show the first one
		 */
		if(show.next().length > 0){
			next = show.next();
		}else{
			next = jQuery(domElements[0]);
		}

		// We only do things if we don't have a mouseover state
		if(!swapImages.mousehover && !swapImages.focus){

			// Do the fading
			next.fadeIn(swapImages.animationDuration, function(){
				next.addClass(cssClass);
			});
			if(next.hasClass('first')){
				jQuery('.roundedbox-teaser-accordion h3.first').click();
			}else if(next.hasClass('middle')){
				jQuery('.roundedbox-teaser-accordion h3.middle').click();
			}else{
				jQuery('.roundedbox-teaser-accordion h3.last').click();
			}
			//jQuery('.roundedbox-teaser-accordion').accordion( "resize" );

			
			show.fadeOut(swapImages.animationDuration, function(){
				show.removeClass(cssClass);
			});
			
		}

	},

	init: function(img, h3Elemente){
		jQuery(img[0]).addClass('show');
		jQuery(img[0]).addClass('first');
		jQuery(img[1]).addClass('middle');
		jQuery(img[2]).addClass('last');

		jQuery(h3Elemente[0]).addClass('show');
		jQuery(h3Elemente[0]).addClass('first');
		jQuery(h3Elemente[1]).addClass('middle');
		jQuery(h3Elemente[2]).addClass('last');
	}

};




jQuery(function(){

	/*var img = jQuery('.roundedbox-teaser .aktion-image-wrapper').children('.csc-default');
	swapImages.init(img, jQuery('.roundedbox-teaser-accordion h3'));
	return false;*/

	
	jQuery('.roundedbox-teaser-accordion').accordion({
		//animated: 'bounceslide',
		fillSpace: true
	});

	// Sets the animatation and delay time
	swapImages.delay = 10 * 1000;
	swapImages.animationDuration = 0.5 * 1000;

	// If we have more than one image we can rotate
	var img = jQuery('.roundedbox-teaser .aktion-image-wrapper').children('.csc-default');
	if(img.length > 1){
		swapImages.init(img, jQuery('.roundedbox-teaser-accordion h3'));
		jQuery(document).everyTime(swapImages.delay, function() {
			swapImages.swap(img, 'show');
		}, 0);
	}else if(img.length == 1){
		img.addClass('show');
	}



	// On click on a headline we will display the image to it
	jQuery('.roundedbox-teaser-accordion h3').click(function(){
		jQuery('.roundedbox-teaser .aktion-image-wrapper').children('.csc-default').removeClass('show').css({display: 'none'});
		if(jQuery(this).hasClass('first')) {
			jQuery('.roundedbox-teaser .aktion-image-wrapper .first').addClass('show').css({display: 'block'});
		} else if(jQuery(this).hasClass('middle')) {
			jQuery('.roundedbox-teaser .aktion-image-wrapper .middle').addClass('show').css({display: 'block'});
		} else {
			jQuery('.roundedbox-teaser .aktion-image-wrapper .last').addClass('show').css({display: 'block'});
		}
	});


	// On mouseover we will tell the switcher that the mouse is over
	jQuery('.roundedbox-teaser, .roundedbox-teaser *').bind('mouseenter', function(){
		swapImages.mousehover = true;
	});
	jQuery('.roundedbox-teaser, .roundedbox-teaser input').bind('focus', function(){
		swapImages.focus = true;
	});
	jQuery('.roundedbox-teaser').bind('mouseout', function(){
		swapImages.mousehover = false;
	});
	jQuery('.roundedbox-teaser input').bind('blur', function(){
		swapImages.focus = false;
	});


});var browserName=navigator.appName;var browserVer=parseInt(navigator.appVersion);var version="";var msie4=(browserName=="Microsoft Internet Explorer"&&browserVer>=4);if((browserName=="Netscape"&&browserVer>=3)||msie4||browserName=="Konqueror"||browserName=="Opera"){version="n3";}else{version="n2";}
function blurLink(theObject){if(msie4){theObject.blur();}}
function decryptCharcode(n,start,end,offset){n=n+offset;if(offset>0&&n>end){n=start+(n-end-1);}else if(offset<0&&n<start){n=end-(start-n-1);}
return String.fromCharCode(n);}
function decryptString(enc,offset){var dec="";var len=enc.length;for(var i=0;i<len;i++){var n=enc.charCodeAt(i);if(n>=0x2B&&n<=0x3A){dec+=decryptCharcode(n,0x2B,0x3A,offset);}else if(n>=0x40&&n<=0x5A){dec+=decryptCharcode(n,0x40,0x5A,offset);}else if(n>=0x61&&n<=0x7A){dec+=decryptCharcode(n,0x61,0x7A,offset);}else{dec+=enc.charAt(i);}}
return dec;}
function linkTo_UnCryptMailto(s){location.href=decryptString(s,-2);}
		jQuery(document).ready(function () {
			nxformvalidation.init();
		});