var urlSafe = function(txt) { return escape(txt).replace("+", "%2B"); };

/*
    Form Validation
*/
(function($)
{
	// Formvalidator
	function FormValidator()
	{
		this.defaults =
		{
			onvalidated: null,
			onsucess: null,
			onfail: null
		};
		
		this.validationmethods =
		{
			"nonempty": function(field) { return field.value.length>0; },
			"checked": function(field) { return field.checked; },
			"email": function(field)
			{
				return field.value.search(/^\b[A-Z0-9._%+-]+@[A-Z0-9\.-]+\.[A-Z]{2,}\b$/i)==0;
			},
			"ssn": function(field)
			{
				var i, n, sum = 0, l;
				var validate = /^\d{2}?(\d{6})-?(\d{4})$/;
				
				if(!field.value.search(validate)) return false;
				num = field.value.toString().replace(validate,"$1$2");
				l = num.length;
				if(l==10) l--;
				for(i = l - 1; i >= 0; i--)
				{
					n = parseInt(num.charAt(i)) * (2 - ((l + 3 - i) % 2));
					sum += parseInt(Math.floor(n / 10) + (n % 10));
				}
				return ((10 - (sum % 10)) % 10) == num[num.length-1];
			}
		};
	}
	$.extend(FormValidator.prototype,
	{
		addValidator: function(name, method)
		{
			this.validationmethods[name] = method;
		},
		
		_validateForm: function(form, _settings)
		{
			var processedFields = {};
			var errors = [];
			var settings = $.extend({}, $.formvalidator.defaults, _settings||{});
			$(form).find("input, select").each(function()
			{
				var result = $.fieldvalidator._validateField(this, true, processedFields);
				if(!result.success) errors.push(result);
				processedFields[this] = result.success;
			});
			if(errors.length>0)
				if(settings.onfail) settings.onfail(form, false, errors);
			else
				if(settings.onsuccess) settings.onsuccess(form, true, errors);
			if(settings.onvalidated) settings.onvalidated(form, errors.length==0, errors)
			
			return errors.length==0;
		},
		
		_register: function(validatorInstance)
		{
			$(validatorInstance._element).submit(function() { return $.formvalidator._validateForm(validatorInstance._element, validatorInstance._settings ); });
		}
	});
	
	function FormValidatorInstance(element, settings)
	{
		this._element = element;
		this._settings = settings;
		
		$.formvalidator._register(this);
		
		this.validate = function()
		{
			$.formvalidator._validateForm(this._element, this._settings);
		};
	}
	
	
	// Fieldvalidator
	function FieldValidator()
	{
		this.defaults =
		{
			validators: [],
			failMessage: "Validation failed.",
			region: "",
			onsuccess: null,
			onfail: null
		};
		
		
		this.validators = $.formvalidator.validationmethods;
	}
	$.extend(FieldValidator.prototype,
	{
		getValidator: function(field)
		{
			return $(field).data("validation");
		},
		
		_validateField: function(field, allowScolding, stateLog)
		{
			var _errorElement = $("#jquery-valid-" + $.data(field))
			var result = {success: true, field: field, region: null, message: ""};
			
			var validationSet = $(field).data("validation");
			if(!validationSet) return result;
			var settings = $.extend({}, $.fieldvalidator.defaults, validationSet[0]._settings||{});
			if(allowScolding && settings.mustValidate)
			{
				var failed = false;
				for(var i=0,item; item = settings.mustValidate[i]; ++i)
				{
					var state = stateLog?stateLog[item]:null;
					if(state==null) state = this._validateField(item, false, stateLog).success;
					if(!state) failed = true;
				}
				if(failed) return result;
			}
			
			for(var i=0, mi=validationSet.length; i<mi; ++i)
			{
				validationName = validationSet[i]._validator;
				var validator = $.fieldvalidator.validators[validationName];
				if(validator(field)) continue;
				
				// validation failed.
				result.success = false;
				result.message = typeof(settings.failMessage)=="function"?settings.failMessage(validationName, field):settings.failMessage;
				
				if(settings.region)
				{
					var fieldCaption = "jquery-valid-" + $.data(field);
					if(!_errorElement.length)
					{
						_errorElement = $("<div class=\"validation-error\" id=\"" + fieldCaption + "\"></div>");
						_errorElement.hover(
							function() { $(field).addClass("invalid-error");    },
							function() { $(field).removeClass("invalid-error"); }
						);
						_errorElement.click(
							function() { field.focus(); }
						);
						$(typeof(settings.region)=="function"?settings.region.call(field):settings.region).append(_errorElement);
					}
				}
				
				
				
				if(allowScolding && _errorElement)
				{
					_errorElement.addClass("active-validation-error");
					_errorElement.html(result.message);
				}
				
				if(settings.onfail)
					settings.onfail.call(field, allowScolding, validationName);
				if(settings.onvalidate)
					settings.onvalidate.call(field, allowScolding, success);
				return result;
			};
			
			if(_errorElement)
			{
				_errorElement.removeClass("active-validation-error");
				_errorElement.html("");
			}
			if(settings.onsuccess)
				settings.onsuccess.call(field, allowScolding);
			if(settings.onvalidate)
				settings.onvalidate.call(field, allowScolding, success);
			return result;
		},
		
		_register: function(validatorInstance)
		{
			if(!$(validatorInstance._element).data("bound-field-validation"))
			{
				$(validatorInstance._element).change(function()
				{
					$.fieldvalidator._validateField(validatorInstance._element, true);
				});
				
				$(validatorInstance._element).keyup(function(e)
				{
					$.fieldvalidator._validateField(validatorInstance._element, false);
				});
				
				$(validatorInstance._element).data("bound-field-validation", true)
			}
		}
	});
	
	function FieldValidatorInstance(element, settings, validator)
	{
		this._element = element;
		this._settings = settings;
		this._validator = validator;
		
		$.fieldvalidator._register(this);
	}
	
	// Init field/formvalidators
	$.formvalidator  = new FormValidator();
	$.fieldvalidator = new FieldValidator();
	
	$.fn.attachValidator = function(validator, settings)
	{
		this.each(function()
		{
			switch(this.nodeName)
			{
				case "FORM":
					settings = validator;
					var valid = $(this).data("validation")||[];
					valid.push(new FormValidatorInstance(this, settings));
					$(this).data("validation", valid);
					break;
					
					
				default:
					var _settings = settings||{};
					var validators = _settings.validators||(typeof(validator)=="string"?[validator]:validator);
					_settings.validators = null;
					
					var valid = $(this).data("validation")||[];
					for(var i=0, mi=validators.length; i<mi; ++i)
					{
						// if this validator already exists for the element it will be skipped.
						if($.grep(valid, function(item) { return item._validator==validators[i]; }).length>0) return;
						
						valid.push(new FieldValidatorInstance(this, _settings, validators[i]));
					};
					$(this).data("validation", valid);
			};
		});
		return this;
	};
})(jQuery);