RedmaxForms = Class.create({
	
	cssDefaultvalueClass	: 'formDefaultvalue',
	cssValidClass			: 'formValidationPassed',
	cssErrorClass			: 'formValidationError',
	cssErrorBox				: 'errorBox',
	
	validationTypes			: ['isNotEmpty', 'isEmailAddress', 'isNumber'],
	defaultValues			: [],
	form					: null,
	
	initializeForm: function(formId) {
		this.form = $(formId);
		
		inputFields = this.getFormFields();
		inputFields.each(function(inputField) {
			
			if (inputField.type != 'hidden' && inputField.type != 'submit') {
				this.saveDefaultValue(inputField);
				$(inputField).observe('focus', this.validateOnFocus.bind(this, inputField));
				$(inputField).observe('blur', this.validateOnBlur.bind(this, inputField));
				
				this.generateErrorBox(inputField);
			}
  
		}, this);
		
		// Set formvalidator handler on submit button
		this.form.observe('submit', this.onSubmit.bind(this));
	},
	
	/*
	 * chooseMethod, switch from method button
	 * @param none
	 */
	chooseMethod:function()
	{		
		if(!$('econsult').hasClassName('econsult-active'))
		{
			$('gesprek').addClassName('gesprek-active');
			$('econsult').addClassName('econsult-active');
			$('method').setValue('econsult');
		}
		else 
		{
			$('econsult').removeClassName('econsult-active');
			$('gesprek').removeClassName('gesprek-active');
			$('method').setValue('gesprek');
		}	
	},
	
	
	/**
	 * return all the available fields of the form;
	 */
	getFormFields: function() {
		return this.form.select('input', 'textarea');
	},
	
	/**
	 * Get the default value of a formfield
	 * 
	 * @param {Object} inputField
	 * @return The default value
	 */
	getDefaultValue: function(inputField) {
		return this.defaultValues[inputField.id]
	},
	
	/**
	 * @param {Object} inputField
	 */
	restoreDefaultValue: function(inputField) {
		var defaultValue = this.getDefaultValue(inputField);
		if ($F(inputField) == '') {
			$(inputField).value = defaultValue;
		}
		$(inputField).addClassName(this.cssDefaultvalueClass);
	},
	
	/**
	 * @param {Object} inputField
	 */
	saveDefaultValue: function(inputField) {
		this.defaultValues[inputField.id] = $F(inputField); 
	},
	
	/**
	 * @param {Object} inputField
	 */
	generateErrorBox: function(inputField) {
		var errorText = this.getErrorText(inputField);
		if (errorText != null) {
			var errorElement = new Element("div", { 'class' : this.cssErrorBox, 'id' : inputField.id + "ErrorBox" });
			errorElement.update(this.getErrorText(inputField));
			Element.insert(inputField, { after: errorElement });
			$(inputField.id + "ErrorBox").hide();
		}
	},
	
	/**
	 * @param {Object} inputField
	 */
	getValidationType: function(inputField) {
		var classNames = inputField.classNames();
		var validationType;
		classNames.each(function(className) {
			if (this.validationTypes.indexOf(className) != -1) {
				validationType = className;
			}
		}, this);
		return validationType;
	},
	
	/**
	 * @param {Object} inputField
	 */
	removeDefaultValue: function(inputField) {
		if ($(inputField).hasClassName(this.cssDefaultvalueClass)) {
			$(inputField).removeClassName(this.cssDefaultvalueClass);
		}
	},
	
	/**
	 * @param {Object} inputField
	 */
	validateField: function(inputField) {
		var validationType = this.getValidationType(inputField);
		var fieldValue = $F(inputField);
		
		if (validationType != null) {
			// The value may not be equal to the default value
			if (fieldValue == this.getDefaultValue(inputField)) {
				return false;
			}
			
			switch (validationType.toLowerCase()) {
				case 'isnotempty': return this.isNotEmpty(fieldValue); break;
				case 'isemailaddress': return this.isEmailAddress(fieldValue); break;
				case 'isnumber': return this.isNumber(fieldValue); break;
				default:
					alert('validationType:' + validationType + ' is not defined!');
			}
		}
		// There is no validation available, return true;
		return true;
	},
	
	/**
	 * @param {Object} inputField
	 */
	validateOnFocus: function(inputField) {
		if ($F(inputField) == this.getDefaultValue(inputField)) {
			$(inputField).value = '';
		}
	},
	
	/**
	 * @param {Object} inputField
	 */
	validateOnBlur: function(inputField) {
		if (this.getValidationType(inputField) != null) {
			if (this.validateField(inputField)) {
				this.hideError(inputField);
			} else {
				this.displayError(inputField);
			}
		}
		
		// Restore default value is field is empty
		if ($F(inputField) == '') {
			this.restoreDefaultValue(inputField);
		} 
	},
	
	/**
	 * @param {String} value
	 */
	isNotEmpty: function(value) {
		var re = /.+/;
	    if(!value.match(re)) {
	        return false;
	    } else {
	        return true;
	    }
	},
	
	/**
	 * Check value for a valid email address
	 * 
	 * @param {String} value
	 */
	isEmailAddress: function(value) {
		var re = /^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$/;
		if (!value.match(re)) {
			return false;
		} else {
			return true;
		}
	},
	
	/**
	 * 
	 * @param {String} value
	 */
	isNumber: function(value) {
		var re = /^[-]?\d*\.?\d*$/;
		value = value.toString();
		if (!value.match(re) && isNotEmpty( value )) {
			return false;
		} else {
		    return true;
		}
	},
	
	/**
	 * @param {Object} inputField
	 */
	getErrorText: function(inputField) {
		var errroText = null;
		if ($(inputField.id + 'ErrorText')) {
			var errorText = $F(inputField.id + 'ErrorText');
		}
		return errorText;
	},
	
	/**
	 * @param {Object} inputField
	 */
	displayError: function(inputField) {
		this.removeDefaultValue(inputField);
		$(inputField).addClassName(this.cssErrorClass);
		if ($(inputField).hasClassName(this.cssValidClass)) {
			$(inputField).removeClassName(this.cssValidClass);
		}
		
		if ($(inputField.id + "ErrorBox") != null) {
			$(inputField.id + "ErrorBox").show();
		}
	},
	
	/**
	 * @param {Object} inputField
	 */
	hideError: function(inputField) {
		this.removeDefaultValue(inputField);
		$(inputField).addClassName(this.cssValidClass);
		if ($(inputField).hasClassName(this.cssErrorClass)) {
			$(inputField).removeClassName(this.cssErrorClass);
		}
		
		if ($(inputField.id + "ErrorBox") != null) {
			$(inputField.id + "ErrorBox").hide();
		}
	},
	
	/**
	 * @return {Boolean}
	 */
	validateForm: function() {
		var formIsValid = true;
		inputFields = this.getFormFields();
		inputFields.each(function(inputField) {
			if (inputField.type != 'hidden' && inputField.type != 'submit') {
				if (!this.validateField(inputField)) {
					this.displayError(inputField);
					formIsValid = false;
				}
			}
		}, this);
		return formIsValid;
	},
	
	
	getUrlVars: function()
	{
	    var vars = [], hash;
	    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');

	    for(var i = 0; i < hashes.length; i++)
	    {
	        hash = hashes[i].split('=');
	        vars.push(hash[0]);
	        vars[hash[0]] = hash[1];
	    }

	    return vars;
	},
	
	formRequest:	function(formId)
	{
		var paramFormId = Form.serialize(formId);
		var hash = this.getUrlVars(); 

		new Ajax.Request(  
				'/Ajax?module=Reaction&method=post_reaction',  
	   			{ 
		   			method: 'post', 
		   			parameters: paramFormId,  
	  				onComplete: function(request)
	  				{		  		
						window.location.href='/over-novarum/actueel?path=' + hash['path'];						
		  			}, 
		  			evalScript: false  
	   			});
	},
	
	/**
	 * 
	 */
	onSubmit: function(event) {			
		// Stop form submit on validation error
		if (!this.validateForm()) {

			Event.stop(event);
		} 
		else
		{
			if(this.form == "reactionForm")
			{
				this.formRequest('reactionForm');
			}			
		}
	}
});