// 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 = "מס' הטלפון שהקלדת אינו תקין"
		ERROR_NOT_EQUAL_NUMBER = "המספרים אינם זהים"
		ERROR_EQUAL_NUMBER = "המספרים זהים"
		ERROR_NOT_SMALL_NUMBER = "המספר הראשון אינו קטן מהשני"
		ERROR_NOT_BIG_NUMBER = "המספר הראשון אינו גדול מהשני"
		ERROR_NOT_SMALL_OR_EQUAL_NUMBER = "המספר הראשון אינו קטן או שווה לשני"
		ERROR_NOT_BIG_OR_EQUAL_NUMBER = "המספר הראשון אינו גדול או שווה לשני"
	}
	
	// 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"
		ERROR_NOT_EQUAL_NUMBER = "The Numbers are not equal"
		ERROR_EQUAL_NUMBER = "The numbers are equal"
		ERROR_NOT_SMALL_NUMBER = "The first number is not smaller then the second one"
		ERROR_NOT_BIG_NUMBER = "The first number is not bigger then the second one"
		ERROR_NOT_SMALL_OR_EQUAL_NUMBER = "The first number is not smaller or equal then the second one"
		ERROR_NOT_BIG_OR_EQUAL_NUMBER = "The first number is not bigger or equal then the second one"
	}
}

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)
{
	if (validator_div == "") return; // Exit if empty validator, allows for using the functions without UI error msgs
	
	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 = trim(field.value);
	var s = new String();
	
	if (str == "" || str=="null" ||  str.length==0 )
	{
		setError(validator_div, ERROR_EMPTY);
		return false; // mark as dirty
	} 
	else
	{
		clearError(validator_div);
		return true;	
	}
}

function validateNonEmptyEditor(field, validator_div)
{			
	var str = eval("obj_" + field.id + ".getHTMLBody()");
	
	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 numeric value is "=" or "!=" or "<" or ">" or ">=" or "<="  to a given number
function validate2Numbers(field, validator_div, gNumber, opretor)
{
 	if (isNaN(field.value))
 	{
		setError(validator_div, ERROR_INVALID_NUMBER);
		return false; // mark as dirty
	}
	var fNumber = field.value;
	
	switch (opretor)
	{
	case '==','=':
	    if (fNumber != gNumber)
	    {
	        setError(validator_div, ERROR_NOT_EQUAL_NUMBER);
		    return false; // mark as dirty
	    }
	    
    case '!=':
        if (fNumber == gNumber)
	    {
	        setError(validator_div, ERROR_EQUAL_NUMBER);
		    return false; // mark as dirty
        }
	    break;
	case '<':
        if (fNumber >= gNumber)
	    {
	        setError(validator_div, ERROR_NOT_SMALL_NUMBER);
		    return false; // mark as dirty
        }
		break;
    case '>':
        if (fNumber <= gNumber)
	    {
	        setError(validator_div, ERROR_NOT_BIG_NUMBER);
		    return false; // mark as dirty
        }
        break;
    case '<=':
        if (fNumber > gNumber)
	    {
	        setError(validator_div, ERROR_NOT_SMALL_OR_EQUAL_NUMBER, ERROR_NOT_BIG_OR_EQUAL_NUMBER);
		    return false; // mark as dirty
        }
    case '>=':
        if (fNumber < gNumber)
	    {
	        setError(validator_div, ERROR_NOT_BIG_OR_EQUAL_NUMBER);
		    return false; // mark as dirty
        }
        break;
	}	
	
	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. 
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 validateDate(field, validator_div)
{
	var dateStr = field.value;
	var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/;
	var matchArray = dateStr.match(datePat); 

	if (dateStr == "")
	{		
		clearError(validator_div);
		return true;
	}

	if (matchArray == null) 
	{
		setError(validator_div, ERROR_INVALID_DATE);
		return false;
	}

	day = matchArray[1];
	month = matchArray[3]; 
	year = matchArray[4];

	if (month < 1 || month > 12) 
	{ 
		setError(validator_div, ERROR_INVALID_DATE);
		return false;
	}

	if (day < 1 || day > 31) 
	{
		setError(validator_div, ERROR_INVALID_DATE);
		return false;
	}

	if ((month==4 || month==6 || month==9 || month==11) && day==31) 
	{
		setError(validator_div, ERROR_INVALID_DATE);
		return false;
	}

	if (month == 2) // check for february 29th
	{ 
		var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		
		if (day>29 || (day==29 && !isleap)) 
		{
			setError(validator_div, ERROR_INVALID_DATE);
			return false;
	   }
	}
	
	clearError(validator_div);
	return true;
}


function validateCheckboxList(field, validator_div)
{
	clearError(validator_div);
	
	for (var i=0; i<field.length; i++)
	{
		if (field[i].checked) return true;
	}
	
	if (field.checked) return true; // incase there's only one checkbox, it's not an array
	
	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 selectAll(field)
{
	for (var i=0; i<field.options.length; i++)
	{		
		field.options[i].selected = true;
	}
}

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

function addParam(controlText, paramName, paramValue)
{	
	return "<param name='" + paramName + "' value='" + paramValue + "'>";
}

function createFlash(DivID, ObjectID, WIDTH, HEIGHT, MOVIE)
{  
	var s = "<object classid='clsid:d27cdb6e-ae6d-11cf-96b8-444553540000' codebase='http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0' width='" + WIDTH + "' height='"+HEIGHT+"' id='"+ObjectID+"'>";
	
	s += addParam(s, "movie", MOVIE);
	s += addParam(s, "uiMode", "none");
	s += addParam(s, "wMode", "transparent");	
	s += "<EMBED wmode='transparent' src='" + MOVIE + "' quality=high width='" + WIDTH + "'height='" + HEIGHT + "' TYPE='application/x-shockwave-flash' "
	  +  "PLUGINSPAGE='http://www.macromedia.com/go/getflashplayer'> </EMBED>";	
	s += "</object>"
	
	document.getElementById(DivID).innerHTML += s;	
}		

function sendToFriend(str)
{
	openCenterWnd('send_to_friend.asp?site_lan='+str+'&url=' + escape(window.location.href), 450, 300, '', true, '');
}	  

function trim(str)
{
   return str.replace(/^\s*|\s*$/g,"");
}