/////////////////////////////////////////////////////////////////////////////////

// PasswordTest object constructor function.
function PasswordTester()
{
};

// Test function to valid password values

PasswordTester.prototype.test = function(aValue)
{
	if ( !aValue ) 
	{
		return false;
	}
	
	var lBasePattern = new RegExp(/^([a-z]|[A-Z]|[0-9]){6,20}$/);
	var lNumChkPattern = new RegExp(/^[a-zA-Z0-9]+$/);
	
	lTest = lBasePattern.test(aValue);
	if ( lTest )
	{
		lTest = lNumChkPattern.test(aValue);
	}
	
	return lTest;
};

///////////////////////////////////////////////////////////////////////////////

function FormChecker()
{
};

FormChecker.OtherFunctions = new Array();
FormChecker.required_class = "field_required";
FormChecker.warning_class = "field_warning";
FormChecker.correct_class = "field_correct";
FormChecker.required_attribute = "re";
FormChecker.optional_attribute = "nre";
FormChecker.messagename_attribute = "messagename";
FormChecker.FormErrorMessage = "Please check the following fields: ";
FormChecker.ValuesChanged = false;

FormChecker._setCorrectClass = function(aField)
{
    if (aField == null)
    {
        return;
    }
    else
    {
        CSSClass.add(aField, FormChecker.correct_class);
        CSSClass.remove(aField, FormChecker.required_class);
        CSSClass.remove(aField, FormChecker.warning_class);
    }
}

FormChecker._setWarningClass = function(aField)
{
    if (aField == null)
    {
        return;
    }
    else
    {
        CSSClass.add(aField, FormChecker.warning_class);
        CSSClass.remove(aField, FormChecker.required_class);
        CSSClass.remove(aField, FormChecker.correct_class);
    }
}

FormChecker._setRequiredClass = function(aField)
{
    if (aField == null)
    {
        return;
    }
    else
    {
        CSSClass.add(aField, FormChecker.required_class);
        CSSClass.remove(aField, FormChecker.correct_class);
        CSSClass.remove(aField, FormChecker.warning_class);
    }
}

FormChecker._setNotRequiredClass = function(aField)
{
    if (aField == null)
    {
        return;
    }
    else
    {
        CSSClass.remove(aField, FormChecker.required_class);
        CSSClass.remove(aField, FormChecker.correct_class);
        CSSClass.remove(aField, FormChecker.warning_class);
    }
}

FormChecker._getRegEx = function(aField) 
{
    if (aField == null)
    {
        return null;
    }

    var lAttribute = aField.getAttribute(FormChecker.required_attribute);
    
    if (lAttribute == null) 
    {
        lAttribute = aField.getAttribute(FormChecker.optional_attribute);
   		if (lAttribute == null) 
   		{
   			return null;
   		}
   }
   
   var lAttributeType = typeof(lAttribute);
   lAttributeType = lAttributeType.toUpperCase();
   
   if (lAttributeType == "FUNCTION")
   {
       return lAttribute;
   }
   else if (lAttributeType != "STRING") 
   {
       return null;
   }
   
   return FormChecker.getStandardRegularExpression(lAttribute, aField.length);
};


FormChecker.getStandardRegularExpression = function(expression_name, expected_field_length)
{
    var lExpression = null;
   	 switch (expression_name)
   	 {
   		case "url_label":
   			lExpression = new RegExp(/^[a-z0-9]+$/);
    		break;
   			
   	    case "logonname":
   	        lExpression = new RegExp(/^.{3,}$/);
    		break;
   	    
   		case "password":
   			lExpression = new PasswordTester();
   			break;

  		case "email":
    		lExpression = new RegExp(/^[\w\-\.]+@([a-zA-Z0-9\-]+\.)+[a-zA-Z]{2,6}$/);
    		break;
    		
        case "email_collection":
            lExpression = new RegExp(/^([\w\-\.]+@([a-zA-Z0-9\-]+\.)+[a-zA-Z]{2,6})(\,[ ]*[\w\-\.]+@([a-zA-Z0-9\-]+\.)+[a-zA-Z]{2,6})*$/);
            break;
            
  		case "tel":
    		lExpression = new RegExp(/^1?[\- ]?\(?\d{3}\)?[\- ]?\d{3}[\- ]?\d{4}.*$/);
    		break;
    		
  		case "phone":
  		case "fax":
    		lExpression = new RegExp(/^([\+]?[\d]{1,3}[\-\. ])?([\(]?[\d]{3}[\)]?[\-\. ])?\d{3}[\-\. ]?\d{4}.*$/);
    		break;
    		
  		case "date":
    		lExpression = new RegExp(/^(0?[0-9]|1[0-2])\D(0?[0-9]|1[0-9]|2[0-9]|3[0-1])\D(\d{4})$/);
    		break;

		case "percent":
		    lExpression = new RegExp(/^([0-99]{1,2}|100)$/);
		    break;
		    
  		case "text":
    		lExpression = new RegExp(/^.+$/);
    		break;
    		
    	case "simpletext":
    		lExpression = new RegExp(/^[\w\/\.\,\-\s]+$/);
    		break;
    		
    	case "textarea":
    		lExpression = new RegExp(/^(.|\n)+$/);
    		break;
    		
    	case "textarea_500":
		    lExpression = new RegExp(/^(.|\n){0,500}$/);
		    break;    		
		    
    	case "text_no_space":
    		lExpression = new RegExp(/^[\w]+$/);
            break;
        case "website":
    		lExpression = new RegExp(/^(http:\/\/){0,1}[^/][\-a-zA-Z0-9_/\.\?=]*$/);
            break;
  		case "money":
    		lExpression = new RegExp(/^\d+([\.]\d\d)?$/);
    		break;
    		
    	case "integer":
    		lExpression = new RegExp(/^\d+$/);
    		break;
        case "boolean":
            lExpression = new RegExp(/^(((T|t)rue)|((F|f)alse))$/);
            break;
  		case "select":
    		lExpression = new RegExp(/^.+$/);
    		break;

        case "postalzip":
        case "zipcode":
        
            switch (expected_field_length)
            {
                case 6:
                case 7:
		            lExpression = new RegExp(/^[a-zA-Z]\d[a-zA-Z] ?\d[a-zA-Z]\d$/);
		            break;
		            
		        case 5:
		        case 10:
		            lExpression = new RegExp(/^\d{5}(\-\d{4})?$/);
		            break;
		            
		        default:
		    	    lExpression = new RegExp(/^\d{5}(\-\d{4})?$/);
		    }
		    break;
  	    
  	    default:
            var lBegin = 0; 
            var lEnd = expression_name.length;
            if (expression_name.charAt(0) == "/") lBegin = 1;
            if (expression_name.charAt(expression_name.length - 1) == "/") lEnd = expression_name.length - 1;
            lExpression = new RegExp(expression_name.slice(lBegin, lEnd));
    }
    
    return lExpression;
}



FormChecker.addOtherFunction = function(aFunction)
{
    FormChecker.OtherFunctions[FormChecker.OtherFunctions.length] = aFunction;
}

FormChecker.processOtherFunctions = function(aForm)
{
    for(var lIdx = 0; lIdx < FormChecker.OtherFunctions.length; ++lIdx)
    {
        var lSuccess = FormChecker.OtherFunctions[lIdx](aForm);
        if (!lSuccess)
        {
            return false;
        }
    }
    
    return true;
}

FormChecker.checkForm = function(aForm) 
{
    if (!aForm)
    {
        return false;
    }
	else if (FormChecker._isMacIE())
	{
		return true;
	}

    var lMessage = "";
    var lNoErrors = true;
    var lMessageTracker = [];
	for (i = 0; i < aForm.length; i++) 
	{
	    var lObject = aForm.elements[i];
	    var lStatus = FormChecker.checkField(lObject);
	    lNoErrors = lNoErrors && lStatus;
	    
	    var lMessageName = lObject.getAttribute(FormChecker.messagename_attribute);
	    if (!lMessageName)
	    {
	        lMessageName = lObject.name;
	    }
	    if (!lStatus && lMessageName && !lMessageTracker[lMessageName])
	    {
	        if (lMessage != "")
	        {
	            lMessage = lMessage + ",\n";
	        }
	        
	        lMessage = lMessage + "\t" + lMessageName;
	        
	        lMessageTracker[lMessageName] = true;
	    }
    }
    
    if (!lNoErrors && FormChecker.FormErrorMessage != null && FormChecker.FormErrorMessage != "")
    {
        alert(FormChecker.FormErrorMessage + "\n\n" + lMessage);
    }
    
    if (lNoErrors)
    {
        lNoErrors = FormChecker.processOtherFunctions(aForm);        
    }    

    return lNoErrors;
};



FormChecker._isMacIE = function()
{
	var BV = parseFloat(navigator.appVersion.indexOf("MSIE")>0?navigator.appVersion.split(";")[1].substr(6):navigator.appVersion);
	var BN = navigator.appName;
	var nua = navigator.userAgent;
	var IsMac=(nua.indexOf('Mac')!=-1);
	var IE=(BN.indexOf('Explorer')!=-1);
	return ( IE && IsMac );
};

FormChecker.checkField = function(aField)
{
    if (aField == null)
    {
        return false;
    }
	else if (FormChecker._isMacIE())
	{
		return true;
	}

	// SELECT BOX NEED TO VERIFIED DIFFERENTLY. MUST INSPECT SELECTED OPTIONS DIRECTLY.
		
	var lNodeName = aField.nodeName.toUpperCase();
    
    if ( lNodeName != 'SELECT' && lNodeName != 'INPUT' && lNodeName != 'TEXTAREA' )
    {
		// Only want to process INPUT, TEXTAREA and SELECT
        return true;
    }
	else if ( lNodeName == 'SELECT' )
	{
		var lSuccess = false;
		
//		aField.className = "";
		
		var lRegText = aField.getAttribute(FormChecker.required_attribute);
		if (lRegText)
		{
            var lSelectedIndex = aField.selectedIndex;
            if ( lSelectedIndex < 0 ||  aField.options[lSelectedIndex].value == "" )
			{
				lSuccess = false;
				FormChecker._setWarningClass(aField);
		   	}
			else
			{
				lSuccess = true;
				FormChecker._setCorrectClass(aField);
		   	}
		}
		else
		{
		    lSuccess = true;
		}
		
		return lSuccess;
	}	
	else if ( lNodeName == 'TEXTAREA' )
	{
	}
	else if ( lNodeName == 'INPUT' )
	{
		// We have an INPUT field. Don't check buttons, file uploads, or hidden fields.

		var lInputType = aField.type.toUpperCase();
		if ( lInputType == 'HIDDEN' || lInputType == 'FILE' || lInputType == 'BUTTON' || lInputType == 'SUBMIT'
		 || lInputType == 'RESET' )
		{
			return true;
		}
	}
	else
	{
	}
	
	var lRegExp = FormChecker._getRegEx(aField);
	if (lRegExp == null)
	{
		return true;
	}

	//var lText = aField.value;
	//var temp_value_array = lText.match(/^\s*([^\s]?.*)\s*$/i);// dtc - 1/31/2007 added this to see what was in the array while debugging
	
	aField.value = aField.value.replace(/^\s+/,'').replace(/\s+$/,'')	// trim whitespace
	
	var lStatus = true;
	
	if ( lRegExp.test(aField.value) ) 
	{
		FormChecker._setCorrectClass(aField);
		lStatus = true;
	}
	else if (!aField.getAttribute(FormChecker.optional_attribute)) 
	{
  		FormChecker._setWarningClass(aField);
  		lStatus = false;
	} 
	else if (aField.value == "") 
	{
 		FormChecker._setCorrectClass(aField);
 		lStatus = true;
	}
	else
	{
  		FormChecker._setWarningClass(aField);
  		lStatus = false;
	}
	
	if (aField.confirmationfield)
	{
	    if (aField.value != "")
	    {
	        lStatus = (aField.value == aField.confirmationfield.value);
	        if (lStatus)
	        {
	            FormChecker._setCorrectClass(aField.confirmationfield);
	        }
	        else
	        {
	            FormChecker._setWarningClass(aField.confirmationfield);
	        }
	    }
	}
	
	return lStatus;
};

function FormChecker_FieldCallback()
{
    FormChecker.checkField(this);
}

FormChecker.identifyField = function(aField, aExpression, aRequired, aMessageName)
{
    if (!aField || !aExpression)
    {
        return;
    }
    
    aField.setAttribute(FormChecker.messagename_attribute, aMessageName);
    
    if (aRequired)
    {
        aField.setAttribute(FormChecker.required_attribute, aExpression);
    }
    else
    {
        aField.setAttribute(FormChecker.optional_attribute, aExpression);
    }
}

FormChecker.linkPasswordConfirmation = function(aPasswordField, aConfirmationField)
{
    if (!aPasswordField && !aConfirmationField)
    {
        return;
    }
        
    aPasswordField.confirmationfield = aConfirmationField;  
    aConfirmationField.confirmationfield = aPasswordField;
}

FormChecker.comparepasswords = function(aPasswordField,aConfirmationField)
{
    //DTC ADDED THIS BECAUSE WE NEED TO MAKE SURE THEY ARE EQUAL TO EACH OTHER
    if(aPasswordField.value != aConfirmationField.value) 
    {
           //DTC IF THEY ARE NOT EQUAL WE NEED TO HIGHLIGHT THE FIELD AND PASS AN ERROR MESSAGE BACK TO THE USER
          FormChecker.FormErrorMessage+="\nPasswords do not match\n";
          FormChecker._setWarningClass(aPasswordField);
          FormChecker._setWarningClass(aConfirmationField);
    } 
    else
    {
          FormChecker._setCorrectClass(aPasswordField);
          FormChecker._setCorrectClass(aConfirmationField);
    } 
}

FormChecker_OnChangeCallback = function()
{
    FormChecker.ValuesChanged = true;
}

FormChecker.initializeForm = function(aForm) 
{
    if (aForm == null)
    {
        return;
    }
    
	for (i = 0; i < aForm.length; i++) 
	{
	    var lType = aForm.elements[i].type;
	    if (!lType) 
	    {
	        continue;
	    }
		if ( (lType != "text") && (lType != "password") && (lType != "textarea") && (lType.toString().charAt(0) != "s")) 
		{
		    continue;
		}
		
		var lObject = aForm.elements[i];
		if ( !lObject )
		{
		    continue;
		}
		
		var lRequiredAttribute = lObject.getAttribute(FormChecker.required_attribute);
		var lOptionalAttribute = lObject.getAttribute(FormChecker.optional_attribute);
		if (lRequiredAttribute != null && lRequiredAttribute != '') 
		{
		    FormChecker._setRequiredClass(lObject);
	        lObject.onblur = FormChecker_FieldCallback;
		}
		else if (lOptionalAttribute != null && lOptionalAttribute != '') 
		{
		    FormChecker._setNotRequiredClass(lObject);
	        lObject.onblur = FormChecker_FieldCallback;
		}
		
//		lObject.onchange = FormChecker_OnChangeCallback;
	    
	}
};

///////////////////////////////////////////////////////////////////////////////

// This code is from the book JavaScript: The Definitive Guide, 5th Edition,
// by David Flanagan. Copyright 2006 O'Reilly Media, Inc. (ISBN #0596101996)
// (cref. http://davidflanagan.com/javascript5/)

/**
 * CSSClass.js: utilities for manipulating the CSS class of an HTML element.
 * 
 * This module defines a single global symbol named CSSClass.  This object
 * contains utility functions for working with the class attribute (className
 * property) of HTML elements.  All functions take two arguments: the element
 * e being tested or manipulated and the CSS class c that is to be tested,
 * added, or removed.  If element e is a string, it is taken as an element
 * id and passed to document.getElementById().
 */
var CSSClass = {};  // Create our namespace object

// Return true if element e is a member of the class c; false otherwise
CSSClass.is = function(e, c) {
    if (typeof e == "string") e = document.getElementById(e); // element id

    // Before doing a regexp search, optimize for a couple of common cases.
    var classes = e.className;
    if (!classes) return false;    // Not a member of any classes
    if (classes == c) return true; // Member of just this one class

    // Otherwise, use a regular expression to search for c as a word by itself
    // \b in a regular expression requires a match at a word boundary.
    return e.className.search("\\b" + c + "\\b") != -1;
};

// Add class c to the className of element e if it is not already there.
CSSClass.add = function(e, c) {
    if (typeof e == "string") e = document.getElementById(e); // element id
    if (CSSClass.is(e, c)) return; // If already a member, do nothing
    if (e.className) c = " " + c;  // Whitespace separator, if needed
    e.className += c;              // Append the new class to the end
};

// Remove all occurrences (if any) of class c from the className of element e
CSSClass.remove = function(e, c) {
    if (typeof e == "string") e = document.getElementById(e); // element id
    // Search the className for all occurrences of c and replace with "".
    // \s* matches any number of whitespace characters.
    // "g" makes the regular expression match any number of occurrences
    e.className = e.className.replace(new RegExp("\\b"+ c+"\\b\\s*", "g"), "");
};

///////////////////////////////////////////////////////////////////////////////