package com.mediarain.utils
{
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.events.ProgressEvent;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
 
	[Event(name="progress", type="flash.events.ProgressEvent")]
	[Event(name="complete", type="flash.events.Event")]
	/**
	 * A object which consolidates a group of objects that provide progress information.  Types
	 * of objects include UrlLoader and LoaderInfo objects. This allows a simple way for displaying
	 * overall progress for multiple loaders.
	 * 
	 * When a single loader is registered, the percentLoaded is simply the bytes loaded divided by
	 * the bytes total for the loader.  When there are multiple loaders registered, percentLoaded
	 * reflects the number of loaders completed divided by the total number of registered loaders.
	 * The reason why using multiple loaders is less accurate is because a loader does not know
	 * how many bytes it will be loading until the first response from the server.  Because loaders
	 * are often queued, this means that we can't determine the total number of bytes to be loaded
	 * for all registered loaders up front.
	 */
	public class BatchLoaderInfo extends EventDispatcher
	{
		[Bindable]
		/**
		 * The percentage of all registered loaders which are loaded.
		 * When there is a single loader, this is simply the bytes loaded divided by the bytes total
		 * for the loader.  When there are multiple loaders, this is the number of loaders
		 * which have completed their loading process divided by the total number of registered
		 * loaders.  This value is between 0 and 1.
		 * @see doUpdateStats
		 */
		public var percentLoaded:Number;
 
		/**
		 * @private
		 * Registered loaders.
		 */
		protected var loaders:Array = [];
 
		/**
		 * Timer used to delay updating status till the next frame.
		 */
		protected var updateStatsDelayTimer:Timer;
 
		/**
		 * Whether stats are flagged to be updated.
		 */
		protected var statsNeedUpdating:Boolean = false;
 
		/**
		 * Registers a loader with the registry.
		 * @param loader Any object that dispatches ProgressEvent.PROGRESS, Event.COMPLETE, and
		 * IOErrorEvent.IO_ERROR events as well as provides bytesLoaded and bytesTotal properties.
		 * Examples include UrlLoader or LoaderInfo objects.
		 */
		public function register(loader:IEventDispatcher):void
		{
			if (loaders.indexOf(loader) == -1)
			{
				loaders.push(loader);
				loader.addEventListener(ProgressEvent.PROGRESS, loaderProgressHandler);
				loader.addEventListener(Event.COMPLETE, loaderCompleteHandler);
				loader.addEventListener(IOErrorEvent.IO_ERROR, loaderErrorHandler);
				updateStats();
			}
		}
 
		/**
		 * Unregisters a loader from the registry.
		 * @param loader Any object that dispatches ProgressEvent.PROGRESS, Event.COMPLETE, and
		 * IOErrorEvent.IO_ERROR events as well as provides bytesLoaded and bytesTotal properties.
		 * Examples include UrlLoader or LoaderInfo objects.
		 */
		public function unregister(loader:IEventDispatcher):void
		{
			if (loaders.indexOf(loader) > -1)
			{
				loaders.splice(loaders.indexOf(loader), 1);
				loader.removeEventListener(ProgressEvent.PROGRESS, loaderProgressHandler);
				loader.removeEventListener(Event.COMPLETE, loaderCompleteHandler);
				loader.removeEventListener(IOErrorEvent.IO_ERROR, loaderErrorHandler);
				updateStats();
			}
		}
 
		/**
		 * Unregisters all the currently registered loaders.
		 */
		public function unregisterAll():void
		{
			// Use a copy of the loaders array because the original loaders array will be
			// manipulated as we loop through removing loaders.
			var loaders:Array = loaders.slice();
			for each (var loader:IEventDispatcher in loaders)
			{
				unregister(loader);
			}
		}
 
		/**
		 * Updates stats when progress events are dispatched.
		 */
		protected function loaderProgressHandler(event:ProgressEvent):void
		{
			updateStats();
		}
 
		/**
		 * Updates stats when complete events are dispatched.
		 */
		protected function loaderCompleteHandler(event:Event):void
		{
			updateStats();
		}
 
		/**
		 * Updates stats when error events are dispatched.
		 */
		protected function loaderErrorHandler(event:IOErrorEvent):void
		{
			// Because the loader will never reach a complete state because of the error,
			// we'll unregister the loader now.
			unregister(IEventDispatcher(event.target));
			updateStats();
		}
 
		/**
		 * Marks that we need to update stats.  We delay the actual updating of the stats
		 * until the next frame as a type of invalidation/validation cycle like the Flex components
		 * go through.  This is to avoid duplicate calls to the stat updating logic within a
		 * single render.
		 */
		protected function updateStats():void
		{
			if (!statsNeedUpdating)
			{
				statsNeedUpdating = true;
 
				if (!updateStatsDelayTimer)
				{
					updateStatsDelayTimer = new Timer(0, 1);
				}
 
				updateStatsDelayTimer.reset();
				updateStatsDelayTimer.addEventListener(TimerEvent.TIMER_COMPLETE, doUpdateStats);
				updateStatsDelayTimer.start();
			}
		}
 
		/**
		 * Updates percentLoaded stats.  When there is a single loader, this is simply the bytes 
		 * loaded divided by the bytes total for the loader.  When there are multiple loaders, this 
		 * is the number of loaders which have completed their loading process divided by the total 
		 * number of registered loaders.  The reason we can't go off bytes when there are multiple
		 * loaders is because a loader's totalBytes is only populated once it has made its initial
		 * request to the server.  Usually requests are queued, which means the third loader might 
		 * not make its initial request until the first request has returned. This means we don't 
		 * know our grand total number of bytes at the beginning, which is imperative to have
		 * to make an accurate bytesLoaded/bytesTotal calculation.
		 */
		protected function doUpdateStats(event:TimerEvent):void
		{
			updateStatsDelayTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, doUpdateStats);
 
			if (statsNeedUpdating)
			{
				// See the asdoc for this function to understand why we have these different cases.
				if (loaders.length > 1)
				{
					var loadersComplete:uint = 0;
 
					for each (var loader:Object in loaders)
					{
						// bytesTotal is only populated (greater than 0) once the loader has made 
						// its request to the server.
						if (loader.bytesTotal > 0 && loader.bytesLoaded == loader.bytesTotal)
						{
							loadersComplete++;
						}
					}
 
					if (loaders.length == 0)
					{
						percentLoaded = 1;
					}
					else
					{
						percentLoaded = loadersComplete / loaders.length;
					}
				}
				else if (loaders.length == 1)
				{
					// bytesTotal is only populated (greater than 0) once the loader has made 
					// its request to the server.
					if (loaders[0].bytesTotal > 0)
					{
						percentLoaded = loaders[0].bytesLoaded / loaders[0].bytesTotal; 
					}
					else
					{
						percentLoaded = 0;
					}
				}
				else
				{
					percentLoaded = 1;
				}
 
				dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS));
 
				// If all the loaders we have registered have completed loading, we'll
				// unregister all of them and dispatch a complete event.
				if (percentLoaded == 1)
				{
					unregisterAll();
					updateStatsDelayTimer = null;
					dispatchEvent(new Event(Event.COMPLETE));
				}
 
				// Reset the flag.
				statsNeedUpdating = false
			}
		}
	}
}