StatsConsolidator.as

package org.assetloader.base
{
	import org.assetloader.core.ILoadStats;
	import org.assetloader.core.ILoader;
	import org.assetloader.signals.LoaderSignal;
	import org.assetloader.signals.ProgressSignal;

	/**
	 * @author Matan Uberstein
	 */
	public class StatsConsolidator
	{
		protected var _loaders : Array;
		protected var _stats : ILoadStats;

		protected var _numLoaders : int;
		protected var _numComplete : int;

		protected var _onOpen : LoaderSignal;
		protected var _onProgress : ProgressSignal;
		protected var _onComplete : LoaderSignal;

		public function StatsConsolidator()
		{
			_loaders = [];
			_stats = new LoaderStats();

			_onOpen = new LoaderSignal();
			_onProgress = new ProgressSignal();
			_onComplete = new LoaderSignal();
		}

		public function add(loader : ILoader) : void
		{
			if(_loaders.indexOf(loader) == -1)
			{
				loader.onStart.add(start_handler);
				loader.onOpen.add(open_handler);
				loader.onProgress.add(progress_handler);
				loader.onComplete.add(complete_handler);

				_loaders.push(loader);
				_numLoaders = _loaders.length;
			}
			else
				throw new Error("Already contains loader."); //FIXME: needs proper AssetLoaderError
		}


		public function remove(loader : ILoader) : void
		{
			var index : int = _loaders.indexOf(loader);
			if(index != -1)
			{
				loader.onStart.remove(start_handler);
				loader.onOpen.remove(open_handler);
				loader.onProgress.remove(progress_handler);
				loader.onComplete.remove(complete_handler);

				_loaders.splice(index, 1);
				_numLoaders = _loaders.length;
			}
			else
				throw new Error("Does not contain loader."); //FIXME: needs proper AssetLoaderError
		}

		public function destroy() : void
		{
			for each(var loader : ILoader in _loaders)
			{
				remove(loader);
			}
			_onProgress.removeAll();
		}

		protected function start_handler(signal : LoaderSignal) : void
		{
			for each(var loader : ILoader in _loaders)
			{
				loader.onStart.remove(start_handler);
			}
			_stats.start();
		}

		protected function open_handler(signal : LoaderSignal) : void
		{
			_stats.open();
			_onOpen.dispatch(signal.loader);
		}

		protected function progress_handler(signal : ProgressSignal) : void
		{
			var bytesLoaded : uint;
			var bytesTotal : uint;
			for each(var loader : ILoader in _loaders)
			{
				bytesLoaded += loader.stats.bytesLoaded;
				bytesTotal += loader.stats.bytesTotal;
			}
			_stats.update(bytesLoaded, bytesTotal);

			_onProgress.dispatch(signal.loader, _stats.latency, _stats.speed, _stats.averageSpeed, _stats.progress, _stats.bytesLoaded, _stats.bytesTotal);
		}

		protected function complete_handler(signal : LoaderSignal, payload : *) : void
		{
			_numComplete++;
			if(_numComplete == _numLoaders)
			{
				_stats.done();
				_onComplete.dispatch(signal.loader);
			}
		}

		public function get stats() : ILoadStats
		{
			return _stats;
		}

		public function get onOpen() : LoaderSignal
		{
			return _onOpen;
		}

		public function get onProgress() : ProgressSignal
		{
			return _onProgress;
		}

		public function get onComplete() : LoaderSignal
		{
			return _onComplete;
		}
	}
}