var jsDebug;
var dataEntityList;
var dataEntityHashTable;


if (typeof (included_scripts) == 'undefined')
{
        var included_scripts = new Object();
}
included_scripts_import("/signup/DataEntity.js");	// ("ValidationObject.js");
function included_scripts_import(jsFile)
{
        if (included_scripts[jsFile] != null)
                return;
        var scriptElt = document.createElement('script');
        scriptElt.type = 'text/javascript';
        scriptElt.src = jsFile;
        document.getElementsByTagName('head')[0].appendChild(scriptElt);
        included_scripts[jsFile] = jsFile;
}

function debug(level, message)
{
	if (jsDebug == undefined) jsDebug = document.getElementById("jsDebug").value;
	if (jsDebug >= level)
		alert("Debug(" + jsDebug + "/" + level + ")->" + message);
}
//
//	general string functions
//
function trim(stringToTrim) 
{
	return stringToTrim.replace(/^\s+|\s+$/g,"");
}
function ltrim(stringToTrim) 
{
	return stringToTrim.replace(/^\s+/,"");
}
function rtrim(stringToTrim) 
{
	return stringToTrim.replace(/\s+$/,"");
}
function matches_email(myDataEntity)
{
	myvalue = myDataEntity.value;
	if (isEmpty(myvalue))
	{
		myDataEntity.setValidationError("must be populated");
		return false;
	}
	emailvalue = dataEntityHashTable['email'].value;
	
//	if (jsDebug == 0) alert("myvalue:<" + myvalue + "> VS emailvalue:<" + emailvalue + ">");
	if (myvalue == emailvalue)
	{
		return  true;
	}
	else
	{
		myDataEntity.setValidationError("and \"Email Address\" must be equal");
		return false;
	}
}

function isEmpty(string)
{
	newstring = trim(string);
	if (newstring.length == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
function confirmation(query)
{
//	newQuery = stripHtml(query);
	var answer = confirm(query);	//	newQuery);	//	(query);
	return answer;
} 

function resetFormFields()
{
        var resetFormFields = document.getElementById("resetFormFields").value;
        debug(1, "resetFormFields()->resetFormFields:" + resetFormFields);
        if (resetFormFields == undefined )
                return;
        if (resetFormFields == null )
                return;
        if (resetFormFields == 0)
                return;
//	disabledList = document.getElementById("disabled").value;
	if (dataEntityList == undefined)
	{
		loadDataEntityList();
	}
	count = 0;
        for (var i = 0; i < dataEntityList.length; i++)
        {
//
//      fields in order of completion, set first field to have focus
//
		thisDataEntity = dataEntityList[i];
		debug(1, "thisDataEntity.id:<" + thisDataEntity.id + ">");
		if (!thisDataEntity.isHidden())
			count++;
//		saveJsDebug = jsDebug; jsDebug = 2;

		thisDataEntity.reset(count);

//		jsDebug = saveJsDebug;
	
	}
}

function disableAllDisabledFields()
{
	revertAllToOriginalState();
}
function resetForm(form)
{
	debug(1, "resetForm()->calling resetFormFields()");
	resetFormFields();
	document.getElementById('requestStatusSpan').innerHTML = "<b>INFO: </b>Form Reset!";
	document.getElementById('requestStatusSpan').style.color="#000000";
	return true;
}
function setErrorMessage(errorMessage)
{
	return;
	document.getElementById('requestStatusSpan').innerHTML = "<b>ERROR: </b>" + errorMessage;
	document.getElementById('requestStatusSpan').style.color="#FF0000";
}
function setError(errorMessage, formField, errorCount, formFieldPrompt)
{
	if (errorMessage != null && errorMessage != "")
	{
		setErrorMessage(errorMessage);
	}
	if (errorCount == 1)
	{
//--------------------------------------------------------------------------------
		debug(2, "errorCount:<" + errorCount + "> formField:<" + formField.id + ">");
//--------------------------------------------------------------------------------
//		elementToFocus = formField;
//--------------------------------------------------------------------------------
		formField.focus();	
		if (formField.type == "text")
			formField.select();
		formFieldPrompt.style.color = '#FF0000';
	}
	else
	{
		debug(2, "errorCount:<" + errorCount + "> formField:<" + formField.id + ">");
		formFieldPrompt.style.color = '#F62817';
	}
}
function setMessage(message, color)
{
	
	requestStatusSpan = document.getElementById('requestStatusSpan');
	if (requestStatusSpan)
			requestStatusSpan.innerHTML = "<b>" + message + "</b>";

	if (color != null)
		if (requestStatusSpan)
			requestStatusSpan.style.color = color;	//	"#312D83";	//	"#0030BE";
}
function setCaretToStart(element, focusElement)
{
	if (element.createTextRange)
	{
		var range = element.createTextRange();
		range.collapse(true);
		range.select();
	}
	else if (element.setSelectionRange)
	{
		element.focus();
		element.setSelectionRange(0,0);
	}
	debug( 2, "element.id:<" + element.id + "> focusElement:<" + (focusElement == undefined ? 'UNDEFINED' : focusElement.id) + ">");
	if (focusElement != undefined)
	{
		focusElement.focus();
		if (focusElement.type == "text")
			focusElement.select();
	}
}
//--------------------------------------------------------------------------------
//	validation routines...
//--------------------------------------------------------------------------------
function optional_isPassword(myDataEntity)
{
	if (isPopulated(myDataEntity))
		return isPassword(myDataEntity);
	return true;
}
function isPassword(myDataEntity)
{
	value = myDataEntity.value;
	rc = true;
	if (value == null || value == "" || isEmpty(value))
	{
		rc = false;
	}
	newvalue = trim(value);
	if  (newvalue.length < 6)
	{
		rc = false;
	}
	if (rc == false)
	{
		myDataEntity.setValidationError("length must be at least 6:<" + newvalue + ">, length:<" + newvalue.length + ">");
	}
//	alert("isPopulated()->myDataEntity.prompt:<" + myDataEntity.prompt + ">, value:<" + value + ">rc:<" + rc + ">");
	return rc;	
}
function optional_isPopulated(myDataEntity)
{
	return true;	
}
function isPopulated(myDataEntity)
{
	value = myDataEntity.value;
	rc = true;
	if (value == null || value == "")
		rc =  false;
	else if (isEmpty(value))
		rc =  false;
	if (rc == false)
	{
		myDataEntity.setValidationError("must be populated");
	}
//	alert("isPopulated()->myDataEntity.prompt:<" + myDataEntity.prompt + ">, value:<" + value + ">rc:<" + rc + ">");
	return rc;	
}
function isChecked(myDataEntity)
{
	value = myDataEntity.value;
	debug(1, 'isChecked()->value:<' + value + '>');
//	return false;
	rc = true;
	if (value == null || value == "" || value == 'false')
		rc =  false;
	else if (isEmpty(value))
		rc =  false;
	if (rc == false)
	{
		myDataEntity.setValidationError("must be checked");
	}
//	alert("isPopulated()->myDataEntity.prompt:<" + myDataEntity.prompt + ">, value:<" + value + ">rc:<" + rc + ">");
	return rc;	
}

function isURL(myDataEntity) 
{
	var value=myDataEntity.element.value;
	debug(1, "isURL()->value:<" + value + ">");
	if (value == null || value == "" || value == undefined)
	{
		 myDataEntity.setValidationError("must be populated");
		 return false; 
	}
	var reg = /^https?:\/\/[A-Za-z0-9\.-]{3,}\.[A-Za-z]{3}/;
//NG	var reg = /^https?:\/\/[A-Za-z0-9\.-]{3,}\.[A-Za-z]{3}$/;
//	var reg = /^http\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?$;
//	var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;
	if (reg.test(value) == false) 
	{
		myDataEntity.setValidationError("invalid URL specified, must include 'http://'");
		return false; 
	}
	return true;
}
function isPlatform(myDataEntity)
{
	value = myDataEntity.value;
	rc = true;
	if (value == "0")
		rc =  false;
	if (rc == false)
	{
		myDataEntity.setValidationError("must be selected");
	}
	return rc;	
}
function isSelected(myDataEntity)
{
	value = myDataEntity.value;
	debug(1, 'isSelected()->value:<' + value + '>');
	rc = true;
	if (value == "0")
		rc =  false;
	if (rc == false)
	{
		myDataEntity.setValidationError("must be selected");
	}
	return rc;	
}
function optional_isSelected(myDataEntity)
{
	value = myDataEntity.value;
	debug(1, 'isSelected()->value:<' + value + '>');
	rc = true;
	if (value == "0")
		rc =  true;
	if (rc == false)
	{
		myDataEntity.setValidationError("must be selected");
	}
	return rc;	
}
function optional_isPopulated_3(myDataEntity)
{
	if (isPopulated(myDataEntity))
		return isPopulated_3(myDataEntity);
	return true;	
}
function isPopulated_3(myDataEntity)
{
	value = myDataEntity.value;
	rc = true;
	if (value == null || value == "")
		rc = false;
	else if (isEmpty(value))
		rc =  false;
	newvalue = trim(value);
	if (newvalue.length != 3)
		rc = false;
	if (rc == false)
	{
		myDataEntity.setValidationError("must be three characters in length! newvalue:<" + newvalue + ">, length: <" + newvalue.length + ">");
	}
	return rc;	
}
function optional_isNumeric(myDataEntity)
{
	if (isPopulated(myDataEntity))
		return isNumeric(myDataEntity);
	myDataEntity.element.value = "0";
	myDataEntity.value = "0";
	debug(1, "optional_isNumeric()->set value to 0");
	return true;	
}
function isNumeric(myDataEntity)
{
	value = myDataEntity.value;
	debug( 1, "isNumeric(myDataEntity.id:<" + myDataEntity.id + ">, value:<" + value + ">, value.toString.match():<" + value.toString().match(/^[-]?\d*\.?\d*$/) + ">");
	rc = true;
	if (value == null || value == "")
		rc = false;
	if (!value.toString().match(/^[-]?\d*\.?\d*$/)) 
		rc =  false;

	if (rc == false)
	{
		myDataEntity.setValidationError("must be populated!");
	}
	return rc;
}
function optional_isNumeric_GT_ZERO(myDataEntity)
{
	if (isPopulated(myDataEntity))
		return isNumeric_GT_ZERO(myDataEntity);
	myDataEntity.element.value = "0";
	myDataEntity.value = "0";
	debug(1,"optional_isNumeric_GT_ZERO()->set value to 0");
	return true;	
}
function isNumeric_GT_ZERO(myDataEntity)
{
	rc = true;
	if (!isNumeric(myDataEntity))
	{
		myDataEntity.setValidationError( "must be numeric and greater than zero");
		rc =  false;
	}
	value = myDataEntity.value;
	if (value <= 0)
	{
		myDataEntity.setValidationError("must be greater than zero:<" + value + ">");
		rc = false;
	}
	return rc;
}
function optional_isEmail(myDataEntity)
{
	if (isPopulated(myDataEntity))
		return isEmail(myDataEntity);
	return true;	
}
function isEmail(myDataEntity)
{
	value = myDataEntity.value;
	rc = true;
	var reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;
	if(reg.test(value) == false) 
	{
		rc = false;
		myDataEntity.setValidationError("must be valid email address!");
	}
	return rc;
}
function optional_isPhone(myDataEntity)
{
	if (isPopulated(myDataEntity))
		return isPhone(myDataEntity);
	return true;	
}
function isPhone(myDataEntity)
{
	value = myDataEntity.value;
	rc = true;
	if (value == null)
		rc =  false;
//
// strip out acceptable non-numeric characters
//
	var stripped = value.replace(/[\(\)\.\-\+\ ]/g, '');

	if (stripped == null || stripped == "")
		rc = false;

	newDataEntity = myDataEntity;
	newDataEntity.value = stripped;
	rc = isNumeric(newDataEntity);

	if (rc == false)
	{
		myDataEntity.setValidationError("must be a phone number");
	}
	return rc;
}
//
//	this function no longer used, but might be useful later on....
//
function getElementValues(element)
{
	type = element.type;
	value = "";
	id = element.id;

	if (type == "checkbox")
	{
		debug( 1, "getElementValues()->id:<" + id + "> in checkbox processing....");
		var nodeList = document.getElementsByName(element.id);
		for (var loop = 0; loop < nodeList.length; loop++)
		{
			debug( 1, "getElementValues()->id:<" + id + ">nodeList[loop]:<" + nodeList[loop].checked + ">");
			if (nodeList[loop].checked)
			{
				if (value == "")
				{
					value = nodeList[loop].value;
				}
				else
				{
					value += "," + nodeList[loop].value;
				}
			}
		}
	}
	else if (type == "select-multiple")
	{
		debug(1, "getElementValues()->id:<" + id + "> in select-multiple processing....");
		select = element;	
		for (var loop = 0; loop < select.length; loop++)
		{
			if (select[loop].selected)
			{
				if (value == "")
				{
					value = select[loop].value;
				}
				else
				{
					value += "," + select[loop].value;
				}
			}
		}
	}
	else    //      if (type == "text")
	{
		debug(1, "getElementValues()->id:<" + id + "> in OTHER-TYPE processing....");
		value = element.value;
	}
	debug(1, "getElementValues()->id:<" + id + "> value:<" + value + ">");
	return value;
}
function countOccurrencesInString(string, target)
{
	count = 0;
	while (true)
	{
		pos = string.indexOf(target);
		if (pos < 0)
			break;
		count++;
		pos++;
		string = string.substring(pos+1);
	}
	return count;
}
function isATriplet(triplet)
{
	count = countOccurrencesInString(triplet, "|");
	if (count == 2)
		return true;
	else
		return false;
}
function getPromptElementIdFromTriplet(triplet)
{
	tripletArray =  triplet.split("|");
	return tripletArray[2];
}
function getElementIdFromTriplet(triplet)
{
	tripletArray =  triplet.split("|");
	return tripletArray[0];
}
function getElementValidateFunctionFromTriplet(triplet)
{
	tripletArray =  triplet.split("|");
	return tripletArray[1];
}
function replaceLineBreakWithSpace(string)
{
	newstring =  string.replace(/<br>/g," ");
	return newstring.replace(/<BR>/g," ");
}
function removeBold(string)
{
	newstring =  string.replace(/"<b>"/g," ");
	string =  newstring.replace(/"<\/b>"/g," ");
	newstring =  string.replace(/<B>/g," ");
	string =  newstring.replace(/"<\/B>"/g," ");
	
	return string;
}
function stripHtml(string)
{
	newstring = replaceLineBreakWithSpace(string);
	string = removeBold(newstring);
	return string;
}
//
//	validate individual entry
//
function validateThis(obj)
{
	rc = true;
	id = obj.id;
	myDataEntity = dataEntityHashTable[id];
	myDataEntity.value = obj.value;
	debug(2, "validateThis()->id:<" + id + ">, value:<" + obj.value + ">, call validateIt()");
	rc = myDataEntity.validateIt();
	if (rc == false)
	{
		errorText = myDataEntity.getValidationError();
                alert(errorText);
		myDataEntity.setError(1); 
                setErrorMessage("Errors Detected, See Items in Red, above!");
	}
	return rc;
}
function updateThis(obj)
{
	rc = true;
	id = obj.id;
	myDataEntity = dataEntityHashTable[id];
	myDataEntity.value = obj.value;
	return rc;
}
//
// in case back button hit, don't do submit, just go back....
//
function selectButton(chosen, targetId)
{
    debug(1, 'selectButton()->chosen:<' + chosen + '>');
	buttonSelected = document.getElementById('buttonSelected');
    debug(1, 'selectButton()->buttonSelected:<' + buttonSelected + '>');
    debug(1, 'selectButton()->targetId:<' + targetId + '>');
	if (buttonSelected == undefined || buttonSelected == null)
	{
    	debug(1, 'selectButton()->since buttonSelected is null or undefined, create it!');
		buttonSelected = document.createElement('input');
		buttonSelected.setAttribute('type', 'hidden');
		buttonSelected.setAttribute('id', 'buttonSelected');
		buttonSelected.setAttribute('value', chosen);
    	debug(1, 'selectButton()->now append it');
		targetId.appendChild(buttonSelected);
	}
	else
	{
		buttonSelected.value = chosen;
	}
    return true;
}
//
// in case FINISH button hit, redirect new page
//
function selectFinishButton(target)
{
    debug(1, 'selectFinishButton()->target:<' + target + '>');

	window.top.location.href = target;
    return true;
}
function validate(confirmationPrompt)
{
	debug(1, "Function: validate(confirmationPrompt:<" + confirmationPrompt + ">)");

	if (confirmationPrompt == undefined)
		var dontConfirm = true;
/*
 * what if back button hit;
 */
    buttonSelected = document.getElementById('buttonSelected');
    if (buttonSelected != undefined)
	{
		debug(1, 'validate()->buttonSelected:<' + buttonSelected.value + '>');
		if (buttonSelected.value == 'back')
		{

//			submit = document.getElementById('Submit');
//			submit.value = 'Back';
			return true;
			
		}
	}

	debug(1, 'validate()->SO VALIDATE!');
	errorCount = 0;	
	var formFieldsList = document.getElementById("formFieldsList").value;
	var formFieldsArray = formFieldsList.split(",");
	var errorElement;
	var errorMessage = "";
	var separator = "";
	var errorText = "Error List:\n";
	var errorSeparator = "";
	var rc = true;
	if (dataEntityList == undefined)
	{
		debug(1, 'validate()->loadDataEntityList()');
		loadDataEntityList();
	}
	else
	{
		debug(1, 'validate()->reloadDataEntityList()');
		reloadDataEntityValues();
	}
	for (var i = 0;  i < dataEntityList.length; i++)
	{
		myDataEntity = dataEntityList[i];
		rc = myDataEntity.validateIt();

		debug(1,"validate()->myDataEntity:<" + myDataEntity.id + ">, value:<" + myDataEntity.value + ">, result:<" + rc + ">, error:<" + myDataEntity.getValidationError() + ">");
		if (rc == false)
		{
			errorCount++;
			myDataEntity.setError(errorCount);
			errorText += errorSeparator + myDataEntity.getValidationError();
			errorSeparator = "\n";
		}	

		else
		{
			myDataEntity.setValid();
		}

//
// doesn't really belong here. should be encapsulated somewhere else -- DataEntityList object? TBD
//
		if (!myDataEntity.isHidden() && myDataEntity.isCurrentlyEnabled() && myDataEntity.prompt != undefined)
		{
			confirmationPrompt += separator + myDataEntity.prompt + ": " + myDataEntity.value;
			separator = "\n";
		}
	}
	if (errorCount > 0)
	{
		setErrorMessage("Errors Detected, See Items in Red, above!");
		alert(errorText);
		return false;
	}
	setMessage("INFO: Data Validated....", "#312D83");
	confirmationPrompt += "?";
	debug(1, "validate()->confirmationPrompt:<" + confirmationPrompt + ">");
	if (!dontConfirm)
		answer = confirmation(confirmationPrompt);
	else
		answer = true;
	return answer;
}
var active_fgcolor = "blue";
function deactivateSubmit(id)
{
	debug(1, "deactivateSubmit()->id:<" + id + ">");
	element = document.getElementById(id);
	if (element != undefined)
	{
		element.disabled = true;
		element.style.color="grey";
		return true;
	}
	return false;
}
function reactivateSubmit(id)
{
	element = document.getElementById(id);
	debug(1, "reactivateSubmit()->id:<" + id + ">");
	if (element != undefined)
	{
		element.disabled = false;
		element.style.color=active_fgcolor;
		return true;
	}
	return false;
}

function anyDataEntered(form)
{
	debug(3, "anyDataEntered(), form:<" + form.id + ">, elements:<" + form.elements.length + ">");
	populatedCount = 0;
	firstElement = null;
	for (var i = 0; i < form.elements.length; i++)
	{
		element = form.elements[i];
		if (firstElement == null)
			firstElement = element;
		debug(3, "anyDataEntered(), element:<" + element.id + ">, type:<" + element.type + ">, value:<" + element.value + ">");
		if (element.type != "button" && element.type != "submit")
		{
			if (element.value != "")
			{
				debug(3, "anyDataEntered(), element:<" + element.id + ">, type:<" + element.type + ">, value:<" + element.value + "> HAS VALUE!");
				return true;
			}
		}
	}
	alert("No Data Entered -- at least one field MUST be populated!");
	firstDataEntity = dataEntityHashTable[firstElement.id];
	firstDataEntity.setError(1);
	return false;
}