/**
 * Image loader and cacher
 * Loads images with bitmap caching
 *
 * @author		Zeh Fernando
 * @version		1.4.4
 *
 * 18 jun 07 (1.4.4) - complete overhaul on the loading procedure, to avoid problems with images being removing halfway through the loading but still caching
 * 04 jun 07 (1.3.4) - small fix, removed the "smooth" value for the constructor (leftover; was always ignored)
 * 17 may 07 (1.3.3) - new parameter for loadImage(), for bitmap smoothing (default true)
 * 17 apr 07 (1.3.2) - fix for not recognizing cached images after the cached ones were already loaded (thanks to Nick Shaw for pointing the error)
 * 21 mar 07 (1.3.1) - new loadings for an image that's already loading with a lower priority will mime but actually up the original priority
 * 20 mar 07 (1.3.0) - clearCache()
 * 17 mar 07 (1.2.0) - setSlots() method for the static class
 * 15 mar 07 (1.1.0) - Handles priority
 * 25 dec 06 (1.0.0) - First version
 */

/*
Usage:

import zeh.loading.ImageLoader;

var xx = new ImageLoader(whateverMC);
xx.onStart = function() {
};
xx.onUpdate = function(f:Number) {
};
xx.onComplete = function() {
};
xx.loadImage("whatever.jpg");

With priority:

loader1.loadImage("whatever1.jpg", 5);
loader2.loadImage("whatever2.jpg", 0);

Then yy will load before xx.
Priority is just a comparison number; two imageloaders can have the same priority (the first one loads first).
Default priority is 5.

*/

/*
TODO:
Same-priority management based on scope of the instance
*/

import zeh.loading.LoadingQueue;
import flash.display.BitmapData;

class zeh.loading.ImageLoader {

	private static var _queue:LoadingQueue;				// Queue which contains the images being loaded
	private static var _activeLoaders:Array;			// List of active loaders {target:MovieClip, url:String, priority:Number, smoothed:Boolean}
	private static var _imageQueue:Array;				// List of images being loaded {url:String, target:MovieClip}
	private static var _imageCache:Array;				// List of cached images {url:String, bmp:BitmapData}
	private static var _maxSlots:Number;				// Number of maximum global loading slots

	public var target:MovieClip;						// Where the image will be loaded
	public var url:String;								// URL to be loaded
	public var priority:Number;							// Priority order: ie, 0 is most urgent, 5/undefined is default, 10 is less urgent
	public var smoothed:Boolean;						// Whether the image should be smoothed or not when attached

	public var onStart:Function;
	public var onUpdate:Function;
	public var onComplete:Function;


	// ================================================================================================================
	// INSTANCE functions ---------------------------------------------------------------------------------------------

	// Constructor
	public function ImageLoader (p_target:MovieClip) {
		init();
		target = p_target;
		smoothed = true;
	}

	// Adds a new MovieClip to the loading queue
	public function loadImage (p_url:String, p_priority:Number, p_smoothed:Boolean) {
		url = p_url;
		priority = p_priority;
		if (p_smoothed != undefined) smoothed = p_smoothed;
		addActiveLoader(this);
	}

		

	// ================================================================================================================
	// STATIC functions -----------------------------------------------------------------------------------------------

	private static function init (): Void {
		// Initializes everything (ran several times, when needed)

		if (_root.__ImageLoader_Controller__ == undefined) {
			// Not started
			var $ic:MovieClip = _root.createEmptyMovieClip("__ImageLoader_Controller__", _root.getNextHighestDepth());
			$ic.onEnterFrame = function() {
				ImageLoader.tick();
			}

			if (_maxSlots == undefined) _maxSlots = 2;
			_queue = new LoadingQueue(_root, _maxSlots);
			_activeLoaders = new Array();
			if (_imageCache == undefined) createImageCache();
		}

	}

	private static function addActiveLoader (p_il:ImageLoader): Void {
		// Adds a loader to the list
		var $i:Number;

		// Checks if there's an equivalent on the cache already
		var $bmp:BitmapData = getBitmapFromURL(p_il.url);
		if ($bmp != null) {
			// Already found, so simply adds this image
//			trace ("ImageLoader :: URL "+p_il.url+" is cached, just attaches");
			p_il.onStart.apply(p_il.target);
			p_il.onUpdate.apply(p_il.target, [1]);
			attachImage(p_il.target, $bmp, p_il.smoothed);
			p_il.onComplete.apply(p_il.target);
			deactivateIfNeeded();
			return;
		}

		// Only if it doesn't exist
		// TODO: allow an overwrite of the url if a second loadImage is done?
		for ($i = 0; $i < _activeLoaders.length; $i++) {
			if (_activeLoaders[$i] == p_il) return;
		}

		// Checks whether there's a loading already taking place for this image
		if (getQueuedFromURL(p_il.url) == null) {
//			trace ("ImageLoader :: " + p_il.url + " ainda não tá sendo carregada, dá load");
			startLoadingURL(p_il.url, p_il.priority);
		}

		// Pushes this activeloader to the list to be checked later
		p_il.onStart.apply(p_il.target);
		_activeLoaders.push(p_il);
		// TODO: check priority in case of a new loading, how to overwrite?
	}

	public static function getQueuedFromURL(p_url:String): MovieClip {
		// Based on the URL, return the queued movieclip, if any
		for (var $i = 0; $i < _imageQueue.length; $i++) {
			if (_imageQueue[$i].url == p_url) {
				return _imageQueue[$i].target;
			}
		}
		return null;
	}

	public static function startLoadingURL(p_url:String, p_priority:Number): Void {
		// Start loading an URL on a hidden movieclip
		var $cl:MovieClip = _root.__ImageLoader_CacheLoader__;
		var $dd:Number = $cl.getNextHighestDepth();
		var $container = $cl.createEmptyMovieClip("_queue_"+$dd, $dd);
		_imageQueue.push({url:p_url, target:$container});
		_queue.addMovie($container, p_url, p_priority);
		_queue.start();
	}
	
	public static function tick(): Void {
		// Executes a check on everything
		var $i:Number;

		// Check image queue -- read images as needed as they finish loading
		// TODO -- check if an image should be removed from here if their final containing movieclips are all removed
		for ($i = 0; $i < _imageQueue.length; $i++) {
			var $iq:Object = _imageQueue[$i];
			$l = $iq.target.getBytesLoaded();
			$t = $iq.target.getBytesTotal();
			if ($iq.target._width > 0 && $l >= $t && $t >= 20) {
				// This image has finished loading, so move from the queue to the cache
				var $bmp:BitmapData = new BitmapData($iq.target._width, $iq.target._height, true, 0x00ffffff);
				$bmp.draw($iq.target);
//				trace ("ImageLoaded :: bitmap " + $bmp + " has loaded on " + $iq.target);
				$iq.target.removeMovieClip();
				_imageCache.push({url:$iq.url, bmp:$bmp});
				_imageQueue.splice($i, 1);
				$iq = undefined;
				$i--;
			}
		}

		// Check active loaders -- attach images or update the % of loaded as needed
		var $l:Number, $t:Number, $f:Number;
		var $hasFinishedAny:Boolean = false;
		for ($i = 0; $i < _activeLoaders.length; $i++) {
			var $al:ImageLoader = _activeLoaders[$i];
			
			if ($al.target.getBytesLoaded == undefined) {
				// Container has been removed during loading!
				$al.target = undefined;
				$al = undefined;
				_activeLoaders.splice($i, 1);
				$i--;
				$hasFinishedAny = true;
			} else {
				// First, check if it's from the queue
				var $target:MovieClip = getQueuedFromURL($al.url);
				if ($target != null) {
					// It's on the queue, so it's still loading
					$l = $target.getBytesLoaded();
					$t = $target.getBytesTotal();
					$f = $t > 20 ? $l / $t : 0;
					$al.onUpdate.apply($al.target, [$f]);
				} else {
					// Not on the queue, so it's loaded already
					var $bmp:BitmapData = getBitmapFromURL($al.url);
					$al.onUpdate.apply($al.target, [1]);
//					trace ("ImageLoaded :: attaching " + $bmp + " to " + $al.target);
					attachImage($al.target, $bmp, $al.smoothed);
					$al.onComplete.apply($al.target);
					_activeLoaders.splice($i, 1);
					$i--;
					$hasFinishedAny = true;
				}
			}
		}

		if ($hasFinishedAny) deactivateIfNeeded;
	}

	private static function deactivateIfNeeded(): Void {
		// Deactivates this if needed
		if (_activeLoaders.length == 0) {
			_activeLoaders = undefined;
			_queue = undefined;
			_root.__ImageLoader_Controller__.removeMovieClip();
		}
	}

	private static function attachImage(p_mc:MovieClip, p_bmp:BitmapData, p_smoothed:Boolean): Void {
		// Attaches the image to the movieclip
//		trace ("ImageLoader :: attaching "+p_bmp+" in "+p_mc);
		p_mc.attachBitmap(p_bmp, p_mc.getNextHighestDepth(), undefined, p_smoothed);
	}

	public static function setSlots(p_slots:Number): Void {
		// Sets the number of maximum slots for loading
		if (isNaN(p_slots) || p_slots < 1) p_slots = 1;
		_maxSlots = p_slots;
		_queue.setSlots(p_slots);
	}

	public static function getBitmapFromURL(p_url:String): BitmapData {
		// Basead on an url, returns a BitmapData instance
		for (var $i = 0; $i < _imageCache.length; $i++) {
			if (_imageCache[$i].url == p_url) {
				return _imageCache[$i].bmp;
			}
		}
		return null;
	}

	public static function clearCache(dispose:Boolean): Void {
		// Clears the cache of images
		// Dispose of images if needed
		if (dispose) {
			for (var i:Number = 0; i < _imageCache.length; i++) {
				_imageCache[i].bmp.dispose();
				_imageCache[i] = undefined;
			}
			_imageCache = undefined;
			for (var i:Number = 0; i < _imageQueue.length; i++) {
				_imageQueue[i].removeMovieClip();
				_imageQueue[i] = undefined;
			}
			_imageQueue = undefined;
		}
		createImageCache();
	}

	private static function createImageCache(): Void {
		// Cria a cache de imagens
		_imageCache = new Array();
		if (_imageQueue == undefined) _imageQueue = new Array();
		if (_root.__ImageLoader_CacheLoader__ == undefined) {
			var $cl:MovieClip = _root.createEmptyMovieClip("__ImageLoader_CacheLoader__", _root.getNextHighestDepth());
			$cl._visible = false;
			$cl._alpha = 0;
		}
		
	}
	
}