/* Validates a form called "form", for use with the opt-in and preferences forms. */
function f_validateForm(a_sFormName)
{
   if (typeof(a_sFormName) == "undefined")
   {
      a_sFormName = "form";
   }
   var l_okay = true;

   for (var j=0; j < document.forms[a_sFormName].elements.length; j++)
   {
      var l_element = document.forms[a_sFormName].elements[j];
      f_useHiddenFieldIfCheckbox(l_element);

      var sFieldNameRequired = l_element.name + "_REQUIRED";
      var elRequired = document.forms[a_sFormName].elements[sFieldNameRequired];

      if (elRequired)
      {
         if (elRequired.value == "T" && l_element.value == "")
         {
            alert("You must fill in all the required fields.");
            return;
         }
      }
      //text areas can only be 255 in size
      if(l_element.type == "textarea")
      {
         if (l_element.value.length > 255)
         {
            alert("Please limit your entries to only 255 characters");
            return;
         }
      }
      var sFieldNameDataType = l_element.name + "_DATATYPE";
      var elDataType = document.forms[a_sFormName].elements[sFieldNameDataType];

      if (elDataType)
      {
         if (l_element.value != "")
         {
            if (elDataType.value == "time")
            {
               l_okay = f_isValidTime(l_element.value);
            }
            if (elDataType.value == "date")
            {
               l_okay = f_isValidDate(l_element.value);
            }
            if (elDataType.value == "numeric")
            {
               l_okay = f_isNumeric(l_element.value);
            }
            if (elDataType.value == "email")
            {
               l_okay = f_isValidEmail(l_element.value);
            }
            if (!l_okay)
            {
               l_element.focus();
               return;
            }
         }
      }
   }
	if(a_sFormName=='newsletterform'){
		sendnewsletter();
		return false;//ReWe
	} else if(a_sFormName=='myform_1'){
		sencontact(1);
	} else if(a_sFormName=='myform_2'){
		sencontact(2);
	} else if(a_sFormName=='myform_3'){
		sencontact(3);
	} else if(a_sFormName=='myform_4'){
		sencontact(4);
	} else if(a_sFormName=='myform_5'){
		sencontact(5);
	} else if(a_sFormName=='myform_6'){
		sencontact(6);
	} else if(a_sFormName=='myform_7'){
		sencontact(7);
	} else if(a_sFormName=='myform_8'){
		sencontact(8);
	}
   //document.forms[a_sFormName].submit();
}

function f_initializeForm() {
   // Timezone offset to support send hour
   if (document.forms[0].tzOffset != undefined) {
       var now = new Date();
       var tzOffset = Math.floor(now.getTimezoneOffset() / 60);
       document.forms[0].tzOffset.value = tzOffset;

       var sendHourSelectName = document.forms[0].sendHourFieldName.value;
       var sendHourSelect = document.forms[0][sendHourSelectName];
       var selectedIndex = sendHourSelect.selectedIndex;
       // index 0 is "Select One"
       // index 1 is "Send Immediatly", which means send hour is 0
       // index 2-169 correspond to send hours 1-168
       if (selectedIndex > 1) {
           // The selected index is at a time slot, so it needs to be adjusted from
           // GMT into the browser's timezone.
           selectedIndex -= tzOffset;

           // Wrap around within range of 2-169
           if (selectedIndex <= 1) {
               selectedIndex += 168;
           } else if (selectedIndex > 169) {
               selectedIndex -= 168;
           }

           sendHourSelect.selectedIndex = selectedIndex;
       }

   }
}

/* checkboxes that have SYSTEM_ before their name should have an accompanying hidden
 field, that does not have the SYSTEM_.  This field should be "Yes" if the checkbox
 is checked, and "No" if it is not */
function f_useHiddenFieldIfCheckbox(a_element)
{
   if (a_element.type == "checkbox" && a_element.name.substring(0, 7) == "SYSTEM_")
   {
      var hiddenElement = eval("document.form.elements['" + a_element.name.substring(7) +"']");

      if (a_element.checked)
      {
         hiddenElement.value = "Yes";
      }
      else
      {
         hiddenElement.value = "No";
      }
   }
}

/* The following are common validation routines used by any screens that need to
 * validate user input.
 */
/* Checks if an email address is valid, modified from http://javascript.internet.com/forms/check-email.html
*/
function f_isValidEmail(a_sEmail)
{
   if (a_sEmail != null && a_sEmail != "")
   {
      /* The following pattern is used to check if the entered e-mail address
         fits the user@domain format.  It also is used to separate the username
         from the domain. */
      var emailPat=/^(.+)@(.+)$/;
      /* The following string represents the pattern for matching all special
         characters.  We don't want to allow special characters in the address.
         These characters include ( ) < > @ , ; : \ " . [ ]    */
      var specialCharsUser="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
      var specialCharsDomain="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]\\'";

      /* The following string represents the range of characters allowed in a
         username or domainname.  It really states which chars aren't allowed. */
      var validCharsUser="\[^\\s" + specialCharsUser + "\]";
      var validCharsDomain="\[^\\s" + specialCharsDomain + "\]";
      /* The following pattern applies if the "user" is a quoted string (in
         which case, there are no rules about which characters are allowed
         and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
         is a legal e-mail address. */
      var quotedUser="(\"[^\"]*\")";
      /* The following pattern applies for domains that are IP addresses,
         rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
         e-mail address. NOTE: The square brackets are required. */
      var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
      /* The following string represents an atom (basically a series of
         non-special characters.) */
      var atomUser=validCharsUser + '+';
      var atomDomain=validCharsDomain + '+';
      /* 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 quoted string. */
      var wordUser="(" + atomUser + "|" + quotedUser + ")";
      // The following pattern describes the structure of the user
      var userPat=new RegExp("^" + wordUser + "(\\." + wordUser + ")*$");
      /* The following pattern describes the structure of a normal symbolic
         domain, as opposed to ipDomainPat, shown above. */
      var domainPat=new RegExp("^" + atomDomain + "(\\." + atomDomain +")*$");


      /* Finally, let's start trying to figure out if the supplied address is
         valid. */

      /* Begin with the coarse pattern to simply break up user@domain into
         different pieces that are easy to analyze. */
      var matchArray=a_sEmail.match(emailPat);
      if (matchArray==null)
      {
        /* Too many/few @'s or something; basically, this address doesn't
           even fit the general mould of a valid e-mail address. */
      	alert("The format of the email address you entered is not valid for email addresses.");
      	return false;
      }
      var user=matchArray[1];
      var domain=matchArray[2];

      // See if "user" is valid
      if (user.match(userPat)==null)
      {
          // user is not valid
          alert("Email username doesn't seem to be valid.");
          return false;
      }

      /* if the e-mail address is at an IP address (as opposed to a symbolic
         host name) make sure the IP address is valid. */
      var IPArray=domain.match(ipDomainPat);
      if (IPArray!=null)
      {
          // this is an IP address
      	  for (var i=1;i<=4;i++)
           {
      	    if (IPArray[i]>255)
             {
      	        alert("Email IP address is invalid!");
      		     return false;
      	    }
          }
          return true;
      }

      // Domain is symbolic name
      var domainArray=domain.match(domainPat);
      if (domainArray==null)
      {
      	alert("Email domain name doesn't seem to be valid.");
         return false;
      }

      /* domain name seems valid, but now make sure that it ends in a
         three-letter word (like com, edu, gov) or a two-letter word,
         representing country (uk, nl), and that there's a hostname preceding
         the domain or country. */

      /* Now we need to break up the domain to get a count of how many atoms
         it consists of. */
      var atomPat=new RegExp(atomDomain,"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.
         alert("Email address must end in a three or four letter domain or a two letter country.");
         return false;
      }

      // Make sure there's a host name preceding the domain.
      if (len<2)
      {
         var errStr="Email address is missing a hostname.";
         alert(errStr);
         return false;
      }
   }

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

/**
 * Checks if a time value is valid
 *
 */
function f_isValidTime(a_sTime)
{
   // Checks if time is in HH:MM:SS AM/PM format.
   // The seconds and AM/PM are optional.

//   var timePat = /^(\d{1,2}):(\d{2})(:(\d{2}))?(\s?(AM|am|PM|pm))?$/;
   var timePat = /^(\d{1,2}):(\d{2})(:(\d{2}))?$/;

   var matchArray = a_sTime.match(timePat);
   if (matchArray == null)
   {
      alert("Time is not in a valid format.");
      return(false);
   }
   hour = matchArray[1];
   minute = matchArray[2];
   second = matchArray[4];

   if (second=="")
   {
      second = null;
   }

   if (hour < 0  || hour > 23)
   {
      alert("Hour must be between 1 and 12. (or 0 and 23 for military time)");
      return(false);
   }
   if (minute<0 || minute > 59)
   {
      alert ("Minute must be between 0 and 59.");
      return(false);
   }
   if (second != null && (second < 0 || second > 59))
   {
      alert ("Second must be between 0 and 59.");
      return(false);
   }
   return(true);
}

/**
 * Validates the characters in the text string.  This routine checks for
 * characters that are not allowed.  The intention is to prevent someone from
 * entering scripting code into a text field on a form.
 * Ideally, we would check that the string contained only the allowed
 * characters, but this gets difficult when you consider other character sets.
 *
 * We disallow the following characters: <, >, ", ', %, ;, (, ), &, +
 *
 */
function f_isValidText(a_sText)
{
   invalidChars = "|/<>%;&+\"\'\\";
   for(i = 0; i < a_sText.length; i++)
   {
      if(invalidChars.indexOf(a_sText.charAt(i)) != -1)
      {
         alert("The following characters are not allowed in text strings: | \\ / < > \" % ; & + \'");
         return(false);
      }

		// tt17390 fix to not allow extended ascii characters to be entered			
      if (a_sText.charCodeAt(i) > 128) {
		  alert("High order or extended ASCII characters are not allowed.");
		  return(false);
	  }
   }

   return(true);
}

function mod(div,base) {
	return Math.round(div - (Math.floor(div/base)*base));
}


/**
 * Checks if a value is a number
 *
 */
function f_isNumeric(a_sNumber)
{
   myString = "0123456789";

   for(i = 0; i < a_sNumber.length; i++)
   {
      if(myString.indexOf(a_sNumber.charAt(i)) == -1)
      {
         alert("The number you entered is invalid");
         return(false);
      }
   }
   return(true);
}
// Declaring valid date character, minimum year and maximum year
var dtCh= "/";
var minYear=1900;
var maxYear=2100;

function isInteger(s)
{
   var i;
   for (i = 0; i < s.length; i++){
      // Check that current character is number.
      var c = s.charAt(i);
      if (((c < "0") || (c > "9")))
      {
         return false;
      }
   }
   // All characters are numbers.
   return true;
}

function stripCharsInBag(s, bag)
{
   var i;
   var returnString = "";
   // Search through string's characters one by one.
   // If character is not in bag, append to returnString.
   for (i = 0; i < s.length; i++)
   {
      var c = s.charAt(i);
      if (bag.indexOf(c) == -1)
      {
         returnString += c;
      }
   }
   return returnString;
}

function daysInFebruary (year)
{
	// February has 29 days in any year evenly divisible by four,
    // EXCEPT for centurial years which are not also divisible by 400.
    return (((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28 );
}

function DaysArray(n)
{
	for (var i = 1; i <= n; i++)
	{
		this[i] = 31;

		if (i==4 || i==6 || i==9 || i==11)
		{
		   this[i] = 30;
		}
		if (i==2)
		{
		   this[i] = 29;
		}
   }
   return this
}


function f_isValidDate(dtStr)
{
   if (dtStr.length != 10)
   {
		alert("The date format should be : mm/dd/yyyy");
		return(false);
   }
	var daysInMonth = DaysArray(12);
	var pos1=dtStr.indexOf(dtCh);
	var pos2=dtStr.indexOf(dtCh,pos1+1);
	var strMonth=dtStr.substring(0,pos1);
	var strDay=dtStr.substring(pos1+1,pos2);
	var strYear=dtStr.substring(pos2+1);
	strYr=strYear;

	if (strDay.charAt(0)=="0" && strDay.length>1)
	{
	   strDay = strDay.substring(1);
	}
	if (strMonth.charAt(0)=="0" && strMonth.length>1)
	{
	   strMonth = strMonth.substring(1);
	}
	for (var i = 1; i <= 3; i++)
	{
		if (strYr.charAt(0)=="0" && strYr.length>1)
		{
		   strYr = strYr.substring(1);
		}
	}
	month=parseInt(strMonth);
	day=parseInt(strDay);
	year=parseInt(strYr);
	if (pos1==-1 || pos2==-1)
	{
		alert("The date format should be : mm/dd/yyyy");
		return(false);
	}
	if (strMonth.length<1 || month<1 || month>12)
	{
		alert("Please enter a valid month");
		return(false);
	}
	if (strDay.length<1 || day<1 || day>31 || (month==2 && day>daysInFebruary(year)) || day > daysInMonth[month])
	{
		alert("Please enter a valid day");
		return(false);
	}
	if (strYear.length != 4 || year==0 || year<minYear || year>maxYear)
	{
		alert("Please enter a valid 4 digit year between "+minYear+" and "+maxYear);
		return(false);
	}
	if (dtStr.indexOf(dtCh,pos2+1)!=-1 || isInteger(stripCharsInBag(dtStr, dtCh))==false)
	{
		alert("Please enter a valid date");
		return(false);
	}
   return(true);
}

function f_isValidLength(a_name, a_maxLength) {
    var data = a_name;
    
    if (data.length > a_maxLength) {
        alert("Maximum field length has been exceeded.");
        return false;
    }
    
    return true;
}