package Utils {

 

        import flash.display.Loader;

        import flash.display.DisplayObject;

        import flash.events.*;

        import flash.net.URLRequest;

        import flash.utils.ByteArray;

 

        public class LoaderQueue {

 

                private var _loads:Array = new Array();

                private var _is_loading:Boolean = false;

                private var _last_loader:Loader;

                private var _current_load:Object;

 

                private var _loaded_objects:Object = new Object;

                //private var _hash_queue:Object;

 

                public function addLoad(url:String, target_obj:Object, countAttempts:int = 3):void{

                        var new_load:Object = {

                                url:url,

                                target:target_obj,

                                countAttempts:countAttempts

                                };

                        _loads.push(new_load);

                        checkQueue();

                }

 

                private function checkQueue(){

                        if(_loads.length){

                                if(!_is_loading){

                                        _current_load = _loads.shift();

                                        startLoad(_current_load.url, _current_load.target);

                                }

                        }

                }

 

                private function startLoad(url, target_obj):void{

                        //Проверяем наличие этого объекта в кэше

                        if(_loaded_objects.hasOwnProperty(url)){

                                if(_loaded_objects[url].is_loaded){

                                        //Такой объект мы уже загружали и он находится в нашем кэше

                                        if(_loaded_objects[url].loaded_object){

                                                var loader:Loader = new Loader();

                                                this.configureListenersBytes(loader);

                                                loader.loadBytes(_loaded_objects[url].loaded_object);

                                                target_obj.addChild(loader);

                                        }

                                }else{

                                        //Объект уже загружается, но еще не загружен, т.е. нужно добавиться в очередь на загрузку

                                        _loaded_objects[url].queue.push(target_obj);

                                }

                                checkQueue();

                        }else{

                                //В кэше нет - значит загружаем с указанного урла

                                var _loader:Loader = new Loader();

                                var urlReq:URLRequest = new URLRequest(url);

                                configureListeners(_loader.contentLoaderInfo);

                                _loader.load(urlReq);

                                _last_loader = _loader;

 

                                _loaded_objects[url] = {

                                        loaded_object: null,

                                        is_loaded: false,

                                        queue: new Array()

                                        }

                                _loaded_objects[url].loaded_object = _loader;

                                _is_loading = true;

                        }

                }

 

        private function configureListeners(dispatcher:IEventDispatcher):void {

            dispatcher.addEventListener(Event.COMPLETE, completeHandler);

            dispatcher.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);

            dispatcher.addEventListener(Event.INIT, initHandler);

            dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);

            dispatcher.addEventListener(Event.OPEN, openHandler);

            dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);

            dispatcher.addEventListener(Event.UNLOAD, unLoadHandler);

        }

 

        private function configureListenersBytes(dispatcher:IEventDispatcher):void {

            dispatcher.addEventListener(AsyncErrorEvent.ASYNC_ERROR, ioErrorHandler);

            dispatcher.addEventListener(Event.COMPLETE, completeHandlerBytes);

            dispatcher.addEventListener(Event.INIT, initHandler);

            dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);

            dispatcher.addEventListener(Event.OPEN, openHandler);

            dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);

            dispatcher.addEventListener(Event.UNLOAD, unLoadHandler);

        }

 

                public function completeHandlerBytes(event:Event):void {

 

                }

 

                public function completeHandler(event:Event):void {

                        var hash_object = _loaded_objects[_current_load.url];

 

                        _current_load.target.addChild(hash_object.loaded_object);

                        //Перезаписываем

                        hash_object.loaded_object = event.currentTarget.bytes;

                        hash_object.is_loaded = true;

                        //trace(event.currentTarget.bytes);

                        if(hash_object.queue.length){

                                for(var i:int = 0; i < hash_object.queue.length; i++){

                                        var loader:Loader = new Loader();

                                        this.configureListenersBytes(loader);

                                        loader.loadBytes(_last_loader.loaderInfo.bytes);

                                        hash_object.queue[i].addChild(loader);

                                }

                        }

 

                        _is_loading = false;

                        checkQueue();

                }

 

                private function httpStatusHandler(event:HTTPStatusEvent):void {

                        //trace("httpStatusHandler: " + event);

                }

 

                private function initHandler(event:Event):void {

                        //trace("initHandler: " + event);

                }

 

                private function ioErrorHandler(event:IOErrorEvent):void {

                        trace("ioErrorHandler: " + event);

                        _is_loading = false;

                        if(_current_load.countAttempts > 0){

                                _current_load.countAttempts--;

                                _loads.push(_current_load);

                        }

                        checkQueue();

                }

 

                private function openHandler(event:Event):void {

                        //trace("openHandler: " + event);

                }

 

                private function progressHandler(event:ProgressEvent):void {

                        //trace("progressHandler: bytesLoaded=" + event.bytesLoaded + " bytesTotal=" + event.bytesTotal);

                }

 

                private function unLoadHandler(event:Event):void {

                        //trace("unLoadHandler: " + event);

                }

        }

}