/* Trim method for string */
String.prototype.trim = function() {
	return this.replace(/^\s+|\s+$/g, ""); 
};

function validate(form) {
	// call any user's functionality before validation
	try {
		validate_startup();
	} catch (e) {
	}
	
	var valid = true;

	// get values from tinyMCE
	try {
		tinyMCE.triggerSave();
	} catch (e) {
	}

  var elements = new Array();
	if(form.tagName.toString().toLowerCase() == 'form') {
		var elements = form.getElementsByTagName('*');
	} else {
		elements[0] = form;
		while((form.tagName.toString().toLowerCase() != 'form') && (form.parentNode != null)) {
			form = form.parentNode;
		}
		if(form.tagName.toString().toLowerCase() != 'form') {
			elements = new Array();
		}
	}
	/* Iterate through the form fields */
	for(var eCounter = 0; eCounter < elements.length; eCounter++) {
		var element = elements[eCounter];
		/* Look for validation data */
		var alt = element.getAttribute('alt')
		if((alt != null) && (alt != undefined) && (alt != '')) {
			/* Try to unserialize validation data */
			try {
				eval("var responseObj = " + alt);
			} catch (e) {
				continue;
			}
			
			/* Trim whitespace */
			element.value = element.value.trim();
			var elementError = false;
			var errorMessage = "";
			
			/* Look for required field and required field error message */
			var required = false;
			if(responseObj['required'] != undefined) {
				required = responseObj['required'];
			}
			if(required) {
    			var requiredMessage = 'Required field';
    			if(responseObj['required_message'] != undefined) {
    				requiredMessage = responseObj['required_message'];
    			}
    			
    			if(element.value.length == 0) {
    				elementError = true;
    				errorMessage = requiredMessage;
    			}
			}
			
			/* Look for validators */
			if((!elementError) && (element.value.length > 0) && ((responseObj['group'] == null) || (check_group_validation(form, element, responseObj['group'])))) {
				for(var vCounter=0; vCounter<responseObj['validators'].length; vCounter++) {
					if(responseObj['validators'][vCounter]['class'] != undefined) {
						var className = responseObj['validators'][vCounter]['class'];
						/* try to create a validator object */
						try {
							eval('var validator = new '+className+'()');
						} catch (e) {
//							alert('Unknown validation class: '+className);
							continue;
						}
						
						/* Attache a standard initialization method */
						validator.initialize=function(parameters) {
							try {
								for(var parameter in parameters) {
									if(parameter=="class")
										this['clas'] = parameters[parameter];
									else
										this[parameter] = parameters[parameter];
								}
							} catch(e) {}
						}
	
						/* Initialize parameters */
						validator.initialize(responseObj['validators'][vCounter]['parameters']);
						
						/* Validate */
						errorMessage = validator.execute(element.value);
						if(errorMessage) {
		    				elementError = true;
		    				break;
						}
					}
				}
			}
			
			/* Show/Hide alerts */
			var alertImg = document.getElementById(element.name+"Error");
			if(elementError) {
				valid = false;
				try {
					my_field_error(element, errorMessage);
					if(alertImg) {
						alertImg.innerHTML = errorMessage;
						alertImg.style.display = 'inline';
					}
				} catch (e) {
					if(alertImg) {
						alertImg.innerHTML = errorMessage;
						alertImg.style.display = 'inline';
					}
				}
			} else {
				try {
					my_field_error(element, null);
					if(alertImg) {
   						alertImg.style.display = 'none';
					}
				} catch (e) {
					if(alertImg) {
   						alertImg.style.display = 'none';
					}
				}
			}
		}
	}
	
	// call any user's functionality after validation
	try {
		validate_shutdown();
	} catch (e) {
	}
	
	return valid;
}

function check_group_validation(form, gElement, group) {
	var elements = form.getElementsByTagName('*');
	for(var eCounter = 0; eCounter < elements.length; eCounter++) {
		var element = elements[eCounter];
		/* Look for validation data */
		var alt = element.getAttribute('alt')
		if((alt != null) && (alt != undefined) && (alt != '')) {
			/* Try to unserialize validation data */
			try {
				eval("var responseObj = " + alt);
			} catch (e) {
				continue;
			}
			
			/* Trim whitespace */
			element.value = element.value.trim();
			
			if((element.value.length > 0) && (responseObj['group'] == group) && (element != gElement)) {
				return true;
			}
		}
	}
	
	return false;
}


/* Validators */

/**
 * sfStringValidator allows you to apply string-related constraints to a
 * parameter.
 *
 * Optional parameters:
 *
 * # insensitive  - [false]              - Whether or not the value check
 *                                                against the array of values is
 *                                                case-insensitive. Note:
 *                                                When using this option, values
 *                                                in the values array must be
 *                                                entered in lower-case.
 * # max          - [none]               - Maximum string length.
 * # max_error    - [Input is too long]  - An error message to use when
 *                                                input is too long.
 * # min          - [none]               - Minimum string length.
 * # min_error    - [Input is too short] - An error message to use when
 *                                                input is too short.
 * # values       - [none]               - An array of values the input
 *                                                is allowed to match.
 * # values_error - [Invalid selection]  - An error message to use when
 *                                                input does not match a value
 *                                                listed in the values array.
 */

/* Constructor */
var sfStringValidator=function() {
	this.insensitive = false;
	this.max = null;
	this.max_error = "Input is too long";
	this.min = null;
	this.min_error = "Input is too short";
	this.values = null;
	this.values_error = "Invalid selection";
}

/* Validation method */
sfStringValidator.prototype.execute=function(value) {
	if ((this.min != null) && (value.length < this.min)) {
		// too short
		return this.min_error;
	}

	if ((this.max != null) && (value.length > this.max)) {
		// too long
		return this.max_error;
	}
    
	if(this.values != null) {
		for(i = 0; i < this.values.length; i++) {
			if((this.insensitive?(this.values[i].toLowerCase()):(this.values[i])) == (this.insensitive?(value.toLowerCase()):(value))) {
				return false;
			}
		}
		
		return this.values_error;
	}

	return false;
}

/**
 * sfNumberValidator verifies a parameter is a number and allows you to apply
 * size constraints.
 *
 * Optional parameters:
 *
 * # max        - [none]                  - Maximum number size.
 * # max_error  - [Input is too large]    - An error message to use when
 *                                                 input is too large.
 * # min        - [none]                  - Minimum number size.
 * # min_error  - [Input is too small]    - An error message to use when
 *                                                 input is too small.
 * # nan_error  - [Input is not a number] - Default error message when
 *                                                 input is not a number.
 * # type       - [Any]                   - Type of number (Any, Float).
 * # type_error - [Wrong input] - An error message to use when
 *                                                 input is not a number.
 */

/* Constructor */
var sfNumberValidator=function() {
	this.max = null;
	this.max_error = "Input is too large";
	this.min = null;
	this.min_error = "Input is too small";
	this.nan_error = "Input is not a number";
	this.type = "any"; // 'any', 'decimal', 'float', 'int', 'integer'
	this.type_error = "Wrong input";
}

/* Validation method */
sfNumberValidator.prototype.execute=function(value) {
	if(isNaN(value)) {
		return this.nan_error;
	}
	
	iValue = parseInt(value, 10);
	fValue = parseFloat(value);
	
	if((this.type == 'int') || (this.type == 'integer')) {
		if(fValue != iValue) {
			return this.type_error;
		}
		pValue = iValue;
	} else {
		pValue = fValue;
	}
	
	if((this.min != null) && (pValue < this.min)) {
		return this.min_error;
	}
	
	if((this.max != null) && (pValue > this.max)) {
		return this.max_error;
	}
	
	return false;
}

/**
 * sfRegexValidator allows you to match a value against a regular expression
 * pattern.
 *
 * Required parameters:
 *
 * # pattern - [none] - A PCRE, preg_match() style regular expression
 *                             pattern.
 *
 * Optional parameters:
 *
 * # match       - [true]          - Indicates that the pattern must be
 *                                          matched or must not match.
 * # match_error - [Invalid input] - An error message to use when the
 *                                          input does not meet the regex
 *                                          specifications.
 */

/* Constructor */
var sfRegexValidator=function() {
	this.match = true;
	this.match_error = "Invalid input";
	this.pattern = null;
}

/* Validation method */
sfRegexValidator.prototype.execute=function(value) {
	if(this.pattern != null) {
		match = Boolean(this.match);
		pos = 0;
		unescaped = "";
		while(pos < this.pattern.length) {
			c = this.pattern.charAt(pos);
			if (c == "\\") {
				pos++;
			}
			try {
				unescaped += this.pattern.charAt(pos);
			} catch(e) {}
			pos++;
		}

		try {		
			eval("regExp = "+unescaped);
			value = String(value);
			if((value.match(regExp) && match) || (!value.match(regExp) && !match)) {
				return false;
			} else {
				return this.match_error;
			}
		} catch(e) {
			return false;
		}
	} else {
		return false;
	}
}

/**
 * sfEmailValidator verifies a parameter contains a value that qualifies as an
 * email address.
 * 
 * Optional parameters:
 *
 * # email_error - [Invalid input] - An error message to use when the
 *                                          input is not an email address
 */

/* Constructor */
var sfEmailValidator=function() {
	this.email_error = "Invalid input";
}

sfEmailValidator.prototype.execute=function(value) {
	regExp  = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})$/;
	if (regExp.test(value)) {
		return false;
	} else {
		return this.email_error;
	}
}


/**
 * sfCompareValidator checks the equality of two different request parameters.
 *
 * Required parameters:
 *     check:          field2
 * 
 * Optional parameters:
 * # compare_error - [The values you entered do not match. Please try again.] - 
 *                           An error message to use when the fields do not match
 */

/* Constructor */
var sfCompareValidator=function() {
	this.check = null;
	this.compare_error = "The values you entered do not match. Please try again";
}

sfCompareValidator.prototype.execute=function(value) {
	if(this.check != null) {
		check_field = document.getElementById(this.check);
		if(check_field != null) {
			check_value = check_field.value;
			if(check_value != value) {
				return this.compare_error;
			}
		}
	}
	
	return false;
}

function my_field_error(dom_element, error_message) {
	if(error_message){
		Element.removeClassName(dom_element, 'form-value-ok');
		Element.addClassName(dom_element, 'form-value-error');
	}else{
		Element.removeClassName(dom_element, 'form-value-error');
		Element.addClassName(dom_element, 'form-value-ok');
	}
}

var sfPropelUniqueValidator=function() {
	this.field = null;
	this.column = null;
	this.clas = null;
	this.unique_error = "Username Already taken";
}

sfPropelUniqueValidator.prototype.execute=function(value) {
	pars = 'class='+this.clas+'&column='+this.column+'&error='+this.unique_error+'&value='+value+'&field='+this.field;
	
	new Ajax.Updater(this.field+'Error', '/sfGuardAuth/uniqueCheck', {asynchronous:true, evalScripts:true, parameters:pars});
}