package com.devahead.utils
{
	import mx.core.UIComponent;
	import mx.validators.Validator;
	import mx.events.ValidationResultEvent;
	import mx.collections.ArrayCollection;
	import mx.events.FlexEvent;

	public class ComponentValidationManager
	{
		protected var _isManagerValid: Boolean = true;
		protected var _managedComponent: UIComponent;
		protected var _managedValidators: Array;
		protected var _isValidationManagementEnabled: Boolean = false;

		// Array of the validators in INVALID state
		protected var _invalidValidators: ArrayCollection = new ArrayCollection();
		protected var _invalidValidationMessages: ArrayCollection = new ArrayCollection();

		/**
		 * Constructor.
		 *
		 * @param managedComponent
		 *   UIComponent managed by the ComponentValidationManager.
		 *   If must not be NULL.
		 * @param managedValidators
		 *   Array of the validators that have to be managed. They must
		 *   all be in VALID state at this time.
		 */
		public function ComponentValidationManager(managedComponent: UIComponent,
			managedValidators: Array)
		{
			// NOTE: I expect that all the managedValidators are VALID at this time

			_managedComponent = managedComponent;
			_managedValidators = managedValidators;

			if (_managedComponent != null && _managedValidators != null &&
				_managedValidators.length > 0)
			{
				for (var i: int = 0; i < _managedValidators.length; i++)
				{
					if (_managedValidators[i] == null || !(_managedValidators[i] is Validator))
					{
						// NULL values or components that are not subclasses of
						// mx.validators.Validator are not allowed.
						_isManagerValid = false;
						break;
					}
				}

				if (_isManagerValid)
				{
					enableValidationManagement();
				}
			}
		}

		/**
		 * Tells if the ComponentValidationManager is valid.
		 *
		 * @return "True" if the manager is valid (i.e. constructors arguments
		 *         where correct).
		 */
		public function get isManagerValid(): Boolean
		{
			return _isManagerValid;
		}

		/**
		 * Managed component.
		 */
		public function get managedComponent(): UIComponent
		{
			return _managedComponent;
		}

		/**
		 * Managed validators.
		 */
		public function get managedValidators(): Array
		{
			return _managedValidators;
		}

		/**
		 * "True" if the validation management is enabled.
		 */
		public function get isValidationManagementEnabled(): Boolean
		{
			return _isValidationManagementEnabled;
		}

		/**
		 * Enables validation management.
		 */
		public function enableValidationManagement(): void
		{
			if (!_isValidationManagementEnabled)
			{
				// Add the listeners for "VALID" and "INVALID" events generated by
				// the managed validators.
				for each (var v: Validator in _managedValidators)
				{
					v.addEventListener(ValidationResultEvent.VALID, onValidatorValidationEvent);
					v.addEventListener(ValidationResultEvent.INVALID, onValidatorValidationEvent);
				}

				_managedComponent.addEventListener(FlexEvent.VALID, onComponentValidationEvent);
				_managedComponent.addEventListener(FlexEvent.INVALID, onComponentValidationEvent);

				_isValidationManagementEnabled = true;
			}
		}

		/**
		 * Disables validation management.
		 */
		public function disableValidationManagement(): void
		{
			if (_isValidationManagementEnabled)
			{
				_managedComponent.removeEventListener(FlexEvent.INVALID, onComponentValidationEvent);
				_managedComponent.removeEventListener(FlexEvent.VALID, onComponentValidationEvent);

				// Remove the listeners for "VALID" and "INVALID" events generated by
				// the managed validators.
				for each (var v: Validator in _managedValidators)
				{
					v.removeEventListener(ValidationResultEvent.VALID, onValidatorValidationEvent);
					v.removeEventListener(ValidationResultEvent.INVALID, onValidatorValidationEvent);
				}

				_invalidValidators.removeAll();
				_invalidValidationMessages.removeAll();

				_isValidationManagementEnabled = false;
			}
		}

		/**
		 * The managed component has been judged VALID by a validator, so we must
		 * update its state.
		 *
		 * @param validatorInstance
		 *   Validator that judged the managed component as VALID.
		 */
		protected function updateManagedComponentValidState(validatorInstance: Validator): void
		{
			var itemIndex: int = _invalidValidators.getItemIndex(validatorInstance);

			if (itemIndex != -1)
			{
				// Remove the validator from the INVALID list
				_invalidValidators.removeItemAt(itemIndex);

				// Remove also the corresponding validation message
				_invalidValidationMessages.removeItemAt(itemIndex);

				if (_invalidValidators.length == 0)
				{
					// Restore the normal state of the managed component (now it's valid)
					_managedComponent.errorString = null;

					if (_managedComponent.focusManager != null &&
						_managedComponent.focusManager.getFocus() == _managedComponent)
					{
						// The managed component has the focus so we must also
						// draw the border.
						_managedComponent.drawFocus(true);
					}
				}
				else
				{
					// The managed component is still INVALID and due to the fact that
					// the error message previously generated by the validator was
					// removed, we must update the message that should now be displayed
					// for the managed component.
					updateManagedComponentInvalidState();
				}
			}
		}

		/**
		 * The managed component has been judged INVALID by a validator, so we must
		 * update its state.
		 *
		 * @param validatorInstance
		 *   Validator that judged the managed component as INVALID.
		 */
		protected function updateManagedComponentInvalidState(
			validatorInstance: Validator = null, validationMessage: String = ""): void
		{
			var isValidationMessageChanged: Boolean = false;

			if (validatorInstance != null)
			{
				if (!_invalidValidators.contains(validatorInstance))
				{
					// Add the validator the the INVALID list
					_invalidValidators.addItem(validatorInstance);

					// Add the corresponding validation message
					_invalidValidationMessages.addItem(validationMessage);

					isValidationMessageChanged = true;
				}
				else
				{
					// The validation message could have changed, so we update it
					// if necessary.
					var oldValidationMessage: String = String(_invalidValidationMessages.getItemAt(
						_invalidValidators.getItemIndex(validatorInstance)));

					if (oldValidationMessage != validationMessage)
					{
						_invalidValidationMessages.setItemAt(validationMessage,
							_invalidValidators.getItemIndex(validatorInstance));

						isValidationMessageChanged = true;
					}
				}
			}
			else
			{
				if (_invalidValidators.length > 0)
				{
					// We force the update of the INVALID state for the managed component
					isValidationMessageChanged = true;
				}
			}

			if (isValidationMessageChanged)
			{
				// We graphically display the error on the managed component

				// We prepare the error message taking into account all those
				// returned by the managed validators that are in the INVALID state.
				var errorMessage: String = "";

				for each (var msg: String in _invalidValidationMessages)
				{
					if (errorMessage != "")
					{
						errorMessage += "\n";
					}

					errorMessage += msg;
				}

				_managedComponent.errorString = errorMessage;

				if (_managedComponent.focusManager != null &&
					_managedComponent.focusManager.getFocus() == _managedComponent)
				{
					// The managed component has the focus so we must also draw the border
					_managedComponent.drawFocus(true);
				}
			}
		}

		/**
		 * Handler for the validation events coming from the managed component.
		 *
		 * @param event
		 *   Validation event.
		 */
		protected function onComponentValidationEvent(event: FlexEvent): void
		{
			if (event.target == _managedComponent)
			{
				// We check that the INVALID state is kept correctly for the managed
				// component if it is in fact INVALID (this is useful to avoid the
				// interference of the function "validationResultHandler" in
				// mx.core.UIComponent with the management made internally by
				// ComponentValidationManager).
				updateManagedComponentInvalidState();
			}
		}

		/**
		 * Handler for the validation events coming from the managed validators.
		 *
		 * @param event
		 *   Validation event.
		 */
		protected function onValidatorValidationEvent(event: ValidationResultEvent): void
		{
			if (event.type == ValidationResultEvent.VALID)
			{
				updateManagedComponentValidState(Validator(event.target));
			}
			else if (event.type == ValidationResultEvent.INVALID)
			{
				updateManagedComponentInvalidState(Validator(event.target), event.message);
			}
		}
	}
}

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
	pageTitle="Multiple validators on a single component - devahead BLOG"
	layout="vertical" horizontalAlign="left"
	applicationComplete="{onApplicationComplete(event)}">

	<mx:Script>
		<![CDATA[
			import com.devahead.utils.ComponentValidationManager;
			import mx.events.FlexEvent;

			protected const TOO_SHORT_ERROR: String = "String must not be shorter than {0} characters";
			protected const TOO_LONG_ERROR: String = "String must not be longer than {0} characters";

			protected var compValManager: ComponentValidationManager;

			protected function onApplicationComplete(event: FlexEvent): void
			{
				compValManager = new ComponentValidationManager(textInput2, [strVal2a, strVal2b]);
			}
		]]>
	</mx:Script>

	<mx:StringValidator id="strVal1a" minLength="1" maxLength="4"
		source="{textInput1}" property="text"
		tooShortError="{TOO_SHORT_ERROR}" tooLongError="{TOO_LONG_ERROR}"/>
	<mx:StringValidator id="strVal1b" minLength="4" maxLength="6"
		source="{textInput1}" property="text"
		tooShortError="{TOO_SHORT_ERROR}" tooLongError="{TOO_LONG_ERROR}"/>

	<mx:StringValidator id="strVal2a" minLength="1" maxLength="4"
		source="{textInput2}" property="text"
		tooShortError="{TOO_SHORT_ERROR}" tooLongError="{TOO_LONG_ERROR}"/>
	<mx:StringValidator id="strVal2b" minLength="4" maxLength="6"
		source="{textInput2}" property="text"
		tooShortError="{TOO_SHORT_ERROR}" tooLongError="{TOO_LONG_ERROR}"/>

	<mx:Label text="Validator A: string length >= 1 and &lt;= 4"/>
	<mx:Label text="Validator B: string length >= 4 and &lt;= 6"/>
	<mx:Label text="Only 4 characters strings should be recognized as valid" fontWeight="bold"/>

	<mx:HBox>
		<mx:Label text="Write something:"/>
		<mx:TextInput id="textInput1"/>
		<mx:Button label="Validate (A -> B)"
			click="{strVal1a.validate(); strVal1b.validate()}"/>
		<mx:Button label="Validate (B -> A)"
			click="{strVal1b.validate(); strVal1a.validate()}"/>
		<mx:Label text="(without ComponentValidationManager)" fontWeight="bold"/>
	</mx:HBox>

	<mx:HBox>
		<mx:Label text="Write something:"/>
		<mx:TextInput id="textInput2"/>
		<mx:Button label="Validate (A -> B)"
			click="{strVal2a.validate(); strVal2b.validate()}"/>
		<mx:Button label="Validate (B -> A)"
			click="{strVal2b.validate(); strVal2a.validate()}"/>
		<mx:Label text="(with ComponentValidationManager)" fontWeight="bold"/>
	</mx:HBox>

</mx:Application>