var emailRegEx = /^([\w\-]+)(.[\w\-]+)*@([\w\-]+)(.[\w\-]+)*(.[\w\-]{2,3}){1,2}$/;
var vehicleRegEx = '/^([a-zA-Z]{3}\s?(\d{3}|\d{2}|d{1})\s?[a-zA-Z])|([a-zA-Z]\s?(\d{3}|\d{2}|\d{1})\s?[a-zA-Z]{3})|(([A-HK-PRSVWYa-hk-prsvwy][aA-hHjJ-pPrR-yY])\s?([0][2-9]|[1-9][0-9])\s?[aA-hHjJ-pPrR-zZ]{3})$' 
var weakPasswordRegEx = /^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])\w{6,}$/;
var medPasswordRegEx = /^(?=.*\d)(?=.*[a-zA-Z])\w{6,}$/;
var strongPasswordRegEx = /^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])\w{6,}$/;
var filePathRegEx = /(.*)[\/\\]([^\/\\]+\.\w+)$/;
var urlRegEx = /^(http:\/\/www.|https:\/\/www.|ftp:\/\/www.|www.){1}([\w]+)(.[\w]+){1,2}$/;
var integerRegEx = /^-?\d+$/;
var decimalRegEx = /^[-+]?[0-9]+(\.[0-9]+)?$/;
var telephoneRegEx = /^([0-9]{11})$/;
var postcodeRegEx = /\b[a-z]{1,2}\d{1,2}[a-z]?\s*\d[a-z]{2}\b/i;
var dateRegEx = /^([0-9]){2}(\/|-){1}([0-9]){2}(\/|-)([0-9]){4}$/;
var emailErrorMsg = "must contain a valid email address";
var vehicleErrorMsg = "must contain a valid UK Registration number";
var dateErrorMsg = "must contain a valid date (mm/dd/yyyy)";
var requiredErrorMsg = "is a required field";
var urlErrorMsg = "is not a valid URL";
var filePathErrorMsg = "is not a valid filepath";
var postcodeErrorMsg = "is not a valid UK postcode";
var weakPasswordErrorMsg = "is not a valid password (must contain at least one digit/lowercase/uppercase letter and be at least six characters long)";
var medPasswordErrorMsg = "is not a valid password (must contain at least one digit/lowercase/uppercase letter and be at least six characters long)";
var strongPasswordErrorMsg = "is not a valid password (must contain at least one digit/lowercase/uppercase letter and be at least six characters long)";
var integerErrorMsg = "is not a valid number";
var decimalErrorMsg = "is not a valid decimal";
var telephoneErrorMsg = "is not a valid UK telephone";
var countErrorMsg = "should have {1} {2} selected items";
var valueErrorMsg = "should be {1} {2}";
var elementMatchErrorMsg = "must be {1} {2}";

		var emailRegEx = /^([\w\-]+)(.[\w\-]+)*@([\w\-]+)(.[\w\-]+)*(.[\w\-]{2,3}){1,2}$/;
		var emailErrorMsg = "Enter a valid email";
	
//var returnFunc;
				
/*
 * Adds onsubmit handler to any forms in the
 * document with the 'validate' class attached
 */
function initialiseForms()
{	
	//alert('init validator');
	for(var i = 0; i < document.forms.length; i++)
	{
		var form = document.forms[i];
		var classAttribute = getClassAttribute(form);

		if(!isNull(classAttribute))
		{			
			var splitArray = classAttribute.split(" ");
			for(var j = 0; j < splitArray.length; j++ )
			{
				if(splitArray[j].length > 0 && splitArray[j].charAt(0) == '#')
				{
					if(splitArray[j] == "#validate")
					{
						addEventHandler(form, 'submit', validateForm);
						//addEventHandler(form, 'submit', submitForm);
					}
					else if(splitArray[j] == "#debug")
					{
						//window.onerror = showError;
					}
					else
					{
						var func = splitArray[j].substring(1);
						if(func.substring(0,1) == 'A')
						{
							//alert(func.substring(1));
							window.postFunc =  eval(func.substring(1));
						}
						else
						{
							//alert('wrong' + func);
							window.returnFunc = eval(func);
							
						}
					}
				}
			}
		}
	}
}
function submitForm(e)
{
	alert('submitForm:' + e.returnValue);
}
/*
 * Form submit handler.
 * validates the submitted form elements
 * using validation classes attached to each element.
 * Launches an alert if any elements fail validation. 
 */
function validateForm(e)
{
	//alert('validateForm');
	var returnVal = true;
		
	var form = e.currentTarget || event.srcElement;
	var validator = new Validator();
	
	returnVal = validator.validate(form);

	if(!returnVal)
	{
		window.returnFunc( validator.getErrors());
		if (e && e.preventDefault)
		{
    		e.preventDefault(); // DOM workaround
    	}
	}
	else
	{
		if(window.postFunc())
		{
			//alert('postfunc');
			window.postFunc();
		}
		if (e && e.preventDefault)
		{
    		e.preventDefault(); // DOM workaround
    	}
	}
	if(e.returnValue )
	{
		e.returnValue = returnVal;
	}
	//else
	//{
	//	window.event.returnValue = returnVal;
	//} 
	return returnVal;
}

// non event call
function validateFormData(form)
{	
	//alert('validateForm');
	var returnVal = true;
		
	//var form = e.currentTarget || event.srcElement;
	var validator = new Validator();
	
	returnVal = validator.validate(form);

	if(!returnVal)
	{
		window.returnFunc( validator.getErrors());
		//if (e && e.preventDefault)
		//{
    	//	e.preventDefault(); // DOM workaround
    	//}
	}
	return returnVal;
}

/*
 * Shows all errors in dialogue box;
 * The validator uses this function if it is specified n the 
 * classes parameter of the form in question
 */
function alertErrors(errorArray)
{
	if(errorArray.length > 0)
	{
		var msg = "";
		for(var i = 0; i < errorArray.length ; i++)
		{
			msg += getElementName(errorArray[i][0]) + " ";
			var messageArray = errorArray[i][1];
			for(var j = 0 ; j < messageArray.length ; j++)
			{
				msg += messageArray[j];
				msg += "\n";
			}
		}
		alert(msg);
	} 
}

/*
 * Shows all errors in elements attached to the form;
 * the element id's must follow the following pattern 
 * 	id="msg_<element name>"
 * E.g.
 *	id="msg_password"
 */
function showErrors(errorArray)
{
	if(errorArray.length > 0)
	{
		for(var i = 0; i < errorArray.length ; i++)
		{
			var msgElement = document.getElementById("msg_" +  getElementName(errorArray[i][0]));
			if(msgElement != null)
			{
				var msg = "";
				var messageArray = errorArray[i][1];
				for(var j = 0 ; j < messageArray.length ; j++)
				{
					msg += messageArray[j];
					msg += "; ";
				}
				msgElement.innerHTML = msg;
			}
		}
	} 
}
/*
 * Constructs a new Validator Object
 */
function Validator() 
{
	this.msg = "";
	this.errorArray = new Array();
	
	this.validate = function(form)
	{
		//alert('Validator.validate');
		var returnVal = true;
		// get the unique element names
		var elementNames = getElementNames(form);
		for(var i = 0; i < elementNames.length ; i++)
		{
			// validate each element
			var element = form.elements[elementNames[i]];
			this.addError(element, this.validateElements(element));
		}
		return this.errorArray.length == 0;
	};
	
	this.validateElements = function(element)
	{
		//alert('Validator.validateElements');
		var errorArray = new Array();
		// get all validation rules for the element  
		var validationRules = getValidationRules(element);	
		// loop through the rules applying each in turn
		for(var i = 0 ; i < validationRules.length ; i++)
		{
			var errMsg = this.validateElement(element, validationRules[i]);
			if(errMsg != null)
			{
				errorArray[errorArray.length] = errMsg;
			}
		}
		return errorArray;
	};
	
	this.validateElement = function(element, ruleArray)
	{
		var errMesage;
		if(element.disabled)
		{
			return errMesage;
		}
		//alert('Validator.validateElement:' + ruleArray[0]);
		
		switch(ruleArray[0])
		{
			case "#regEx":
				errMesage = matchTest(element, getVariable(ruleArray[1] + "RegEx")) ? null : getVariable(ruleArray[1] + "ErrorMsg");
			break	
			case "#count":
				errMesage = countTest(element, ruleArray[1], ruleArray[2]) ? null : countErrorMsg;
			break;					
			case "#value":
				errMesage = valueTest(element, ruleArray[1], ruleArray[2]) ? null : valueErrorMsg;
			break;			
			case "#required":
				errMesage = !isEmptyCollection(element) ? null : requiredErrorMsg;
			break			
			case "#elementMatch":
			case "#fieldmatch":
				errMesage = matchElement(element, ruleArray[1], ruleArray[2]) ? null : elementMatchErrorMsg;
			break
		}
		return errMesage != null ? formatMessage(element, errMesage, ruleArray[1], ruleArray[2]) : errMesage;
	};
	
	this.addError = function(element, error)
	{
		//alert('Validator.addError');
		if(error.length > 0)
		{
			this.errorArray[this.errorArray.length] = new Array(element, error);
		}
	};
	
	this.getErrors = function()
	{
		return this.errorArray;
	};
}

function formatMessage(element, errorMsg, param1, param2)
{
	errorMsg = errorMsg.replace("{0}", getElementName(element));
	if(param1 != null)
	{
		errorMsg = errorMsg.replace("{1}", getHReadable(param1));
	}
	if(param2 != null)
	{
		errorMsg = errorMsg.replace("{2}", getHReadable(param2));
	} 
	return errorMsg;
}

/*
 * Returns true if the element value 
 * returns a match against the regular expression regEx
 */
function matchTest(element, regEx)
{
	// TODO: make this work across multiples
	var value = element.nodeType == 1 ? element.value : element;	
	return (value == '' || new RegExp(regEx).test(value));
}

/*
 * Returns true if the count of values in the element
 * are related to the testValue as specified by the operator
 */
function countTest(element, operator, testValue)
{
	return test(getValues(element).length, testValue, operator);
}
	
/*
 * Returns true if all values in the element
 * are related to the testValue as specified by the operator
 */
function valueTest(element, operator, testValue)
{
	var returnVal = true;
	var elementValues = getValues(element);
	
	for(var i = 0 ; i < elementValues.length ; i++)
	{
		var ret = test(elementValues[i], testValue, operator);
		
		returnVal = test(elementValues[i], testValue, operator) ? returnVal : false;
		
	}
	return returnVal;
}

/*
 * Returns true if the valueToTest is related 
 * to the testValue as specified by the operator
 */
function test(valueToTest, testValue, operator)
{
	var returnVal = false;

	valueToTest = !isNaN(valueToTest) ? parseFloat(valueToTest) : valueToTest;
	testValue = !isNaN(testValue) ? parseFloat(testValue) : testValue;
		
	if(testValue != null)
	{
		if(operator == '<')
		{
			returnVal = valueToTest < testValue;
		}
		else if(operator == '>')
		{
			returnVal = valueToTest > testValue;
		}
		else  if(operator == '!')
		{
			returnVal = valueToTest != testValue;
		}
		else
		{
			returnVal = valueToTest == testValue;
		}
	}
	return returnVal;
}

/*
 * Returns true if the element value is related 
 * to the value of the named test element as specified by the operator
 */
function matchElement (element, operator, testElement)
{
	//var testValue = getElementByName(element.form, testElement).value;
	//alert(testElement);
	var testElement =  getElementByName(element.form, testElement);
	if(isEmptyElement(testElement))
	{
		return true;
	}
	else
	{
		return test(element.value, testElement.value, operator);
	}
}

/*
 * Returns the named variable
 */
function getVariable(variableName)
{ 
	return eval(variableName);
}

/*
 * Returns a human readable version of the 
 * operator
 */
function getHReadable(operator)
{
	var hReadable = "";
	switch(operator)
	{
		case ">":
			hReadable = "greater than";
		break
		case "<":
			hReadable = "smaller than";
		break
		case "!":
			hReadable = "not equal to";
		break
		case "=":
			hReadable = "equal to";
		break
		default:
			var elem = getElement(operator);
			hReadable = elem ? getElementName(elem) : operator;
	}
	return hReadable;
}

/*
 * Returns a String Array of validation classes 
 * found attached to the supplied form element
 * Note: this can be a collection of elements e.g. radio inputs
 * or single elements
 */
function getValidationRules(element)
{
	var valTypes = new Array();
	if(isArray(element))
	{
		// only select the first one
		//for(var i = 0 ; i < element.length ; i++)
		//{
			valTypes = valTypes.concat(getElementValidationRules(element[0]));
		//}
		// return only the unique values
		valTypes = getUniqueArray(valTypes);
	}
	else
	{
		valTypes = getElementValidationRules(element);
	}
	return valTypes;
}

/*
 * Returns a String Array of validation classes 
 * found attached to the supplied single element
 */
function getElementValidationRules(formElement)
{
	var classAttribute = getClassAttribute(formElement);
	var validationArray = new Array();
	if(classAttribute != null)
	{
		var splitArray = classAttribute.split(" ");
		for(var j = 0; j < splitArray.length; j++ )
		{
			// split the values
			if(splitArray[j].length > 0 && splitArray[j].charAt(0) == '#')
			{	
				var paramSplit = splitArray[j].split("_");
				var rulearray;
				if(paramSplit.length > 2)
				{
					rulearray = new Array();
					rulearray[0] = paramSplit[0];
					rulearray[1] = paramSplit[1];
					var sp2 = paramSplit[2];
					for(var i = 3; i < paramSplit.length ; i++)
					{
						sp2 = sp2 + "_" + paramSplit[i];
					}
					rulearray[2] = sp2;
				}
				else
				{
					rulearray = paramSplit;
				}
				validationArray[validationArray.length] = rulearray;
			}
		}
	}
	return 	validationArray;
}

/* 
 * adds the initialiseforms 
 * function to the document's onload event
 */
addLoadEvent(initialiseForms)