var reInteger = /^[0-9]+$/											// Integer - [0 to 9] matches the preceding characters 1 or more times
var reYear = /^[1-2]?[089]?[0-9][0-9]$/								// Year - beginning with 1 or 2, second digit 0, 8 or 9 and then any two digits
var reDate = /^[0-3]?[0-9]\/[0-3]?[0-9]\/[1-2]?[089]?[0-9][0-9]$/
var dteNow = new Date();
var theYear = dteNow.getFullYear();

function validateDDL(Id, NotSelectedValue, Msg)
{
	if (typeof document.getElementById(Id)!= "undefined" && document.getElementById(Id)!=null && document.getElementById(Id).value == NotSelectedValue)
	{
		if(document.getElementById(Id)!=null)alert(Msg);
		if(document.getElementById(Id)!=null)document.getElementById(Id).focus();
		return false;
	}
	return true;
}



// Loans gadget validation.
function ValidateLoansGadget()
{
	// Loan amount.
	if (!isFieldValidAndFocus(document.getElementById("Amount"), 'Integer', false, 'Loan amount'))
		return false;

	// Term.
	if (!validateDDL("term", "select", "Please select the repayment period"))
		return false;

	// Date of birth.
	if (!isFieldValidAndFocus(document.getElementById("C1DoBDate"), 'Day', false, 'Date of birth (day)'))
		return false;
	if (!isFieldValidAndFocus(document.getElementById("C1DoBMonth"), 'Month', false, 'Date of birth (month)'))
		return false;
	if (!isFieldValidAndFocus(document.getElementById("C1DoBYear"), 'Year', false, 'Date of birth (year)'))
		return false;

	var currentTime = new Date();
	var entDay = document.getElementById("C1DoBDate").value;
	var entMonth = document.getElementById("C1DoBMonth").value;
	var entYear = document.getElementById("C1DoBYear").value;
	if(entYear > currentTime.getFullYear() ||
		(entYear == currentTime.getFullYear() &&
		entMonth >= (currentTime.getMonth() + 1) &&
		entDay > currentTime.getDate()))
	{
		alert("Date of birth cannot be in the future");
		document.getElementById("C1DoBYear").focus();
		document.getElementById("C1DoBYear").select();
		return false;
	}

	// Residential status.
	if (!validateDDL("C9", "", "Please select your residential status"))
		return false;

	// Search type.
	if (document.getElementById("SmartSearch") && !document.getElementById("SmartSearch").checked && !document.getElementById("QuickSearch").checked)
	{
		alert("Please select the type of search your require");
		return false;
	}

	// All fields valid.
	return true;
}

function isIntegerInRange(s, a, b) {
	if (!reInteger.test(s)) return false;
		if ((s.length == 2) && (s.substring(0, 1) == '0')) {
			s = s.substring(1);
		}
	var num = parseInt (s);
	return ((num >= a) && (num <= b));
}

// isDate checks that the three values strDay, strMonth and strYear will form a valid date.
// If any of these values are preceded by 0 then it is first stripped from the value before
// the test is carried out.
function isDate(strDay, strMonth, strYear) {
	switch(strMonth)
	{
		case 'January':
			strMonth = '1';
			break;
		case 'February':
			strMonth = '2';
			break;
		case 'March':
			strMonth = '3';
			break;			
		case 'April':
			strMonth = '4';
			break;			
		case 'May':
			strMonth = '5';
			break;			
		case 'June':
			strMonth = '6';
			break;			
		case 'July':
			strMonth = '7';
			break;			
		case 'August':
			strMonth = '8';
			break;			
		case 'September':
			strMonth = '9';
			break;			
		case 'October':
			strMonth = '10';
			break;			
		case 'November':
			strMonth = '11';
			break;			
		case 'December':
			strMonth = '12';
			break;			
	}
	if (strDay.substring(0, 1) == '0') {
		strDay = strDay.substring(1);
	}
	if (strMonth.substring(0, 1) == '0') {
		strMonth = strMonth.substring(1);
	}
	var CheckDate = strDay;
	var CheckMonth = strMonth;
	var CheckYear = strYear;

	if (((isNaN(CheckDate)) || (isNaN(CheckMonth))) || (isNaN(CheckYear))) {
		return false;
	}
	var mydate = new Date(parseInt(CheckYear), (parseInt(CheckMonth) - 1), parseInt(CheckDate));

	if (mydate.getFullYear() != parseInt(CheckYear)) {
		return false;
	}
	if (mydate.getMonth() != (parseInt(CheckMonth) - 1)) {
		return false;
	}
	if (mydate.getDate() != parseInt(CheckDate)) {
		return false;
	}
	return true;
}


function trim(strInput) {
	var tmpInput = strInput;
	if (tmpInput != "") {
		var ch = tmpInput.substring(0, 1);
		while (ch == " ") { 
		 	tmpInput = tmpInput.substring(1, tmpInput.length);
	 		ch = tmpInput.substring(0, 1);
		}
		ch = tmpInput.substring(tmpInput.length-1, tmpInput.length);
		while (ch == " ") { 
	 		tmpInput = tmpInput.substring(0, tmpInput.length-1);
	 		ch = tmpInput.substring(tmpInput.length-1, tmpInput.length);
		}
	}
	return tmpInput;
}


function isValid(strInput, strType)
{
	if ((validated == 'Yes') || (firstCheck == 'Yes')) {
		validating = strInput.name;
		firstCheck = 'No' 
	}
	if (validating == strInput.name) {
		if ((strInput.value == null) || (strInput.value.length == 0)) {
			if (strInput.id == 'emptyOK') {
				findElement(strInput.name);
				validated = 'Yes';
				return true;
			}
			else {
					validated = 'No';
					alert("This box cannot be left blank.");
					strInput.form.elements[strInput.name].focus();
					strInput.form.elements[strInput.name].select();
					return false;
			}
		}
		else
		{
    		switch (strType)
			{

				case 'Integer':
					if (reInteger.test(strInput.value) == true) {
						findElement(strInput.name);
						validated = 'Yes';
						return true;
					}
					else {
						validated = 'No';
						alert("The value entered must only contain numeric characters.");
						strInput.form.elements[strInput.name].focus();
						strInput.form.elements[strInput.name].select();
						return false;
					}
					break;
				case 'Day':
					if (isIntegerInRange(strInput.value, 1, 31) == true) {
						findElement(strInput.name);
						validated = 'Yes';
						return true;
					}
					else {
						validated = 'No';
						alert("The value entered must be a valid day of the month.");
						strInput.form.elements[strInput.name].focus();
						strInput.form.elements[strInput.name].select();
						return false;
					}
					break;
				case 'Month':
					if (isIntegerInRange(strInput.value, 1, 12) == true) {
						findElement(strInput.name);
						validated = 'Yes';
						return true;
					}
					else {
						validated = 'No';
						alert("The value entered must be a valid month in the year.");
						strInput.form.elements[strInput.name].focus();
						strInput.form.elements[strInput.name].select();
						return false;
					}
					break;
				case 'Year':
					if (strInput.value.length == 2) {
						if ((strInput.value.substring(0, 1) == '0') || (strInput.value.substring(0, 1) == '1')) {
							strInput.value = '20' + strInput.value;
						}
						else {
							strInput.value = '19' + strInput.value;
						}
					}
					if ((reYear.test(strInput.value) == true) && (strInput.value.length != '3') && (!isIntegerInRange(strInput.value, 1900, parseInt(thisYear) + 5))) {
						var k = 0;
						while ((strInput.name != strInput.form.elements[k].name) && (k < strInput.form.elements.length)) {
							++k;
						}
						if (isDate(strInput.form.elements[k-2].value, strInput.form.elements[k-1].value, strInput.value)) {
							findElement(strInput.name);
							validated = 'Yes';
							return true;
						}
						else {
							validated = 'No';
							alert("Please enter a valid date.");
							strInput.form.elements[k-2].focus();
							strInput.form.elements[k-2].select();
							return false;
						}	
					}
					else {
						validated = 'No';
						alert("Please enter a valid four digit year.");
						strInput.form.elements[strInput.name].focus();
						strInput.form.elements[strInput.name].select();
						return false;
					}
					break;				
				case 'NoTypeCheck':
					validated = 'Yes';
					return true;
					break;
			}
		}
	}
}	

// initialise should be run in the 'body onLoad' event to set the values of the elementOK array
// to 'No' unless the elements already contain some text. 
function initialise() {
	elementOK = new Array();
	for (n = 0 ; n < document.forms[0].elements.length ; ++n) {
		if (document.forms[0].elements[n].value == "") {
			elementOK[n] = 'No';
		}
		else {
			elementOK[n] = 'Yes';
		}
	}
validated = 'No';
firstCheck = 'Yes';
}

// findElement finds the relevant element on the form and sets the value of elementOK to 'Yes'
// once the element has been validated through the onBlur event.
function findElement(strElement) {
var i = 0
	while ((strElement != document.forms[0].elements[i].name) && (i < document.forms[0].elements.length)) {
	++i;
	}
	elementOK[i] = 'Yes';
}

// submitCheck puts the focus on each element of the form in turn in order to trigger the onBlur event
// and hence validate the element.
function submitCheck() 
{
	document.forms[0].elements[0].focus();
	for (j = 1 ; j < document.forms[0].elements.length - 1 ; ++j) 
	{
		if (document.forms[0].elements[j-1].type == 'text') 
		{
			if((document.forms[0].elements[j-1].id != 'emptyOK') || (document.forms[0].elements[j-1].value.length>0))
			{
				document.forms[0].elements[j].focus();
				if (elementOK[j-1] == 'No') 
				{
					alert("Please enter or correct the selected data on this page.");
					return false;
				}
			}
		}
	}
	return true;
}

function isFieldValid(strInput, strType, blnAllowEmpty, strName, blnDisplayMessage)
{
  blnReturnValue = true;
  strMessage = "";
  
 	if(arguments.length<3)
	{
		allowEmpty = false;
	}

	if(arguments.length<4)
	{
		strName = strInput.name;
	}

	if(arguments.length<5)
  {
    blnDisplayMessage = true;
  }

  //Remove any leading or trailing spaces from the input string
  strInput.value = trim(strInput.value);

  if ((strInput.value == null) || (strInput.value.length == 0))
  {
  	blnReturnValue = blnAllowEmpty;

		if (!blnReturnValue)
    {
			alert(strName + " cannot be left blank.");
			return false;
		}
    else
    {
      return true;
    }
	}

	switch (strType)
	{
	case 'Integer':
				  blnReturnValue = (reInteger.test(strInput.value) == true);
           if (!blnReturnValue)
           {
             strMessage = strName + " must only contain numeric characters.";
           }
 					break;
    case 'Date':
            blnReturnValue = (reDate.test(strInput.value) == true);
            if (!blnReturnValue)
            {
              strMessage = strName + " must be a valid date. (e.g. 31/12/1999)";
  					}
            break;
	case 'Day':
				  blnReturnValue = (isIntegerInRange(strInput.value, 1, 31) == true);
           if (!blnReturnValue)
           {
             strMessage = strName + " must be a valid day of the month.";
 					}
  				break;
	case 'Month':
				  blnReturnValue = (isIntegerInRange(strInput.value, 1, 12) == true);
           if (!blnReturnValue)
           {
             strMessage = strName + " must be a valid month in the year.";
           }
 					break;
	case 'Year':
 					if (strInput.value.length == 2)
           {
					  if ((strInput.value.substring(0, 1) == '0') || (strInput.value.substring(0, 1) == '1'))
             {
						  strInput.value = '20' + strInput.value;
					  }
 						else
             {
  						strInput.value = '19' + strInput.value;
	  				}
				  }
					  if ((reYear.test(strInput.value) == true) && (strInput.value.length != '3') && (isIntegerInRange(strInput.value, 1900, parseInt(theYear) + 5)))
           {
					  var k = 0;
 						while ((strInput.name != strInput.form.elements[k].name) && (k < strInput.form.elements.length)) 
             {
  						++k;
					  }
 						if (isDate(strInput.form.elements[k-2].value, strInput.form.elements[k-1].value, strInput.value)) 
             {
	  					blnReturnValue = true;
				  	}
					  else 
             {
	  					blnReturnValue = false;
			  			strMessage = strName + " must be a valid date.";
 						}	
  				}
	  			else 
           {
					  blnReturnValue = false;
		  			strMessage = strName + " must be a valid four digit year.";
 					}
				break;
	case 'NoTypeCheck':
					blnReturnValue = true;
				break;
	default:
         blnReturnValue = false;
         strMessage = strType + " is not a valid validation type!";        
	}
  
  if (!blnReturnValue && blnDisplayMessage)
  {
    alert(strMessage);
  }
  return blnReturnValue;
}

function isFieldValidAndFocus(strInput, strType, blnAllowEmpty, strName)
{
  if (! strInput)
    return true;  //Return true if object doesn't exist.
    
  blnReturnValue = isFieldValid(strInput, strType, blnAllowEmpty, strName);
  if (!blnReturnValue)
  {
    strInput.select();
    strInput.focus();
  }
  return blnReturnValue;
}