var MW_bSetFocusOnError = false; // attempt to set focus to a problem field...may want to disable this if dealing with layers and hidden form fields

// the ultimate JavaScript validator - wrapper function...looks for validation cues in the form and then uses
// the main function to call the correct function and build an error message to show all errors to the user
function MW_validator_wrapper(form) {
	if (!form.elements['_skip_validation'] || (form.elements['_skip_validation'] && form.elements['_skip_validation'].value.indexOf('client') == -1)) {	
		var strAlertMessage = '';
		var strFieldName = '';
		var bValid = true; // assume we can submit the form unless we prove otherwise...
		var ptrField = null; // capture the field of the first bad form input and send them back there
		var arrInvalidFields = new Array(); // capture an array of pointers to invalid fields
		
		if (form._validationMessage && form._validationMessage.value != '') {
			strAlertMessage = form._validationMessage.value + '\n\n';
		}
		else {
			strAlertMessage = 'The following errors occurred with this form submission:\n\n';
		}
		
		// loop through the form looking for validation messages
		for (var i = 0; i < form.elements.length; i++) {
			if (form.elements[i].name && form.elements[i].name.indexOf('_validate_') == 0) {
				// we've found an element to validate...
				// get the field name
				strFieldName = form.elements[i].name.split('validate_')[1];

				
				if (form.elements[strFieldName]) { // if this field exists...then try and validate it
					arrValidationReturn = MW_validator(form.elements[strFieldName], form.elements[i].value, null);
					if (!arrValidationReturn[0]) {
						bValid = false;
						
						// hacky for now, but it will have to do...
						if (form.elements[i].value.indexOf('conditional') == -1) {
							arrInvalidFields.push(form.elements[strFieldName]);
						}
						else {
							var crazyString = eval(form.elements[i].value.split(':')[1]);
							arrInvalidFields.push(form.elements[crazyString.split('~')[1]]);
						}
						if (form.elements['_validateMessage_' + strFieldName]) {
							strAlertMessage += form.elements['_validateMessage_' + strFieldName].value + '\n';
						}
						else {
							strAlertMessage += arrValidationReturn[1];
						}
					}
				}
			}	
		}
		
		if (bValid) {
			return true;	
		}
		else {
			alert(strAlertMessage);
			// things aren't valid...rip through all of the form fields and set their class back to valid

			for (i = 0; i < form.elements.length; i++) {
				if (form.elements[i].name && form.elements[i].name.indexOf('_') != 0 && form.elements[i].type != 'submit' && form.elements[i].type != 'button' && form.elements[i].type != 'checkbox' && form.elements[i].type != 'radio') {
					form.elements[i].className = 'MW_form_' + form.elements[i].type + '_blur';
				}
			}

			// mark the improperly filled out fields
			for (i = 0; i < arrInvalidFields.length; i++) {
				arrInvalidFields[i].className = 'MW_form_' + arrInvalidFields[i].type + '_error';
			}
			if (arrInvalidFields.length > 0) _MW_setFocus(arrInvalidFields[0]);
			return false;	
		}
	}
}

// the ultimate JavaScript validator - version one...displays the first error and then 
// returns false at that point...
function MW_validator(uField, uValType, uEMessage) {
	// create the array we're going to pass back...assume that we're valid until proven otherwise
	var arrReturnValue = new Array();
	arrReturnValue[0] = true;
	arrReturnValue[1] = ''; // empty error message value...
	
	// split the validation types into an array
	var valTypeArray = new Array();
	uValType = MW_stripChars(uValType, ' ');
	if (uValType.indexOf(',') != -1) {
		valTypeArray = uValType.split(',')
	}
	else {
		valTypeArray[0] = uValType;
	}
	// trim all spaces in the inputs
	for (var i = 0; i < valTypeArray.length; i++) valTypeArray[i].replace(/ /gi, '');
	var functionName, extraArgs;

	for (i = 0; i < valTypeArray.length; i++) {
		extraArgs = '';
		// figure out if there are extra parameters
		if (valTypeArray[i].indexOf(':') != -1) {
			functionName = valTypeArray[i].split(':')[0];
			extraArgs = ',' + valTypeArray[i].split(':')[1];
		}
		else {
			functionName = valTypeArray[i];
		}
		var typeValue;
	
		(uField.type)?typeValue = uField.type.split('-')[0]:typeValue = uField[0].type.split('-')[0];
		
		if (!eval('_MW_' + typeValue + '_' + functionName + '(uField, uEMessage' + extraArgs + ');')) {
			arrReturnValue[0] = false;
			arrReturnValue[1] += _MW_create_error_message(uField, functionName, extraArgs);
		}
	}

	return arrReturnValue;
}

function _MW_create_error_message(field, functionName, extraArgs) {
	var strErrorMessage;
	
	// figure out if we're dealing with checkboxes or radio buttons
	if (field.length) {
		var strFieldDescription = field[0].name;
		// see if we have a field describing this field's visual name
		if (field[0].form.elements['_description_' + field[0].name]) {
			strFieldDescription = field[0].form.elements['_description_' + field[0].name].value;
		}
	}
	else {
		var strFieldDescription = field.name; // default to this unless we can find a name...
		
		// see if we have a field describing this field's visual name
		if (field.form.elements['_description_' + field.name]) {
			strFieldDescription = field.form.elements['_description_' + field.name].value;
		}
	}
	
	switch (functionName) {
		case 'nonEmpty':
			strErrorMessage = MW_labels_validation['message_0001'] + strFieldDescription + '\n';
			break;
		case 'notSelected':
			strErrorMessage = MW_labels_validation['message_0001'] + strFieldDescription + '\n';
			break;
		case 'minLength':
			strErrorMessage = strFieldDescription + MW_labels_validation['message_0010'] + MW_stripChars(extraArgs, ' ,') + MW_labels_validation['message_0004'] + '\n';
			break;
		case 'maxLength':
			strErrorMessage = strFieldDescription + MW_labels_validation['message_0003'] + MW_stripChars(extraArgs, ' ,') + MW_labels_validation['message_0004'] + '\n';
			break;
		case 'match':
			strErrorMessage = strFieldDescription + MW_labels_validation['message_0005'] + MW_stripChars(extraArgs, ' ,') + '\n';
			break;
		default:
			strErrorMessage = MW_labels_validation['message_0008'] + strFieldDescription + '\n';
			break;
	}

	return strErrorMessage;
}

function _MW_textarea_nonEmpty(field, message) {
	return _MW_text_nonEmpty(field, message);
}
function _MW_password_nonEmpty(field, message) {
	return _MW_text_nonEmpty(field, message);
}
function _MW_file_nonEmpty(field, message) {
	return _MW_text_nonEmpty(field, message);
}
function _MW_hidden_nonEmpty(field, message) {
	return _MW_text_nonEmpty(field, message);
}

function _MW_password_match(field, message, matchField) {
	return _MW_text_match(field, message, matchField);
}

function _MW_password_minLength(field, message, minLength) {
	return _MW_text_minLength(field, message, minLength);
}

function _MW_text_match(field, message, matchField) {
	if (field.value != field.form.elements[matchField].value) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_nonEmpty(field, message) {
	if (field.value == '') {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}
function _MW_textarea_minLength(field, message, minLength) {
	return _MW_text_minLength(field, message, minLength);
}
function _MW_text_minLength(field, message, minLength) {
	if (field.value.length < minLength) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}
function _MW_textarea_maxLength(field, message, maxLength) {
	return _MW_text_maxLength(field, message, maxLength)
}
function _MW_text_maxLength(field, message, maxLength) {
	if (field.value.length > maxLength) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_email(field, message) {
	if (!_MW_validate_email(field.value)) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_numeric(field, message) {
	if (!_MW_validate_numeric(field.value)) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_positiveNumeric(field, message) {
	if (!_MW_validate_numeric_positive(field.value)) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_currency(field, message) {
	if (!_MW_validate_currency(field.value)) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_postalCode_Canada(field, message) {
	if (field.value == '') {
		return true;
	}
	if (!_MW_validate_postalCode_Canada(field.value)) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_text_dateGTE(field, message, compareField) {
	var compareField = field.form.elements[compareField];
	// make sure we're dealing with valid dates...
	if (!_MW_validate_date_mmddyyyy(field.value) || !_MW_validate_date_mmddyyyy(compareField.value)) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	else {
		if (!_MW_validate_date_gte(new Date(field.value), new Date(compareField.value))) {
			_MW_sendAlert(message);
			_MW_setFocus(field);
			return false;
		}
		else {
			return true;
		}
	}
}

function _MW_select_notFirst(field, message) {
	if (field.selectedIndex == 0) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	return true;
}

function _MW_select_minSelected(field, message, minSelected) {
	var selectCount = 0;
	for (var i = 0; i < field.options.length; i++) {
		if (field.options[i].selected) {
			selectCount++;
		}
	}
	if (selectCount < minSelected) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	else
		return true;
}

function _MW_select_maxSelected(field, message, maxSelected) {
	var selectCount = 0;
	for (var i = 0; i < field.options.length; i++) {
		if (field.options[i].selected) {
			selectCount++;
		}
	}
	if (selectCount > maxSelected) {
		_MW_sendAlert(message);
		_MW_setFocus(field);
		return false;
	}
	else
		return true;
}

function _MW_select_conditional(field, message, conditionalExtras) {
	//'1~mlsnumber~nonEmpty|numeric'
	var bValueFound = false;
	
	var fieldValue = conditionalExtras.split('~')[0];
	if (field.length) {
		var conditionalField = field[0].form.elements[conditionalExtras.split('~')[1]];
	}
	else {
		var conditionalField = field.form.elements[conditionalExtras.split('~')[1]];
	}
	var conditionalValidation = conditionalExtras.split('~')[2].split('|').join(',');

	if (_getSelectValue(field) == fieldValue) {
		if (!MW_validator(conditionalField, conditionalValidation, null)) {
			return false;
		}
		else {
			return true;
		}
	}
	else {
		return true;
	}
}

function _MW_radio_notSelected(field, message) {
	var valid = false;
	for (var i = 0; i < field.length; i++) {
		if (field[i].checked) {
			valid = true;
			break;
		}
	}
	if (!valid) {
		_MW_sendAlert(message);
		if (field.length) {
			_MW_setFocus(field[0]);
		}
		else {
			_MW_setFocus(field);
		}
	}
	return valid;
}

function _MW_radio_conditional(field, message, conditionalExtras) {
	//'1~mlsnumber~nonEmpty|numeric'
	var bValueFound = false;
	
	var fieldValue = conditionalExtras.split('~')[0];
	if (field.length) {
		var conditionalField = field[0].form.elements[conditionalExtras.split('~')[1]];
	}
	else {
		var conditionalField = field.form.elements[conditionalExtras.split('~')[1]];
	}
	var conditionalValidation = conditionalExtras.split('~')[2].split('|').join(',');

	if (_MW_getRadioValue(field) == fieldValue) {
		if (!MW_validator(conditionalField, conditionalValidation, null)) {
			return false;
		}
		else {
			return true;
		}
	}
	else {
		return true;
	}
}

function _MW_checkbox_notSelected(field, message) {
	var valid = false;
	if (field.checked != undefined) {
		// single checkbox
		valid = field.checked;
	}
	else {
		for (var i = 0; i < field.length; i++) {
			if (field[i].checked) {
				valid = true;
				break;
			}
		}
	}
	if (!valid) {
		_MW_sendAlert(message);
		(field.checked != undefined)?_MW_setFocus(field):_MW_setFocus(field[0]);
	}
	return valid;
}

function _MW_checkbox_minSelected(field, message, minSelected) {
	var selectCount = 0;
	for (var i = 0; i < field.length; i++) {
		if (field[i].checked) {
			selectCount++;
		}
	}
	if (selectCount < minSelected) {
		_MW_sendAlert(message);
		_MW_setFocus(field[0]);
		return false;
	}
	else
		return true;
}

function _MW_checkbox_maxSelected(field, message, maxSelected) {
	var selectCount = 0;
	for (var i = 0; i < field.length; i++) {
		if (field[i].checked) {
			selectCount++;
		}
	}
	if (selectCount > maxSelected) {
		_MW_sendAlert(message);
		_MW_setFocus(field[0]);
		return false;
	}
	else
		return true;
}

// this function defends against null messages...if you don't want the validator
// to send the user an alert...just pass the "null" value as the message parameter
// or an empty string
function _MW_sendAlert(message) {
	if (message && message != '') {
		alert(message);
	}
}

// this function defends against null messages...if you don't want the validator
// to send the user an alert...just pass the "null" value as the message parameter
// or an empty string
function _MW_setFocus(ptrField) {
	if (MW_bSetFocusOnError) {
		field.focus();
	}
}