YUI.add('io-base', function (Y, NAME) {

/**

Base IO functionality. Provides basic XHR transport support.

@module io

@submodule io-base

@for IO

**/

var // List of events that comprise the IO event lifecycle.

    EVENTS = ['start', 'complete', 'end', 'success', 'failure', 'progress'],

    // Whitelist of used XHR response object properties.

    XHR_PROPS = ['status', 'statusText', 'responseText', 'responseXML'],

    win = Y.config.win,

    uid = 0;

/**

The IO class is a utility that brokers HTTP requests through a simplified

interface.  Specifically, it allows JavaScript to make HTTP requests to

a resource without a page reload.  The underlying transport for making

same-domain requests is the XMLHttpRequest object.  IO can also use

Flash, if specified as a transport, for cross-domain requests.

@class IO

@constructor

@param {Object} config Object of EventTarget's publish method configurations

                    used to configure IO's events.

**/

function IO (config) {

    var io = this;

    io._uid = 'io:' + uid++;

    io._init(config);

    Y.io._map[io._uid] = io;

}

IO.prototype = {

    //--------------------------------------

    //  Properties

    //--------------------------------------

   /**

    * A counter that increments for each transaction.

    *

    * @property _id

    * @private

    * @type {Number}

    */

    _id: 0,

   /**

    * Object of IO HTTP headers sent with each transaction.

    *

    * @property _headers

    * @private

    * @type {Object}

    */

    _headers: {

        'X-Requested-With' : 'XMLHttpRequest'

    },

   /**

    * Object that stores timeout values for any transaction with a defined

    * "timeout" configuration property.

    *

    * @property _timeout

    * @private

    * @type {Object}

    */

    _timeout: {},

    //--------------------------------------

    //  Methods

    //--------------------------------------

    _init: function(config) {

        var io = this, i, len;

        io.cfg = config || {};

        Y.augment(io, Y.EventTarget);

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

            // Publish IO global events with configurations, if any.

            // IO global events are set to broadcast by default.

            // These events use the "io:" namespace.

            io.publish('io:' + EVENTS[i], Y.merge({ broadcast: 1 }, config));

            // Publish IO transaction events with configurations, if

            // any.  These events use the "io-trn:" namespace.

            io.publish('io-trn:' + EVENTS[i], config);

        }

    },

   /**

    * Method that creates a unique transaction object for each request.

    *

    * @method _create

    * @private

    * @param {Object} cfg Configuration object subset to determine if

    *                 the transaction is an XDR or file upload,

    *                 requiring an alternate transport.

    * @param {Number} id Transaction id

    * @return {Object} The transaction object

    */

    _create: function(config, id) {

        var io = this,

            transaction = {

                id : Y.Lang.isNumber(id) ? id : io._id++,

                uid: io._uid

            },

            alt = config.xdr ? config.xdr.use : null,

            form = config.form && config.form.upload ? 'iframe' : null,

            use;

        if (alt === 'native') {

            // Non-IE and IE >= 10  can use XHR level 2 and not rely on an

            // external transport.

            alt = Y.UA.ie && !SUPPORTS_CORS ? 'xdr' : null;

            // Prevent "pre-flight" OPTIONS request by removing the

            // `X-Requested-With` HTTP header from CORS requests. This header

            // can be added back on a per-request basis, if desired.

            io.setHeader('X-Requested-With');

        }

        use = alt || form;

        transaction = use ? Y.merge(Y.IO.customTransport(use), transaction) :

                            Y.merge(Y.IO.defaultTransport(), transaction);

        if (transaction.notify) {

            config.notify = function (e, t, c) { io.notify(e, t, c); };

        }

        if (!use) {

            if (win && win.FormData && config.data instanceof win.FormData) {

                transaction.c.upload.onprogress = function (e) {

                    io.progress(transaction, e, config);

                };

                transaction.c.onload = function (e) {

                    io.load(transaction, e, config);

                };

                transaction.c.onerror = function (e) {

                    io.error(transaction, e, config);

                };

                transaction.upload = true;

            }

        }

        return transaction;

    },

    _destroy: function(transaction) {

        if (win && !transaction.notify && !transaction.xdr) {

            if (XHR && !transaction.upload) {

                transaction.c.onreadystatechange = null;

            } else if (transaction.upload) {

                transaction.c.upload.onprogress = null;

                transaction.c.onload = null;

                transaction.c.onerror = null;

            } else if (Y.UA.ie && !transaction.e) {

                // IE, when using XMLHttpRequest as an ActiveX Object, will throw

                // a "Type Mismatch" error if the event handler is set to "null".

                transaction.c.abort();

            }

        }

        transaction = transaction.c = null;

    },

   /**

    * Method for creating and firing events.

    *

    * @method _evt

    * @private

    * @param {String} eventName Event to be published.

    * @param {Object} transaction Transaction object.

    * @param {Object} config Configuration data subset for event subscription.

    */

    _evt: function(eventName, transaction, config) {

        var io          = this, params,

            args        = config['arguments'],

            emitFacade  = io.cfg.emitFacade,

            globalEvent = "io:" + eventName,

            trnEvent    = "io-trn:" + eventName;

        // Workaround for #2532107

        this.detach(trnEvent);

        if (transaction.e) {

            transaction.c = { status: 0, statusText: transaction.e };

        }

        // Fire event with parameters or an Event Facade.

        params = [ emitFacade ?

            {

                id: transaction.id,

                data: transaction.c,

                cfg: config,

                'arguments': args

            } :

            transaction.id

        ];

        if (!emitFacade) {

            if (eventName === EVENTS[0] || eventName === EVENTS[2]) {

                if (args) {

                    params.push(args);

                }

            } else {

                if (transaction.evt) {

                    params.push(transaction.evt);

                } else {

                    params.push(transaction.c);

                }

                if (args) {

                    params.push(args);

                }

            }

        }

        params.unshift(globalEvent);

        // Fire global events.

        io.fire.apply(io, params);

        // Fire transaction events, if receivers are defined.

        if (config.on) {

            params[0] = trnEvent;

            io.once(trnEvent, config.on[eventName], config.context || Y);

            io.fire.apply(io, params);

        }

    },

   /**

    * Fires event "io:start" and creates, fires a transaction-specific

    * start event, if `config.on.start` is defined.

    *

    * @method start

    * @param {Object} transaction Transaction object.

    * @param {Object} config Configuration object for the transaction.

    */

    start: function(transaction, config) {

       /**

        * Signals the start of an IO request.

        * @event io:start

        */

        this._evt(EVENTS[0], transaction, config);

    },

   /**

    * Fires event "io:complete" and creates, fires a

    * transaction-specific "complete" event, if config.on.complete is

    * defined.

    *

    * @method complete

    * @param {Object} transaction Transaction object.

    * @param {Object} config Configuration object for the transaction.

    */

    complete: function(transaction, config) {

       /**

        * Signals the completion of the request-response phase of a

        * transaction. Response status and data are accessible, if

        * available, in this event.

        * @event io:complete

        */

        this._evt(EVENTS[1], transaction, config);

    },

   /**

    * Fires event "io:end" and creates, fires a transaction-specific "end"

    * event, if config.on.end is defined.

    *

    * @method end

    * @param {Object} transaction Transaction object.

    * @param {Object} config Configuration object for the transaction.

    */

    end: function(transaction, config) {

       /**

        * Signals the end of the transaction lifecycle.

        * @event io:end

        */

        this._evt(EVENTS[2], transaction, config);

        this._destroy(transaction);

    },

   /**

    * Fires event "io:success" and creates, fires a transaction-specific

    * "success" event, if config.on.success is defined.

    *

    * @method success

    * @param {Object} transaction Transaction object.

    * @param {Object} config Configuration object for the transaction.

    */

    success: function(transaction, config) {

       /**

        * Signals an HTTP response with status in the 2xx range.

        * Fires after io:complete.

        * @event io:success

        */

        this._evt(EVENTS[3], transaction, config);

        this.end(transaction, config);

    },

   /**

    * Fires event "io:failure" and creates, fires a transaction-specific

    * "failure" event, if config.on.failure is defined.

    *

    * @method failure

    * @param {Object} transaction Transaction object.

    * @param {Object} config Configuration object for the transaction.

    */

    failure: function(transaction, config) {

       /**

        * Signals an HTTP response with status outside of the 2xx range.

        * Fires after io:complete.

        * @event io:failure

        */

        this._evt(EVENTS[4], transaction, config);

        this.end(transaction, config);

    },

   /**

    * Fires event "io:progress" and creates, fires a transaction-specific

    * "progress" event -- for XMLHttpRequest file upload -- if

    * config.on.progress is defined.

    *

    * @method progress

    * @param {Object} transaction Transaction object.

    * @param {Object} progress event.

    * @param {Object} config Configuration object for the transaction.

    */

    progress: function(transaction, e, config) {

       /**

        * Signals the interactive state during a file upload transaction.

        * This event fires after io:start and before io:complete.

        * @event io:progress

        */

        transaction.evt = e;

        this._evt(EVENTS[5], transaction, config);

    },

   /**

    * Fires event "io:complete" and creates, fires a transaction-specific

    * "complete" event -- for XMLHttpRequest file upload -- if

    * config.on.complete is defined.

    *

    * @method load

    * @param {Object} transaction Transaction object.

    * @param {Object} load event.

    * @param {Object} config Configuration object for the transaction.

    */

    load: function (transaction, e, config) {

        transaction.evt = e.target;

        this._evt(EVENTS[1], transaction, config);

    },

   /**

    * Fires event "io:failure" and creates, fires a transaction-specific

    * "failure" event -- for XMLHttpRequest file upload -- if

    * config.on.failure is defined.

    *

    * @method error

    * @param {Object} transaction Transaction object.

    * @param {Object} error event.

    * @param {Object} config Configuration object for the transaction.

    */

    error: function (transaction, e, config) {

        transaction.evt = e;

        this._evt(EVENTS[4], transaction, config);

    },

   /**

    * Retry an XDR transaction, using the Flash tranport, if the native

    * transport fails.

    *

    * @method _retry

    * @private

    * @param {Object} transaction Transaction object.

    * @param {String} uri Qualified path to transaction resource.

    * @param {Object} config Configuration object for the transaction.

    */

    _retry: function(transaction, uri, config) {

        this._destroy(transaction);

        config.xdr.use = 'flash';

        return this.send(uri, config, transaction.id);

    },

   /**

    * Method that concatenates string data for HTTP GET transactions.

    *

    * @method _concat

    * @private

    * @param {String} uri URI or root data.

    * @param {String} data Data to be concatenated onto URI.

    * @return {String}

    */

    _concat: function(uri, data) {

        uri += (uri.indexOf('?') === -1 ? '?' : '&') + data;

        return uri;

    },

   /**

    * Stores default client headers for all transactions. If a label is

    * passed with no value argument, the header will be deleted.