// Form Field Types
var FIELD_TYPE_CHECKBOX = 1;
var FIELD_TYPE_SELECT = 2;

var DEFAULT_VALIDATOR_CLASS_NAME = "validator"; // Default class name
var VALIDATOR_CLASS_NAME = DEFAULT_VALIDATOR_CLASS_NAME; // Current class name


var is_valid = true; // Main Flag
var highlighted_errors = false; // Note: when using this feature, don't use <td style="background-color: ...">
								// Note: the validator DIV must be located directly inside the TD (validtor_div.parent. ...)
var highlighted_errors_color = ""; // Color to use as background in cells which have errors.
var validation_language = "he"; // Default language for error messages

function initErrorStrings()
{	
	// Hebrew Error Messages
	if (validation_language == "he")
	{
		ERROR_EMPTY = "אנא מלא שדה זה";
		ERROR_SPACE_NOT_ALLOWED = "סיסמא אינה יכולה להכיל רווחים"
		ERROR_PASSWORDS_NOT_EQUAL = "הסיסמאות אינן זהות"
		ERROR_INVALID_LENGTH = "אנא הקלד לפחות %1 תווים";
		ERROR_INVALID_EMAIL = "אנא תקן את פורמט האימייל שלך";
		ERROR_INVALID_NUMBER = "אנא הקלד מספר";
		ERROR_INVALID_USERNAME = "אנא הקלד אותיות אנגליות וספרות בלבד"
		ERROR_INVALID_SELECTION = "אנא בחר פריט מתוך הרשימה"
		ERROR_INVALID_MULTI_SELECTION = "אנא בחר לפחות פריט אחד"
		ERROR_INVALID_CREDIT_CARD_NUM = "אנא הקלד מס' כרטיס אשראי תקין"
		ERROR_INVALID_ID_NUM = "אנא הקלד מס' תעודת זהות תקין"
		ERROR_INVALID_DATE = "אנא בחר תאריך חוקי"
		ERROR_CHECKBOX_NOT_CHECKED = "יש לסמן וי בשדה זה"
		ERROR_INVALID_PHONE = "מס' הטלפון שהקלדת אינו תקין"
	}
	
	// English Error Messages
	if (validation_language == "en")
	{
		ERROR_EMPTY = "Required Field";
		ERROR_SPACE_NOT_ALLOWED = "Password cannot contain spaces"
		ERROR_PASSWORDS_NOT_EQUAL = "Passwords don't match"
		ERROR_INVALID_LENGTH = "Minimum %1 characters required";
		ERROR_INVALID_EMAIL = "Enter a valid E-mail";
		ERROR_INVALID_NUMBER = "Numeric value required";
		ERROR_INVALID_USERNAME = "Only use english letters and numbers"
		ERROR_INVALID_SELECTION = "Choose an item"
		ERROR_INVALID_MULTI_SELECTION = "Choose at least 1 item"
		ERROR_INVALID_CREDIT_CARD_NUM = "Invalid Credit Card Number"
		ERROR_INVALID_ID_NUM = "Invalid personal ID number"
		ERROR_INVALID_DATE = "Invalid date"
		ERROR_CHECKBOX_NOT_CHECKED = "Field must be checked"
		ERROR_INVALID_PHONE = "Invalid phone number"
	}
}

initErrorStrings(); // Call to initialize

// Sets the validation language and reloads the strings
function setValidationLanguage(lang)
{
	validation_language = lang;
	initErrorStrings();
}

function isExplorer()
{
	return navigator.appName.indexOf("Explorer") > -1;
}

function setInnerText(element, text)
{
	if (isExplorer()) 
			element.innerText = text;
		else
			element.textContent = text;
}

function setValidatorClassName(class_name)
{
	VALIDATOR_CLASS_NAME = class_name;
}

function restoreValidatorClassName()
{
	VALIDATOR_CLASS_NAME = DEFAULT_VALIDATOR_CLASS_NAME;
}

// Inits the highlighting variables
function setHighlightedErrors(highlight, color)
{
	highlighted_errors = highlight;
	highlighted_errors_color = color;
}

// clears all errors
function clearErrors()
{
	var divs = document.getElementsByTagName("div");
	var validator_div;
	
	for (i=0;i<=divs.length;i++) 
	{
		try {
			if (divs[i].tagName == "DIV")				
				if (divs[i].className == VALIDATOR_CLASS_NAME)
				{
					validator_div = divs[i];
					
					try
					{
						validator_div.style.display = "none";
					
						if (highlighted_errors) validator_div.parentNode.style.backgroundColor = "";
					}
					catch (e)
					{
						alert("Validator <DIV> not found: " + validator_div); 
					}
				}
		}
		catch (e)
		{
		
		}
	}
}

// Clears the validation flag
function clearValidationFlag()
{	
	is_valid = true;
	
	clearErrors();
}

// Returns true if all validators passed
function isValid()
{
	return is_valid;
}

//Clear the validator error
function clearError(validator_div)
{
	/* this function is not in use, functionality has been moved to clearErrors
	try
	{
		document.all[validator_div].style.display = "none";
		if (highlighted_errors) document.all[validator_div].parentElement.style.backgroundColor = "";
	}
	catch (e)
	{
		alert("Validator <DIV> not found: " + validator_div); 
	} */
}

// Set the validtor error message
function setError(validator_div, err_msg)
{
	var div = document.getElementById(validator_div);
	
	is_valid = false;
	
	try 
	{			
		div.style.display = "block";
	
		//if (div.innerHTML == "") setInnerText(div, err_msg);
		if (div.getAttribute("error") == null) 
			setInnerText(div, err_msg);
		else
			setInnerText(div, div.getAttribute("error"));
			
		if (highlighted_errors) div.parentNode.style.backgroundColor = highlighted_errors_color;
	}
	catch (e)
	{	
		alert("Validator <DIV> not found: " + validator_div);
	}
}

// Validate a non-empty field
function validateNonEmpty(field, validator_div)
{
	var str = field.value;
	
	if (str == "" || str=="null" ||  str.length==0 )
	{
		setError(validator_div, ERROR_EMPTY);
		return false; // mark as dirty
	} 
	else
	{
		clearError(validator_div);
		return true;	
	}
}

// Validate an e-mail address
function validateEmail(field, validator_div)
{
  var Email = field.value;
  
  if (Email.length > 0 )
	  {
		var i   = Email.indexOf("@")
		var j   = Email.indexOf(".",i)
		var k   = Email.indexOf(",")
		var kk  = Email.indexOf(" ")
		var jj  = Email.lastIndexOf(".") + 1
		var len = Email.length
		
		if (!(i > 0 && j > (i + 1) && k == -1 && kk == -1 && (len - jj) >= 2 && (len - jj) <= 3))
		{
			setError(validator_div, ERROR_INVALID_EMAIL);
			return false; // mark as dirty
		}
  }  
  
  clearError(validator_div);
  return true;
}

// Validates a numeric value
function validateNumber(field, validator_div)
{
 	if (isNaN(field.value))
 	{
		setError(validator_div, ERROR_INVALID_NUMBER);
		return false; // mark as dirty
	}
	
	clearError(validator_div);
	return true;
}

// Validates a field is of a minimum length
function validateMinLength(field, min_length, validator_div)
{
	var err = ERROR_INVALID_LENGTH;
	
	if (!validateNonEmpty(field, validator_div)) 
		return false; // fail if empty
	
	if (field.value.length < min_length)
	{
		err = err.replace("%1", min_length); // put min_length into the error message
		
		setError(validator_div, err);
		return false; // mark as dirty
	}
	
	clearError(validator_div);
	return true;
}

// Validates a User name (english letter and numbers)
function validateUserName(field, validator_div)
{
 	var valid_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 	var str = field.value;
 	
 	if (validateNonEmpty(field, validator_div))
 	{
 		for (var i=0;i<=str.length;i++)
 		{
 			//alert(str.indexOf(str.charAt(i), valid_chars));
			if (valid_chars.indexOf(str.charAt(i)) == -1)
			{
				setError(validator_div, ERROR_INVALID_USERNAME);
				return false; // mark as dirty
			}
		}
		
		clearError(validator_div);
		return true;
	}
	else
	{
		return false; // validateNonEmpty failed so we fail too.
	}	
}

// Validates a password field
function validatePassword(field, min_length, validator_div)
{
	if (validateMinLength(field, min_length, validator_div))
 	{
 		if (field.value.indexOf(" ") > -1)
 		{
			setError(validator_div, ERROR_SPACE_NOT_ALLOWED);
			return false; // mark as dirty
		}
	
		clearError(validator_div);
		return true;
	}
	else
		return false; // validateMinLength failed so we fail too.
}

// Validates both password fields match
function validatePasswordsEqual(field1, field2, validator_div)
{
	if (field1.value != field2.value)
	{
		setError(validator_div, ERROR_PASSWORDS_NOT_EQUAL);
		return false; // mark as dirty
	}
	else
	{
		clearError(validator_div);
		return true;
	}
}

// Validate that a selection was made in a combobox (that the first item is not the selected one
function validateSelection(field, validator_div)
{
	if (field.selectedIndex == 0) 
	{
		setError(validator_div, ERROR_INVALID_SELECTION);
		return false; // mark as dirty
	}

	clearError(validator_div);

	return true;
}

// Validate that a selection was made in a multiline select (at least 1 item must be selected)
function validateMultiSelection(field, validator_div)
{	
	if (field.selectedIndex == -1) 
	{
		setError(validator_div, ERROR_INVALID_MULTI_SELECTION);
		return false; // mark as dirty
	}
	
	clearError(validator_div);
	return true;
}

// Validates that at least 1 checkbox in a checkbox list (group) is checked. 
// Checkboxes must have id=<field name><option number> attribute e.g. id=hobbies1 id=hobbies2
function validateStatus(field, num_of_opt, validator_div)
{
	for (var i=1; i<=num_of_opt; i++)
	{
		if (document.getElementById(field + i).checked) 
		{	
			clearError(validator_div);
			return true;
		}
	}
	
	setError(validator_div, ERROR_INVALID_MULTI_SELECTION);
	return false; // mark as dirty
}	

// Validates that at least 1 checkbox in a checkbox list (group) is checked. 
// Checkboxes must have id=<field name><option number> attribute e.g. id=hobbies1 id=hobbies2
function validateRadioList(field, validator_div)
{
	clearError(validator_div);
	
	for (var i=0; i<field.length; i++)
	{
		if (field[i].checked) return true;
	}
	
	setError(validator_div, ERROR_INVALID_MULTI_SELECTION);
	return false; // mark as dirty
}

// Validates a credit card is a numeric field with minimum 8 digits
function validateCreditCardNum(field, validator_div)
{
	var err = ERROR_INVALID_LENGTH;
	var r;
	
	if (field.value == "") return true; // empty is valid. 
	if (!validateNumber(field, validator_div)) return false; // not a number, invalid				
	if (field.value.length < 8)
	{
		err = err.replace("%1", 8); // put 8 into the error message
		
		setError(validator_div, err);
		return false; // mark as dirty
	}
	
	if (field.value.length < 10)
		r = checkShortIsraCard(field.value);
	else
		r = checkLUHN(field.value);
	
	if (!r) 
	{
		setError(validator_div, ERROR_INVALID_CREDIT_CARD_NUM);
		return false;
	}
}	

function validatePersonalIdNum(field, validator_div)
{
	
	if (field.value == "") return true; // empty is valid. 
	if (!validateNumber(field, validator_div)) return false; // not a number, invalid
	if (field.value.length < 8) return false; // not empty but too short
	
	if (!checkLUHN(field.value)) 
	{
		setError(validator_div, ERROR_INVALID_ID_NUM);
		return false;
	}
	
	
	clearError(validator_div);
	return true;
}	

function validateChecked(field, validator_div)
{
	if (!field.checked) {
		setError(validator_div, ERROR_CHECKBOX_NOT_CHECKED);
		return false; // mark as dirty
	}
	
	clearError(validator_div);
	return true;
}

function validateDateSelection(day, month, year, validator_div)
{
	if ((day.selectedIndex == 0) ||(month.selectedIndex == 0) ||(year.selectedIndex == 0))
	{
		setError(validator_div, ERROR_INVALID_DATE);
		return false; // mark as dirty
	}
	
	clearError(validator_div);
	return true;
}

function validateDate(field, validator_div)
{	
	var d = field.value;
	
	d = d.replace(".", "/"); // replace 1st dot if exists
	d = d.replace(".", "/"); // replace 2nd dot if exists		
	
	if (isNaN(Date.parse(d)))
	{
		setError(validator_div, ERROR_INVALID_DATE);
		return false;
	}
	else return true;
}

function validateCheckboxList(field, validator_div)
{
	clearError(validator_div);
	
	for (var i=0; i<field.length; i++)
	{
		if (field[i].checked) return true;
	}
	
	setError(validator_div, ERROR_INVALID_MULTI_SELECTION);
	return false; // mark as dirty
}

// Validates a User name (english letter and numbers)
function validatePhone(field, validator_div)
{
 	var valid_chars = "0123456789- ";
 	var str = field.value;
 	
 	for (var i=0;i<=str.length;i++)
 	{
 		//alert(str.indexOf(str.charAt(i), valid_chars));
		if (valid_chars.indexOf(str.charAt(i)) == -1)
		{
			setError(validator_div, ERROR_INVALID_PHONE);
			return false; // mark as dirty
		}
	}
	
	clearError(validator_div);
	return true;
}

function joinField(srcArray, dest, field_type)
{	
	var s = "";

	for (i=0; i < srcArray.length; i++)
	{
		switch (field_type)
		{
			case FIELD_TYPE_CHECKBOX: if (srcArray[i].checked) s = s + srcArray[i].value + ", "; break;
			case FIELD_TYPE_SELECT: if (srcArray[i].selected) s = s + srcArray[i].value + ", "; break;
		}
	}
	
	if (s != "") s = s.substr(s, s.length-2);
	
	dest.value = s;
}

function selectByValue(field, val)
{
	for (var i=0; i<field.options.length; i++)
	{
		if (field.options[i].value == val) field.selectedIndex = i;
	}
}

function checkByList(field, list)
{
	var arr = list.split(", ");
	
	for (var i=0; i<field.length; i++)
	{
		for (var j=0; j<arr.length; j++)
		{
			if (field[i].value == arr[j]) field[i].checked = true;
		}
	}
	
}

function checkLUHN(num){
 
    var sum = 0;
    var d;
    
    if (parseInt(num) == 0) return false;
    
    while (num.length < 9) num = "0" + num;    
    
    for (var i=0; i<num.length; i++)
    {		
		d = parseInt(num.substring(i, i+1));
		c = (i%2+1)
		
		if (d*c > 9)		
			sum = sum + (d*c)%10+1;
		else
			sum = sum + (d*c);						
	}
            
    if (sum % 10 == 0)
		return true;
	else
		return false;
}

function checkShortIsraCard(num){
 
    var sum = 0;
    var d;
    
    if (parseInt(num) == 0) return false;
    
    while (num.length < 9) num = "0" + num;    
    
    for (var i=0; i<num.length; i++)
    {		
		d = parseInt(num.substring(i, i+1));
		c = 9-i
		sum = sum + (d*c);		
	}
            
    if (sum % 11 == 0)
		return true;
	else
		return false; 
}

// Clears an HTML form, clears all text fields and selections.
function clearHtmlForm(form)
{
	var e;
	
	for (var i=0; i < form.elements.length; i++)
	{				
		e = form.elements[i];
		
		if ((e.tagName == "INPUT") && (e.type == "text")) e.value = "";
		if ((e.tagName == "INPUT") && (e.type == "password")) e.value = "";
		if ((e.tagName == "INPUT") && (e.type == "checkbox")) e.checked = false;
		if ((e.tagName == "INPUT") && (e.type == "radio")) e.checked = false;
		if (e.tagName == "TEXTAREA") e.value = "";
		if (e.tagName == "SELECT") e.selectedIndex = 0;
	}
}