var fieldValidationArray = new Array() ;   // will act like our collection of validation objects
var indexToNameMap = new Array();  // define array to hold names that are the index to fieldValidationArray, to help iterate serially
var rangePair = new Array(); // will contain arrays with two elements whose elemets are field objects
															// the frst element will be the specification and the other is the range

var chkBoxEnabledCount=0;
var chkBoxEnabledMax = 0;
var validationSucessful=true;
var rangeChecksDisabled = false;
/*************************
 *   validation object   *
 *************************/
//Validation object Constructor
function validationObject(fieldName,displayName,optionalFlag,minEntryFlag,dataType,minValue, maxValue, badIndexValue) {
	var valObject = new Object();
	valObject.fieldName	 = 	fieldName		||	"Un-named";  //name that appears in the name attribute of the field
	valObject.displayName = 	displayName ||	"Un-named";  // a descriptive name, for error message displays
	valObject.optionalFlag = optionalFlag 	||	true;		// True indicates the field is optional false=required
	valObject.minEntryFlag = minEntryFlag 	||	false;      // field participates in the "minimum entry" rule
	valObject.dataType = 	dataType 		||	"String";   // type of data, String, Number (only Number is used for data validation)
	if (isEmpty(minValue)) valObject.minValue='none';
	else 	valObject.minValue = 	minValue ;			// minimum llowable value if data type is Number
	valObject.maxValue = 	maxValue 		||	'none';		    // Maximum allowable value if the datatype is number
	valObject.badOptionIndex = badIndexValue || -1;
	valObject.alternateValidation = null;
	valObject.additionalValidation=null;
	valObject.enabled = true;
	valObject.isEnabled = isEnabled;
	return valObject;
}

/***************************************************
 *  Class Methods for the Validation object        *
 ***************************************************/
function isEnabled() {
	if (this.enabled==true) return true;
	else return false;
}



/***************************************************
 *  Helper Methods for the Validation object       *
 ***************************************************/
function enableField(formName,fieldName,enabledFlag) {
	if (isNull(formName) || isNull(fieldName) || isNull(enabledFlag)) return false;
	//alert(formName+" / "+fieldName+" / "+enabledFlag);
	var fldValObject = fieldValidationArray[fieldName];
	var fldObject = document.forms[formName][fieldName];  	// get the field object;
	if (!isNull(fldObject)) {
		switch(enabledFlag) {
			case true:
				fldValObject.enabled = true;
				fldObject.onfocus=null;
				if (isIE) fldObject.style.background="#ffffff";
				break;
			case false:
				fldObject.value=""; // clear the field
				fldValObject.enabled = false;
				fldObject.onfocus=blockKeys;
				if (isIE) fldObject.style.background="#cccccc";
				break;
		}
	}
}
/*******************************************************************************/
function enableRangeChecks()  {rangeChecksDisabled = false; }
function disableRangeChecks() {rangeChecksDisabled = true; }


function addValidationObject(valObject) {
	fieldValidationArray[valObject.fieldName] = valObject;
	indexToNameMap[indexToNameMap.length] = valObject.fieldName;
}
/*******************************************************************************/

function addAdditionalValidation(fldName,validationFunction){
	if (isNull(fldName) || isNull(validationFunction) ) return false;
	var valObject = fieldValidationArray[fldName];
	if (isNull(valObject)) return false;

	valObject.additionalValidation = validationFunction;  	// get the validation object

}
/*******************************************************************************/


function setAlternateValidation(fldName,valFunctionName) {
	if (isNull(fldName) || isNull(validationFunction) ) return false;
	var valObject = fieldValidationArray[fldName];
	if (isNull(fldObject)) return false;

	valObject.alternateValidation = validationFunctionName;  	// get the validation object
}
/*******************************************************************************/

function blockKeys() {
		if (!validationSucessful) return false;

		this.blur();
	if (countryInits.toUpperCase()=="MX") {
		alert('Esta campo es incapacitar\nEs necesario pulsar en la check box por capictar lo.');
	} else {

		
			alert('This field has been disabled\nThe check box must be checked to enable it');
		

	}
		 return false;
}
/*******************************************************************************/

function setAllValidationEvent(theFormName,evntName) {
	var fldName ;
	var fldValObject;  	// get the validation object
	for (var i=0;i<indexToNameMap.length;i++)
	{
		fldName = indexToNameMap[i];
		fldValObject = fieldValidationArray[fldName];  	// get the validation object
		switch(evntName.toLowerCase()) {
			case 'onblur':
				document.forms[theFormName][fldName].onblur=validateField;

				break;
			case 'onchange':
				document.forms[theFormName][fldName].onchange=validateField;
				break;
			case 'onkeypress':
				document.forms[theFormName][fldName].onkeypress=validateField;
				break;
			case 'onkeyup':
				document.forms[theFormName][fldName].onkeyup=validateField;
				break;
			}
	}

}

function validateField() {
/*  Return true if the field is valid */

	if (isNull(this)) return false;  // hmmm, thats strange.
	validationSucessful=false;

	var rtnValue = doValidation(this);
	if (rtnValue==true){ setRangeValue(this);}
	validationSucessful=rtnValue;
	return rtnValue;
}

function doValidation(theField){
	var valObject = fieldValidationArray[theField.name];
	var fldValue;
	var uomValue
	if(!isNull(valObject.alternateValidation)) {
		if (valObject.alternateValidation()==false) return false;
	} else {
		if (theField.type=="checkbox" && !theField.checked) return false;  // ignore checkbox that's not checked '

		if (theField.value!="") {
			fldValue = theField.value;
			if (valObject.dataType=="Number") {
				var uomFld = theField.form[theField.name+'UOM']
				if (!isNull(uomFld)) {
					uomValue = uomFld.options[uomFld.selectedIndex].value
				} else uomValue='';
				var minValue = adjustValue(valObject.minValue,theField.form,theField.name);
				var maxValue = adjustValue(valObject.maxValue,theField.form,theField.name);
				if (isNaN(fldValue)) {
					alert("field: "+valObject.displayName+"\n is only allowed to have numbers.");
					theField.focus();
					return false;
				}
				//Only check the ranges that are numeric
				if (!rangeChecksDisabled) {
					if(isNaN(valObject.minValue) && !isNaN(valObject.maxValue)) {  // only max range
						if (fldValue > maxValue) {
							alert("field: "+valObject.displayName+" \nmust not be larger than "+maxValue+' '+uomValue);
							theField.focus();
							return false;
						}
					} else 	if(!isNaN(valObject.minValue) && isNaN(valObject.maxValue)) {  // only min range
						if (fldValue < minValue) {
							alert("field: "+valObject.displayName+" \nmust not be smaller than "+minValue+' '+uomValue);
							//theField.focus();
							return false;
						}

					} else 	if(!isNaN(valObject.minValue) && !isNaN(valObject.maxValue)) {  // both range values
						if (fldValue < minValue || fldValue > maxValue) {

									
										alert(" "+valObject.displayName+" \nmust be in the range of \n"+minValue+' '+uomValue+" and "+maxValue+' '+uomValue);
									



							//theField.focus();
							return false;
						}

					}
				}
			}
		}
	}

	if (valObject.additionalValidation != null && this.onfocus==null) {
		return valObject.additionalValidation(theField);
	}

	return true;
}

/** validate the fields on the specified form..assuming the fields in the validation array are on this form **/
function validateFields(theFormName)
{
	var fldName ;
	var fldObject

	for (var i=0;i<indexToNameMap.length;i++)
	{
		fldName = indexToNameMap[i];
		fldObject = document.forms[theFormName][fldName];  	// get the field object;
		if (fldObject==null) continue; // bad field.. hmmm
		if(document.forms[theFormName][fldName][0]!=undefined ) {
			var gotOne = false;
			for (var j=0; j < document.forms[theFormName][fldName].length && gotOne==false;j++) {
		 		if (doValidation(document.forms[theFormName][fldName][j])) gotOne=true;
			}
			if (gotOne==false) {
					var fldDspName = fieldValidationArray[fldName].displayName;  	// get the validation object
					alert("field: "+fldDspName+" \nA value for this required field has not bee supplied.");
				return false;
			}
		} else {
		 		if (!doValidation(fldObject)) return false;
		}
	}
	return true;
}


function dumpArray() {  // debugging function..
	var dmp;
	for (var i=0;i<indexToNameMap.length ;i++)
	{
		fldName = indexToNameMap[i];
		fldValObject = fieldValidationArray[fldName];  	// get the validation object
		dmp=dmp+i+"  "+fldName+"-> "+ fldValObject.fieldName+" / "+fldValObject.displayName+"\n";
	}
		alert(dmp);
}


/* minimumEntry: verify that the minimum fields have been populated with info */
function validateMinimumEntry(theForm)
{
	var reqFlds="\n";
	var minEntry = false;
	var minEntryCount = 0;
	var fldName ;
	var fldValObject ;  	// get the validation object
	var fldObject;
	var objType;
	var fldValue;

	// dumpArray	(); // debuging: list the items in the validation array.

	for (var i=0;i<indexToNameMap.length && minEntry==false;i++)
	{
		fldName = indexToNameMap[i];
		fldValObject = fieldValidationArray[fldName];  	// get the validation object
		if (fldValObject.minEntryFlag!=true ) continue
		fldObject = theForm[fldName];

		// hmm if the object is undefind..then may be more than one item with that name..get the 0'th element '
		if(isNull(fldObject.name)) fldObject = theForm[fldName][0];
		if (isNull(fldObject.name)) continue;  // still undefined...then skip it
		fldValue="";
		{
			reqFlds+=('\n'+fldValObject.displayName); 			//append name to our string of names, with a leading line break
			minEntryCount++;

			objType = fldObject.type
			switch (objType.toLowerCase()) {
				case 'checkbox':
					if (!isNull(theForm[fldName][0])) { // is it a group of checkboxes
						for (var j=0; j < theForm[fldName].length;j++) {
							if(theForm[fldName][j].checked) {
								fldObject = theForm[fldName][j];
								break; // get out of loop, we found one that's checked '
							}
						}
					}
					if(!isNull(fldObject) && fldObject.checked) fldValue = fldObject.value;

					break;
				case 'password':
				case 'text':
				case 'textarea':
					fldValue = fldObject.value;
					break;
				case 'select-one':
				case 'select-multiple':
					if (fldObject.selectedIndex!=-1) fldValue = fldObject.options[fldObject.selectedIndex];
					break;
			}

			if (trim(fldValue)!="")
			{
				minEntry=true;
			}
		}
	}
	if (minEntryCount!=0  && minEntry==false)
	{
		
			alert ("A value for at least one of the following, is required:\n"+reqFlds);
		
		return false;
	} else return true;


}
//==============  O T H E R    V A L I D A T I O N    F U N C T I O N S  ========================

	function chkSpringMaterial(theForm) {  // check that at least on of the Spring material check boxes has been selected
	//** Check for entry of at least one spring material
		chkCount=0;
		for(var j=0;j<theForm.springMaterial.length;j++) {
			if (theForm.springMaterial[j].checked==true) chkCount++;
		}
		return (chkCount<1?false:true);
	}

	function chkSpringRange(theForm) {  // check to see that at least one of the check box for the spring range has been selected
		chkCount=0;
		for(var j=0;j<theForm.springRange.length;j++) {
			if (theForm.springRange[j].checked==true) chkCount++;
		}
		return (chkCount<1?false:true);
	}


	function isLoadLenValid(theFormName) {
	// check to se if the load lengths have been entered with it's corresponding Load'
		var l1,l2,f1,f2
		var msg="";
		l1 = isEmpty(document[theFormName].L1Len.value);
		l2 = isEmpty(document[theFormName].L2Len.value);
		f1 = isEmpty(document[theFormName].F1Load.value);
		f2 = isEmpty(document[theFormName].F2Load.value);

		if (l1!=f1) {
			msg+="if specifying load/length info\n the Length 1 and Load 1 fields must both be specified.";
		}
		if (l2!=f2) {
			if (!isEmpty(msg)) msg+='\n========================================================\n';
			msg+="if specifying load/length info\n the Length 2 and Load 2 fields must both be specified.";
		}
		if (!isEmpty(msg)) {
			alert(msg);
			return false;
		}
		return true;
	}

/******************************
 * addRangePage: this function will add the two specified field objects to array elements thatwill be assigned
 * to the rangePair array.
 ********************************/
 function addRangePair(formName,specFldName, rangeFldName) {
 var specFldObj;
 var rangeFldObj;
 if (isNull(formName) || isNull(specFldName) || isNull(rangeFldName)) return false
 if (isNull(document.forms[formName])) return false; //form not in document
 specFldObj = document.forms[formName][specFldName];
 rangeFldObj = document.forms[formName][rangeFldName];

 	if (!isNull(specFldObj) && !isNull(rangeFldObj)) {
 		var fldArray = new Array();
 		fldArray[0] = specFldObj;
 		fldArray[1] = rangeFldObj;
	}
 		// ok add this array to the rangePair array
 		rangePair[rangePair.length]=fldArray;
 }


 /***********************************
  * setRangeValue: this function will investigate the spec field and its related range field.
  *  If the specfield is not empty and is numeric, and the range field is empty, then the range field will the
  * set to 10% of the value of the spec field
  *************************************************/
 	function setRangeValue(fldObject) {
	 if (isNull(fldObject)) return false;
 	 var specField;
 	 var rangeField;

 	for (var i = 0; i< rangePair.length;i++) {
 		specField=rangePair[i][0];
 		rangeField = rangePair[i][1];
 		if (specField==fldObject || rangeField==fldObject) {
			if (isEmpty(rangeField.value) && (!isEmpty(specField.value) && isNumeric(specField.value))) {
				rangeField.value = (specField.value * .10);
			}
			if (!isEmpty(rangeField.value) && isEmpty(specField.value)) {
				rangeField.value = '';
			}
		}
 	}
 }

 function setCheckBoxEnabledMax(n)  {
 	if (!isNumeric(n)) return false;
 	 chkBoxEnabledMax = n;
 }

 //enable/disable fields in fieldList if chkBoxField is unchecked/checked
 function chkBoxClick(fldObject,fieldList) {
 if (isNull(fldObject)) return false;
	 if (fldObject.checked) {
			if (chkBoxEnabledMax<(chkBoxEnabledCount+1)){
					fldObject.checked = false;  // uncheck this item
					alert('Only '+chkBoxEnabledMax+' items can be selected');
					return false;
			}
			chkBoxEnabledCount++;
	} else chkBoxEnabledCount--;

	if(chkBoxEnabledCount<0) chkBoxEnabledCount=0;  // we may over decrement..so just set to 0 if we did

	if (!isEmpty(trim(fieldList))) {
		var frmName = fldObject.form.name;
		var fldList = fieldList.split(",");
		for (var i=0;i<fldList.length;i++) {
			enableField(frmName,fldList[i],fldObject.checked);
		}
	}
}

//Initialize the setting of the chkboxEnabledCount to reflect the checked check boxes
function initCheckBoxCount(frmName,chkBoxList,resetFlag) {
	if (isNull(resetFlag)) resetFlag = false;
	if (isNull(frmName) || isNull(chkBoxList)) return false;
	if (isNull(document.forms[frmName])) return false;
	var chkBoxes = chkBoxList.split(',');
	var chkBoxName;
	var chkboxObj;
	for (var i = 0; i<chkBoxes.length;i++) {
		chkBoxName = chkBoxes[i];
		chkboxObj = document.forms[frmName][chkBoxName];
		if (isNull(chkboxObj)) continue;
		if (!resetFlag) {
			if (chkboxObj.checked) {
				chkBoxEnabledCount++;
			}
		}	else {
			chkboxObj.checked=false; //set checked off, if resetting or already unchecked
			chkboxObj.onclick();	 // ok.. go run the function assigned with the onclick event of that checkbox.
		}
	}
}

//if this is a Netscape browser (ver 4) then set the noEntry fields value to "--"'s '

function setNoEntryFields(frmName,fieldList) {
	if (isNull(frmName) || isNull(fieldList)) return false;
	if (isNull(document.forms[frmName])) return false;
	var flds = fieldList.split(',');
	var fldName;
	var fldObj;
	for (var i = 0; i<flds.length;i++) {
		fldName = flds[i];
		fldObj = document.forms[frmName][fldName];
		if (isNull(fldObj)) continue;
		fldObj.onfocus=noEntry;
		fldObj.value='--------------';
	}
}

function adjustValue(inpValue,theForm,theFieldName) {
// adjust the inpValue to the correct UOM based on the existance of a UOM field
	var uomFld = theFieldName + "UOM";
	var rtnValue = inpValue;
	var pi = Math.PI;
	if (!isNull(theForm[uomFld])) {
		var uomValue = theForm[uomFld].options[theForm[uomFld].selectedIndex].value.toLowerCase()
		switch (uomValue) {
			case 'cm':
				rtnValue= Round((inpValue *2.54),3)
				break
			case 'mm':
				rtnValue= Round(inpValue * 25.4,3)
				break
			case 'n':
				rtnValue= Round(inpValue * 4.448,3)
				break
			case 'n/mm':
				rtnValue= Round(inpValue * 0.175133,3)
				break
			case 'n/m':
				rtnValue= Round(inpValue /8.852,3)
				break
			case 'lb/ft':
				rtnValue= Round(inpValue / 12)
				break
			case 'rad':
				rtnValue= Round(inpValue * (pi/180),3)
				break
			case 'rev':
				rtnValue= Math.round(inpValue/360,0)
				break
		}
	}
	return rtnValue;
}

function Round(value,pow) {
	var powOfTen = Math.pow(10,pow);
	var rtnValue= ( Math.round(value*powOfTen)/powOfTen);
	return rtnValue;
}