//
// Constants for isCharsInBag
//

var NUMBERS_ONLY = "0123456789";
var ALPHABETS_ONLY = "abcdefghijklmnopqrstuvwxyz";
var ALPHANUMERIC = NUMBERS_ONLY + ALPHABETS_ONLY;
var COMMON_SPECIAL = " ,/-._";
var ALLOW_SPACE=" ";

//
// Other constants - for specific types of fields
//

var PHONE = NUMBERS_ONLY+"()[]+"+COMMON_SPECIAL;
var ADDRESS = ALPHANUMERIC+"&@#()[]!"+COMMON_SPECIAL;
var ZIPCODE = ALPHANUMERIC + COMMON_SPECIAL;
var ALPHA_SPACE = ALPHABETS_ONLY+ALLOW_SPACE;
var URL = ALPHANUMERIC+"/-.";

//
// Check if a field contains only a given set of characters
//

function isCharsInBag (s, bag)	
{  
	// Search through string's characters one by one.

	for (var i = 0; i < s.length; i++)
    	{   
   		// Check that current character isn't whitespace.
        	var c = s.charAt(i);

	        if (bag.indexOf(c) == -1) 
		   return false;
    	}

    	return true;
}

//
//  URL Check 



function isUrl (s, bag)	
{  
	// Search through string's characters one by one.

	for (var i = 0; i < s.length; i++)
    	{   
   		// Check that current character isn't whitespace.
        	var c = s.charAt(i);

	        if (bag.indexOf(c) == -1) 
	        {
	           alert("Invalid URL");
	        
		       return false;
		    }
		   
		   if(!(s.indexOf('.') == -1))
		   {
		      var dotindex = s.indexOf('.');
		      s=s.substring(dotindex,s.length);
		      
		   }
		   else
		   {
		     alert(" Please Check Your URL");
		     return false;
		   }      
		 
    	   	
        }
        return true;
}





//
// Check to see if a field is empty
//

function isEmpty(s)   			
{
	return ((s == null) || (s.length == 0));
}




//
// Check to see if a field is all whitespace
//

function isWhitespace(s)		
{
	var whitespace="\t\n\r";

	var i;   
 	
	// Is s empty?
  
	if (isEmpty(s))	       
    	    return true; 		       

	// Search through string's characters one by one
	// until we find a non-whitespace character.
	// When we do, return false; if we don't, 
	// return true.

       	for (i = 0; i < s.length; i++)
	{					    
          // Check that current character isn't whitespace.
   	  
         var c = s.charAt(i);
	
         if (whitespace.indexOf(c) == -1)
	     return false;
	}				  

        // All characters are whitespace.
         
         return true;
}

//
// Append a string to another
//

function buildStr(s, s1)		
{
   if (s.length > 0) 
       s = " " + s;

    s = s + s1;
    return s;
}

//
// Validate a list box to make sure that a valid option is selected
//

function validateList(field, fieldName)
{
 if (field.selectedIndex == 0)
  {
    alert("Please select the "+fieldName);
    focusSelect();
    return false;
  }
   return true;
}   

//
// Validate a set of radio buttons and make sure that one is always
// selected
//

function validateCheckBox(field, fieldName)
{
   for (var checked in field)
   {
     if (field[checked].checked == true)
     {
       return true;
     }
   }

  alert("Please select one of the options in the "+fieldName+" field");
  //net();
  return;
}


//
// Netscape requires a reload after a validation/alert
//

function net()
{
	if(navigator.appName=="Netscape")
	{
		//document.reload();
	}
}


//Check Date
function checkDate(f) {
	var v_chkstr = "0123456789/" ;
	var v_ok = "yes" ;
	var v_temp ;
	
	if (f.length < 8 || f.length > 10) 
	   return false ;
	for (i=0;i<f.length;i++)
	 {
		v_temp = "" + f.substring(i,i+1) ;
		if (v_chkstr.indexOf(v_temp) == "-1") v_ok = "no" ;
		if (v_ok == "no") break ;
		}
	
	if (v_ok == "no")
	   return false;
	else
	   return true;
}


//
//To check the Email Id is valid
//
function emailCheck(emailStr) 		
{
	var emailPat=/^(.+)@(.+)$/			
	/* Email Pattern*/ 
	
	var specialChars="\\(\\)<>@,;:`~!#$%^*\\\\\\\"\\.\\[\\]"
	/* The string represents the chars aren't allowed in a username or domainname. */
	
	var validChars="\[^\\s" + specialChars + "\]"
	/* 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 atom=validChars + '+'
	/* 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 word="(" + atom + "|" + quotedUser + ")"
	// The following pattern describes the structure of the user
	
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
	/* The following pattern describes the structure of a normal symbolic domain, as opposed 	to ipDomainPat, shown above. */
	
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")


	/*main()*/
	/* 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=emailStr.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("Email Id seems Invalid. Re-Enter")
	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("The email address 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("The email Destination IP address is invalid!")
	return false
	}
	}
	return true
	}

	// Domain is symbolic name
	var domainArray=domain.match(domainPat)
	if (domainArray==null)
	{
	alert("The email address 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, In), 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(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.
	alert("The email address must end in a Four-letter domain, or two letter country.")
	return false
	}
	// Make sure there's a host name preceding the domain.
	if(len<2) 
	{ 
	var errStr="The email address is missing a hostname!"
	alert(errStr)
	return false
	}
	// If we've gotten this far, everything's valid!
	return true;
}