/*******************************************************************************
 *
 *	***Support Functions***
 *
 *	isEmpty(value)
 *	checkLength(value, max_acceptable_length)
 *	validateZipInput(value)
 *	validatePartialZipInput(value)
 *	validateAlphaInput(value)
 *	validateEmailInput(value)
 *	adjustParagraphStatus(element, class)
 *	
 *******************************************************************************/

/**
 *	Checks to see if the passed value is empty ('') or NULL.  Returns false if
 *	not empty ('') or NULL.
 *
 *	@param  value value to check
 *	@return boolean
 */ 
function isEmpty(value)
{
	return value.length === 0 || null === value;
}

/**
 *	Checks to see if the length of the passed value is less than the maximum
 *	acceptable length.
 *
 *	@param  value 				  value who's length will be checked 
 *	@param  max_acceptable_length length threshold
 *	@return boolean
 */
function checkLength(value, lenth)
{
	if(value.length > length)
	{
		return false;
	}
	return true;
}

/**
 *	Validate zipcode input.  The regexp makes sure the value is 5 numeric digits.
 *	This is primaritly used on a blur event.
 *
 *	@param  value potential zipcode input
 *	@return boolean
 */ 
function validateZipInput(value)
{
	var regexpZip = /^\d{5}$/;
	return regexpZip.test(value);
}

/**
 *	Validate partial zipcode input.  The regexp makes sure the value is 5 numeric
 *	digits or less.  This is primarily used on keydown or keyup events.
 *
 *	@param  value potential zipcode input
 *	@return boolean
 */ 
function validatePartialZipInput(value)
{
	var regexpZip = /^\d{0,5}$/;
	return regexpZip.test(value);
}

/**
 *	Validate input that must only contain spaces or case insensitive letters.
 *
 *	@param  value potential alphabetic input
 *	@return boolean
 */
function validateAlphaInput(value)
{
	var regexpAlpha = /^(?:[a-z][-.\s]?)*$/i;
	return regexpAlpha.test(value);
}

function validateNumericInput(value)
{
	var regexpNumber = /^[0-9]*$/;
	return regexpNumber.test(value);	
}

/**
 *	Validate input that must be in email format (user@domainname.highlevel)
 *
 *	@param  value potential email input
 *	@return boolean
 */
function validateEmailInput(value)
{
	var regexpEmail = /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,}$/;
	return regexpEmail.test(value);
}

/**
 * Change the status (error, correct) of a paragraph that contains an input element.
 * 
 * @param  element paragraph (<p>) element that contains an input element
 * @param  class   class to change element to
 */
function adjustParagraphStatus(element, newClass)
{	
	var parent = $(element).parent();
	$(parent).removeClass();
	$(parent).addClass(newClass);
}

/**
 * Display message in Firebug debug console.
 * @param message
 * @return
 */
function debug(message)
{
	console.debug(message);
}

/*******************************************************************************
 *
 *	***On-Submit Validation Functions***
 *	
 *	validateRequiredSelectsOnSubmit(elementsAndMessages)
 *	validateRequiredChecksOnSubmit(elementsAndMessages)
 *	validateRequiredTextOnSubmit(elementsAndMessages)
 *	validateRequiredEmailOnSubmit(
 *	checkFormErrorsOnSubmit(formEl)	
 *	
 *******************************************************************************/

/**
 * 	Make sure that required select elements don't contain an empty value or the 
 * 	value they were initiated to
 * 
 * 	@param  elementsAndMessages JSON object that contains select elements to check
 * 								as well as their corresponding empty error class
 * 								and correct class.
 */
function validateRequiredSelectsOnSubmit(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function(){
		var element			= this.element;
		var emptyClass		= this.classes.requiredErrorClass;
		var correctClass	= this.classes.correctClass;
		var initialValue	= this.initialValue;
		var value 			= $(element).val();
		var initial 		= initialValue && initialValue == value;
		if(isEmpty(value) || initial)
		{
			adjustParagraphStatus(element, emptyClass);
		}
		else
		{
			adjustParagraphStatus(element, correctClass);
		}
	});
}

/**
 * 	Check to make sure that required groups of checkboxes have at least one checkbox checked.
 * 	Checky check check.   
 * 
 * 	@param  elementsAndMessages JSON object that contains select elements to check
 * 								as well as their corresponding empty error class
 * 								and correct class.
 */
function validateRequiredChecksOnSubmit(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function(){
		var element 		= this.element;
		var emptyClass 		= this.classes.requiredErrorClass;
		var correctClass	= this.classes.correctClass;
		var checkCount 		= $(element).find(':checked').length;
		if(checkCount <= 0)
		{
			adjustParagraphStatus(element, emptyClass);
		}
		else
		{
			adjustParagraphStatus(element, correctClass);
		}
	});
}

/**
 *	Make sure that required text fields are not empty prior to submit
 *
 *	@param  elementsAndMessages JSON object that contains text elements to check
 * 								as well as their corresponding empty error class
 * 								and correct class.
 */
function validateRequiredTextOnSubmit(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function(){
		var element 			= this.element;
		var emptyClass			= this.classes.requiredErrorClass;
		var correctClass		= this.classes.correctClass;
		var formatClass			= this.classes.formatErrorClass;
		var initialValue		= this.initialValue;
		var value 				= $(element).val();
		var initial 			= initialValue && initialValue == value;
		if(isEmpty(value) || initial)
		{
			adjustParagraphStatus(element, emptyClass);
		}
		//else if(!validateAlphaInput(value))
		//{
		//	adjustParagraphStatus(element, formatClass);	
		//}
		else
		{
			adjustParagraphStatus(element, correctClass);
		}
	});
}

function validateRequiredAlphaOnSubmit(elementsAndMessages)
{
    $(elementsAndMessages.required).each(function(){
		var element 			= this.element;
		var emptyClass			= this.classes.requiredErrorClass;
		var correctClass		= this.classes.correctClass;
		var formatClass			= this.classes.formatErrorClass;
		var initialValue		= this.initialValue;
		var value 				= $(element).val();
		var initial 			= initialValue && initialValue == value;
		if(isEmpty(value) || initial)
		{
			adjustParagraphStatus(element, emptyClass);
		}
		else if(!validateAlphaInput(value))
		{
			adjustParagraphStatus(element, formatClass);	
		}
		else
		{
			adjustParagraphStatus(element, correctClass);
		}
	});
}

function validateRequiredNumericOnSubmit(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function(){
		var element 			= this.element;
		var emptyClass			= this.classes.requiredErrorClass;
		var correctClass		= this.classes.correctClass;
		var formatClass			= this.classes.formatErrorClass;
		var initialValue		= this.initialValue;
		var value 				= $(element).val();
		var initial 			= initialValue && initialValue == value;
		if(isEmpty(value) || initial)
		{
			adjustParagraphStatus(element, emptyClass);	
		}
		else if(!validateNumericInput(value))
		{
			adjustParagraphStatus(element, formatClass);	
		}
		else
		{
			adjustParagraphStatus(element, correctClass);	
		}
	});	
}

/**
 * 	Make sure that required select elements don't contain an empty value or the 
 * 	value they were initiated to
 * 
 * 	@param  elementsAndMessages JSON object that contains select elements to check
 * 								as well as their corresponding empty error class
 * 								and correct class.
 */
function validateRequiredEmailOnSubmit(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function(){
		var element 			= this.element;
		var emptyClass			= this.classes.requiredErrorClass;
		var formatErrorClass	= this.classes.formatErrorClass;
		var value				= $(element).val();
		if(isEmpty(value))
		{
			adjustParagraphStatus(element, emptyClass);
		}
		else if(!validateEmailInput(value))
		{
			adjustParagraphStatus(element, formatErrorClass);
		}
	});
}

/**
 *	Check to see if there are any errors displayed in a form element.
 *	If there are, block submission.
 *
 *	@param  formEl element in which to check for errors
 *	@return boolean
 *
 *	TODO figure out how this is going to work since errors have different classes now.
 */
function checkFormErrorsOnSubmit(formEl)
{
	if($(formEl).find("p[class*='error']").length > 0)
	{
		return false;
	}
	return true;
}

/*******************************************************************************
 *
 *	***Pre-submit Validation Functions***
 *	
 *	validateRequiredSelects(elementsAndMessages)
 *	validateRequiredChecks(elementsAndMessages)
 *	validateEmail(element, statusClasses, required, length, lengthErrorClass);
 *	validateZip(element, statusClasses, required)
 *	validateAlpha(element, statusClasses, required, length)
 *	validateNumeric(element, statusClasses, required, length)
 *	validateOpenText(element, statusClasses, required, length)
 *	
 *******************************************************************************/

/**
 * 	Validate required selects prior to submit.  Make sure that the proper status
 * 	is on them when they are changed.
 * 
 * 	@param  elementsAndMessages JSON object that contains select elements to check
 * 								as well as their corresponding required class
 * 								and correct class.
 */
function validateRequiredSelects(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function(){
		var element			= this.element;
		var requiredClass	= this.classes.requiredClass;
		var requiredError	= this.classes.requiredErrorClass;
		var correctClass	= this.classes.correctClass;
		var initialValue	= this.initialValue;
		$(element)
		.change(function(){
			var value 			= $(element).val();
			var initial 		= initialValue && initialValue == value;
			if(isEmpty(value) || initial)
			{
				adjustParagraphStatus(element, requiredClass);
			}
			else
			{
				adjustParagraphStatus(element, correctClass);
			}
		})
		.blur(function(){
			var value			= $(element).val();
			var initial = initialValue && initialValue == value;
			if(isEmpty(value) || initial)
			{
				adjustParagraphStatus(element, requiredError);
			}
		});
	});
}

/**
 * 	Validate required checkboxes prior to submit.
 * 	
 * 	@param  elementsAndMessages JSON object that contains select elements to check
 * 								as well as their corresponding required class
 * 								and correct class.
 */
function validateRequiredChecks(elementsAndMessages)
{
	$(elementsAndMessages.required).each(function()
	{
		var element 			= this.element;
		var requiredClass 		= this.classes.requiredClass;
		var correctClass		= this.classes.correctClass;
		
		$(element).find(':checkbox').click(function(){
			//count current checks
			var checkCount = $(element).find(':checked').length;
			if(checkCount <= 0)
			{
				adjustParagraphStatus(element, requiredClass);
			}
			else
			{
				adjustParagraphStatus(element, correctClass);
			}
		});
	});
}

/**
 * 	Validate an email input prior to submit.
 * 
 * 	@param element       the input element that contains the potential email value
 *  @param statusClasses JSON object that contains the required class and other
 *  					 error classes
 *  @param required		 boolean showing if this value is required for submission
 *  @param length		 the maximum length that the element's value can be
 */
function validateEmail(element, statusClasses, required, length)
{
	$(element)
		.keyup(function(e){
			var value = $(element).val();
			if(length && !checkLength(value))
			{
				adjustParagraphStatus(element, statusClasses.requiredErrorClass);
			}
			else if(required && isEmpty(value))
			{
				if(e.keyCode == 8)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
			}
			else if(validateEmailInput(value))
			{
				adjustParagraphStatus(element, statusClasses.correctClass);
			}
			else
			{
				adjustParagraphStatus(element, statusClasses.requiredClass);
			}
		})
		.blur(function(){
			var value = $(element).val();
			if(isEmpty(value))
			{
				if(required)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
				else
				{
					adjustParagraphStatus(element, "");
				}
			}
			else
			{
				if(length && !checkLength(length, value))
				{
					adjustParagraphStatus(element, statusClasses.lengthErrorClass);
				}
				else if(validateEmailInput(value))
				{
					adjustParagraphStatus(element, statusClasses.correctClass);
				}
				else if(!validateEmailInput(value))
				{
					adjustParagraphStatus(element, statusClasses.formatErrorClass);
				}
			}
	});
}

/**
 * 	Validate a zipcode input prior to submit
 * 
 * 	@param element       the input element that contains the potential email value
 *  @param statusClasses JSON object that contains the required class and other
 *  					 error classes
 *  @param required		 boolean showing if this value is required for submission
 */
function validateZip(element, statusClasses, required)
{
	$(element)
		.keyup(function(){
			var value = $(element).val();
			if(required && isEmpty(value))
			{
				if(e.keyCode == 8)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
			}
			else if(validateZipInput(value))
			{
				adjustParagraphStatus(element, statusClasses.correctClass);
			}
			else if(validatePartialZipInput(value) && required)
			{
				adjustParagraphStatus(element, statusClasses.requiredClass);
			}
			else if(validatePartialZipInput(value))
			{
				adjustParagraphStatus(element, "");
			}
			else
			{
				adjustParagraphStatus(element, statusClasses.formatErrorClass);
			}
		})
		.blur(function(){
			var value = $(element).val();
			if(isEmpty(value))
			{
				if(required)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
				else
				{
					adjustParagraphStatus(element, "");
				}
			}
			else
			{
				if(validateZipInput(value))
				{
					adjustParagraphStatus(element, statusClasses.correctClass);
				}
				else if(!validateZipInput(value))
				{
					adjustParagraphStatus(element, statusClasses.formatErrorClass);
				}
			}
	});
}

/**
 * 	Validate an alpha input prior to submit
 * 
 * 	@param element       the input element that contains the potential email value
 *  @param statusClasses JSON object that contains the required class and other
 *  					 error classes
 *  @param required		 boolean showing if this value is required for submission
 */
function validateAlpha(element, statusClasses, required, length)
{
	$(element)
		.keyup(function(e){
			var value = $(element).val();
			if(required && isEmpty(value))
			{
				if(e.keyCode == 8)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
			}
			else if(length && !checkLength(length, value))
			{
				adjustParagraphStatus(element, statusClasses.lengthErrorClass);
			}
			else if(!validateAlphaInput(value))
			{
				adjustParagraphStatus(element, statusClasses.formatErrorClass);
			}
			else if(required)
			{
				adjustParagraphStatus(element, statusClasses.requiredClass);
			}
		})
		.blur(function(){
			var value = $(element).val();
			if(isEmpty(value))
			{
				if(required)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
				else
				{
					adjustParagraphStatus(element, "");
				}
			}
			else
			{
				if(length && !checkLength(length, value))
				{
					adjustParagraphStatus(element, statusClasses.lengthErrorClass);
				}
				else if(validateAlphaInput(value))
				{
					adjustParagraphStatus(element, statusClasses.correctClass);
				}
				else if(!validateAlphaInput(value))
				{
					adjustParagraphStatus(element, statusClasses.formatErrorClass);
				}
			}
	});
}

/**
 * 	Validate a numeric input prior to submit
 * 
 * 	@param element       the input element that contains the potential email value
 *  @param statusClasses JSON object that contains the required class and other
 *  					 error classes
 *  @param required		 boolean showing if this value is required for submission
 */
function validateNumeric(element, statusClasses, required, length)
{
	$(element)
		.keyup(function(e){
			var value = $(element).val();
			if(required && isEmpty(value))
			{
				if(e.keyCode == 8)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
			}
			else if(length && !checkLength(length, value))
			{
				adjustParagraphStatus(element, statusClasses.lengthErrorClass);
			}
			else if(!validateNumericInput(value))
			{
				adjustParagraphStatus(element, statusClasses.formatErrorClass);
			}
			else if(required)
			{
				adjustParagraphStatus(element, statusClasses.requiredClass);
			}
		})
		.blur(function(){
			var value = $(element).val();
			if(isEmpty(value))
			{
				if(required)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
				else
				{
					adjustParagraphStatus(element, "");
				}
			}
			else
			{
				if(length && !checkLength(length, value))
				{
					adjustParagraphStatus(element, statusClasses.lengthErrorClass);
				}
				else if(validateNumericInput(value))
				{
					adjustParagraphStatus(element, statusClasses.correctClass);
				}
				else if(!validateNumericInput(value))
				{
					adjustParagraphStatus(element, statusClasses.formatErrorClass);
				}
			}
	});
}

/**
 * 	Validate a open text prior to submit
 * 
 * 	@param element       the input element that contains the potential email value
 *  @param statusClasses JSON object that contains the required class and other
 *  					 error classes
 *  @param required		 boolean showing if this value is required for submission
 */
function validateOpenText(element, statusClasses, required, length)
{
	$(element)
		.keyup(function(e){
			var value = $(element).val();
			if(required && isEmpty(value))
			{
				if(e.keyCode == 8)
				{
					adjustParagraphStatus(element, statusClasses.requiredClass);
				}
			}
			else if(length && !checkLength(length, value))
			{
				adjustParagraphStatus(element, statusClasses.lengthErrorClass);
			}
			else if(required)
			{
				adjustParagraphStatus(element, statusClasses.requiredClass);
			}
		})
		.blur(function(){
			var value = $(element).val();
			if(isEmpty(value))
			{
				if(required)
				{
					adjustParagraphStatus(element, statusClasses.requiredErrorClass);
				}
				else
				{
					adjustParagraphStatus(element, "");
				}
			}
			else
			{
				if(length && !checkLength(length, value))
				{
					adjustParagraphStatus(element, statusClasses.lengthErrorClass);
				}
				else
				{
					adjustParagraphStatus(element, statusClasses.correctClass);
				}
			}
	});
}

(function($){
	$.fn.schoolFundraisingForm = function(options){
		var defaults = {
			nameId:				"name",
			emailId:			"email",
			quantityId:			"quantity",
			statusClasses:		{
									requiredClass:			"required",
									correctClass:			"correct",
									requiredErrorClass:		"required_error",
									formatErrorClass:		"format_error",
									takenErrorClass:		"taken_error",
									lengthErrorClass:		"length_error"
								},
			emailPrefilled:		false	
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			var nameInputEl = $('#' + options.nameId);
			var emailInputEl = $('#' + options.emailId);
			var quantityInputEl = $('#' + options.quantityId);
			
			var requiredTextFields   =  { "required": [
			                                       {"element": nameInputEl, "classes": options.statusClasses}
			                             ]
			};
			
			var requiredEmailFields  =  { "required": [
			                                           	{"element": emailInputEl, "classes": options.statusClasses }
			                                          ]
			};
			validateEmail(emailInputEl, options.statusClasses, true);
			validateAlpha(nameInputEl, options.statusClasses, true);
			validateNumeric(quantityInputEl, options.statusClasses, true);
			
			$(formEl)
				.submit(function(){
					validateRequiredAlphaOnSubmit(requiredTextFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					return checkFormErrorsOnSubmit(formEl);
			});
				
		});
	};	
})(jQuery);
	
(function($){	
	$.fn.schoolSignupForm = function(options){
		var defaults = {
			firstID: 			'firstname',
			lastID: 			'lastname',
			emailID: 			'email',
			phoneID: 			'phone',
			schoolID: 			'school_name',
			ageID: 				'group_age',
			statusClasses:		{
									requiredClass:			"required",
									correctClass:			"correct",
									requiredErrorClass:		"required_error",
									formatErrorClass:		"format_error",
									takenErrorClass:		"taken_error",
									lengthErrorClass:		"length_error"
								},
			emailPrefilled:		false
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			//find input elements
			var firstInputEl     = 	$('#' + options.firstID);
			var lastInputEl      = 	$('#' + options.lastID);
			var emailInputEl     = 	$('#' + options.emailID);
			var phoneInputEl	 =  $('#' + options.phoneID);
			var schoolInputEl	 =  $('#' + options.schoolID);
			var ageInputEl		 =  $('#' + options.ageID);
			
			
			/**
			 * These are required TEXT fields only.  Selects receive special treatment due to the possibility of an initial value.  
			 */
			var requiredTextFields   =  { "required": [
			                                       {"element": firstInputEl, "classes": options.statusClasses},
			                                       {"element":  lastInputEl, "classes": options.statusClasses},
			                                       {"element":schoolInputEl, "classes": options.statusClasses},
			                                       {"element": phoneInputEl, "classes": options.statusClasses}
			                             ]
			};
			
			var requiredEmailFields  =  { "required": [
			                                           	{"element": emailInputEl, "classes": options.statusClasses }
			                                          ]
			};
			
			validateEmail(emailInputEl, options.statusClasses, true);
			validateAlpha(firstInputEl, options.statusClasses, true);
			validateAlpha(lastInputEl, options.statusClasses, true);
			validateOpenText(schoolInputEl,options.statusClasses, true);
			validateOpenText(phoneInputEl,options.statusClasses, true);
			
			/**
			 * Custom code for this form
			 */
			
			if(options.emailPrefilled)
			{
				if(isEmpty($(emailInputEl).val()))
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.requiredErrorClass);
				}
				else if(!validateEmailInput($(emailInputEl).val()))
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.formatErrorClass);
				}
				else
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.correctClass);
				}
				
			}
			//end of custom code
			
			$(formEl)
				.submit(function(){
					validateRequiredTextOnSubmit(requiredTextFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					//all errors are now shown
					return checkFormErrorsOnSubmit(formEl);
				});
		});
	};
})(jQuery);


(function($){
	$.fn.professionalVolunteerForm = function(options){
		var defaults = {
			firstID: 					'tfa_FirstName',	
			lastID: 					'tfa_LastName',
			emailID: 					'tfa_email',
			countryID:					'tfa_Country',
			cityID:						'tfa_City',
			stateID: 					'tfa_State',
			zipID: 						'tfa_Zip',
			emailOptID:					'tfa_Email',
			statusClasses:		{
				requiredClass:			"required",
				correctClass:			"correct",
				requiredErrorClass:		"required_error",
				formatErrorClass:		"format_error",
				takenErrorClass:		"taken_error",
				lengthErrorClass:		"length_error"
			}
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			//find input elements
			var firstInputEl    = $('#' + options.firstID);
			var lastInputEl     = $('#' + options.lastID);
			var emailInputEl    = $('#' + options.emailID);
			var countryInputEl	= $('#' + options.countryID);
			var cityInputEl		= $('#' + options.cityID);
			var stateInputEl	= $('#' + options.stateID);
			var zipInputEl		= $('#' + options.zipID);
			var emailOptEl 		= $('#' + options.emailOptID);
			
			/**
			 * These are required TEXT fields only.  Selects receive special treatment due to the possibility of an initial value.  
			 */
			var requiredTextFields   =  { "required": [
			                                       { "element":   firstInputEl, "classes": options.statusClasses },
			                                       { "element":    lastInputEl, "classes": options.statusClasses },
			                                       { "element":    cityInputEl,	"classes": options.statusClasses }
			                             ]
			};
			
			/**
			 * These are required single SELECT fields only.
			 */
			var requiredSelectFields =  { "required": [
			                                       {"element":  countryInputEl, "classes": options.statusClasses }
			                             ]
			};
			
			var requiredEmailFields  =  { "required": [
			                                           	{"element": emailInputEl, "classes": options.statusClasses }
			                                          ]
			};
			                                           
			
			//add event listeners to input fields.
			validateAlpha(firstInputEl, 	options.statusClasses, true);
			validateAlpha(lastInputEl,  	options.statusClasses, true);
			validateAlpha(cityInputEl,  	options.statusClasses, true);
			validateEmail(emailInputEl,		options.statusClasses, true);
			validateZip(zipInputEl,			options.statusClasses, false);
			validateRequiredSelects(requiredSelectFields);
			
			/**
			 * Custom code for this form
			 */
			$(countryInputEl)
			.change(function(){
				if($(this).val() == 'tfa_UnitedStates')
				{
					$('#us_only').slideDown();
				}
				else
				{
					$('#us_only').slideUp();
				}
			});
			//end of custom code
			
			$(formEl)
				.submit(function(){
					validateRequiredTextOnSubmit(requiredTextFields);
					validateRequiredSelectsOnSubmit(requiredSelectFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					//all errors are now shown
					return checkFormErrorsOnSubmit(formEl);
				});
		});
	};
})(jQuery);

(function($){
	$.fn.localVolunteerForm = function(options){
		var defaults = {
			firstID: 					'tfa_FirstName',	
			lastID: 					'tfa_LastName',
			emailID: 					'tfa_email',
			addressID:					'tfa_Address',
			cityID:						'tfa_City',
			stateID: 					'tfa_State',
			zipID: 						'tfa_Zip',
			telephoneID:				'tfa_Phone',
			helpWithID:					'tfa_Whichthingsareyo',
			whenAvailableID:			'tfa_Whichbestdescrib',
			emailOptID:					'tfa_Newsletter',
			carID:						'tfa_Haveacar',
			statusClasses:		{
				requiredClass:			"required",
				correctClass:			"correct",
				requiredErrorClass:		"required_error",
				formatErrorClass:		"format_error",
				takenErrorClass:		"taken_error",
				lengthErrorClass:		"length_error"
			}
			
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			//find input elements
			var firstInputEl    = $('#' + options.firstID);
			var lastInputEl     = $('#' + options.lastID);
			var emailInputEl    = $('#' + options.emailID);
			var addressInputEl	= $('#' + options.addressID);
			var cityInputEl		= $('#' + options.cityID);
			var stateInputEl	= $('#' + options.stateID);
			var zipInputEl		= $('#' + options.zipID);
			var phoneInputEl	= $('#' + options.telephoneID);
			var helpWithEl		= $('#' + options.helpWithID);
			var emailOptEl 		= $('#' + options.emailOptID);
			var whenAvailableEl = $('#' + options.whenAvailableID);
			/**
			 * These are required TEXT fields only.  Selects receive special treatment due to the possibility of an initial value.  
			 */
			var requiredTextFields   =  { "required": [
			                                       { "element":	   cityInputEl, "classes": options.statusClasses },
			                                       { "element": addressInputEl, "classes": options.statusClasses },
			                                       { "element":   firstInputEl, "classes": options.statusClasses },
			                                       { "element":     zipInputEl, "classes": options.statusClasses },
			                                       { "element":    lastInputEl, "classes": options.statusClasses }
			                             ]
			};
			/**
			 * These are required single SELECT fields only.
			 */
			var requiredSelectFields =  { "required": [
			                                       { "element":    stateInputEl, "classes": options.statusClasses },
			                                       { "element": whenAvailableEl, "classes": options.statusClasses }
			                             ]
			};
			
			/**
			 * These are groups of checkboxes that require at least one check
			 */
			var requiredCheckFields = { "required": [
			                                         { "element":    helpWithEl, "classes": options.statusClasses }
			                                        ]
									  };
			var requiredEmailFields = { "required": [
			                                         { "element": emailInputEl, "classes": options.statusClasses }
			                                        ]
			};
			//add event listeners to input fields.
			validateAlpha(firstInputEl, 	options.statusClasses, true);
			validateAlpha(lastInputEl,  	options.statusClasses, true);
			validateAlpha(cityInputEl,  	options.statusClasses, true);
			validateEmail(emailInputEl,		options.statusClasses, true);
			validateZip(zipInputEl,			options.statusClasses, true);
			validateOpenText(addressInputEl,options.statusClasses, true);
			validateRequiredChecks(requiredCheckFields);
			validateRequiredSelects(requiredSelectFields);
			
			/**
			 * Custom code for this form
			 */
		
			//end of custom code
			
			$(formEl)
				.submit(function(){
					validateRequiredTextOnSubmit(requiredTextFields);
					validateRequiredChecksOnSubmit(requiredCheckFields);
					validateRequiredSelectsOnSubmit(requiredSelectFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					//all errors are now shown
					return checkFormErrorsOnSubmit(formEl);
				});
		});
	};
})(jQuery);


//todo add conorg validation (required select)
(function($){
	$.fn.internalLeadForm = function(options){
		var defaults = {
			firstID: 			'tfa_FirstName',
			lastID: 			'tfa_LastName',
			countryID: 			'tfa_Country',
			addressID:			'tfa_Address',
			cityID:				'tfa_City',
			stateID: 			'tfa_State',
			zipID: 				'tfa_Zip',
			telephoneID:		'tfa_Telephone',
			emailID: 			'tfa_Email',
			statusID:			'tfa_ConstituentStatu',
			conOrgTypeID:		'tfa_ConstituentOrgan',
			adConTypeID:		'tfa_AdvisorConsultan1',
			primaryID:			'tfa_PrimaryCompanyCo',
			notesID:			'tfa_Notes1',
			creatorID:			'tfa_RecordCreator',
			engageID:			'tfa_MeansofEngagemen',
			emailOptID:			'tfa_2854245388162',
			priorityID:			'tfa_Yes',
			statusClasses:		{
									requiredClass:			"required",
									correctClass:			"correct",
									requiredErrorClass:		"required_error",
									formatErrorClass:		"format_error",
									takenErrorClass:		"taken_error",
									lengthErrorClass:		"length_error"
								}
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			//find input elements
			var firstInputEl    = $('#' + options.firstID);
			var lastInputEl     = $('#' + options.lastID);
			var countryInputEl  = $('#' + options.countryID);
			var addressInputEl	= $('#' + options.addressID);
			var cityInputEl		= $('#' + options.cityID);
			var stateInputEl	= $('#' + options.stateID);
			var zipInputEl		= $('#' + options.zipID);
			var phoneInputEl	= $('#' + options.telephoneID);
			var emailInputEl    = $('#' + options.emailID);
			var statusInputEl	= $("#" + options.statusID);
			var conOrgInputEl 	= $('#' + options.conOrgTypeID);
			var adConInputEl	= $('#' + options.adConTypeID);
			var primaryInputEl	= $('#' + options.primaryID);
			var notesInputEl	= $('#' + options.notesID);
			var creatorInputEl	= $('#' + options.creatorID);
			var engageInputEl	= $('#' + options.engageID);
			var emailOptEl 		= $('#' + options.emailOptID);
			var priorityEl		= $('#' + options.priorityID);
			
			/**
			 * These are required TEXT fields only.  Selects receive special treatment due to the possibility of an initial value.  
			 */
			var requiredTextFields   	=  { "required": [
			                                       {"element":   firstInputEl, "classes": options.statusClasses},
			                                       {"element":    lastInputEl, "classes": options.statusClasses},
			                                       {"element": creatorInputEl, "classes": options.statusClasses},
			                                       {"element":  engageInputEl, "classes": options.statusClasses},
			                                       {"element": countryInputEl, "classes": options.statusClasses}
			                             ]
									};
			
			var requiredSelectFields	=  { "required":[
			                        	           {"element": conOrgInputEl, "classes": options.statusClasses} 
			                        	 ]	
			};
				
			/**
			 * These are groups of checkboxes that require at least one check
			 */
			var requiredCheckFields = { "required": [
			                                         {"element": statusInputEl, "classes": options.statusClasses}
			                                        ]
									  };
			
			var requiredEmailFields = { "required": [
			                                         { "element": emailInputEl, "classes": options.statusClasses }
			                                        ]
			};
			
			//add event listeners to input fields.
			validateAlpha(firstInputEl, 	options.statusClasses, true);
			validateAlpha(lastInputEl,  	options.statusClasses, true);
			validateAlpha(countryInputEl,  	options.statusClasses, true);
			validateAlpha(cityInputEl,  	options.statusClasses, false);
			validateAlpha(creatorInputEl,  	options.statusClasses, true);
			validateOpenText(engageInputEl,	options.statusClasses, true);
			validateEmail(emailInputEl,		options.statusClasses, true);
			validateZip(zipInputEl,			options.statusClasses, false);
			validateRequiredSelects(requiredSelectFields);
			validateRequiredChecks(requiredCheckFields);
			
			/**
			 * Custom code for this form
			 */
		
			//end of custom code
			
			$(formEl)
				.submit(function(){
					validateRequiredTextOnSubmit(requiredTextFields);
					validateRequiredChecksOnSubmit(requiredCheckFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					validateRequiredSelectsOnSubmit(requiredSelectFields);
					//all errors are now shown
					return checkFormErrorsOnSubmit(formEl);
				});
		});
	};
})(jQuery);


(function($){
	$.fn.fundraiseForm = function(options){
		var defaults = {
			firstID: 			'tfa_FirstName',
			lastID: 			'tfa_LastName',
			emailID: 			'tfa_Email',
			countryID: 			'tfa_Country',
			stateID: 			'tfa_statetate',
			tellusID:			'tfa_Tellusalittleabo',
			howMuchID:			'tfa_Howmuchdoyouthin',
			newsletterID:		'tfa_2092639046940',
			statusClasses:		{
									requiredClass:			"required",
									correctClass:			"correct",
									requiredErrorClass:		"required_error",
									formatErrorClass:		"format_error",
									takenErrorClass:		"taken_error",
									lengthErrorClass:		"length_error"
								},
			emailPrefilled:		true
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			//find input elements
			var firstInputEl     = $('#' + options.firstID);
			var lastInputEl      = $('#' + options.lastID);
			var emailInputEl     = $('#' + options.emailID);
			var countryInputEl   = $('#' + options.countryID);
			var stateInputEl     = $('#' + options.sateID);
			var zipInputEl       = $('#' + options.zipID);
			var tellUsInputEl	 = $('#' + options.tellusID);
			var howMuchInputEl   = $('#' + options.howMuchID);
			
			/**
			 * These are required TEXT fields only.  Selects receive special treatment due to the possibility of an initial value.  
			 */
			var requiredTextFields   =  { "required": [
			                                       {"element": tellUsInputEl,  "classes": options.statusClasses},
			                                       {"element": howMuchInputEl, "classes": options.statusClasses},
			                  	 		           {"element": firstInputEl,   "classes": options.statusClasses},
			                  	 		           {"element": lastInputEl,    "classes": options.statusClasses}
			                             ]
			};
			
			var requiredSelectFields =  { "required": [
			                                           {"element": countryInputEl, "classes": options.statusClasses}
			                                          ]
										};
			
			var requiredEmailFields = { "required": [
			                                         { "element": emailInputEl, "classes": options.statusClasses }
			                                        ]
			};
			
			//add event listeners to input fields.
			validateEmail(emailInputEl, options.statusClasses, true);
			validateAlpha(firstInputEl, options.statusClasses, true);
			validateAlpha(lastInputEl, options.statusClasses, true);
			validateOpenText(tellUsInputEl, options.statusClasses, true);
			validateOpenText(howMuchInputEl, options.statusClasses, true);
			validateRequiredSelects(requiredSelectFields);
			
			/**
			 * Custom code for this form
			 */
			if(options.emailPrefilled)
			{
				if(isEmpty($(emailInputEl).val()))
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.requiredErrorClass);
				}
				else if(!validateEmailInput($(emailInputEl).val()))
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.formatErrorClass);
				}
				else
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.correctClass);
				}
				
			}
			
			$('#us_only').hide();
			$(countryInputEl)
			.change(function(){
				if($(this).val() == 'tfa_UnitedStates')
				{
					$('#us_only').slideDown();
				}
				else
				{
					$('#us_only').slideUp();
				}
			});
			//end of custom code
			
			$(formEl)
				.submit(function(){
					validateRequiredTextOnSubmit(requiredTextFields);
					validateRequiredSelectsOnSubmit(requiredSelectFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					//all errors are now shown
					return checkFormErrorsOnSubmit(formEl);
				});
		});
	};
})(jQuery);


(function($){
	$.fn.newsletterForm = function(options){
		var defaults = {
			emailID: 			'email',
			firstID: 			'firstName',
			lastID: 			'lastName',
			countryID: 			'country',
			stateID: 			'state',
			zipID: 				'zip',
			referenceID: 		'reference',
			statusClasses:		{
									requiredClass:			"required",
									correctClass:			"correct",
									requiredErrorClass:		"required_error",
									formatErrorClass:		"format_error",
									takenErrorClass:		"taken_error",
									lengthErrorClass:		"length_error"
								},
			emailPrefilled:		true
		};
		var options = $.extend(defaults, options);
		return this.each(function(){
			var formEl = $(this);
			//find input elements
			var emailInputEl     = 	$('#' + options.emailID);
			var firstInputEl     = 	$('#' + options.firstID);
			var lastInputEl      = 	$('#' + options.lastID);
			var countryInputEl   = 	$('#' + options.countryID);
			var stateInputEl     =	$('#' + options.sateID);
			var zipInputEl       = 	$('#' + options.zipID);
			var referenceInputEl =  $('#' + options.referenceID);
			
			/**
			 * These are required TEXT fields only.  Selects receive special treatment due to the possibility of an initial value.  
			 */
			var requiredTextFields   =  { "required": [
			                                       {"element": firstInputEl, "classes": options.statusClasses},
			                                       {"element":  lastInputEl, "classes": options.statusClasses}
			                             ]
			};
			
			var requiredSelectFields =  { "required": [
			                                       {"element": countryInputEl,   "classes": options.statusClasses},
			                                       {"element": referenceInputEl, "classes": options.statusClasses}
			                             ]
			};
			
			var requiredEmailFields  =  { "required": [
			                                           	{"element": emailInputEl, "classes": options.statusClasses }
			                                          ]
			};
			
			
			validateEmail(emailInputEl, options.statusClasses, true);
			validateAlpha(firstInputEl, options.statusClasses, true);
			validateAlpha(lastInputEl, options.statusClasses, true);
			validateRequiredSelects(requiredSelectFields);
			validateZip(zipInputEl, options.statusClasses, false);
			
			/**
			 * Custom code for this form
			 */
			
			if(options.emailPrefilled)
			{
				if(isEmpty($(emailInputEl).val()))
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.requiredErrorClass);
				}
				else if(!validateEmailInput($(emailInputEl).val()))
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.formatErrorClass);
				}
				else
				{
					adjustParagraphStatus(emailInputEl, options.statusClasses.correctClass);
				}
				
			}
			
			$(countryInputEl)
				.change(function(){
					if($(this).val() == 'United States')
					{
						$('#us_only').slideDown();
					}
					else
					{
						$('#us_only').slideUp();
					}
				});
			
			$(referenceInputEl)
				.change(function(){
					var el = $(this);
					var value = $(el).val();
					if($(this).val() == 'Other')
					{
						adjustParagraphStatus($('#reference_paragraph select'), options.statusClasses.requiredClass);
						if(isEmpty($('#other_paragraph input').val()))
						{
							$('#other_paragraph input')
								.val("Tell us...")
								.focus(function(){
									if(this.value == "Tell us...")
									{
										this.value = "";
									}
								})
								.blur(function(){
									if(isEmpty(this.value))
									{
										this.value = "Tell us...";
										adjustParagraphStatus($('#reference_paragraph select'), options.statusClasses.requiredErrorClass);
									}
									else if(this.value == "Tell us...")
									{
										adjustParagraphStatus($('#reference_paragraph select'), options.statusClasses.requiredErrorClass);
									}
									else
									{
										adjustParagraphStatus($('#reference_paragraph select'), options.statusClasses.correctClass);
									}
								})
								.keyup(function(e){
									if(isEmpty(this.value))
									{
										adjustParagraphStatus($('#reference_paragraph select'), options.statusClasses.requiredErrorClass);
									}
									else
									{
										adjustParagraphStatus($('#reference_paragraph select'), options.statusClasses.requiredClass);
									}
										 
								});
						}
						$('#reference_paragraph select').attr("id", "").attr("name", "");
						$('#other_paragraph').show('slow');
						$('#other_paragraph input').attr("id", "reference").attr("name","reference");
						
					}
					else
					{
						$('#other_paragraph input').attr("id", "").attr("name","");
						$('#other_paragraph').slideUp();
						$('#reference_paragraph select').attr("id", "reference").attr("name", "reference");
					}
				});
			//end of custom code
			
			$(formEl)
				.submit(function(){
					validateRequiredTextOnSubmit(requiredTextFields);
					validateRequiredSelectsOnSubmit(requiredSelectFields);
					validateRequiredEmailOnSubmit(requiredEmailFields);
					/**
					 * Validate reference.  Reference receives special treatment because of the 'other' text field.
					 */
					if($(referenceInputEl).val() == "Other" && ($('#reference').val() == "Tell us..." || isEmpty($('#reference').val())))
					{
						adjustParagraphStatus($(this), options.statusClasses.requiredErrorClass);
					}
					else
					{
						adjustParagraphStatus($(this), options.statusClasses.correctClass);
					}
					
					//all errors are now shown
					return checkFormErrorsOnSubmit(formEl);
				});
		});
	};
})(jQuery);