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

function validate(form) {
	var showError = 0;
	// 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];
		showMessage="";
		showMessage1="";		

		/* Look for validation data */
		var alt = element.getAttribute('alt')

		if((alt != null) && (alt != undefined) && (alt != '') && (alt != 'Date') ) {
			/* Try to unserialize validation data */
			try {
				eval("var responseObj = " + alt);
			} catch (e) {

				continue;
			}
			/* Trim whitespace */
			try {
				element.value = element.value.trim();
			} catch (e) {

				continue;
			}

			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'];
			}
			try {
				if($("flightsBackDate") &&  $("flightsBackDate").value=="" && $('flightsDoubleTicket').checked==true) required=true;;
			} catch (e) {

				continue;
			}				
			if(required) {
				showError =1;
				
    			var requiredMessage = 'Required field';
    			if(responseObj['required_message'] != undefined) {
    				requiredMessage = responseObj['required_message'];
    			}
    			
    			if(element.value.length == 0 && element.disabled==false) {

    				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) {
				valid = false;
				try {
					my_field_error(element, errorMessage);
				} catch (e) {
					if(alertImg) {
						alertImg.alt = errorMessage;
						alertImg.title = errorMessage;
						//alertImg.style.display = 'block';
						try {

						if($("snif_id").value=="") $("snif_id_label").setStyle({color: '#FF0000'});
						if($("snif_id").value!="") $("snif_id_label").setStyle({color: '#FFFFFF'});
						} catch (e) {
	
						}
						$(element.id+"_label").setStyle({color: '#FF0000'});
						$('error_js').value="ok";
					}
				}
			} else {
				
				try {
				$(element.id+"_label").setStyle({color: '#FFFFFF'});
				my_field_error(element, null);
				} catch (e) {
					if(alertImg) {
   						alertImg.style.display = 'none';
						
					}
				}
			}
			
		}
		
	}
	if(form.tagName.toString().toLowerCase() == 'form' && $('error_js').value!="")
	{ 

		alert("נא למלא את כל השדות");
		$('error_js').value="";
	}
	// 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;
}

/**
*
* sfTwoWaysComparator
*
*/
var sfTwoWaysValidator=function() {
	this.element = null;

}

/* Validation method */
sfTwoWaysValidator.prototype.execute=function(value) {
	if($(this.element).checked && value!="") return false;

	return false;
}

/**
 * sfDAteComparatorValidator 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 sfDateComparatorValidator=function() {
	this.compare = null;
}
function usDate(value)
{
	
	arr = DecomposeDate(value);
	return arr[2]+"/" +arr[1]+"/"+arr[0];
}
/* Validation method */
sfDateComparatorValidator.prototype.execute=function(value) {
	

	date1 = new Date(usDate(value));
	y = usDate($(this.compare).value);
	date2 = new Date(y);
	if(date1>date2) return false;
	return true;
}

function DecomposeDate(LeParam1){ 

	// Sépare les jours, les mois et les années dans une date de type "22/05/1981"
	// Renvoye le tout dans un tableau de taille 3
	
	LeRetour = new Array(3);
	LeJour="";
	LeMois="";
	LeAnnee="";
	
	// Extraction du jour
	i=0;
	while((LeParam1.charAt(i)!="/")&&(i<10)){
	LeJour+=LeParam1.charAt(i);
	i++;
	}
	if(LeJour.charAt(0)=="0"){
	LeJour=LeJour.charAt(1);
	}
	LeParam1=LeParam1.substring(i+1,LeParam1.length);
	
	// Extraction du mois
	i=0;
	while((LeParam1.charAt(i)!="/")&&(i<10)){
	LeMois+=LeParam1.charAt(i);
	i++;
	}
	if(LeMois.charAt(0)=="0"){
	LeMois=LeMois.charAt(1);
	}
	LeParam1=LeParam1.substring(i+1,LeParam1.length);
	
	
	// Extraction de l'année
	LeAnnee=LeParam1;
	LeRetour[0]=LeJour;
	LeRetour[1]=LeMois;
	LeRetour[2]=LeAnnee;
	return LeRetour;
}

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