function isNumeric(val)
{
	return !(isNaN(parseFloat(val)));
}

function makeElementList(arrList)
{
	var strReturn;
	strReturn = "";

	if (arrList.length - 1 == 0)
	{
		//There should be more than one element in a group, but...
		strReturn = getElementDisplayName(arrList[0]);
	}
	else if (arrList.length - 1 == 1)
	{
		//Only two elements in the group.
		strReturn = getElementDisplayName(arrList[0]) + ' or ' + getElementDisplayName(arrList[1]);

	}
	else
	{
		//More than two elements in the group.
		for (var i = 0; i < arrList.length - 1; i++)
		{
			strReturn += getElementDisplayName(arrList[i]) + ', ';
		}
		strReturn += 'or ' + getElementDisplayName(arrList[arrList.length - 1]);
	}

	return strReturn;
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/
function getGroupClass(element, generalGroup)
{
	var classList;
	var groupClass;
	var re = new RegExp("group[\\d]", "gi");
	classList = $(element).className;
//	classList = 'groupNotEmpty group1';
	groupClass = re.exec(classList);
	return groupClass;
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/

function getElementDisplayName(element)
{
	if (element == 'undefined' || !(element))
	{
		return '';
	}

	if ($(element).readAttribute('title') != null)
	{
		return $(element).readAttribute('title');
	}
	else if ($(element).readAttribute('name') != null)
	{
		return $(element).readAttribute('name');
	}
	else if ($(element).readAttribute('id') != null)
	{
		return $(element).readAttribute('id');
	}
	else
	{
		return '';
	}
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/
function serializeNonForm(elements, options)
{
	if (typeof options != 'object') options = { hash: !!options };
	else if (options.hash === undefined) options.hash = true;
	var key, value, submitted = false, submit = options.submit;

	var data = elements.inject({ }, function(result, element)
	{
		if (!element.disabled && element.name)
		{
			key = element.name; value = $(element).getValue();
			if (value != null && (element.type != 'submit' || (!submitted && submit !== false && (!submit || key == submit) && (submitted = true))))
			{
				if (key in result)
				{
					// a key is already present; construct an array of values
					if (!Object.isArray(result[key])) result[key] = [result[key]];
					result[key].push(value);
				}
				else result[key] = value;
			}
		}
		return result;
	});

	//	return options.hash ? data : Hash.toQueryString(data);
	return Hash.toQueryString(data);
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/
function getElementsOfNonForm(form)
{
	return $A($(form).getElementsByTagName('*')).inject([],
		function(elements, child)
		{
			if (Form.Element.Serializers[child.tagName.toLowerCase()])
				elements.push(Element.extend(child));
			return elements;
		}
	);
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/
function radioIsSelected(radioGroupName)
{
	return ( GetRadioVal(radioGroupName) != '' );
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/
function isDate(sDate)
{
	var re = /^\d{1,2}\/\d{1,2}\/\d{4}$/
	if (re.test(sDate))
	{
		var dArr = sDate.split("/");
		var d = new Date(sDate);
		return d.getMonth() + 1 == dArr[0] && d.getDate() == dArr[1] && d.getFullYear() == dArr[2];
	}
	else
	{
		return false;
	}
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function GetRadioVal(radioGroupName)
{
	return $$("input:checked[type='radio'][name='"+radioGroupName+"']").pluck("value");
}
/**------------------------------------------------------------------------------------------------------------------------------------**/

/**------------------------------------------------------------------------------------------------------------------------------------**/

function getRandomString() 
{
	var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
	var string_length = 6;
	var randomstring = '';
	for (var i=0; i<string_length; i++)
	{
		var rnum = Math.floor(Math.random() * chars.length);
		randomstring += chars.substring(rnum,rnum+1);
	}

	return randomstring;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function trim(str)
{
	if (str == null)
		return str;
	else
		return str.replace(/^\s+|\s+$/gi,"");
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function ltrim(str)
{
	if (str == null)
		return str;
	else
		return str.replace(/^\s+/gi,"");
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function rtrim(str)
{
	if(str == null)
		return str;
	else
		return str.replace(/\s+$/gi,"");
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isNotEmpty(val)
{
	if (val != null)
	{
		return (val.length > 0);
	}
	else
	{
		return false;
	}

}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isAtLeastLength(val, minLength)
{
	return (val.length >= minLength);
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isAtLeastValue(val, minValue)
{
	return (val >= minValue);
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isEmail(val)
{
	if(val==''){ return true; }

	var emailRegEx = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
//	var emailRegEx = /^([\w]+)(.[\w]+)*@([\w]+)(.[\w]{2,3}){1,2}$/;
	return emailRegEx.test(val);
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isAuthorFieldUnique(fieldName, val)
{
	var jsonResult = "helllllo";
//	var jsonResult = null;
	var pars = 'fieldName='+fieldName+'&val='+val+'&date='+Date();
	new Ajax.Request(daDomain+'/blimda/AutoForm/IsAuthorFieldUnique.asp', {
		parameters: pars,
		asynchronous: false,
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){alert("Server error.  Try again."); alert(theResponse.responseText);}
	});
	return jsonResult;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isAuthorNameUnique(val1, val2)
{
	var jsonResult = null;
	var pars = 'val1='+val1+'&val2='+val2+'&date='+Date();
	new Ajax.Request(daDomain+'/blimda/AutoForm/IsAuthorNameUnique.asp', {
		parameters: pars,
		asynchronous: false,
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){alert("Server error.  Try again.");}
	});
	return jsonResult;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isEntityFieldUnique(fieldName, val)
{
	var jsonResult = null;
	var pars = 'fieldName='+fieldName+'&val='+val+'&date='+Date();
	new Ajax.Request(daDomain+'/blimda/AutoForm/IsEntityFieldUnique.asp', {
		parameters: pars,
		asynchronous: false,
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){alert("Server error.  Try again.");}
	});
	return jsonResult;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isAuthorFieldUniqueNotSelf(fieldName, val, primKeyVal)
{
	var jsonResult = null;
	var pars = 'fieldName='+fieldName+'&val='+val+'&primKeyVal='+primKeyVal+'&date='+Date();
	new Ajax.Request(daDomain+'/blimda/AutoForm/IsAuthorFieldUniqueNotSelf.asp', {
		parameters: pars,
		asynchronous: false,
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){alert("Server error.  Try again.");}
	});
	return jsonResult;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isAuthorNameUniqueNotSelf(val1, val2, primKeyVal)
{
	var jsonResult = null;
	var pars = 'val1='+val1+'&val2='+val2+'&primKeyVal='+primKeyVal+'&date='+Date();
	new Ajax.Request(daDomain+'/blimda/AutoForm/IsAuthorNameUniqueNotSelf.asp', {
		parameters: pars,
		asynchronous: false,
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){alert("Server error.  Try again.");}
	});
	return jsonResult;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function isEntityFieldUniqueNotSelf(fieldName, val, primKeyVal)
{
	var jsonResult = null;
	var pars = 'fieldName='+fieldName+'&val='+val+'&primKeyVal='+primKeyVal+'&date='+Date();
	new Ajax.Request(daDomain+'/blimda/AutoForm/IsEntityFieldUniqueNotSelf.asp', {
		parameters: pars,
		asynchronous: false,
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){alert("Server error.  Try again.");}
	});
	return jsonResult;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function atLeastChecked(checkGroupName, min)
{
	var numChecked = 0;
	$$('input[name='+checkGroupName+'][type=checkbox]').each(function(aCheckbox)
	{if (aCheckbox.checked){numChecked++;}});

	return (numChecked >= min);
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function handleAParticularForm(formID, actionPage, divID)
{
	var jsonResult = "";
	var serializedParams = Form.serializeElements( $(formID).getElements() );
	var pars = serializedParams;
	new Ajax.Request(daDomain+actionPage, {
		parameters: pars,
		asynchronous: false,
		method: 'get',
		onSuccess: function(theResponse){jsonResult = theResponse.responseText.evalJSON();},
		onFailure: function(theResponse){jsonResult = "{'successfulInsert':false, 'message':'There was an error when processing your form.'}".evalJSON();}
	});
	if(jsonResult.successfulInsert)
	{
		$(divID).update(jsonResult.message)
	}
	else
	{
		$(divID).update(jsonResult.message);
	}
	return false;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function joinFormWrapper(formID)
{
	var formObj = validateAParticularForm(formID);

	if(formObj == null)
	{
		alert('Error:  Check formID');
		return false;
	}

	if(!formObj.isValid)
	{
		displayErrors(formObj);
	}
	else
	{
		alert('congrats.  valid form.');
	}
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function validateAParticularForm(formID)
{
	var myForm;
	var myTruths;
	var shouldContinue = true;
	var serializedParams
	var jsonText;
	var ElGroup;
	var classList;
	var groupClass;

	if ($(formID).tagName.toLowerCase() == 'form')
	{
		myForm = $(formID).getElements();
		myForm = $A(myForm);
	}
	else
	{
		myForm = getElementsOfNonForm(formID);
		myForm = $A(myForm);
	}
	jsonText = "{\"elements\" : [";
	myForm.each(function(formEl, i)
	{
		jsonText += " {\"element\" : \""+$(formEl).readAttribute('name')+"\" , ";

		if ($F(formEl) == null || $F(formEl) == '')
		{
			jsonText += " \"elementValue\"  : \""+"\", ";
		}
		else
		{
			if ($F(formEl).indexOf("\n") > -1 || $F(formEl).indexOf("\r") > -1)
			{
				jsonText += " \"elementValue\"  : \""+$F(formEl).replace(/\n/gi, "\\n").replace(/\r/gi, "\\r")+"\", ";
			}
		}
		if ($(formEl).readAttribute('title') != '' && $(formEl).readAttribute('title') != null)
		{
			jsonText += " \"elementTitle\"  : \""+$(formEl).readAttribute('title')+"\", ";
		}
		else
		{
			jsonText += " \"elementTitle\"  : \""+formEl.name+"\", ";
		}

		jsonText += " \"errors\"  : [";

		if ($(formEl).hasClassName('isDate'))
		{
			if (!isDate($F(formEl)))
			{
				jsonText += "\"isDate\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('isNumeric'))
		{
			if (!isNumeric($F(formEl)))
			{
				jsonText += "\"isNumeric\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('entitynameUnique'))
		{
			if (!isEntityFieldUnique("entityname", $F(formEl)).isUnique)
			{
				jsonText += "\"entitynameUnique\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('authoremailUnique'))
		{
			if (!isAuthorFieldUnique("authoremail", $F(formEl)).isUnique)
			{
				jsonText += "\"authoremailUnique\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('usernameUnique'))
		{
			if (!isAuthorFieldUnique("username", $F(formEl)).isUnique)
			{
				jsonText += "\"usernameUnique\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('isNotEmpty'))
		{
			if ($(formEl).type == 'radio')
			{
				if ( !radioIsSelected($(formEl).readAttribute('name')) )
				{
					jsonText += "\"isNotEmpty\",";
					shouldContinue = false;
				}
			}
			else
			{
				if ( !isNotEmpty($F(formEl)) )
				{
					jsonText += "\"isNotEmpty\",";
					shouldContinue = false;
				}
			}
		}
		if ($(formEl).hasClassName('isEmail'))
		{
			if (!isEmail($F(formEl)))
			{
				jsonText += "\"isEmail\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('atLeastChecked'))
		{
			//$w(formEl.className)
			if (!atLeastChecked(formEl.name, 1))
			{
				jsonText += "\"atLeastChecked\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('isConfirmation'))
		{
			var otherEl = $(formID).select("[name="+formEl.name.replace('confirm', '')+"]")[0];
			if($F(otherEl) != $F(formEl))
			{
				jsonText += "\"isConfirmation\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('groupNotEmpty'))
		{
			var re = new RegExp("group[\\d]", "gi");
			classList = $(formEl).className;
			groupClass = re.exec(classList);

			if ( $(formID).select('groupNotEmpty', '.'+groupClass).find( function(i){return $(i).present();} ) == null ) 
			{
				jsonText += "\"groupNotEmpty\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('emailIsFamiliar'))
		{
			if (isAuthorFieldUnique("authoremail", $F(formEl)).isUnique)
			{
				jsonText += "\"emailIsFamiliar\",";
				shouldContinue = false;
			}
		}
		if ($(formEl).hasClassName('usernameIsFamiliar'))
		{
			if (isAuthorFieldUnique("username", $F(formEl)).isUnique)
			{
				jsonText += "\"usernameIsFamiliar\",";
				shouldContinue = false;
			}
		}


		if (jsonText.charAt(jsonText.length-1) == ",")
		{
			jsonText = jsonText.substring(0, jsonText.length-1);
		}
		jsonText += " ]},";
	});
	if (jsonText.charAt(jsonText.length-1) == ",")
	{
		jsonText = jsonText.substring(0, jsonText.length-1);
	}
	jsonText += "],";
	jsonText += "\"isValid\" : "+shouldContinue+",";
	jsonText += "\"formID\" : \""+formID+"\"";
	jsonText += "}"
	jsonText = jsonText.evalJSON();
//	return false;
	return jsonText;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function displayErrors(formObj)
{
	var errorMessages = new Array();
	errorMessages["entitynameUnique"]	=	"Name already exists.";
	errorMessages["authoremailUnique"]	=	"E-mail already exists.";
	errorMessages["usernameUnique"]		=	"Username already exists.";
	errorMessages["isNotEmpty"]			=	"<field> cannot be empty.";
	errorMessages["isEmail"]			=	"'<val>' is not a valid email address.";
	errorMessages["atLeastChecked"]		=	"Must check at least one.";
	errorMessages["isConfirmation"]		=	"<field> Confirmation mismatch.";
	errorMessages["groupNotEmpty"]		=	"Either <groupmembers> must not be empty.";
	errorMessages["isDate"]				=	"'<val>' is not a recognized date.  Try using the format mm/dd/yyyy";
	errorMessages["isNumeric"]			=	"'<val>' is not a recognized number.";

	var errorMessageFormatted;
	var formEl;
	var groupMembers;
	var groupClass;
	var membersList;
	var formElNameSelector;
	var errorCountNameSelector;

	formObj.elements.each(function(formEl)
	{
		formElNameSelector = $(formObj.formID).select('[name='+formEl.element+'Warning'+']')[0];
		if ($(formEl.element+'Warning') != null || $(formElNameSelector) != null)
		{
//			$(formEl.element+'Warning').update('');
			$(formElNameSelector).update('');
			formEl.errors.each(function(elerror)
			{
				if (elerror == 'groupNotEmpty')
				{
					groupClass = getGroupClass($(formObj.formID).select('[name='+formEl.element+']')[0], 'groupNotEmpty');
					groupMembers = $(formObj.formID).select('.'+groupClass);
					membersList = makeElementList(groupMembers);
				}
				errorMessageFormatted = errorMessages[elerror].replace("<val>", formEl.elementValue);
				errorMessageFormatted = errorMessageFormatted.replace("<field>", formEl.elementTitle);
				errorMessageFormatted = errorMessageFormatted.replace("<groupmembers>", membersList);
//				$(formEl.element+'Warning').insert(errorMessageFormatted + '<br>');
				$(formElNameSelector).insert(errorMessageFormatted + '<br>');
			});
		}
	});

	errorCountNameSelector = $(formObj.formID).select('[name=errorCount]')[0];

	if ($('errorCount') != null || $(errorCountNameSelector) != null)
	{
		if( $('errorCount') )
		{
			$('errorCount').update('There are '+countErroneousElements(formObj)+' errors in your form.');
		}
		else if( $(errorCountNameSelector) )
		{
			$(errorCountNameSelector).update('There are '+countErroneousElements(formObj)+' errors in your form.');
		}
	}
	return false;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function countErrors(formObj)
{
	var errorCount;
	errorCount = 0;

	if (formObj == null)
	{
		errorCount = -1
	}

	formObj.elements.each(function(formEl)
	{
		errorCount += formEl.errors.length
	});

	return errorCount;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/
function countErroneousElements(formObj)
{
	var errorCount;
	errorCount = 0;

	if (formObj == null)
	{
		errorCount = -1
	}

	formObj.elements.each(function(formEl)
	{
		if (formEl.errors.length > 0)
		{
			errorCount += 1
		}
	});

	return errorCount;
}
/**--------------------------------------------------------------------------------------------------------**/

/**--------------------------------------------------------------------------------------------------------**/