YUI.add('uploader-queue', function (Y, NAME) {

/**

* The class manages a queue of files that should be uploaded to the server.

* It initializes the required number of uploads, tracks them as they progress,

* and automatically advances to the next upload when a preceding one has completed.

* @module uploader-queue

*/

/**

* This class manages a queue of files to be uploaded to the server.

* @class Uploader.Queue

* @extends Base

* @constructor

*/

var UploaderQueue = function() {

    this.queuedFiles = [];

    this.uploadRetries = {};

    this.numberOfUploads = 0;

    this.currentUploadedByteValues = {};

    this.currentFiles = {};

    this.totalBytesUploaded = 0;

    this.totalBytes = 0;

    UploaderQueue.superclass.constructor.apply(this, arguments);

};

Y.extend(UploaderQueue, Y.Base, {

    /**

    * Stored value of the current queue state

    * @property _currentState

    * @type {String}

    * @protected

    * @default UploaderQueue.STOPPED

    */

    _currentState: UploaderQueue.STOPPED,

    /**

    * Construction logic executed during UploaderQueue instantiation.

    *

    * @method initializer

    * @protected

    */

    initializer : function () {},

    /**

    * Handles and retransmits upload start event.

    *

    * @method _uploadStartHandler

    * @param event The event dispatched during the upload process.

    * @private

    */

    _uploadStartHandler : function (event) {

        var updatedEvent = event;

        updatedEvent.file = event.target;

        updatedEvent.originEvent = event;

        this.fire("uploadstart", updatedEvent);

    },

    /**

    * Handles and retransmits upload error event.

    *

    * @method _uploadErrorHandler

    * @param event The event dispatched during the upload process.

    * @private

    */

    _uploadErrorHandler : function (event) {

        var errorAction = this.get("errorAction"),

            updatedEvent = event,

            fileid,

            retries;

        updatedEvent.file = event.target;

        updatedEvent.originEvent = event;

        this.numberOfUploads-=1;

        delete this.currentFiles[event.target.get("id")];

        this._detachFileEvents(event.target);

        event.target.cancelUpload();

        if (errorAction === UploaderQueue.STOP) {

            this.pauseUpload();

        }

        else if (errorAction === UploaderQueue.RESTART_ASAP) {

            fileid = event.target.get("id");

            retries = this.uploadRetries[fileid] || 0;

            if (retries < this.get("retryCount")) {

                this.uploadRetries[fileid] = retries + 1;

                this.addToQueueTop(event.target);

            }

            this._startNextFile();

        }

        else if (errorAction === UploaderQueue.RESTART_AFTER) {

            fileid = event.target.get("id");

            retries = this.uploadRetries[fileid] || 0;

            if (retries < this.get("retryCount")) {

                this.uploadRetries[fileid] = retries + 1;

                this.addToQueueBottom(event.target);

            }

            this._startNextFile();

        }

        this.fire("uploaderror", updatedEvent);

    },

    /**

    * Launches the upload of the next file in the queue.

    *

    * @method _startNextFile

    * @private

    */

    _startNextFile : function () {

        if (this.queuedFiles.length > 0) {

            var currentFile = this.queuedFiles.shift(),

                fileId = currentFile.get("id"),

                parameters = this.get("perFileParameters"),

                fileParameters = parameters.hasOwnProperty(fileId) ? parameters[fileId] : parameters;

            this.currentUploadedByteValues[fileId] = 0;

            currentFile.on("uploadstart", this._uploadStartHandler, this);

            currentFile.on("uploadprogress", this._uploadProgressHandler, this);

            currentFile.on("uploadcomplete", this._uploadCompleteHandler, this);

            currentFile.on("uploaderror", this._uploadErrorHandler, this);

            currentFile.on("uploadcancel", this._uploadCancelHandler, this);

            currentFile.set("xhrHeaders", this.get("uploadHeaders"));

            currentFile.set("xhrWithCredentials", this.get("withCredentials"));

            currentFile.startUpload(this.get("uploadURL"), fileParameters, this.get("fileFieldName"));

            this._registerUpload(currentFile);

        }

    },

    /**

    * Register a new upload process.

    *

    * @method _registerUpload

    * @private

    */

    _registerUpload : function (file) {

        this.numberOfUploads += 1;

        this.currentFiles[file.get("id")] = file;

    },

    /**

    * Unregisters a new upload process.

    *

    * @method _unregisterUpload

    * @private

    */

    _unregisterUpload : function (file) {

        if (this.numberOfUploads > 0) {

            this.numberOfUploads -= 1;

        }

        delete this.currentFiles[file.get("id")];

        delete this.uploadRetries[file.get("id")];

        this._detachFileEvents(file);

    },

    _detachFileEvents : function (file) {

        file.detach("uploadstart", this._uploadStartHandler);

        file.detach("uploadprogress", this._uploadProgressHandler);

        file.detach("uploadcomplete", this._uploadCompleteHandler);

        file.detach("uploaderror", this._uploadErrorHandler);

        file.detach("uploadcancel", this._uploadCancelHandler);

    },

    /**

    * Handles and retransmits upload complete event.

    *

    * @method _uploadCompleteHandler

    * @param event The event dispatched during the upload process.

    * @private

    */

    _uploadCompleteHandler : function (event) {

        this._unregisterUpload(event.target);

        this.totalBytesUploaded += event.target.get("size");

        delete this.currentUploadedByteValues[event.target.get("id")];

        if (this.queuedFiles.length > 0 && this._currentState === UploaderQueue.UPLOADING) {

            this._startNextFile();

        }

        var updatedEvent = event,

            uploadedTotal = this.totalBytesUploaded,

            percentLoaded = Math.min(100, Math.round(10000*uploadedTotal/this.totalBytes) / 100);

        updatedEvent.file = event.target;

        updatedEvent.originEvent = event;

        Y.each(this.currentUploadedByteValues, function (value) {

            uploadedTotal += value;

        });

        this.fire("totaluploadprogress", {

            bytesLoaded: uploadedTotal,

            bytesTotal: this.totalBytes,

            percentLoaded: percentLoaded

        });

        this.fire("uploadcomplete", updatedEvent);

        if (this.queuedFiles.length === 0 && this.numberOfUploads <= 0) {

            this.fire("alluploadscomplete");

            this._currentState = UploaderQueue.STOPPED;

        }

    },

    /**

    * Handles and retransmits upload cancel event.

    *

    * @method _uploadCancelHandler

    * @param event The event dispatched during the upload process.

    * @private

    */

    _uploadCancelHandler : function (event) {

        var updatedEvent = event;

        updatedEvent.originEvent = event;

        updatedEvent.file = event.target;

        this.fire("uploadcancel", updatedEvent);

    },

    /**

    * Handles and retransmits upload progress event.

    *

    * @method _uploadProgressHandler

    * @param event The event dispatched during the upload process.

    * @private

    */

    _uploadProgressHandler : function (event) {

        this.currentUploadedByteValues[event.target.get("id")] = event.bytesLoaded;

        var updatedEvent = event,

            uploadedTotal = this.totalBytesUploaded,

            percentLoaded = Math.min(100, Math.round(10000*uploadedTotal/this.totalBytes) / 100);

        updatedEvent.originEvent = event;

        updatedEvent.file = event.target;

        this.fire("uploadprogress", updatedEvent);

        Y.each(this.currentUploadedByteValues, function (value) {

            uploadedTotal += value;

        });

        this.fire("totaluploadprogress", {

            bytesLoaded: uploadedTotal,

            bytesTotal: this.totalBytes,

            percentLoaded: percentLoaded

        });

    },

    /**

    * Starts uploading the queued up file list.

    *

    * @method startUpload

    */

    startUpload: function() {

        this.queuedFiles = this.get("fileList").slice(0);

        this.numberOfUploads = 0;

        this.currentUploadedByteValues = {};

        this.currentFiles = {};

        this.totalBytesUploaded = 0;

        this._currentState = UploaderQueue.UPLOADING;

        while (this.numberOfUploads < this.get("simUploads") && this.queuedFiles.length > 0) {

            this._startNextFile();

        }

    },

    /**

    * Pauses the upload process. The ongoing file uploads

    * will complete after this method is called, but no

    * new ones will be launched.

    *

    * @method pauseUpload

    */

    pauseUpload: function () {

        this._currentState = UploaderQueue.STOPPED;

    },

    /**

    * Restarts a paused upload process.

    *

    * @method restartUpload

    */

    restartUpload: function () {

        this._currentState = UploaderQueue.UPLOADING;

        while (this.numberOfUploads < this.get("simUploads")) {

             this._startNextFile();

        }

    },

    /**

    * If a particular file is stuck in an ongoing upload without

    * any progress events, this method allows to force its reupload

    * by cancelling its upload and immediately relaunching it.

    *

    * @method forceReupload

    * @param file {File} The file to force reupload on.

    */

    forceReupload : function (file) {

        var id = file.get("id");

        if (this.currentFiles.hasOwnProperty(id)) {

            file.cancelUpload();

            this._unregisterUpload(file);

            this.addToQueueTop(file);

            this._startNextFile();

        }

    },

    /**

    * Add a new file to the top of the queue (the upload will be

    * launched as soon as the current number of uploading files

    * drops below the maximum permissible value).

    *

    * @method addToQueueTop

    * @param file {File} The file to add to the top of the queue.

    */

    addToQueueTop: function (file) {

            this.queuedFiles.unshift(file);

    },

    /**

    * Add a new file to the bottom of the queue (the upload will be

    * launched after all the other queued files are uploaded.)

    *

    * @method addToQueueBottom

    * @param file {File} The file to add to the bottom of the queue.

    */

    addToQueueBottom: function (file) {

            this.queuedFiles.push(file);

    },

    /**

    * Cancels a specific file's upload. If no argument is passed,

    * all ongoing uploads are cancelled and the upload process is

    * stopped.

    *

    * @method cancelUpload

    * @param file {File} An optional parameter - the file whose upload

    * should be cancelled.

    */

    cancelUpload: function (file) {

        var id,

            i,

            fid;

        if (file) {

            id = file.get("id");

            if (this.currentFiles[id]) {

                this.currentFiles[id].cancelUpload();

                this._unregisterUpload(this.currentFiles[id]);

                if (this._currentState === UploaderQueue.UPLOADING) {

                    this._startNextFile();

                }

            }

            else {

                for (i = 0, len = this.queuedFiles.length; i < len; i++) {

                    if (this.queuedFiles[i].get("id") === id) {

                        this.queuedFiles.splice(i, 1);

                        break;

                    }

                }

            }

        }

        else {

            for (fid in this.currentFiles) {

                this.currentFiles[fid].cancelUpload();