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

/**

* This module provides a UI for file selection and multiple file upload capability using

* Flash as a transport engine.

* The supported features include: automatic upload queue management, upload progress

* tracking, file filtering, server response retrieval and error reporting.

*

* @module uploader-flash

* @deprecated

*/

// Shorthands for external modules

var substitute            = Y.Lang.sub,

    UploaderQueue         = Y.Uploader.Queue;

/**

 * Embed a Flash applications in a standard manner and communicate with it

 * via External Interface.

 * @module swf

 */

    var Event = Y.Event,

        SWFDetect = Y.SWFDetect,

        Lang = Y.Lang,

        uA = Y.UA,

        Node = Y.Node,

        Escape = Y.Escape,

        // private

        FLASH_CID = "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000",

        FLASH_TYPE = "application/x-shockwave-flash",

        FLASH_VER = "10.0.22",

        EXPRESS_INSTALL_URL = "http://fpdownload.macromedia.com/pub/flashplayer/update/current/swf/autoUpdater.swf?" + Math.random(),

        EVENT_HANDLER = "SWF.eventHandler",

        possibleAttributes = {align:"", allowFullScreen:"", allowNetworking:"", allowScriptAccess:"", base:"", bgcolor:"", loop:"", menu:"", name:"", play: "", quality:"", salign:"", scale:"", tabindex:"", wmode:""};

        /**

         * The SWF utility is a tool for embedding Flash applications in HTML pages.

         * @module swf

         * @title SWF Utility

         * @requires event-custom, node, swfdetect

         */

        /**

         * Creates the SWF instance and keeps the configuration data

         *

         * @class SWF

         * @uses Y.Event.Target

         * @constructor

         * @param {String|HTMLElement} id The id of the element, or the element itself that the SWF will be inserted into.

         *        The width and height of the SWF will be set to the width and height of this container element.

         * @param {String} swfURL The URL of the SWF to be embedded into the page.

         * @param {Object} p_oAttributes (optional) Configuration parameters for the Flash application and values for Flashvars

         *        to be passed to the SWF. The p_oAttributes object allows the following additional properties:

         *        <dl>

         *          <dt>version : String</dt>

         *          <dd>The minimum version of Flash required on the user's machine.</dd>

         *          <dt>fixedAttributes : Object</dt>

         *          <dd>An object literal containing one or more of the following String keys and their values: <code>align,

         *              allowFullScreen, allowNetworking, allowScriptAccess, base, bgcolor, menu, name, quality, salign, scale,

         *              tabindex, wmode.</code> event from the thumb</dd>

         *        </dl>

         */

function SWF (p_oElement /*:String*/, swfURL /*:String*/, p_oAttributes /*:Object*/ ) {

    this._id = Y.guid("yuiswf");

    var _id = this._id;

    var oElement = Node.one(p_oElement);

    var p_oAttributes = p_oAttributes || {};

    var flashVersion = p_oAttributes.version || FLASH_VER;

    var flashVersionSplit = (flashVersion + '').split(".");

    var isFlashVersionRight = SWFDetect.isFlashVersionAtLeast(parseInt(flashVersionSplit[0], 10), parseInt(flashVersionSplit[1], 10), parseInt(flashVersionSplit[2], 10));

    var canExpressInstall = (SWFDetect.isFlashVersionAtLeast(8,0,0));

    var shouldExpressInstall = canExpressInstall && !isFlashVersionRight && p_oAttributes.useExpressInstall;

    var flashURL = (shouldExpressInstall)?EXPRESS_INSTALL_URL:swfURL;

    var objstring = '<object ';

    var w, h;

    var flashvarstring = "yId=" + Y.id + "&YUISwfId=" + _id + "&YUIBridgeCallback=" + EVENT_HANDLER + "&allowedDomain=" + document.location.hostname;

    Y.SWF._instances[_id] = this;

    if (oElement && (isFlashVersionRight || shouldExpressInstall) && flashURL) {

        objstring += 'id="' + _id + '" ';

        if (uA.ie) {

            objstring += 'classid="' + FLASH_CID + '" ';

        } else {

            objstring += 'type="' + FLASH_TYPE + '" data="' + Escape.html(flashURL) + '" ';

        }

        w = "100%";

        h = "100%";

        objstring += 'width="' + w + '" height="' + h + '">';

        if (uA.ie) {

            objstring += '<param name="movie" value="' + Escape.html(flashURL) + '"/>';

        }

        for (var attribute in p_oAttributes.fixedAttributes) {

            if (possibleAttributes.hasOwnProperty(attribute)) {

                objstring += '<param name="' + Escape.html(attribute) + '" value="' + Escape.html(p_oAttributes.fixedAttributes[attribute]) + '"/>';

            }

        }

        for (var flashvar in p_oAttributes.flashVars) {

            var fvar = p_oAttributes.flashVars[flashvar];

            if (Lang.isString(fvar)) {

                flashvarstring += "&" + Escape.html(flashvar) + "=" + Escape.html(encodeURIComponent(fvar));

            }

        }

        if (flashvarstring) {

            objstring += '<param name="flashVars" value="' + flashvarstring + '"/>';

        }

        objstring += "</object>";

        //using innerHTML as setHTML/setContent causes some issues with ExternalInterface for IE versions of the player

        oElement.set("innerHTML", objstring);

        this._swf = Node.one("#" + _id);

    } else {

        /**

         * Fired when the Flash player version on the user's machine is

         * below the required value.

         *

         * @event wrongflashversion

         */

        var event = {};

        event.type = "wrongflashversion";

        this.publish("wrongflashversion", {fireOnce:true});

        this.fire("wrongflashversion", event);

    }

}

/**

 * @private

 * The static collection of all instances of the SWFs on the page.

 * @property _instances

 * @type Object

 */

SWF._instances = SWF._instances || {};

/**

 * @private

 * Handles an event coming from within the SWF and delegate it

 * to a specific instance of SWF.

 * @method eventHandler

 * @param swfid {String} the id of the SWF dispatching the event

 * @param event {Object} the event being transmitted.

 */

SWF.eventHandler = function (swfid, event) {

    SWF._instances[swfid]._eventHandler(event);

};

SWF.prototype = {

    /**

     * @private

     * Propagates a specific event from Flash to JS.

     * @method _eventHandler

     * @param event {Object} The event to be propagated from Flash.

     */

    _eventHandler: function(event) {

        if (event.type === "swfReady") {

            this.publish("swfReady", {fireOnce:true});

            this.fire("swfReady", event);

        } else if(event.type === "log") {

            Y.log(event.message, event.category, this.toString());

        } else {

            this.fire(event.type, event);

        }

    },

        /**

     * Calls a specific function exposed by the SWF's

     * ExternalInterface.

     * @method callSWF

     * @param func {String} the name of the function to call

     * @param args {Array} the set of arguments to pass to the function.

     */

    callSWF: function (func, args)

    {

    if (!args) {

          args= [];

    }

        if (this._swf._node[func]) {

        return(this._swf._node[func].apply(this._swf._node, args));

        } else {

        return null;

        }

    },

    /**

     * Public accessor to the unique name of the SWF instance.

     *

     * @method toString

     * @return {String} Unique name of the SWF instance.

     */

    toString: function()

    {

        return "SWF " + this._id;

    }

};

Y.augment(SWF, Y.EventTarget);

Y.SWF = SWF;

    /**

     * The FileFlash class provides a wrapper for a file pointer stored in Flash. The File wrapper

     * also implements the mechanics for uploading a file and tracking its progress.

     * @module file-flash

     */

    /**

     * The class provides a wrapper for a file pointer in Flash.

     * @class FileFlash

     * @extends Base

     * @constructor

     * @param {Object} config Configuration object.

     */

    var FileFlash = function(o) {

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

    };

    Y.extend(FileFlash, Y.Base, {

       /**

        * Construction logic executed during FileFlash instantiation.

        *

        * @method initializer

        * @protected

        */

        initializer : function (cfg) {

            if (!this.get("id")) {

                this._set("id", Y.guid("file"));

            }

        },

       /**

        * Handler of events dispatched by the Flash player.

        *

        * @method _swfEventHandler

        * @param {Event} event The event object received from the Flash player.

        * @protected

        */

        _swfEventHandler: function (event) {

          if (event.id === this.get("id")) {

          switch (event.type) {

            /**

             * Signals that this file's upload has started.

             *

             * @event uploadstart

             * @param event {Event} The event object for the `uploadstart` with the

             *                      following payload:

             *  <dl>

             *      <dt>uploader</dt>

             *          <dd>The Y.SWF instance of Flash uploader that's handling the upload.</dd>

             *  </dl>

             */

            case "uploadstart":

                 this.fire("uploadstart", {uploader: this.get("uploader")});

                 break;

            case "uploadprogress":

                  /**

                   * Signals that progress has been made on the upload of this file.

                   *

                   * @event uploadprogress

                   * @param event {Event} The event object for the `uploadprogress` with the

                   *                      following payload:

                   *  <dl>

                   *      <dt>originEvent</dt>

                   *          <dd>The original event fired by the Flash uploader instance.</dd>

                   *      <dt>bytesLoaded</dt>

                   *          <dd>The number of bytes of the file that has been uploaded.</dd>

                   *      <dt>bytesTotal</dt>

                   *          <dd>The total number of bytes in the file (the file size)</dd>

                   *      <dt>percentLoaded</dt>

                   *          <dd>The fraction of the file that has been uploaded, out of 100.</dd>

                   *  </dl>

                   */

                 this.fire("uploadprogress", {originEvent: event,

                                              bytesLoaded: event.bytesLoaded,

                                              bytesTotal: event.bytesTotal,

                                              percentLoaded: Math.min(100, Math.round(10000*event.bytesLoaded/event.bytesTotal)/100)

                                             });

                 this._set("bytesUploaded", event.bytesLoaded);

                 break;

            case "uploadcomplete":

                  /**

                   * Signals that this file's upload has completed, but data has not yet been received from the server.

                   *

                   * @event uploadfinished

                   * @param event {Event} The event object for the `uploadfinished` with the

                   *                      following payload:

                   *  <dl>

                   *      <dt>originEvent</dt>

                   *          <dd>The original event fired by the Flash player instance.</dd>

                   *  </dl>

                   */

                 this.fire("uploadfinished", {originEvent: event});

                 break;

            case "uploadcompletedata":

                /**

                 * Signals that this file's upload has completed and data has been received from the server.

                 *

                 * @event uploadcomplete

                 * @param event {Event} The event object for the `uploadcomplete` with the

                 *                      following payload:

                 *  <dl>

                 *      <dt>originEvent</dt>

                 *          <dd>The original event fired by the Flash player instance.</dd>

                 *      <dt>data</dt>

                 *          <dd>The data returned by the server.</dd>

                 *  </dl>

                 */

                 this.fire("uploadcomplete", {originEvent: event,

                                              data: event.data});

                 break;

            case "uploadcancel":

                /**

                 * Signals that this file's upload has been cancelled.

                 *

                 * @event uploadcancel

                 * @param event {Event} The event object for the `uploadcancel` with the

                 *                      following payload:

                 *  <dl>

                 *      <dt>originEvent</dt>

                 *          <dd>The original event fired by the Flash player instance.</dd>

                 *  </dl>

                 */

                 this.fire("uploadcancel", {originEvent: event});

                 break;

            case "uploaderror":

                /**

                 * Signals that this file's upload has encountered an error.

                 *

                 * @event uploaderror

                 * @param event {Event} The event object for the `uploaderror` with the

                 *                      following payload:

                 *  <dl>

                 *      <dt>originEvent</dt>

                 *          <dd>The original event fired by the Flash player instance.</dd>

                 *      <dt>status</dt>

                 *          <dd>The status code reported by the Flash Player. If it's an HTTP error,

                 *                then this corresponds to the HTTP status code received by the uploader.</dd>

                 *      <dt>statusText</dt>

                 *          <dd>The text of the error event reported by the Flash Player.</dd>

                 *      <dt>source</dt>

                 *          <dd>Either "http" (if it's an HTTP error), or "io" (if it's a network transmission

                 *              error.)</dd>

                 *  </dl>

                 */

                 this.fire("uploaderror", {originEvent: event, status: event.status, statusText: event.message, source: event.source});

          }

        }

        },

       /**

        * Starts the upload of a specific file.

        *

        * @method startUpload

        * @param url {String} The URL to upload the file to.

        * @param parameters {Object} (optional) A set of key-value pairs to send as variables along with the file upload HTTP request.

        * @param fileFieldName {String} (optional) The name of the POST variable that should contain the uploaded file ('Filedata' by default)

        */

        startUpload: function(url, parameters, fileFieldName) {

        if (this.get("uploader")) {

            var myUploader = this.get("uploader"),

                fileField = fileFieldName || "Filedata",

                id = this.get("id"),

                params = parameters || null;

            this._set("bytesUploaded", 0);

            myUploader.on("uploadstart", this._swfEventHandler, this);

            myUploader.on("uploadprogress", this._swfEventHandler, this);

            myUploader.on("uploadcomplete", this._swfEventHandler, this);

            myUploader.on("uploadcompletedata", this._swfEventHandler, this);

            myUploader.on("uploaderror", this._swfEventHandler, this);

            myUploader.callSWF("upload", [id, url, params, fileField]);

         }

        },