// JavaScript Document
// Validate changed Password
function validate_passwords()
{
	var oform = document.change_password
	if (trimAll(oform.txt1.value) == "")
	{
		alert("The New Password field is empty!")
		oform.txt1.focus()
		return false
	}

	if (trimAll(oform.txt2.value) == "")
	{
		alert("The Confirm Password field is empty!")
		oform.txt2.focus()
		return false
	}
	
	if (trimAll(oform.txt1.value) != trimAll(oform.txt1.value))
	{
		alert("The Confirm Password does not match the New Password!")
		oform.txt2.focus()
		return false
	}

	oform.zstr.value = MakeZstr(trimAll(oform.txt1.value))

	// submit the form
	oform.submit()
}

// validate new email address
function validate_new_email()
{
	var oform = document.change_email
	if (trimAll(oform.email.value) == "")
	{
		alert("The Email field is empty!")
		oform.email.focus()
		return false
	}

	// check for a valid email address entered
	if (!emailCheck(trimAll(oform.email.value))) 
	{
		alert("The Email address entered is not recognised!")
		oform.email.focus()
		return false
	}
	// update save flag
	oform.save_state.value = "yes"
	// submit the form
	oform.submit()
}

// Validate a new member
function validate_new_member()
{
	var oform = document.join_form
	if (trimAll(oform.username.value) == "")
	{
		alert("The User Name is empty!")
		oform.username.focus()
		return false
	}

	if (trimAll(oform.firstname.value) == "")
	{
		alert("The First Name is empty!")
		oform.firstname.focus()
		return false
	}
	
	if (trimAll(oform.lastname.value) == "")
	{
		alert("The Last Name is empty!")
		oform.lastname.focus()
		return false
	}
	
	if (trimAll(oform.email.value) == "")
	{
		alert("The Email field is empty!")
		oform.email.focus()
		return false
	}

	// check for a valid email address entered
	if (!emailCheck(trimAll(oform.email.value))) 
	{
		alert("The Email address entered is not recognised!")
		oform.email.focus()
		return false
	} 

	if (trimAll(oform.selHearAboutUs.value) == "-1")
	{
		alert("Please select from the list showing how you heard about A1?")
		oform.selHearAboutUs.focus()
		return false
	}


	if (trimAll(oform.txt2.value) == "")
	{
		alert("The Password field is empty!")
		oform.txt2.focus()
		return false
	}
	
 	var objRegExp = /^([a-zA-Z]{4,12}[0-9]{0,9})$/gi;

    if(objRegExp.test(oform.username.value) == false) 
	{
		alert("The Unique User Name must begin with at least 4 characters and contain no spaces full stops or underscore characters")
		return false
    }

	// convert the field contents
	oform.h_username.value = pCase(oform.username.value)
	oform.h_firstname.value = pCase(oform.firstname.value)
	oform.h_lastname.value = pCase(oform.lastname.value)
	oform.h_txt2.value = trimAll(oform.txt2.value) 
	oform.h_email.value = MakeLowerCase(oform.email.value)
	oform.zstr.value = MakeZstr(trimAll(oform.txt2.value))

	// submit the form
	oform.submit()
}

// converts the string passed in into a Proper Case string
function pCase(s) 
{ return s.replace(/(\w)(\w*)/g,function (strMatch, strFirst, strRest, intMatchPos, strSource) 
	{ return strFirst.toUpperCase() + strRest.toLowerCase(); } );} 

// trims off leading and trailing spaces
function trimAll(strValue) 
{
 var objRegExp = /^(\s*)$/;

    //check for all spaces
    if(objRegExp.test(strValue)) {
       strValue = strValue.replace(objRegExp, '');
       if( strValue.length == 0)
          return strValue;
    }

   //check for leading & trailing spaces
   objRegExp = /^(\s*)([\W\w]*)(\b\s*$)/;
   if(objRegExp.test(strValue)) {
       //remove leading and trailing whitespace characters
       strValue = strValue.replace(objRegExp, '$2');
    }
  return strValue;
}

// convert to field to uppercase 
function MakeUpperCase(strValue)
{
	var re = / /g;
	strValue = strValue.replace(re, "");
	var re = /'/g;
	strValue = strValue.replace(re, "`");
	strValue = strValue.toUpperCase();
  return strValue;
}

function MakeLowerCase(strValue)
{
	var re = / /g;
	strValue = strValue.replace(re, "");
	var re = /'/g;
	strValue = strValue.replace(re, "`");
	strValue = strValue.toLowerCase();
  return strValue;
}

// A JavaScript implementation of the Secure Hash Algorithm 
// Convert a 32-bit number to a hex string with ms-byte first
var hex_chr = "0123456789abcdef";
function hex(num)
{
  var str = "";
  for(var j = 7; j >= 0; j--)
    str += hex_chr.charAt((num >> (j * 4)) & 0x0F);
  return str;
}

// Convert a string to a sequence of 16-word blocks, stored as an array.
// Append padding bits and the length, as described in the SHA1 standard.
function str2blks_SHA1(str)
{
  var nblk = ((str.length + 8) >> 6) + 1;
  var blks = new Array(nblk * 16);
  for(var i = 0; i < nblk * 16; i++) blks[i] = 0;
  for(i = 0; i < str.length; i++)
    blks[i >> 2] |= str.charCodeAt(i) << (24 - (i % 4) * 8);
  blks[i >> 2] |= 0x80 << (24 - (i % 4) * 8);
  blks[nblk * 16 - 1] = str.length * 8;
  return blks;
}

// Add integers, wrapping at 2^32. This uses 16-bit operations internally 
// to work around bugs in some JS interpreters.
function add(x, y)
{
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

// Bitwise rotate a 32-bit number to the left
function rol(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}

// Perform the appropriate triplet combination function for the current iteration
function ft(t, b, c, d)
{
  if(t < 20) return (b & c) | ((~b) & d);
  if(t < 40) return b ^ c ^ d;
  if(t < 60) return (b & c) | (b & d) | (c & d);
  return b ^ c ^ d;
}

// Determine the appropriate additive constant for the current iteration
 function kt(t)
{
  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
         (t < 60) ? -1894007588 : -899497514;
}

// Take a string and return the hex representation of its SHA-1.
function MakeZstr(str)
{
  var x = str2blks_SHA1(str);
  var w = new Array(80);

  var a =  1732584193;
  var b = -271733879;
  var c = -1732584194;
  var d =  271733878;
  var e = -1009589776;

  for(var i = 0; i < x.length; i += 16)
  {
    var olda = a;
    var oldb = b;
    var oldc = c;
    var oldd = d;
    var olde = e;

    for(var j = 0; j < 80; j++)
    {
      if(j < 16) w[j] = x[i + j];
      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
      t = add(add(rol(a, 5), ft(j, b, c, d)), add(add(e, w[j]), kt(j)));
      e = d;
      d = c;
      c = rol(b, 30);
      b = a;
      a = t;
    }

    a = add(a, olda);
    b = add(b, oldb);
    c = add(c, oldc);
    d = add(d, oldd);
    e = add(e, olde);
  }
  return hex(a) + hex(b) + hex(c) + hex(d) + hex(e);
}

// check and validate an email address
function emailCheck (emailStr) 
{
	//var emailStr=ofield.value
	var emailPat=/^(.+)@(.+)$/
	var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
	var validChars="\[^\\s" + specialChars + "\]"
	var quotedUser="(\"[^\"]*\")"
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
	var atom=validChars + '+'
	var word="(" + atom + "|" + quotedUser + ")"
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")
	
	// 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("The Email address seems incorrect (check for @ and .'s problems)")
		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 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 domain name doesn't seem to be valid.")
		return false
	}
	/* 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 three-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
	}
	return true;
}