/* N.B. Wordt ook aangeroepen door de NVPMT (lidaanmeld.php) !! */
/* Changes:  Sandeep V. Tamhankar (stamhankar@hotmail.com)

   1.1.2: Fixed a bug where trailing . in e-mail address was passing
            (the bug is actually in the weak regexp engine of the browser; I
            simplified the regexps to make it work).
   1.1.1: Removed restriction that countries must be preceded by a domain,
            so abc@host.uk is now legal.  However, there's still the
            restriction that an address must end in a two or three letter
            word.
     1.1: Rewrote most of the function to conform more closely to RFC 822.
     1.0: Original

 this script and many more are available free online at
 The JavaScript Source!! http://javascript.internet.com
*/

function trim(str) {                             //strip spaces from beginning and end
	return str.replace(/^\s*|\s*$/g,"");
}

function emailCheck (emailStr) {
	emailStr = trim(emailStr);                     //strip white spaces from beginning and end

var emailPat=/^(.+)@(.+)$/                       //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 specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]" //represents the pattern for matching all special characters.  We don't want to allow special characters in the address. These characters include ( ) < > @ , ; : \ " . [ ]    */
var validChars="\[^\\s" + specialChars + "\]"    //represents the range of characters allowed in a username or domainname.  It really states which chars aren't allowed. */
//var quotedUser="(\"[^\"]*\")"                    //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 ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/   //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 atom=validChars + '+'                        //represents an atom (basically a series of non-special characters.)
//var word="(" + atom + "|" + quotedUser + ")"     //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 + ")"                        //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

var userPat=new RegExp("^" + word + "(\\." + word + ")*$") //the structure of the user
var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")//the structure of a normal symbolic domain, as opposed to ipDomainPat, shown above.

/* 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 address seems incorrect (check @ and .'s)")
    return false
  }

var user=matchArray[1]
var domain=matchArray[2]

// See if "user" is valid
  if (user.match(userPat)==null) {               //if user is not valid
//   alert("The 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) {                           //if this is an IP address
    for (var i=1;i<=4;i++) {
      if (IPArray[i]>255) {
//       alert("Destination IP address is invalid!")
	return false
      }
    }
    return true
  }

//domain is a symbolic name
var domainArray=domain.match(domainPat)
  if (domainArray==null) {
//   alert("The 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(atom,"g")
var domArr=domain.match(atomPat)
var len=domArr.length
  if (domArr[domArr.length-1].length<2 ||
      domArr[domArr.length-1].length>3) {        // if the address does not end in a two letter or three letter word.
//   alert("The address must end in a three-letter domain, or two letter country.")
    return false
  }

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

  return true;                                   //email address is ok
}