/*
-----------------------------------------------
Validate Script
language=JavaScript1.1
-----------------------------------------------
*/

//	Return a value with leading and trailing white spaces removed
function trim(str)
{
////	var reTrim = /^\s*|\s*$/g;
//	var reTrim = /^\s*(\S[\s\S]*?)\s*$/;
//
////	if (str.length == 0) {
////		return "";
////	}
////	else {
//		str.match(reTrim);
//
//		return RegExp.$1;
////	}

	return str.replace(/^\s*([\S\s]*?)\s*$/, '$1');
}


//	Determine if an entered value is empty or all white spaces
function isBlank(str)
{
	var reEmpty = /^\s*$/;

	return reEmpty.test(str);
}


//Function for determining if form value is a number.
//Note:  The JScript isNaN method is a more elegant way to determine whether
//a value is not a number. However, some older browsers do not support this method.
function isValidNumber(sNumber)
{
	var numberPat = /^\d+$/;

	//	Check to see if the format is ok?
	return sNumber.match(numberPat) != null
}


function isValidZip(sZip)
{
	var zipPat = /^(\d{5})(\-(\d{4}))?$/;

	return sZip.match(zipPat) != null;
}


function isValidCreditCard(sCardNumber)
{
	var cardPat = /^\d{10,19}$/;

	return sCardNumber.match(cardPat) != null;
}


function isValidMoney(sMoney)
{
//	var moneyPat = /^(\$?)(\d(1,3))(((\,?)(\d(3)))?)(((\.)(\d(2)))?)$/;
//	var moneyPat = /^(((\d{1,3})((\,\d{3})?))|(\d{4}))((\.\d{2})?)$/;
//	var moneyPat = /^((\d(1,1))\,(\d{1,3}\,\d{3})|(\d{1,7}))((\.\d{2})?)$/;
	var moneyPat = /^(((\d{1})\,(\d{3}),(\d{3}))|((\d{1,3}\,\d{3})|(\d{1,7})))((\.\d{2})?)$/;

	//	Check to see if the format is ok?
	return sMoney.match(moneyPat) != null;
}


function isValidExpirationDate(sDate) {
	var sMonth, sYear;

	//	Checks for a date in the format MM/YYYY
	if (!(/^(\d{1,2})\/(\d{2,4})$/.test(sDate))) {
		alert("Invalid expiration date format.");

		return false;
	}

	sMonth = RegExp.$1;
	sYear = RegExp.$2;

	var dToday = new Date();
	var iMonth = dToday.getMonth() + 1;
	var iYear = dToday.getFullYear();

	if (sMonth < 1 || sMonth > 12) {
		alert("Invalid value entered for expiration month.");

		return false;
	}

	if (sYear.length == 2) {
		sYear = parseInt(iYear / 100) + sYear;
	}

	if (sYear < iYear || sYear > iYear + 10) {
		alert("Invalid value entered for expiration year.");

		return false;
	}

	if (sYear == iYear) {
		if (sMonth < iMonth) {
			alert("Please enter a future expiration date.");

			return false;
		}
	}

	return true;
}


function isValidDate(sDate)
{
	//	Checks for the following valid date formats:
	//	MM/DD/YY   MM/DD/YYYY   MM-DD-YY   MM-DD-YYYY
	//	Also separates date into month, day, and year variables

	//	Match format string to ensure a valid date format
	var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{2}|\d{4})$/;

	//	To require a 4 digit year entry, we can use this line instead:
	//var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/;

	//	Check to see if the format is ok?
	var matchArray = sDate.match(datePat);

	if (matchArray == null) {
		alert("Date is not in a valid format.")
		return false;
	}

	//	Parse date into variables
	month = matchArray[1];
	day = matchArray[3];
	year = matchArray[4];

	//	Check month range
	if (month < 1 || month > 12) {
		alert("Month must be between 1 and 12.");
		return false;
	}

	//	Check the day range
	if (month==4 || month==6 || month==9 || month==11)
		lastday=30;
	else
		if (month==2)
			lastday=29;
		else
			lastday=31;
	if (day < 1 || day > lastday)
	{
		alert("Day must be between 1 and " + lastday + ".");
		return false;
	}

	//	Check the year range
	if (year <= 99 && year >= 70)
		year = parseInt(year) + 1900;
	else
		if (year < 70 && year >= 0)
			year = parseInt(year, 10) + 2000;
		else
			if (year < 1970 || year >= 2070)
			{
				alert("Year is not in the proper range.");
				return false;
			}

	//	Fine tune the day validation for February
	if (month==2 && day==29 && !(year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))) {
		alert("February 29, " + year + " is not a valid .");
		return false;
	}

	// Date is valid
	return true;
}


function isValidPhone(phoneStr) {
	var phonePat = /^\d{3}-\d{3}-\d{4}/;
	var phonePat2 = /^(999) 999-9999$/;

	var matchArray=phoneStr.match(phonePat);

	if (matchArray==null) {
		return false;
	}

	return true;
}


function isValidEmail(emailStr, bRequired, bInteractive)
{
	if (bRequired == null) {
		bRequired = false;
	}

	if (bInteractive == null) {
		bInteractive = true;
	}

	//	Check for blank entry
	if (isBlank(emailStr)) {
		if (!bRequired) {
			return true;
		}
		else {
			if (bInteractive) {
				alert("Please enter an email address.");
			}

			return false;
		}
	}

	//	This pattern is used to check if the entered e-mail address fits the
	//	user@domain format.  It's also used to separate the username from the domain.
	var emailPat=/^(.+)@(.+)$/;


	//	The following string represents a pattern used to match special characters.
	//	The special characters that are not allowed in an e-mail address are:
	//	< > @ , ; : " . <space> [ ] ( ) \
	var specialChars="<>@,;:\\\"\\.\\s\\[\\]\\(\\)\\\\";


	//	The following string represents the range of characters 
	//	that are not allowed in a username or domain.
	var validChars="\[^" + specialChars + "\]";


	//	The following pattern represents the range of characters allowed as the
	//	first character in a valid username or domain.  It is presently set to
	//	the same as above, but any different constraints would be made here.
	var firstChars=validChars;


	//	The following string represents an atom (basically a series of
	//	non-special characters.)
	var atom="(" + firstChars + validChars + "*" + ")";


	//	The following pattern applies if the username is a quoted string.
	//	A quoted username has no rules about which characters are allowed
	//	and which aren't; anything goes. (eg. "jiminy cricket"@disney.com)
	var quotedUser="(\"[^\"]*\")";


	//	The following string represents one word in the typical username.
	//	For example, in john.doe@somewhere.com, john and doe are words.
	//	Basically, a word is either an atom or a quoted string.
	var word="(" + atom + "|" + quotedUser + ")";


	// The following pattern describes the structure of the full username
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");


	//	The following patter applies for domains that are IP addresses,
	//	rather than symbolic names.  (eg. job@[123.45.67.89] is valid)
	//	NOTE: The square brackets are required.
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;


	//	The following pattern describes the structure of a normal
	//	symbolic domain, as opposed to ipDomainPat, shown above.
	var domainPat=new RegExp("^" + atom + "(\\." + atom + ")*$");


	//	Check for blank entry
	if (bRequired) {
		if (isBlank(emailStr)) {
			if (bInteractive) {
				alert("Please enter a valid email address.");
			}
			return false;
		}
	}


	//	Finally, start trying to figure out if the supplied address is valid.
	//	Begin with the course pattern to simply break up the user@domain
	//	into different pieces that are easy to analyze.
	var matchArray=emailStr.match(emailPat);


	//	Check for the presence of an @ sign.
	if (matchArray==null) {
		if (bInteractive) {
			alert("Email address is invalid.  Check for an '@' sign.");
		}
		return false;
	}


	//	Capture the username and domain sections
	var user=matchArray[1];
	var domain=matchArray[2];


	// See if the username is valid
	if (user.match(userPat)==null) {
		if (bInteractive) {
			alert("Email username is invalid.");
		}
		return false;
	}


	//	Determine if an IP address has been entered 
	//	(as opposed to a symbolic host name).
	var IPArray=domain.match(ipDomainPat);


	//	If an IP address has been entered, make sure it's valid.
	if (IPArray!=null) {
		for (var i=1;i<=4;i++) {
			if (IPArray[i]>255) {
				if (bInteractive) {
					alert("Destination IP address is invalid.");
				}
				return false;
			}
		}
	 
		return true;
	}


	// Domain is symbolic name
	var domainArray=domain.match(domainPat)


	//	Check the domain for invalid characters
	if (domainArray==null) {
		if (bInteractive) {
			alert("Email domain has invalid characters.");
		}
		return false;
	}


	//	So far the domain name seems valid.  Now we need to break up
	//	the domain to get the count of how many atoms it consists of.
	var atomPat=new RegExp(atom,"g");
	var domArr=domain.match(atomPat);
	var len=domArr.length;


	//	Make sure that the domain name consists of more than 1 atom
	if (len < 2) {
		if (bInteractive) {
			alert("Email domain is not in the proper format.");
		}
		return false;
	}


	//	Make sure the domain name ends in an atom between 2 and 4 characters long.
	var tldLen = domArr[len-1].length;
	if (tldLen<2 || tldLen>4) {
		if (bInteractive) {
			alert("Email address must end in a domain of two to four letters.");
		}
		return false;
	}


	//	If a domain name ends in a two-letter country code, the full domain
	//	must include a hostname and category (e.g. host.co.uk or host.pub.nl).
//	if (domArr[domArr.length-1].length==2 && len<3) {
//		if (bInteractive) {
//		   alert("A country code must be preceeded by a hostname and category.");
//		}
//	   return false;
//	}

	
	// If we've gotten this far, everything's valid!
	return true;
}