// requires: StringExtensions.js
	// description: generic form validation functions
	//
	function FormValidator()
	{

		// verify and format either 5 or 9 digit zip code
		FormValidator.prototype.formatZip = function(number)
		{
			var formatedZipcode = false;

			var pureNumber = number.parseNumber();

			if(pureNumber.checkLength(5))
			{
				// return a 5 digit zip code
				formatedZipcode = pureNumber;
			}
			else if(pureNumber.checkLength(9))
			{
				// return a hyphanated 9 digits zip code
				formatedZipcode = pureNumber.substr(0,5) + "-" + pureNumber.substr(5,4);
			}

			return formatedZipcode;
		}

		// format credit card number... verification is done by this.isLUHNValidCard
		FormValidator.prototype.formatCreditCard = function(numberString)
		{
			var formatedCreditCard = false;

			var pureNumber = numberString.parseNumber();

			switch(pureNumber.length)
			{
				case 16:
					// format filtered number into xxxx-xxxx-xxxx-xxxx
					formatedCreditCard = pureNumber.substr(0,4) + "-" + pureNumber.substr(4,4) + "-" + pureNumber.substr(8,4) + "-" + pureNumber.substr(12,4);
					break;
				case 15:
					// format filtered number into xxxx-xxxxxx-xxxxx
					formatedCreditCard = pureNumber.substr(0,4) + "-" + pureNumber.substr(4,6) + "-" + pureNumber.substr(10,5);
					break;
				case 14:
					// format filtered number into ?
				case 13:
					// format filtered number into ?
					formatedCreditCard = pureNumber;
					break;
			}

			return formatedCreditCard;
		}

		// verify and format full phone number
		FormValidator.prototype.formatPhone = function(numberString)
		{
			var formatedPhone = false;

			var pureNumber = numberString.parseNumber();

			if(pureNumber.checkLength(10))
			{
				// format filtered number into (xxx)xxx-xxxx
				formatedPhone = "(" + pureNumber.substr(0,3) + ")" + pureNumber.substr(3,3) + "-" + pureNumber.substr(6,4);
			}

			return formatedPhone;
		}

		// verify well formedness of email adress
		FormValidator.prototype.validateEmailAddress = function(emailString)
		{
			var isValidAddress = false;

			var emailFilter=/^.+@.+\..{2,3}$/;			// make sure address is in proper format 
			var illegalChars= /[\(\)\<\>\,\;\:\\\/\"\[\]]/;		// ensure address contains no illegal characters: ()<>[],;:\/
			var illegalLegalCharCombos = /[\.\@][\.\@]/;		// ensure legal characters are properly seperated from one another

			if(emailFilter.test(emailString) && !emailString.match(illegalChars) && !emailString.match(illegalLegalCharCombos))
			{
				isValidAddress = true;
			}

			return isValidAddress;
		}

		/*// check to see if user has entered data into field
		FormValidator.prototype.validateFieldDataExists = function(formField)
		{
			var isFilledOut = false;		// assume a problem or empty field

			switch(this.checkFieldType(formField))
			{
				case FormValidator.SELECT_LIST:
					isFilledOut = this.verifySelectListData(formField);
					break;
				case FormValidator.CHECK_LIST:
					isFilledOut = this.verifyCheckListData(formField);
					break;
				case FormValidator.INPUT_FIELD:
					isFilledOut = this.verifyInputFieldData(formField);
					break;
			}
			return isFilledOut;
		}*/

		// check to see if user has entered data into field
		FormValidator.prototype.validateFieldDataExists = function(formField, errorString)
		{
			var isFilledOut = false;		// assume a problem or empty field

			switch(this.checkFieldType(formField))
			{
				case FormValidator.SELECT_LIST:
					isFilledOut = this.verifySelectListData(formField);
					break;
				case FormValidator.CHECK_LIST:
					isFilledOut = this.verifyCheckListData(formField);
					break;
				case FormValidator.INPUT_FIELD:
					isFilledOut = this.verifyInputFieldData(formField);
					break;
			}
			
			if(!isFilledOut)
			{
				this.throwError(formField, errorString);
				return false;
			}

			return isFilledOut;
		}

		// takes string as argument... NaN!; for details concerning lund algorythm visit: http://www.beachnet.com/~hstiles/cardtype.html
		FormValidator.prototype.isLUHNValidCard = function(numberString)
		{
			var isValid = false;

			var creditCardString = numberString.parseNumber();

			// verify the number is minimum length before processing it
			if(creditCardString.length >= 13)
			{
				var reversedCreditCardString =  creditCardString.reverse();		// reverse the number string (its easier to work from the back of the card number and proceed forward)

				var checkDigit = parseInt(reversedCreditCardString.substr(0,1));	// save check digit; this is to be added into final processed number
				var reversedCardNumberString = reversedCreditCardString.substr(1);	// exclude check digit from the card string we are going to process
				var luhnNumber = 0;							// value container - final number

				for(i=0; i < reversedCardNumberString.length; i++)
				{
					var cardDigit = parseInt(reversedCardNumberString.charAt(i));
					var processedNumber = 0;					// value container

					// process even numbers further
					if(i % 2 == 0)
					{
						var multipliedNumberString = (cardDigit * 2) + "";	// multiply even numbers by 2 and convert result to string
						var processedMultipledNumber = 0;			// value container

						for(j=0; j < multipliedNumberString.length; j++)
						{
							// add the digits of the multipied card number together
							processedMultipledNumber = processedMultipledNumber + parseInt(multipliedNumberString.charAt(j));
						}
						processedNumber = processedMultipledNumber;
					}
					else
					{
						// pass odd numbers thru unchanged
						processedNumber = cardDigit;
					}
					luhnNumber = luhnNumber +  processedNumber;
				}
				if((luhnNumber + checkDigit) % 10 == 0) isValid = true;			// if the end number plus the check digit is evenly divisible by 10 its a valid number
			}
			return isValid
		}

		FormValidator.prototype.checkFieldType = function(formField)
		{
			var fieldType = false;

			if(formField.selectedIndex != null)	// if selectList
				fieldType = FormValidator.SELECT_LIST;
			else if(formField.length != null)	// if checkList
				fieldType = FormValidator.CHECK_LIST;
			else if(formField.value != null)	// if input field
				fieldType = FormValidator.INPUT_FIELD;

			return fieldType
		}

		FormValidator.prototype.verifyCheckListData = function(formField)
		{
			var isChecked = false;

			for (i=0; i<formField.length;i++)
			{
				if (formField[i].checked == true)
				{
					isChecked = true;
					break;
				}
			}

			return isChecked;
		}

		FormValidator.prototype.verifyInputFieldData = function(formField)
		{
			var hasInput = (formField.value != "") ? true : false;
			return hasInput;
		}

		FormValidator.prototype.verifySelectListData = function(formField)
		{
			var isSelected = (formField.selectedIndex != 0) ? true : false;
			return isSelected;
		}

		FormValidator.prototype.throwError = function(formField, errorString)
		{
			var fieldType = this.checkFieldType(formField);

			if(errorString != null) alert(errorString);

			if(fieldType == FormValidator.INPUT_FIELD)
				formField.focus();
			else if(fieldType == FormValidator.SELECT_LIST)
				formField.focus();
			else if(fieldType == FormValidator.CHECK_LIST)
				formField[0].focus();
		}

		//	the following methods should be considered public and are to be used for form validation
		//	use any method above this point at your peril
		//
		FormValidator.prototype.validateField = function(formField, errorString)
		{
			if(!this.validateFieldDataExists(formField))
			{
				this.throwError(formField, errorString);
				return false;
			}
			else if(this.checkFieldType(formField) == FormValidator.INPUT_FIELD)
			{
				// maybe this shouldnt be here... trim spaces from user input and repopulate field
				formField.value = formField.value.trim();
			}
			return true;
		}

		FormValidator.prototype.validateEmailField = function(formField, errorString)
		{
			if(!this.validateEmailAddress(formField.value))
			{
				this.throwError(formField, errorString);
				return false;
			}
			return true;
		}
		
		//
		FormValidator.prototype.validateEmailListField = function(formField, errorString)
		{
			for(i=0; i < formField.length; i++)
			{
				if(!this.validateEmailAddress(formField[i].value))
				{
					this.throwError(formField[i], errorString);
					return false;
				}
			}
			return true;
		}

		FormValidator.prototype.validateZipField = function(formField, errorString)
		{
			var zipcode = this.formatZip(formField.value);

			if(!zipcode)
			{
				this.throwError(formField, errorString);
				return false;
			}
			else
			{
				formField.value = zipcode;
			}
			return true;
		}


		FormValidator.prototype.validateCreditCardField = function(formField, errorString)
		{
			var creditCard = this.formatCreditCard(formField.value);

			if(!creditCard || !this.isLUHNValidCard(creditCard))
			{
				this.throwError(formField, errorString);
				return false;
			}
			else
			{
				formField.value = creditCard;
			}
			return true;
		}

		// used to validate input fields that contain FULL phone numbers: (xxx)xxx-xxxx
		FormValidator.prototype.validatePhoneField = function(formField, errorString)
		{
			var phoneNumber = this.formatPhone(formField.value);

			if(!phoneNumber)
			{
				this.throwError(formField, errorString);
				return false;
			}
			else
			{
				formField.value = phoneNumber;
			}
			return true;
		}

		// tests a form field that should only contain numbers for valid data and ensures that the
		// length of the data is no longer that that specified in numberLength
		// (e.g. to validate a field that should take a 3 digit number as input, one would call:
		// validateNumberFiled(form.filedname, 3 "Please input a 3 digit number");
		//
		FormValidator.prototype.validateNumberField = function(formField, numberLength, errorString)
		{
			var filteredNumber = formField.value.parseNumber();

			if(!filteredNumber.checkLength(numberLength))
			{
				this.throwError(formField, errorString);
				return false;
			}
			else
			{
				formField.value = filteredNumber;
			}
			return true;
		}
		/////my number validation
		FormValidator.prototype.validatemyNumberField = function(formField,  errorString)
		{
			var tempValue=formField.value ;
			var orgLength = tempValue.length ;
			//alert(orgLength);
			var filteredNumber = formField.value.parseNumber();
			
			if(!filteredNumber.checkLength(orgLength) || orgLength==0 )
			{
				this.throwError(formField, errorString);
				return false;
			}
			else
			{	
				//alert(orgLength);
				formField.value = filteredNumber;
			}
			return true;
		}
		// define static variables
		FormValidator.INPUT_FIELD = "input_field";
		FormValidator.CHECK_LIST = "check_list";
		FormValidator.SELECT_LIST = "select_list";
	}