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

/* Not trimmed elements id */
not_trimmed_elements = new Array( /* "password", "current_password", "new_password", "reconfirm_password", "password1", "passwordConfirmation" */);

function validate_check_not_trimed_elements( element )
{
    if (not_trimmed_elements.indexOf( element.id ) == -1) element.value = element.value.trim();
    return false;
}

function validateElement( element, form )
{
    var elementError = false;
    var valid = true;
    /* Look for validation data */
	var alt = element.getAttribute("alt")

	//======== ADD Element  ==============
	//   top.all_elements.push(element.id);
	//========================================
	
	if((alt != null) && (alt != undefined) && (alt != '') || (alt == "validated")) {
	    //======= Add Element if Validation in YAML =============
	      top.all_elements.push(element.id);
	    //=======================================================
	    
		/* Try to unserialize validation data */
		try {
			eval("var responseObj = " + alt);
		} catch (e) {
			return true;
		}
		
		/* Trim whitespace */
		//element.value = element.value.trim();
		validate_check_not_trimed_elements(element);

		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 || (element.type == "checkbox" && !element.checked) || (element.type == "select-one" && element.value == "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) {
								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) {
		    
		    //============ Validation Error - Element ID =============
		    top.error_ids.push(element.id);
		    //========================================================
		    
			valid = false;
			try {
				top.my_field_error(element, errorMessage);
			} catch (e) {
				if(alertImg) {
					alertImg.alt = errorMessage;
					alertImg.title = errorMessage;
					alertImg.style.display = 'inline';
				}
			}
		} else {
			try {
				top.my_field_error(element, null);
			} catch (e) {
				if(alertImg) {
						alertImg.style.display = 'none';
				}
			}
		}
	}

			
	return valid;
}

function validate(form, callback) {
	// 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 valid = true;
    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++)
	{
    		if ( !validateElement( elements[eCounter], form ) )
    		  valid = false;
	}

	// call any user's functionality after validation
	
	try {
		top.validate_shutdown();
	} catch (e) {
	}

	if (valid && callback)
        {
            callback();
        }
        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();
			validate_check_not_trimed_elements(element);

			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";
}

var sfI18NStringValidator = sfStringValidator;

/* 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";
}

var sfI18NNumberValidator = sfNumberValidator;

/* 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;
}

var sfI18NRegexValidator = sfRegexValidator;

/* 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";
}

var sfI18NEmailValidator = sfEmailValidator;

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";
}

var sfI18NCompareValidator = sfCompareValidator;

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;
}