// LiveValidation 1.2 (standalone version)
// Copyright (c) 2007 Alec Hill (www.livevalidation.com)
// LiveValidation is licensed under the terms of the MIT License
var LiveValidation = function(B, A) {
	this.initialize(B, A)
};
LiveValidation.TEXTAREA = 1;
LiveValidation.TEXT = 2;
LiveValidation.PASSWORD = 3;
LiveValidation.CHECKBOX = 4;
LiveValidation.SELECT = 5;
LiveValidation.massValidate = function(C) {
	var D = true;
	for ( var B = 0, A = C.length; B < A; ++B) {
		var E = C[B].validate();
		if (D) {
			D = E
		}
	}
	return D
};
LiveValidation.prototype = {
	validClass : "LV_valid",
	invalidClass : "LV_invalid",
	messageClass : "LV_validation_message",
	validFieldClass : "LV_valid_field",
	invalidFieldClass : "LV_invalid_field",
	initialize : function(D, C) {
		var A = this;
		if (!D) {
			throw new Error(
					"LiveValidation::initialize - No element reference or element id has been provided!")
		}
		this.element = D.nodeName ? D : document.getElementById(D);
		if (!this.element) {
			throw new Error(
					"LiveValidation::initialize - No element with reference or id of '"
							+ D + "' exists!")
		}
		this.validations = [];
		this.elementType = this.getElementType();
		this.form = this.element.form;
		var B = C || {};
		this.validMessage = B.validMessage || "Thankyou!";
		this.insertAfterWhatNode = B.insertAfterWhatNode || this.element;
		this.onValid = B.onValid || function() {
			this.insertMessage(this.createMessageSpan());
			this.addFieldClass()
		};
		this.onInvalid = B.onInvalid || function() {
			this.insertMessage(this.createMessageSpan());
			this.addFieldClass()
		};
		this.onlyOnBlur = B.onlyOnBlur || false;
		this.wait = B.wait || 0;
		this.onlyOnSubmit = B.onlyOnSubmit || false;
		if (this.form) {
			this.formObj = LiveValidationForm.getInstance(this.form);
			this.formObj.addField(this)
		}
		this.element.onfocus = function(E) {
			A.doOnFocus()
		};
		if (!this.onlyOnSubmit) {
			switch (this.elementType) {
			case LiveValidation.CHECKBOX:
				this.element.onclick = function(E) {
					A.validate()
				};
			case LiveValidation.SELECT:
				this.element.onchange = function(E) {
					A.validate()
				};
				break;
			default:
				if (!this.onlyOnBlur) {
					this.element.onkeyup = function(E) {
						A.deferValidation()
					}
				}
				this.element.onblur = function(E) {
					A.doOnBlur()
				}
			}
		}
	},
	add : function(A, B) {
		this.validations.push( {
			type : A,
			params : B || {}
		});
		return this
	},
	deferValidation : function(B) {
		if (this.wait >= 300) {
			this.removeMessageAndFieldClass()
		}
		var A = this;
		if (this.timeout) {
			clearTimeout(A.timeout)
		}
		this.timeout = setTimeout( function() {
			A.validate()
		}, A.wait)
	},
	doOnBlur : function(A) {
		this.focused = false;
		this.validate(A)
	},
	doOnFocus : function(A) {
		this.focused = true;
		this.removeMessageAndFieldClass()
	},
	getElementType : function() {
		switch (true) {
		case (this.element.nodeName == "TEXTAREA"):
			return LiveValidation.TEXTAREA;
		case (this.element.nodeName == "INPUT" && this.element.type == "text"):
			return LiveValidation.TEXT;
		case (this.element.nodeName == "INPUT" && this.element.type == "password"):
			return LiveValidation.PASSWORD;
		case (this.element.nodeName == "INPUT" && this.element.type == "checkbox"):
			return LiveValidation.CHECKBOX;
		case (this.element.nodeName == "SELECT"):
			return LiveValidation.SELECT;
		case (this.element.nodeName == "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!")
		}
	},
	doValidations : function() {
		this.validationFailed = false;
		for ( var C = 0, A = this.validations.length; C < A; ++C) {
			var B = this.validations[C];
			switch (B.type) {
			case Validate.Presence:
			case Validate.Confirmation:
			case Validate.Acceptance:
				this.displayMessageWhenEmpty = true;
				this.validationFailed = !this.validateElement(B.type, B.params);
				break;
			default:
				this.validationFailed = !this.validateElement(B.type, B.params);
				break
			}
			if (this.validationFailed) {
				return false
			}
		}
		this.message = this.validMessage;
		return true
	},
	validateElement : function(A, C) {
		var D = (this.elementType == LiveValidation.SELECT) ? this.element.options[this.element.selectedIndex].value
				: this.element.value;
		if (A == Validate.Acceptance) {
			if (this.elementType != LiveValidation.CHECKBOX) {
				throw new Error(
						"LiveValidation::validateElement - Element to validate acceptance must be a checkbox!")
			}
			D = this.element.checked
		}
		var E = true;
		try {
			A(D, C)
		} catch (B) {
			if (B instanceof Validate.Error) {
				if (D !== "" || (D === "" && this.displayMessageWhenEmpty)) {
					this.validationFailed = true;
					this.message = B.message;
					E = false
				}
			} else {
				throw B
			}
		} finally {
			return E
		}
	},
	validate : function() {
		var A = this.doValidations();
		if (A) {
			this.onValid();
			return true
		} else {
			this.onInvalid();
			return false
		}
	},
	createMessageSpan : function() {
		var A = document.createElement("span");
		var B = document.createTextNode(this.message);
		A.appendChild(B);
		return A
	},
	insertMessage : function(B) {
		this.removeMessage();
		if ((this.displayMessageWhenEmpty && (this.elementType == LiveValidation.CHECKBOX || this.element.value == ""))
				|| this.element.value != "") {
			var A = this.validationFailed ? this.invalidClass : this.validClass;
			B.className += " " + this.messageClass + " " + A;
			if (this.insertAfterWhatNode.nextSibling) {
				this.insertAfterWhatNode.parentNode.insertBefore(B,
						this.insertAfterWhatNode.nextSibling)
			} else {
				this.insertAfterWhatNode.parentNode.appendChild(B)
			}
		}
	},
	addFieldClass : function() {
		this.removeFieldClass();
		if (!this.validationFailed) {
			if (this.displayMessageWhenEmpty || this.element.value != "") {
				if (this.element.className.indexOf(this.validFieldClass) == -1) {
					this.element.className += " " + this.validFieldClass
				}
			}
		} else {
			if (this.element.className.indexOf(this.invalidFieldClass) == -1) {
				this.element.className += " " + this.invalidFieldClass
			}
		}
	},
	removeMessage : function() {
		var A;
		var B = this.insertAfterWhatNode;
		while (B.nextSibling) {
			if (B.nextSibling.nodeType === 1) {
				A = B.nextSibling;
				break
			}
			B = B.nextSibling
		}
		if (A && A.className.indexOf(this.messageClass) != -1) {
			this.insertAfterWhatNode.parentNode.removeChild(A)
		}
	},
	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(" ")
		}
	},
	removeMessageAndFieldClass : function() {
		this.removeMessage();
		this.removeFieldClass()
	}
};
var LiveValidationForm = function(A) {
	this.initialize(A)
};
LiveValidationForm.getInstance = function(A) {
	if (!A.id) {
		A.id = "formId_" + new Date().valueOf()
	}
	if (!window["LiveValidationForm_" + A.id]) {
		window["LiveValidationForm_" + A.id] = new LiveValidationForm(A)
	}
	return window["LiveValidationForm_" + A.id]
};
LiveValidationForm.prototype = {
	initialize : function(B) {
		this.element = B;
		this.fields = [];
		var A = this;
		this.element.onsubmit = function() {
			return LiveValidation.massValidate(A.fields)
		}
	},
	addField : function(A) {
		this.fields.push(A)
	}
};
var Validate = {
	Presence : function(B, C) {
		var C = C || {};
		var A = C.failureMessage || "Acest camp trebuie completat.";
		if (B === "" || B === null || B === undefined) {
			Validate.fail(A)
		}
		return true
	},
	Numericality : function(J, E) {
		var A = J;
		var J = Number(J);
		var E = E || {};
		var F = ((E.minimum) || (E.minimum == 0)) ? E.minimum : null;
		var C = ((E.maximum) || (E.maximum == 0)) ? E.maximum : null;
		var D = ((E.is) || (E.is == 0)) ? E.is : null;
		var G = E.notANumberMessage || "Must be a number!";
		var H = E.notAnIntegerMessage || "Must be an integer!";
		var I = E.wrongNumberMessage || "Must be " + D + "!";
		var B = E.tooLowMessage || "Must not be less than " + F + "!";
		var K = E.tooHighMessage || "Must not be more than " + C + "!";
		if (!isFinite(J)) {
			Validate.fail(G)
		}
		if (E.onlyInteger && (/\.0+$|\.$/.test(String(A)) || J != parseInt(J))) {
			Validate.fail(H)
		}
		switch (true) {
		case (D !== null):
			if (J != Number(D)) {
				Validate.fail(I)
			}
			break;
		case (F !== null && C !== null):
			Validate.Numericality(J, {
				tooLowMessage : B,
				minimum : F
			});
			Validate.Numericality(J, {
				tooHighMessage : K,
				maximum : C
			});
			break;
		case (F !== null):
			if (J < Number(F)) {
				Validate.fail(B)
			}
			break;
		case (C !== null):
			if (J > Number(C)) {
				Validate.fail(K)
			}
			break
		}
		return true
	},
	Format : function(C, D) {
		var C = String(C);
		var D = D || {};
		var A = D.failureMessage || "Not valid!";
		var B = D.pattern || /./;
		if (!B.test(C)) {
			Validate.fail(A)
		}
		return true
	},
	Email : function(B, C) {
		var C = C || {};
		var A = C.failureMessage
				|| "Acest camp trebuie sa contina o adresa de email";
		Validate.Format(B, {
			failureMessage : A,
			pattern : /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
		});
		return true
	},
	Length : function(F, G) {
		var F = String(F);
		var G = G || {};
		var E = ((G.minimum) || (G.minimum == 0)) ? G.minimum : null;
		var H = ((G.maximum) || (G.maximum == 0)) ? G.maximum : null;
		var C = ((G.is) || (G.is == 0)) ? G.is : null;
		var A = G.wrongLengthMessage || "Must be " + C + " characters long!";
		var B = G.tooShortMessage || "Must not be less than " + E
				+ " characters long!";
		var D = G.tooLongMessage || "Must not be more than " + H
				+ " characters long!";
		switch (true) {
		case (C !== null):
			if (F.length != Number(C)) {
				Validate.fail(A)
			}
			break;
		case (E !== null && H !== null):
			Validate.Length(F, {
				tooShortMessage : B,
				minimum : E
			});
			Validate.Length(F, {
				tooLongMessage : D,
				maximum : H
			});
			break;
		case (E !== null):
			if (F.length < Number(E)) {
				Validate.fail(B)
			}
			break;
		case (H !== null):
			if (F.length > Number(H)) {
				Validate.fail(D)
			}
			break;
		default:
			throw new Error(
					"Validate::Length - Length(s) to validate against must be provided!")
		}
		return true
	},
	Inclusion : function(F, G) {
		var G = G || {};
		var C = G.failureMessage || "Must be included in the list!";
		if (G.allowNull && F == null) {
			return true
		}
		if (!G.allowNull && F == null) {
			Validate.fail(C)
		}
		var E = G.within || [];
		var D = false;
		for ( var A = 0, B = E.length; A < B; ++A) {
			if (E[A] == F) {
				D = true
			}
			if (G.partialMatch) {
				if (F.indexOf(E[A]) != -1) {
					D = true
				}
			}
		}
		if ((!G.exclusion && !D) || (G.exclusion && D)) {
			Validate.fail(C)
		}
		return true
	},
	Exclusion : function(A, B) {
		var B = B || {};
		B.failureMessage = B.failureMessage
				|| "Must not be included in the list!";
		B.exclusion = true;
		Validate.Inclusion(A, B);
		return true
	},
	Confirmation : function(C, D) {
		if (!D.match) {
			throw new Error(
					"Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!")
		}
		var D = D || {};
		var B = D.failureMessage || "Does not match!";
		var A = D.match.nodeName ? D.match : document.getElementById(D.match);
		if (!A) {
			throw new Error(
					"Validate::Confirmation - There is no reference with name of, or element with id of '"
							+ D.match + "'!")
		}
		if (C != A.value) {
			Validate.fail(B)
		}
		return true
	},
	Acceptance : function(B, C) {
		var C = C || {};
		var A = C.failureMessage
				|| "Trebuie sa acceptati termenii si conditiile! ";
		if (!B) {
			Validate.fail(A)
		}
		return true
	},
	now : function(A, D, C) {
		if (!A) {
			throw new Error(
					"Validate::now - Validation function must be provided!")
		}
		var E = true;
		try {
			A(D, C || {})
		} catch (B) {
			if (B instanceof Validate.Error) {
				E = false
			} else {
				throw B
			}
		} finally {
			return E
		}
	},
	fail : function(A) {
		throw new Validate.Error(A)
	},
	Error : function(A) {
		this.message = A;
		this.name = "ValidationError"
	}
}