// LiveValidation 1.3 (standalone version)
// Copyright (c) 2007-2008 Alec Hill (www.livevalidation.com)
// LiveValidation is licensed under the terms of the MIT License

/*********************************************** LiveValidation class ***********************************/

/**
 *	validates a form field in real-time based on validations you assign to it
 *	
 *	@var element {mixed} - either a dom element reference or the string id of the element to validate
 *	@var optionsObj {Object} - general options, see below for details
 *
 *	optionsObj properties:
 *							validMessage {String} 	- the message to show when the field passes validation
 *													  (DEFAULT: "Thankyou!")
 *							onValid {Function} 		- function to execute when field passes validation
 *													  (DEFAULT: function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); } )	
 *							onInvalid {Function} 	- function to execute when field fails validation
 *													  (DEFAULT: function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); })
 *							insertAfterWhatNode {Int} 	- position to insert default message
 *													  (DEFAULT: the field that is being validated)	
 *              onlyOnBlur {Boolean} - whether you want it to validate as you type or only on blur
 *                            (DEFAULT: false)
 *              wait {Integer} - the time you want it to pause from the last keystroke before it validates (ms)
 *                            (DEFAULT: 0)
 *              onlyOnSubmit {Boolean} - whether should be validated only when the form it belongs to is submitted
 *                            (DEFAULT: false)						
 */
var LiveValidation = function(element, optionsObj){
	this.initialize(element, optionsObj);
}

LiveValidation.VERSION = '1.3 standalone';

/** element types constants ****/

LiveValidation.TEXTAREA = 1;
LiveValidation.TEXT 	= 2;
LiveValidation.PASSWORD = 3;
LiveValidation.CHECKBOX = 4;
LiveValidation.SELECT   = 5;
LiveValidation.FILE     = 6;

/****** Static methods *******/

/**
 *	pass an array of LiveValidation objects and it will validate all of them
 *	
 *	@var validations {Array} - an array of LiveValidation objects
 *	@return {Bool} - true if all passed validation, false if any fail						
 */
LiveValidation.massValidate = function(validations){
	var returnValue = true;
	for (var i = 0, len = validations.length; i < len; ++i ){
		var valid = validations[i].validate();
		if(returnValue) returnValue = valid;
	}
	return returnValue;
}

/****** prototype ******/

LiveValidation.prototype = {

	validClass: 'codila__LV_valid',
	invalidClass: 'codila__LV_invalid',
	messageClass: 'codila__LV_validation_message',
	validFieldClass: 'codila__LV_valid_field',
	invalidFieldClass: 'codila__LV_invalid_field',

	/**
     *	initialises all of the properties and events
     *
     * @var - Same as constructor above
     */
	initialize: function(element, optionsObj){
		var self = this;
		if(!element) throw new Error("LiveValidation::initialize - No element reference or element id has been provided!");
		this.element = element.nodeName ? element : document.getElementById(element);
		if(!this.element) throw new Error("LiveValidation::initialize - No element with reference or id of '" + element + "' exists!");
		// default properties that could not be initialised above
		this.validations = [];
		this.elementType = this.getElementType();
		this.form = this.element.form;
		// options
		var options = optionsObj || {};
		this.validMessage = options.validMessage || '';
		var node = options.insertAfterWhatNode || this.element;
		this.insertAfterWhatNode = node.nodeType ? node : document.getElementById(node);
		this.onValid = options.onValid || function(){
			this.insertMessage(this.createMessageSpan());
			this.addFieldClass();
		};
		this.onInvalid = options.onInvalid || function(){
			this.insertMessage(this.createMessageSpan());
			this.addFieldClass();
		};
		this.onlyOnBlur =  options.onlyOnBlur || false;
		this.wait = options.wait || 0;
		this.onlyOnSubmit = options.onlyOnSubmit || false;
		// add to form if it has been provided
		if(this.form){
			this.formObj = LiveValidationForm.getInstance(this.form);
			this.formObj.addField(this);
		}
		// events
		// collect old events
		this.oldOnFocus = this.element.onfocus || function(){};
		this.oldOnBlur = this.element.onblur || function(){};
		this.oldOnClick = this.element.onclick || function(){};
		this.oldOnChange = this.element.onchange || function(){};
		this.oldOnKeyup = this.element.onkeyup || function(){};
		this.element.onfocus = function(e){
			self.doOnFocus(e);
			return self.oldOnFocus.call(this, e);
		}
		if(!this.onlyOnSubmit){
			switch(this.elementType){
				case LiveValidation.CHECKBOX:
					this.element.onclick = function(e){
						self.validate();
						return self.oldOnClick.call(this, e);
					}
				// let it run into the next to add a change event too
				case LiveValidation.SELECT:
				case LiveValidation.FILE:
					this.element.onchange = function(e){
						self.validate();
						return self.oldOnChange.call(this, e);
					}
					break;
				default:
					if(!this.onlyOnBlur) this.element.onkeyup = function(e){
						self.deferValidation();
						return self.oldOnKeyup.call(this, e);
					}
					this.element.onblur = function(e){
						self.doOnBlur(e);
						return self.oldOnBlur.call(this, e);
					}
			}
		}
	},

	/**
		 *	destroys the instance's events (restoring previous ones) and removes it from any LiveValidationForms
		 */
	destroy: function(){
		if(this.formObj){
			// remove the field from the LiveValidationForm
			this.formObj.removeField(this);
			// destroy the LiveValidationForm if no LiveValidation fields left in it
			this.formObj.destroy();
		}
		// remove events - set them back to the previous events
		this.element.onfocus = this.oldOnFocus;
		if(!this.onlyOnSubmit){
			switch(this.elementType){
				case LiveValidation.CHECKBOX:
					this.element.onclick = this.oldOnClick;
				// let it run into the next to add a change event too
				case LiveValidation.SELECT:
				case LiveValidation.FILE:
					this.element.onchange = this.oldOnChange;
					break;
				default:
					if(!this.onlyOnBlur) this.element.onkeyup = this.oldOnKeyup;
					this.element.onblur = this.oldOnBlur;
			}
		}
		this.validations = [];
		this.removeMessageAndFieldClass();
	},

	/**
		 *	adds a validation to perform to a LiveValidation object
		 *
		 *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )
		 *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
		 * @return {Object} - the LiveValidation object itself so that calls can be chained
		 */
	add: function(validationFunction, validationParamsObj){
		this.validations.push( {
			type: validationFunction,
			params: validationParamsObj || {}
		} );
		return this;
	},

	/**
			 *	removes a validation from a LiveValidation object - must have exactly the same arguments as used to add it
			 *
			 *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )
			 *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
			 * @return {Object} - the LiveValidation object itself so that calls can be chained
			 */
	remove: function(validationFunction, validationParamsObj){
		function isEmpty(obj) {
			for(var prop in obj) {
				if(obj.hasOwnProperty(prop))
					return false;
			}
			return true;
		}
		var found = false;
		for( var i = 0, len = this.validations.length; i < len; i++ ){
			if( this.validations[i].type == validationFunction ){
				if (this.validations[i].params == validationParamsObj || isEmpty(this.validations[i].params) ) {
					found = true;
					break;
				}
			}
		}
		if(found) this.validations.splice(i,1);
		return this;
	},


	/**
			 * makes the validation wait the alotted time from the last keystroke
			 */
	deferValidation: function(e){
		if(this.wait >= 300) this.removeMessageAndFieldClass();
		var self = this;
		if(this.timeout) clearTimeout(self.timeout);
		this.timeout = setTimeout( function(){
			self.validate()
		}, self.wait);
	},

	/**
			 * sets the focused flag to false when field loses focus
			 */
	doOnBlur: function(e){
		this.focused = false;
		this.validate(e);
	},

	/**
			 * sets the focused flag to true when field gains focus
			 */
	doOnFocus: function(e){
		this.focused = true;
		this.removeMessageAndFieldClass();
	},

	/**
     *	gets the type of element, to check whether it is compatible
     *
     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )
     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
     */
	getElementType: function(){
		switch(true){
			case (this.element.nodeName.toUpperCase() == 'TEXTAREA'):
				return LiveValidation.TEXTAREA;
			case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'TEXT'):
				return LiveValidation.TEXT;
			case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'PASSWORD'):
				return LiveValidation.PASSWORD;
			case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'CHECKBOX'):
				return LiveValidation.CHECKBOX;
			case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'FILE'):
				return LiveValidation.FILE;
			case (this.element.nodeName.toUpperCase() == 'SELECT'):
				return LiveValidation.SELECT;
			case (this.element.nodeName.toUpperCase() == 'INPUT'):
				throw new Error('LiveValidation::getElementType - Cannot use LiveValidation on an ' + this.element.type + ' input!');
			default:
				throw new Error('LiveValidation::getElementType - Element must be an input, select, or textarea!');
		}
	},
    
	/**
     *	loops through all the validations added to the LiveValidation object and checks them one by one
     *
     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )
     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
     * @return {Boolean} - whether the all the validations passed or if one failed
     */
	doValidations: function(){
		this.validationFailed = false;
		for(var i = 0, len = this.validations.length; i < len; ++i){
			var validation = this.validations[i];
			switch(validation.type){
				case Validate.Presence:
				case Validate.Confirmation:
				case Validate.Acceptance:
					this.displayMessageWhenEmpty = true;
					this.validationFailed = !this.validateElement(validation.type, validation.params);
					break;
				default:
					this.validationFailed = !this.validateElement(validation.type, validation.params);
					break;
			}
			if(this.validationFailed) return false;
		}
		this.message = this.validMessage;
		return true;
	},
    
	/**
     *	performs validation on the element and handles any error (validation or otherwise) it throws up
     *
     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )
     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
     * @return {Boolean} - whether the validation has passed or failed
     */
	validateElement: function(validationFunction, validationParamsObj){
		var value = (this.elementType == LiveValidation.SELECT) ? this.element.options[this.element.selectedIndex].value : this.element.value;
		if(validationFunction == Validate.Acceptance){
			if(this.elementType != LiveValidation.CHECKBOX) throw new Error('LiveValidation::validateElement - Element to validate acceptance must be a checkbox!');
			value = this.element.checked;
		}
		var isValid = true;
		try{
			validationFunction(value, validationParamsObj);
		} catch(error) {
			if(error instanceof Validate.Error){
				if( value !== '' || (value === '' && this.displayMessageWhenEmpty) ){
					this.validationFailed = true;
					this.message = error.message;
					isValid = false;
				}
			}else{
				throw error;
			}
		}finally{
			return isValid;
		}
	},
    
	/**
     *	makes it do the all the validations and fires off the onValid or onInvalid callbacks
     *
     * @return {Boolean} - whether the all the validations passed or if one failed
     */
	validate: function(){
		if(!this.element.disabled){
			var isValid = this.doValidations();
			if(isValid){
				this.onValid();
				return true;
			}else {
				this.onInvalid();
				return false;
			}
		}else{
			return true;
		}
	},
	
	/**
   *  enables the field
   *
   *  @return {LiveValidation} - the LiveValidation object for chaining
   */
	enable: function(){
		this.element.disabled = false;
		return this;
	},
  
	/**
   *  disables the field and removes any message and styles associated with the field
   *
   *  @return {LiveValidation} - the LiveValidation object for chaining
   */
	disable: function(){
		this.element.disabled = true;
		this.removeMessageAndFieldClass();
		return this;
	},
    
	/** Message insertion methods ****************************
     * 
     * These are only used in the onValid and onInvalid callback functions and so if you overide the default callbacks,
     * you must either impliment your own functions to do whatever you want, or call some of these from them if you 
     * want to keep some of the functionality
     */
    
	/**
     *	makes a span containg the passed or failed message
     *
     * @return {HTMLSpanObject} - a span element with the message in it
     */
	createMessageSpan: function(){
		var span = document.createElement('span');
		var textNode = document.createTextNode(this.message);
		span.appendChild(textNode);
		return span;
	},
    
	/**
     *	inserts the element containing the message in place of the element that already exists (if it does)
     *
     * @var elementToIsert {HTMLElementObject} - an element node to insert
     */
	insertMessage: function(elementToInsert){
		this.removeMessage();
		if( (this.displayMessageWhenEmpty && (this.elementType == LiveValidation.CHECKBOX || this.element.value == ''))
			|| this.element.value != '' ){
			var className = this.validationFailed ? this.invalidClass : this.validClass;
			elementToInsert.className += ' ' + this.messageClass + ' ' + className;
			if(this.insertAfterWhatNode.nextSibling){
				this.insertAfterWhatNode.parentNode.insertBefore(elementToInsert, this.insertAfterWhatNode.nextSibling);
			}else{
				this.insertAfterWhatNode.parentNode.appendChild(elementToInsert);
			}
		}
	},
    
    
	/**
     *	changes the class of the field based on whether it is valid or not
     */
	addFieldClass: function(){
		this.removeFieldClass();
		if(!this.validationFailed){
			if(this.displayMessageWhenEmpty || this.element.value != ''){
				this.element.className = this.element.className.replace('active', '');
				if(this.element.className.indexOf(this.validFieldClass) == -1) this.element.className += ' ' + this.validFieldClass;
			}
		}else{
			this.element.className = this.element.className.replace('active', '');
			if(this.element.className.indexOf(this.invalidFieldClass) == -1) this.element.className += ' ' + this.invalidFieldClass;
		}
	},
    
	/**
     *	removes the message element if it exists, so that the new message will replace it
     */
	removeMessage: function(){
		var nextEl;
		var el = this.insertAfterWhatNode;
		while(el.nextSibling){
			if(el.nextSibling.nodeType === 1){
				nextEl = el.nextSibling;
				break;
			}
			el = el.nextSibling;
		}
		if(nextEl && nextEl.className.indexOf(this.messageClass) != -1) this.insertAfterWhatNode.parentNode.removeChild(nextEl);
	},
    
	/**
     *	removes the class that has been applied to the field to indicte if valid or not
     */
	removeFieldClass: function(){
		if(this.element.className.indexOf(this.invalidFieldClass) != -1) this.element.className = this.element.className.split(this.invalidFieldClass).join('');
		if(this.element.className.indexOf(this.validFieldClass) != -1) this.element.className = this.element.className.split(this.validFieldClass).join(' ');
	},
        
	/**
     *	removes the message and the field class
     */
	removeMessageAndFieldClass: function(){
		this.removeMessage();
		this.removeFieldClass();
	}

} // end of LiveValidation class

/*************************************** LiveValidationForm class ****************************************/
/**
 * This class is used internally by LiveValidation class to associate a LiveValidation field with a form it is icontained in one
 * 
 * It will therefore not really ever be needed to be used directly by the developer, unless they want to associate a LiveValidation 
 * field with a form that it is not a child of
 */

/**
   *	handles validation of LiveValidation fields belonging to this form on its submittal
   *	
   *	@var element {HTMLFormElement} - a dom element reference to the form to turn into a LiveValidationForm
   */
var LiveValidationForm = function(element){
	this.initialize(element);
}

/**
 * namespace to hold instances
 */
LiveValidationForm.instances = {};

/**
   *	gets the instance of the LiveValidationForm if it has already been made or creates it if it doesnt exist
   *	
   *	@var element {HTMLFormElement} - a dom element reference to a form
   */
LiveValidationForm.getInstance = function(element){
	var rand = Math.random() * Math.random();
	if(!element.id) element.id = 'formId_' + rand.toString().replace(/\./, '') + new Date().valueOf();
	if(!LiveValidationForm.instances[element.id]) LiveValidationForm.instances[element.id] = new LiveValidationForm(element);
	return LiveValidationForm.instances[element.id];
}

LiveValidationForm.prototype = {
  
	/**
   *	constructor for LiveValidationForm - handles validation of LiveValidation fields belonging to this form on its submittal
   *	
   *	@var element {HTMLFormElement} - a dom element reference to the form to turn into a LiveValidationForm
   */
	initialize: function(element){
		this.name = element.id;
		this.element = element;
		this.fields = [];
		// preserve the old onsubmit event
		this.oldOnSubmit = this.element.onsubmit || function(){};
		var self = this;
		this.element.onsubmit = function(e){
			return (LiveValidation.massValidate(self.fields)) ? self.oldOnSubmit.call(this, e || window.event) !== false : false;
		}
	},
  
	/**
   *	adds a LiveValidation field to the forms fields array
   *	
   *	@var element {LiveValidation} - a LiveValidation object
   */
	addField: function(newField){
		this.fields.push(newField);
	},
  
	/**
   *	removes a LiveValidation field from the forms fields array
   *	
   *	@var victim {LiveValidation} - a LiveValidation object
   */
	removeField: function(victim){
		var victimless = [];
		for( var i = 0, len = this.fields.length; i < len; i++){
			if(this.fields[i] !== victim) victimless.push(this.fields[i]);
		}
		this.fields = victimless;
	},
  
	/**
   *	destroy this instance and its events
   *
   * @var force {Boolean} - whether to force the detruction even if there are fields still associated
   */
	destroy: function(force){
		// only destroy if has no fields and not being forced
		if (this.fields.length != 0 && !force) return false;
		// remove events - set back to previous events
		this.element.onsubmit = this.oldOnSubmit;
		// remove from the instances namespace
		LiveValidationForm.instances[this.name] = null;
		return true;
	}
   
}// end of LiveValidationForm prototype

/*************************************** Validate class ****************************************/
/**
 * This class contains all the methods needed for doing the actual validation itself
 *
 * All methods are static so that they can be used outside the context of a form field
 * as they could be useful for validating stuff anywhere you want really
 *
 * All of them will return true if the validation is successful, but will raise a ValidationError if
 * they fail, so that this can be caught and the message explaining the error can be accessed ( as just 
 * returning false would leave you a bit in the dark as to why it failed )
 *
 * Can use validation methods alone and wrap in a try..catch statement yourself if you want to access the failure
 * message and handle the error, or use the Validate::now method if you just want true or false
 */

var Validate = {

	/**
     *	validates that the field has been filled in
     *
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation 
     *													  (DEFAULT: "Can't be empty!")
     */
	Presence: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("CANT_BE_EMPTY");
		if(value === '' || value === null || value === undefined){
			Validate.fail(message);
		}
		return true;
	},

	/**
     *	validates that the field is not empty and non-zero
     *
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Can't be zero!")
     */
	NonZero: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("CANT_BE_ZERO");
		if(value === '0' || value === 0 || value === undefined || value === null || value === '') {
			Validate.fail(message);
		}
		return true;
	},

	/**
     *	validates that the field eqauls 0 or 1
     *
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Can't be zero!")
     */
	Boolean: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_0_OR_1");
		if(value !== '0' && value !== '1') {
			Validate.fail(message);
		}
		return true;
	},
    
	/**
     *	validates that the value is numeric, does not fall within a given range of numbers
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							notANumberMessage {String} - the message to show when the validation fails when value is not a number
     *													  	  (DEFAULT: "Must be a number!")
     *							notAnIntegerMessage {String} - the message to show when the validation fails when value is not an integer
     *													  	  (DEFAULT: "Must be a number!")
     *							wrongNumberMessage {String} - the message to show when the validation fails when is param is used
     *													  	  (DEFAULT: "Must be {is}!")
     *							tooLowMessage {String} 		- the message to show when the validation fails when minimum param is used
     *													  	  (DEFAULT: "Must not be less than {minimum}!")
     *							tooHighMessage {String} 	- the message to show when the validation fails when maximum param is used
     *													  	  (DEFAULT: "Must not be more than {maximum}!")
     *							is {Int} 					- the length must be this long 
     *							minimum {Int} 				- the minimum length allowed
     *							maximum {Int} 				- the maximum length allowed
     *                         onlyInteger {Boolean} - if true will only allow integers to be valid
     *                                                             (DEFAULT: false)
     *
     *  NB. can be checked if it is within a range by specifying both a minimum and a maximum
     *  NB. will evaluate numbers represented in scientific form (ie 2e10) correctly as numbers				
     */
	Numericality: function(value, paramsObj){
		var suppliedValue = value;
		var value = Number(value);
		var paramsObj = paramsObj || {};
		var minimum = ((paramsObj.minimum) || (paramsObj.minimum == 0)) ? paramsObj.minimum : null;
		;
		var maximum = ((paramsObj.maximum) || (paramsObj.maximum == 0)) ? paramsObj.maximum : null;
		var is = ((paramsObj.is) || (paramsObj.is == 0)) ? paramsObj.is : null;
		var notANumberMessage = paramsObj.notANumberMessage || return_codila_translation("MUST_BE_A_NUMBER");
		var notAnIntegerMessage = paramsObj.notAnIntegerMessage || return_codila_translation("MUST_BE_AN_INTEGER");
		var wrongNumberMessage = paramsObj.wrongNumberMessage || return_codila_translation("MUST_BE_") + is;
		var tooLowMessage = paramsObj.tooLowMessage || return_codila_translation("MUST_NOT_BE_LESS_THAN_") + minimum;
		var tooHighMessage = paramsObj.tooHighMessage || return_codila_translation("MUST_NOT_BE_MORE_THAN_") + maximum;
		if (!isFinite(value)) Validate.fail(notANumberMessage);
		if (paramsObj.onlyInteger && (/\.0+$|\.$/.test(String(suppliedValue))  || value != parseInt(value)) ) Validate.fail(notAnIntegerMessage);
		switch(true){
			case (is !== null):
				if( value != Number(is) ) Validate.fail(wrongNumberMessage);
				break;
			case (minimum !== null && maximum !== null):
				Validate.Numericality(value, {
					tooLowMessage: tooLowMessage,
					minimum: minimum
				});
				Validate.Numericality(value, {
					tooHighMessage: tooHighMessage,
					maximum: maximum
				});
				break;
			case (minimum !== null):
				if (typeof(minimum)=='string') {
					if( value < Number($(minimum).value) ) Validate.fail(tooLowMessage);
				} else {
					if( value < Number(minimum) ) Validate.fail(tooLowMessage);
				}
				break;
			case (maximum !== null):
				if (typeof(maximum)=='string') {
					if( value > Number($(maximum).value) ) Validate.fail(tooHighMessage);
				} else {
					if( value > Number(maximum) ) Validate.fail(tooHighMessage);
				}
				break;
		}
		return true;
	},
    
	/**
     *	validates against a RegExp pattern
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Not valid!")
     *							pattern {RegExp} 		- the regular expression pattern
     *													  (DEFAULT: /./)
     *             negate {Boolean} - if set to true, will validate true if the pattern is not matched
   *                           (DEFAULT: false)
     *
     *  NB. will return true for an empty string, to allow for non-required, empty fields to validate.
     *		If you do not want this to be the case then you must either add a LiveValidation.PRESENCE validation
     *		or build it into the regular expression pattern
     */
	Format: function(value, paramsObj){
		var value = String(value);
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("NOT_VALID");
		var pattern = paramsObj.pattern || /./;
		var negate = paramsObj.negate || false;
		if(!negate && !pattern.test(value)) Validate.fail(message); // normal
		if(negate && pattern.test(value)) Validate.fail(message); // negated
		return true;
	},
    
	/**
     *	validates that the field contains a valid email address
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Must be a number!" or "Must be an integer!")
     */
	Email: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_EMAIL_ADDRESS");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
		} );
		return true;
	},
	LoginChars: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("INVALID_CHARS_ENTERED");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^([a-zA-Z0-9\.\-\_]){1,}$/i
		} );
		return true;
	},
	Postcode: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_ZIP_CODE");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{2}\-[0-9]{3}$/i
		} );
		return true;
	},
    
	NIP: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Must be a valid NIP!";
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^(([0-9]{3}\-[0-9]{2}\-[0-9]{2}\-[0-9]{3})|([0-9]{3}\-[0-9]{3}\-[0-9]{2}\-[0-9]{2})|([0-9]{10}))$/i
		} );
		return false;
	},

	controlNIP: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Suma kontrolna niepoprawna";
		value = value.split('');
		count = 0;
		data = new Array();
		for(var i=0 in value){
			if(!isNaN(parseInt(value[i]))){
				data[count] = value[i];
				++count;
			}
		}
		wagi = new Array();
		wagi[0] = 6;
		wagi[1] = 5;
		wagi[2] = 7;
		wagi[3] = 2;
		wagi[4] = 3;
		wagi[5] = 4;
		wagi[6] = 5;
		wagi[7] = 6;
		wagi[8] = 7;
		sum = 0;
		for(var i=0; i<9; ++i){
			sum+=wagi[i]*data[i];
		}
		if((sum % 11) != data[9] || sum==0) {
			Validate.fail(message);
		}
		return true;
	},
	Bank: function(value, paramsObj){
		value = value.split(' ').join('');
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Must be a valid bank account!";
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{26}$/i
		} );
		return true;
	},
	PESEL: function(value, paramsObj){
		value = value.split(' ').join('');
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Must be a valid PESEL!";
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{11}$/i
		} );
		return true;
	},
	controlPESEL: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Suma kontrolna niepoprawna";
		value = value.split('');
		count = 0;
		data = new Array();
		for(var i=0 in value){
			if(!isNaN(parseInt(value[i]))){
				data[count] = value[i];
				++count;
			}
		}
		wagi = new Array();
		wagi[0] = 1;
		wagi[1] = 3;
		wagi[2] = 7;
		wagi[3] = 9;
		wagi[4] = 1;
		wagi[5] = 3;
		wagi[6] = 7;
		wagi[7] = 9;
		wagi[8] = 1;
		wagi[9] = 3;
		sum = 0;
		for(var i=0; i<10; ++i){
			sum+=wagi[i]*data[i];
		}
		mod =10 - (sum % 10);
		if (mod == 10) mod = 0;
		if( mod != data[10] || sum==0) {
			Validate.fail(message);
		}
		return true;
	},
	REGON: function(value, paramsObj){
		value = value.split(' ').join('');
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Must be a valid REGON!";
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{9}$/i
		} );
		return true;
	},
	controlREGON: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Suma kontrolna niepoprawna";
		value = value.split('');
		count = 0;
		data = new Array();
		for(var i=0 in value){
			if(!isNaN(parseInt(value[i]))){
				data[count] = value[i];
				++count;
			}
		}
		wagi = new Array();
		wagi[0] = 8;
		wagi[1] = 9;
		wagi[2] = 2;
		wagi[3] = 3;
		wagi[4] = 4;
		wagi[5] = 5;
		wagi[6] = 6;
		wagi[7] = 7;
		sum = 0;
		for(var i=0; i<8; ++i){
			sum+=wagi[i]*data[i];
		}
		mod = (sum % 11);
		if (mod == 10) mod = 0;
		if( mod != data[8] || sum==0) {
			Validate.fail(message);
		}
		return true;
	},
   
	Time: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_TIME");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-2]{1}[0-9]{1}:[0-5]{1}[0-9]{1}$/i
		} );
		return true;
	},
	GSM: function(value, paramsObj){
		value = value.split(' ').join('');
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_GSM_NUMBER");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[4]{1}[8]{1}[0-9]{9}$/i
		} );
		return true;
	},
	Phone: function(value, paramsObj){
		value = value.split(' ').join('');
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "Musi być poprawnym numerem telefonu";
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^([+]{1})?([(]{1}[0-9]{1,}[)]{1})?[0-9\-]{1,}$/i
		} );
		return true;
	},
	DateTime: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_DATE_AND_TIME");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{4}-(((0[13578]|(10|12))-(0[1-9]|[1-2][0-9]|3[0-1]))|(02-(0[1-9]|[1-2][0-9]))|((0[469]|11)-(0[1-9]|[1-2][0-9]|30))) (([0-1]?[0-9])|([2][0-3])):([0-5]?[0-9])(:([0-5]?[0-9]))?$/i
		} );
		return true;
	},
	 
	Date: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_DATE");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/
		} );
		return true;
	},

	Min18: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("YOU_HAVE_TO_BE_AT_LEAST_18");
		var today = new Date();
		var date=new Date(value);
		date.setFullYear(date.getFullYear()+18);
		if(today<date){
			Validate.fail(message);
		} 
		return true;
	},
	ExtendedDate: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_A_VALID_DATE");
		Validate.Format(value, {
			failureMessage: message,
			pattern: /^[0-9]{4}-(((0[13578]|(10|12))-(0[1-9]|[1-2][0-9]|3[0-1]))|(02-(0[1-9]|[1-2][0-9]))|((0[469]|11)-(0[1-9]|[1-2][0-9]|30)))?$/i
		} );
		return true;
	},
    
	/**
     *	validates the length of the value
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							wrongLengthMessage {String} - the message to show when the fails when is param is used
     *													  	  (DEFAULT: "Must be {is} characters long!")
     *							tooShortMessage {String} 	- the message to show when the fails when minimum param is used
     *													  	  (DEFAULT: "Must not be less than {minimum} characters long!")
     *							tooLongMessage {String} 	- the message to show when the fails when maximum param is used
     *													  	  (DEFAULT: "Must not be more than {maximum} characters long!")
     *							is {Int} 					- the length must be this long 
     *							minimum {Int} 				- the minimum length allowed
     *							maximum {Int} 				- the maximum length allowed
     *
     *  NB. can be checked if it is within a range by specifying both a minimum and a maximum				
     */
	Length: function(value, paramsObj){
		var value = String(value);
		var paramsObj = paramsObj || {};
		var minimum = ((paramsObj.minimum) || (paramsObj.minimum == 0)) ? paramsObj.minimum : null;
		var maximum = ((paramsObj.maximum) || (paramsObj.maximum == 0)) ? paramsObj.maximum : null;
		var is = ((paramsObj.is) || (paramsObj.is == 0)) ? paramsObj.is : null;
		var wrongLengthMessage = paramsObj.wrongLengthMessage || return_codila_translation("MUST_BE_") + is + return_codila_translation("_CHARACTERS_LONG");
		var tooShortMessage = paramsObj.tooShortMessage || return_codila_translation("MUST_NOT_BE_LESS_THAN_") + " " + minimum + " " + return_codila_translation("_CHARACTERS_LONG");
		var tooLongMessage = paramsObj.tooLongMessage || return_codila_translation("MUST_NOT_BE_MORE_THAN") + " " + maximum + " " + return_codila_translation("_CHARACTERS_LONG");
		switch(true){
			case (is !== null):
				if( value.length != Number(is) ) Validate.fail(wrongLengthMessage);
				break;
			case (minimum !== null && maximum !== null):
				Validate.Length(value, {
					tooShortMessage: tooShortMessage,
					minimum: minimum
				});
				Validate.Length(value, {
					tooLongMessage: tooLongMessage,
					maximum: maximum
				});
				break;
			case (minimum !== null):
				if (typeof(minimum)=='string') {
					if( value.length < Number($(minimum).value) ) Validate.fail(tooShortMessage);
				} else {
					if( value.length < Number(minimum) ) Validate.fail(tooShortMessage);
				}
				break;
			case (maximum !== null):
				if (typeof(maximum)=='string') {
					if( value.length > Number($(maximum).value) ) Validate.fail(tooLongMessage);
				} else {
					if( value.length > Number(maximum) ) Validate.fail(tooLongMessage);
				}
				break;
			default:
				throw new Error("Validate::Length - Length(s) to validate against must be provided!");
		}
		return true;
	},
    
	/**
     *	validates that the value falls within a given set of values
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Must be included in the list!")
     *							within {Array} 			- an array of values that the value should fall in 
     *													  (DEFAULT: [])	
     *							allowNull {Bool} 		- if true, and a null value is passed in, validates as true
     *													  (DEFAULT: false)
     *             partialMatch {Bool} 	- if true, will not only validate against the whole value to check but also if it is a substring of the value 
     *													  (DEFAULT: false)
     *             caseSensitive {Bool} - if false will compare strings case insensitively
     *                          (DEFAULT: true)
     *             negate {Bool} 		- if true, will validate that the value is not within the given set of values
     *													  (DEFAULT: false)			
     */
	Inclusion: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_INCLUDED_IN_THE_LIST");
		var caseSensitive = (paramsObj.caseSensitive === false) ? false : true;
		if(paramsObj.allowNull && value == null) return true;
		if(!paramsObj.allowNull && value == null) Validate.fail(message);
		var within = paramsObj.within || [];
		//if case insensitive, make all strings in the array lowercase, and the value too
		if(!caseSensitive){
			var lowerWithin = [];
			for(var j = 0, length = within.length; j < length; ++j){
				var item = within[j];
				if(typeof item == 'string') item = item.toLowerCase();
				lowerWithin.push(item);
			}
			within = lowerWithin;
			if(typeof value == 'string') value = value.toLowerCase();
		}
		var found = false;
		for(var i = 0, length = within.length; i < length; ++i){
			if(within[i] == value) found = true;
			if(paramsObj.partialMatch){
				if(value.indexOf(within[i]) != -1) found = true;
			}
		}
		if( (!paramsObj.negate && !found) || (paramsObj.negate && found) ) Validate.fail(message);
		return true;
	},
    
	/**
     *	validates that the value does not fall within a given set of values
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Must not be included in the list!")
     *							within {Array} 			- an array of values that the value should not fall in 
     *													  (DEFAULT: [])
     *							allowNull {Bool} 		- if true, and a null value is passed in, validates as true
     *													  (DEFAULT: false)
     *             partialMatch {Bool} 	- if true, will not only validate against the whole value to check but also if it is a substring of the value 
     *													  (DEFAULT: false)
     *             caseSensitive {Bool} - if false will compare strings case insensitively
     *                          (DEFAULT: true)			
     */
	Exclusion: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		paramsObj.failureMessage = paramsObj.failureMessage || return_codila_translation("MUST_NOT_BE_INCLUDED_IN_THE_LIST");
		paramsObj.negate = true;
		Validate.Inclusion(value, paramsObj);
		return true;
	},
    
	/**
     *	validates that the value matches that in another field
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Does not match!")
     *							match {String} 			- id of the field that this one should match						
     */
	Confirmation: function(value, paramsObj){
		if(!paramsObj.match) throw new Error("Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!");
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("DOES_NOT_MATCH");
		var match = paramsObj.match.nodeName ? paramsObj.match : document.getElementById(paramsObj.match);
		if(!match) throw new Error("Validate::Confirmation - There is no reference with name of, or element with id of '" + paramsObj.match + "'!");
		if(value != match.value){
			Validate.fail(message);
		}
		return true;
	},
	NoConfirmation: function(value, paramsObj){
		if(!paramsObj.match) throw new Error("Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!");
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || "##FIELDS_CANT_BE_IDENTICAL##";
		var match = paramsObj.match.nodeName ? paramsObj.match : document.getElementById(paramsObj.match);
		if(!match) throw new Error("Validate::Confirmation - There is no reference with name of, or element with id of '" + paramsObj.match + "'!");
		if(value == match.value){
			Validate.fail(message);
		}
		return true;
	},
	/**
     *	validates that the value is true (for use primarily in detemining if a checkbox has been checked)
     *	
     *	@var value {mixed} - value to be checked if true or not (usually a boolean from the checked value of a checkbox)
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation 
     *													  (DEFAULT: "Must be accepted!")
     */
	Acceptance: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var message = paramsObj.failureMessage || return_codila_translation("MUST_BE_ACCEPTED");
		if(!value){
			Validate.fail(message);
		}
		return true;
	},
    
	/**
     *	validates against a custom function that returns true or false (or throws a Validate.Error) when passed the value
     *	
     *	@var value {mixed} - value to be checked
     *	@var paramsObj {Object} - parameters for this particular validation, see below for details
     *
     *	paramsObj properties:
     *							failureMessage {String} - the message to show when the field fails validation
     *													  (DEFAULT: "Not valid!")
     *							against {Function} 			- a function that will take the value and object of arguments and return true or false 
     *													  (DEFAULT: function(){ return true; })
     *							args {Object} 		- an object of named arguments that will be passed to the custom function so are accessible through this object within it 
     *													  (DEFAULT: {})
     */
	Custom: function(value, paramsObj){
		var paramsObj = paramsObj || {};
		var against = paramsObj.against || function(){
			return true;
		};
		var args = paramsObj.args || {};
		var message = paramsObj.failureMessage || return_codila_translation("NOT_VALID");
		if(!against(value, args)) Validate.fail(message);
		return true;
	},
	
	/**
     *	validates whatever it is you pass in, and handles the validation error for you so it gives a nice true or false reply
     *
     *	@var validationFunction {Function} - validation function to be used (ie Validation.validatePresence )
     *	@var value {mixed} - value to be checked if true or not (usually a boolean from the checked value of a checkbox)
     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
     */
	now: function(validationFunction, value, validationParamsObj){
		if(!validationFunction) throw new Error("Validate::now - Validation function must be provided!");
		var isValid = true;
		try{
			validationFunction(value, validationParamsObj || {});
		} catch(error) {
			if(error instanceof Validate.Error){
				isValid =  false;
			}else{
				throw error;
			}
		}finally{
			return isValid
		}
	},
    
	/**
     * shortcut for failing throwing a validation error
     *
     *	@var errorMessage {String} - message to display
     */
	fail: function(errorMessage){
		throw new Validate.Error(errorMessage);
	},
    
	Error: function(errorMessage){
		this.message = errorMessage;
		this.name = 'ValidationError';
	}

}