package
{
    import flash.errors.IOError;
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.IOErrorEvent;
    import flash.events.ProgressEvent;
    import flash.events.SecurityErrorEvent;
    import flash.net.FileReferenceList;
    import flash.net.FileReference;
    import flash.net.FileFilter;
    import flash.net.URLLoader;
    import flash.net.URLRequest;
    import flash.net.URLLoaderDataFormat;
    import flash.net.URLVariables;
    import flash.net.URLRequestMethod;
    import flash.utils.ByteArray;
    /**
     * ...
     * @author sfxworks
     */
    public class FileHandler extends EventDispatcher
    {
        private var files:Vector.<FileReference> = new Vector.<FileReference>();
        private var frlist:FileReferenceList = new FileReferenceList();
        private var _returnVars:Vector.<URLVariables> = new Vector.<URLVariables>();
        private var sizeLimit:int;

        private var _numberOfFiles:int = new int(0);
        private var _numberOfCurrentFile:int = new int(0);
        private var _numberOfFilesProcessed:int = new int(0);

        private var l:URLLoader;
        private var rq:URLRequest;
        private var vars:URLVariables;

        public function FileHandler()
        {

        }

        public function browse(fileFilter:Array = null, fileSizeLimit = null):void
        {
            sizeLimit = new int(fileSizeLimit);
            frlist.addEventListener(Event.SELECT, selectHandler); //Handle when selected.
            switch(fileFilter)
            {
                case null:
                    frlist.browse();
                    break;
                case !null:
                    frlist.browse(fileFilter);
                    break;
            }
        }

        public function uploadAll(url:String, location:String = null, auth:String):void
        {
            _numberOfCurrentFile = 0;
            for (_numberOfCurrentFile; _numberOfCurrentFile < _numberOfFiles; _numberOfCurrentFile++)
            {
                rq = new URLRequest();
                rq.url = url + "?name=" + files[_numberOfCurrentFile].name.toString() + "&auth="+auth + "&location=" + location;
                rq.data = files[_numberOfCurrentFile].data;
                rq.useCache = false;
                rq.method = URLRequestMethod.POST;
                rq.contentType = "application/octet-stream";

                l = new URLLoader();
                l.addEventListener(Event.COMPLETE, fileUploadHandler);
                l.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
                l.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
                l.load(rq);
            }
        }

        private function ioErrorHandler(e:IOErrorEvent):void
        {
            trace("IO ERROR." + e.target);
        }

        private function securityErrorHandler(e:SecurityErrorEvent):void
        {
            trace("SECURITY ERROR." + e.target);
        }

        private function fileUploadHandler(e:Event):void
        {
            _numberOfFilesProcessed++;
            vars = new URLVariables(e.target.data);
            _returnVars.push(vars);
            dispatchEvent(new Event(ProgressEvent.PROGRESS));

            if (_numberOfFiles == _numberOfFilesProcessed)
            {
                dispatchEvent(new Event(Event.COMPLETE));
            }
        }

        private function selectHandler(e:Event):void
        {
            frlist.removeEventListener(Event.SELECT, selectHandler);
            _numberOfFiles = _numberOfFiles + frlist.fileList.length;

            _numberOfCurrentFile = 0;
            for (_numberOfCurrentFile; _numberOfCurrentFile < frlist.fileList.length; _numberOfCurrentFile++)
            {
                var f:FileReference = new FileReference();
                f = e.target.fileList[_numberOfCurrentFile];
                f.addEventListener(Event.COMPLETE, fileLoadCompleteHandler);
                f.load();
            }
        }

        private function fileLoadCompleteHandler(e:Event):void
        {
            files.push(e.target);
            _numberOfFilesProcessed++;
            dispatchEvent(new Event(ProgressEvent.PROGRESS));
            if (_numberOfFiles == _numberOfFilesProcessed)
            {
                _numberOfFilesProcessed = 0;
                dispatchEvent(new Event(Event.COMPLETE));
            }
        }

        public function resetSelf():void
        {
            files = new Vector.<FileReference>();
            frlist = new FileReferenceList();
            _returnVars = new Vector.<Array>();

            _numberOfFiles = new int(0);
            _numberOfCurrentFile = new int(0);
            _numberOfFilesProcessed = new int(0);

            l = new URLLoader();
            rq = new URLRequest();
            vars = new URLVariables();
        }

        public function get returnVars():Vector.<URLVariables>
        {
            return _returnVars;
        }

        public function get numberOfFilesProcessed():int
        {
            return _numberOfFilesProcessed;
        }

        public function get numberOfCurrentFile():int
        {
            return _numberOfCurrentFile;
        }

        public function get numberOfFiles():int
        {
            return _numberOfFiles;
        }
    }

}