/*---------------------------------------------------------------------------------------------------
getCKValidateErrors
---------------------------------------------------------------------------------------------------*/
function getCKValidateErrors(oForm) {
	var args = getCKValidateErrors.arguments;
	var validateSectionID = (args.length==2 ? args[1] : "");
	if (args.length==0 || !oForm) oForm = new Array(); //just so oField lookup below will not error out
	
	var blankErr = "";
	var invalidErr = "";
	var sLabel, sField, sValidation;
	var oEl, oField;
	var aEl = document.getElementsByName("ckValidate");
	for (var index=0; index < aEl.length; index++) {
		oEl = aEl[index];
		sSectionID = (oEl.getAttribute("sectionID") || oEl.getAttribute("sectionid"));

		if ((sSectionID==validateSectionID) || (validateSectionID=="")) {
			sLabel = oEl.getAttribute("label");
			sValidation = oEl.getAttribute("validation")

			//reference element by either the form (default) or id (required for certain ajax style forms that do not have FORM tags)
			
			sField = (oEl.getAttribute("formField") || oEl.getAttribute("formfield"));
			oField = (oForm[sField] || document.getElementById(sField));
		
			if (oField) {
				switch (sValidation) {
					case "checkBlank" :	
						blankErr += checkBlankField(sLabel,oField);
						break;
					case "url" : 
						invalidErr += checkValidRegExp(sLabel,oField,"(http:\/\/|https:\/\/|mailto:).+")
						break;
					default :
						alert("Unknown validation type requested (" + sValidation + ")");
				}
			}
		}
	}
	return Array(blankErr,invalidErr)
}

function validateSection(oForm,sectionID) {
	var errArr;
	var sectionErrArr;
	var args = validateSection.arguments;
	var fnSectionErrors = (args.length == 3 ? args[2] : sectionErrors); //with ajax calls, it's possible to have multiple validation scripts on page. Optional third parameter lets you pass in function to call for section error checks
	
	if ((sectionErrArr = fnSectionErrors(oForm,sectionID)) != null) {
		if (sectionErrArr.length > 0) { //if returning a blank error, just return a false value out of here instead of display any error 
			var errHTML = '<ul style="margin-top:2px;margin-bottom:2px;">';
			for (var index = 0; index < sectionErrArr.length; index++)
				errHTML += "<li>"+sectionErrArr[index]+"</li>";
			errHTML += "</ul>";
			
			oStdContainer.displayError(errHTML,sectionID)
		}
		return false;
	} else {
		clearSectionError(sectionID)
		return true;
	}
}

function ckSectionErrors(oForm,sectionID) {
	var errorStr = "";
	var blankErr = "";
	var invalidErr = "";
	var aErrors = getCKValidateErrors(oForm,sectionID);
	
	blankErr = aErrors[0];
	invalidErr = aErrors[1];
	
	return evalErrors(blankErr,invalidErr);
	
}





function evalSubmission(oForm,invalidSections) {
	//works along with validateSection in the individual pages form submission functions
	var oContainer;
	if (invalidSections.length != 0) {
		invalidSections = invalidSections.replace(/, $/,"");
		var errHTML = "The following section(s) contain errors: " + invalidSections + ".<br>Specific error descriptions appear below each section title."
		if ((!oForm._sectionErrorsOnly) || ((oForm._sectionErrorsOnly) && (oForm._sectionErrorsOnly.value != "true"))) {
			if (oContainer = document.getElementById("errorContainerText")) oContainer.innerHTML = errHTML;
			if (oContainer = document.getElementById("errorContainer")) oContainer.style.display="";
		}
		
		//close out the alert container if it's open so any previous success message doesn't confuse the users
		if (oContainer = document.getElementById("alertContainer")) oContainer.style.display="none";
		
		window.scrollTo(0,0); //go to top so user can always see the error message.
		return false;
	} else {
		if (oContainer = document.getElementById("errorContainer")) oContainer.style.display="none";
		oForm.submit();
		return true;
	}
}
function evalErrors(blankErr,invalidErr) {
	if ((blankErr == "") && (invalidErr == "")) {
		return null;
	} else {
		var errArr = new Array();
		if (blankErr != "") errArr[errArr.length] = "These fields cannot be blank: "+blankErr.replace(/, $/,"");
		if (invalidErr != "") errArr[errArr.length] = "These fields have invalid values: "+invalidErr.replace(/, $/,"");
		return errArr;
	}

}



/*--------------------------------------------------------------------------------
 As you Type Validation
--------------------------------------------------------------------------------*/
function allowRegExp(oEvent,strRegExp) {
	var key,keychar;
	if (window.event) key = window.event.keyCode;
	else if ((oEvent) && (oEvent.charCode != 0 && !oEvent.ctrlKey)) key = oEvent.charCode; //checking charCode for non-zero allows backspace, CTRL+V and other functional keys to pass through and always go to next statement to return true
	else return true;

	var reg = new RegExp(strRegExp)
	keychar = String.fromCharCode(key);
	var matchedArr = keychar.match(reg)
	//alert("keyChar=" + keychar + "\nstrRegExp=" + strRegExp + "\nmatchedArr=" + matchedArr);
	return (matchedArr != null);
}

function allowAlphaNumeric() {
	var strChars = '';
	if (allowAlphaNumeric.arguments.length >= 1) strChars += allowAlphaNumeric.arguments[0];
	var oEvent = (allowAlphaNumeric.arguments.length >= 2 ? allowAlphaNumeric.arguments[1] : (window.event || arguments.callee.caller.arguments[0]));
	return allowRegExp(oEvent,'[a-zA-Z0-9' + strChars + ']');
}
function allowNumeric() {
	var strChars = '';
	if (allowNumeric.arguments.length >= 1) strChars += allowNumeric.arguments[0];
	var oEvent = (allowNumeric.arguments.length >= 2 ? allowNumeric.arguments[1] : (window.event || arguments.callee.caller.arguments[0]));
	return allowRegExp(oEvent,'[0-9' + strChars + ']');
}
function allowEmail() {
	var oEvent = (args.length==1 ? args[0] : (window.event || arguments.callee.caller.arguments[0]));
	return allowAlphaNumeric('@\._\-',oEvent);
}
function allowCurrency() {
	var args = allowCurrency.arguments; //option exists to pass in event object so this function can be called from within another function instead of just used as a direct event handler
	var oEvent = (args.length==1 ? args[0] : (window.event || arguments.callee.caller.arguments[0]));
	return allowRegExp(oEvent,'[\b,0-9\.,\-]');
}

function allowDate() {
	var args = allowDate.arguments; //option exists to pass in event object so this function can be called from within another function instead of just used as a direct event handler
	var oEvent = (args.length==1 ? args[0] : (window.event || arguments.callee.caller.arguments[0]));
	return allowRegExp(oEvent,'[\b,0-9\/]');
}
function allowTime() {
	var args = allowTime.arguments; //option exists to pass in event object so this function can be called from within another function instead of just used as a direct event handler
	var oEvent = (args.length==1 ? args[0] : (window.event || arguments.callee.caller.arguments[0]));
	return allowRegExp(oEvent,'[0-9\:apmAPM]');
}

function allowAllExcept(strRegExp) {
	var key;
	var oEvent = (window.event || arguments.callee.caller.arguments[0]);
	
	if (window.event) key = oEvent.keyCode;
	else if (oEvent.charCode != 0 && !oEvent.ctrlKey) key = oEvent.charCode; //checking charCode for non-zero allows backspace, CTRL+V and other functional keys to pass through and always go to next statement to return true

	var reg = new RegExp(strRegExp)
	var keychar = String.fromCharCode(key);
	
	var matchedArr = keychar.match(reg)
	return (matchedArr == null);
}

/*--------------------------------------------------------------------------------
 Check Blank
--------------------------------------------------------------------------------*/
function checkBlank(field,value) {
	var isBlank;
	var forValue = (checkBlank.arguments.length == 2);
	var checkValue;
	if (forValue) { //submitting an actual value instead of a form field
		isBlank = trim(value) == "";
	} else {
		if (field) {
			if (!field.type) {
				switch (field[0].type) {
					case "radio" :
					case "checkbox":
						isBlank = true;
						for (var i=0; i < field.length && isBlank; i++) {
							isBlank = (!field[i].checked);
						}
						break;
					case "select-one": //will occur if two select boxes with same name on page
						isBlank = true;
						for (var i=0; i < field.length && isBlank; i++) {
							isBlank = (field[i].value == "");
						}
						break;
				}
				for (var i=0; i < field.length; i++) indicateFieldStatus(field[i],!isBlank)
			} else {
				switch (field.type) {
					case "checkbox" : //will get here instead of above if there is only one checkbox with this name on the page
						isBlank = !field.checked;
						break;
					case "select-one" :
						//if the select box size is > 1 then we're assuming the first element is a valid selection
						if (field.size > 1) isBlank = field.selectedIndex < 0
						else {
							//if the value of the first field is an empty string, assume that it is a blank ([Select...]) type option
							isBlank = ((trim(field.options[0].value).length==0 && field.selectedIndex <=0) || (field.selectedIndex == -1));
						}
						break;
					case "text" :
					case "textarea" :
					case "hidden" :
					case "password" :
					case "file":
						isBlank = trim(field.value).length == 0;
						break;
					case "select-multiple" : //return false if select list is empty...unless special attribute set since this mainly applies to the multiple selects in Reports
						isBlank = (field.options.length == 0);
						if ((!isBlank) && (field.validateIndex)) isBlank = field.selectedIndex < 0;
						break;
					default: 
						alert("Encountered a "+field.type+" data type that is not handled.  Name:"+field.name);
				}
				indicateFieldStatus(field,!isBlank)
				
			}
			
		}
		
	}
	
	return (isBlank);
}
function checkBlankField(displayName,field) {
	return (checkBlank(field) ? displayName + ", " : "");
}
function checkBlankValue(displayName,value) {
	return (checkBlank(null,value) ? displayName + ", " : "");
}
/*--------------------------------------------------------------------------------
 Check Valid
--------------------------------------------------------------------------------*/
function checkValid(field,value,valueType) {
	var isValid;
	var forValue = (checkValid.arguments.length == 3);
	var checkValue;

	if ((field) || (forValue)) {
		if (!forValue && field.type != "text") {
			isValid = true; //can't handle anything other than text form fields right now
		} else {
			checkValue = trim((forValue ? value : field.value));
			if (checkValue != "") {
				var checkType = (forValue ? valueType : field.name);
				if (checkType.search(/areacode/i) >=0) {
					isValid = ValidateAreaCode(checkValue);
				} else if (checkType.search(/phonenumber|faxnumber|cellularnumber|faximportnumber/i) >=0) {
					isValid = ValidatePhoneNumber(checkValue);
					if ((isValid) && (!forValue)) field.value = formatPhoneNumber(field.value);
				} else if (checkType.search(/email/i) >=0) {
					isValid = ValidateEmailAddress(checkValue);
				} else if (checkType.search(/zip/i) >=0) {
					isValid = ValidateZipCode(checkValue);
				} else if (checkType.search(/date/i) >=0) {
					isValid = validateDate(checkValue);
				} else {
					isValid = true;
				}
				if (field) indicateFieldStatus(field,isValid)
			} else {
				isValid = true;
			}
			
		}
		
	} 
	
	return (isValid);
}
function checkValidField(displayName,field) {
	return (checkValid(field) ? "" : displayName + ", ");
}
function checkValidValue(displayName,value,valueType) {
	return (checkValid(null,value,valueType) ? "" : displayName + ", ");
}
function checkValidRegExp(displayName,field,strRegExp) {
	var isValid = true;
	if (trim(field.value) != "") {
		var reg = new RegExp(strRegExp);
		isValid = (field.value.match(reg) != null)
		indicateFieldStatus(field,isValid)
	}
	return (isValid ? "" : displayName + ", ");
}
function checkValidFieldSize(displayName,field,min,max) {
	var isValid = true;
	if (trim(field.value) != "") {
		isValid = ((field.value.length >= min) && (field.value.length <= max)) 
		indicateFieldStatus(field,isValid)
		
	}
	return(isValid ? "" : displayName + ", ");
}
function checkValidFieldNumericRange(displayName,oField,min,max) {
	var bValid = true;
	var fieldValue = trim(oField.value);
	if (fieldValue != "") {
		bValid = !isNaN(fieldValue);
		if (bValid) {
			min = parseFloat(min);
			max = parseFloat(max);
			fieldValue = parseFloat(fieldValue);
			bValid = ((fieldValue >= min) && (fieldValue <=max));
		}
		indicateFieldStatus(oField,bValid);
	}
	return (bValid ? "" : displayName +", ");
}

function checkValidEmail(displayName,field) {
	//If the form field name has the word "email" in it, then you should simply call checkValidField().  
	//This function is used when the field name does not contain "email"
	var isValid = true;
	if (trim(field.value) != "") {
		isValid = checkValid(field,field.value,"email")
		indicateFieldStatus(field,isValid)
	}
	return (isValid ? "" : displayName + ", ");
}

function checkValidPassword(displayName,field1,field2) {
	var isValid = true;
	if (trim(field1.value + field2.value) != "") {
		isValid = (field1.value.toUpperCase() == field2.value.toUpperCase()) 
		indicateFieldStatus(field1,isValid)
		indicateFieldStatus(field2,isValid)
	}
	return(isValid ? "" : displayName + ", ");
}
function checkValidFieldContains(displayName,field,value) {
	var isValid = true;
	if (trim(field.value) != "") {
		isValid = (field.value.indexOf(value) != -1)
		indicateFieldStatus(field,isValid)
	}
	return(isValid ? "" : displayName + ", ");
}
/*--------------------------------------------------------------------------------
 Utilities
--------------------------------------------------------------------------------*/
function smallTalkVar(sName) {
	//convert string parameter to smallTalk variable format
	var sVar = sName.replace(/\W/g,"");
	sVar = sVar.slice(0,1).toLowerCase() + sVar.slice(1,sVar.length);
	return sVar;
}
function getCheckedRadioID(field) {
	var checkedID = -1;
	if (field[0].type =="radio") {
		for (var i=0; i < field.length && checkedID == -1; i++) {
			checkedID = (field[i].checked ? i : -1);
		}
	}
	return checkedID;
}
function indicateFieldStatus(field,boolValid) {
	if (field) {
		if (!field.type) {
			switch (field[0].type) {
				case "radio" :
				case "checkbox":
					for (var i=0; i < field.length; i++) {
						field[i].className = (boolValid ? "" : "inputError")
					}
					break;
			}
		} else {
			field.className = (boolValid ? "" : "inputError");
		}
	}
}

/*--------------------------------------------------------------------------------
 Type Specific Validations
--------------------------------------------------------------------------------*/
function ValidateZipCode(Value)
{
	if (Value.indexOf(".") != -1)
		return false;
	if (Value.indexOf(",") != -1)
		return false;
		
	var l = Value.length;	
	if (l == 5)	{
		return !isNaN(Value);
	} else {		
	    if (l == 10) {
			return (!isNaN(Value.substr(0,5))) && (!isNaN(Value.substr(6,4))) && (Value.substr(5,1)=="-");
		} else	{
			return false;	
		}
	}
	return false;
}

function ValidateAreaCode(Value)
{	
	if (Value.indexOf(".") != -1)
		return false;
	if (Value.indexOf(",") != -1)
		return false;
	if (Value.length == 3)
		return !isNaN(Value);
	return false;
}

function formatPhoneNumber(value) {
	//this function is called after validating that the phone number has a valid format
	//strip any existing non-numeric characters
	value=value.replace(/[A-z]\.-,/g,"");
	//put a dash in the appropriate place
	value = value.replace(/(\d{3})(\d{4})/,"$1-$2");
	return value;
}

function ValidatePhoneNumber(Value)
{
	if (Value.indexOf(".") != -1)
		return false;
	if (Value.indexOf(",") != -1)
		return false;
	var l = Value.length;	
	if (l == 7)	{
		return !isNaN(Value);
	} else	{		
	    if (l == 8)
			return (!isNaN(Value.substr(0,2))) && (!isNaN(Value.substr(4,4))) && (Value.substr(3,1)=="-");
		else	
			return false;	
	}
	return false;
}

	
function validateDate(date) {

	var boolReformat = (validateDate.arguments.length == 2) 
	//requires date to be in mm/dd/yyyy, mm/dd/yy, mm-dd-yy, mm-dd-yyyy, or mmddyyyy format
	var strDescrip = ""
	var datePat = /^(\d{1,2})([\/-]*)(\d{1,2})([\/-]*)(\d{2,4})$/;
	var matchArray = date.match(datePat); 
	if ((matchArray == null) || ((date.indexOf("/") == -1) && (date.length != 8)) ) {
		return false;
	} else {
		//now validate the values
		var month = matchArray[1]*1;
		var day = matchArray[3]*1;
		var year = parseInt(matchArray[5]);
		if ((month < 1) || (month > 12)) return false;
		if ((day < 1) || (day > 31)) return false;
		if ((month == 4 || month == 6 || month == 9 || month == 11) && (day == 31)) return false;
		if (month == 2) {
			var isLeap = (year % 4 == 0 && (year % 100 !=0 || year % 400 == 0));
			if (day > 29 || (day == 29 && !isLeap)) return false
		}
		if ((year >= 100) && (year <= 999)) return false; //do not allow three digit year
		if (boolReformat) {
			var dateField = validateDate.arguments[1];
			formatDate(dateField,month,day,year)
		}
		return true;
	}
}
function oldValidateDate(date) {
	//requires date to be in mm/dd/yyyy format
	var strDescrip = ""
	var datePat = /^(\d{1,2})([\/-])(\d{1,2})([\/-])(\d{2,4})$/;
	var matchArray = date.match(datePat);
	if (matchArray == null) {
		return false;
	} else {
		//now validate the values
		var month = matchArray[1];
		var day = matchArray[3];
		var year = parseInt(matchArray[5]);
		//account for 2 digit years. 
		if ((year > 50) && (year <= 99)) year += 1900;
		if ((year >= 0) && (year <= 49)) year += 2000;
		if ((month < 1) || (month > 12)) return false;
		if ((day < 1) || (day > 31)) return false;
		if ((year < 1950) || (year > 3000)) return false;
		if ((month == 4 || month == 6 || month == 9 || month == 11) && (day == 31)) return false;
		if (month == 2) {
			var isLeap = (year % 4 == 0 && (year % 100 !=0 || year % 400 == 0));
			if (day > 29 || (day == 29 && !isLeap)) return false
		}
		return true;
	}
	
}	

function ValidateEmailAddress (emailStr) {
	var emailPat=/^(.+)@(.+)$/
	var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
	var validChars="\[^\\s" + specialChars + "\]"
	var quotedUser="(\"[^\"]*\")"
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
	var atom=validChars + '+'
	var word="(" + atom + "|" + quotedUser + ")"
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")
	var matchArray=emailStr.match(emailPat)
	var strErr = "";
	if (matchArray==null) {
		strErr="Email address seems incorrect (check @ and .'s)";
		return false
	}
	var user=matchArray[1]
	var domain=matchArray[2]
	if (user.match(userPat)==null) {
	    // user is not valid
	    strErr="The user name doesn't seem to be valid.";
	    return false
	}
	var IPArray=domain.match(ipDomainPat)
	if (IPArray!=null) {
	    // this is an IP address
		  for (var i=1;i<=4;i++) {
		    if (IPArray[i]>255) {
		        strErr="Destination IP address is invalid!";
			return false
		    }
	    }
	    return true
	}

	var domainArray=domain.match(domainPat)
	if (domainArray==null) {
		strErr="The domain name doesn't seem to be valid.";
	    return false
	}

	var atomPat=new RegExp(atom,"g")
	var domArr=domain.match(atomPat)
	var len=domArr.length
	if (domArr[domArr.length-1].length<2 || 
	    domArr[domArr.length-1].length>4) {
	   // the address must end in a two letter or three letter word.
	   strErr="The address must end in a three or four letter domain, or two letter country.";
	   return false
	}
	if (len < 2) {
	   strErr="This address is missing a hostname!"
	   return false
	}

	return true;
}