/*

Copyright (c) 2009, Yahoo! Inc. All rights reserved.

Code licensed under the BSD License:

http://developer.yahoo.net/yui/license.txt

version: 3.0.0

build: 1549

*/

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

   /**

   	* Base IO functionality. Provides basic XHR transport support.

   	* @module io

   	* @submodule io-base

   	*/

   /**

	* 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.  YUI.io can also use

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

	*

   	* @class io

   	*/

   /**

   	* @event io:start

   	* @description This event is fired by YUI.io when a transaction is initiated.

   	* @type Event Custom

   	*/

   	var E_START = 'io:start',

   /**

   	* @event io:complete

   	* @description This event is fired by YUI.io when a transaction is complete.

   	* Response status and data are accessible, if available.

   	* @type Event Custom

   	*/

   	E_COMPLETE = 'io:complete',

   /**

   	* @event io:success

   	* @description This event is fired by YUI.io when a transaction is complete, and

   	* the HTTP status resolves to HTTP2xx.

   	* @type Event Custom

   	*/

   	E_SUCCESS = 'io:success',

   /**

   	* @event io:failure

   	* @description This event is fired by YUI.io when a transaction is complete, and

   	* the HTTP status resolves to HTTP4xx, 5xx and above.

   	* @type Event Custom

   	*/

   	E_FAILURE = 'io:failure',

   /**

   	* @event io:end

   	* @description This event signifies the end of the transaction lifecycle.  The

   	* transaction transport is destroyed.

   	* @type Event Custom

   	*/

   	E_END = 'io:end',

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

   	//  Properties

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

   /**

   	* @description A transaction counter that increments for each transaction.

   	*

   	* @property transactionId

   	* @private

   	* @static

   	* @type int

   	*/

   	transactionId = 0,

   /**

   	* @description Object of default HTTP headers to be initialized and sent

   	* for all transactions.

   	*

   	* @property _headers

   	* @private

   	* @static

   	* @type object

   	*/

   	_headers = {

   		'X-Requested-With' : 'XMLHttpRequest'

   	},

   /**

   	* @description Object that stores timeout values for any transaction with

   	* a defined "timeout" configuration property.

   	*

   	* @property _timeout

   	* @private

   	* @static

   	* @type object

   	*/

   	_timeout = {},

   	// Window reference

   	w = Y.config.win;

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

   	//  Methods

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

   /**

   	* @description Method for requesting a transaction. _io() is implemented as

   	* yui.io().  Each transaction may include a configuration object.  Its

   	* properties are:

   	*

   	* method: HTTP method verb (e.g., GET or POST). If this property is not

   	*         not defined, the default value will be GET.

   	*

   	* data: This is the name-value string that will be sent as the transaction

    *		data.  If the request is HTTP GET, the data become part of

    *		querystring. If HTTP POST, the data are sent in the message body.

   	*

   	* xdr: Defines the transport to be used for cross-domain requests.  By

   	*      setting this property, the transaction will use the specified

   	*      transport instead of XMLHttpRequest.  Currently, the only alternate

   	*      transport supported is Flash (e.g., { xdr: 'flash' }).

   	*

   	* form: This is a defined object used to process HTML form as data.  The

   	*       properties are:

   	*       {

   	*	      id: object, //HTML form object or id of HTML form

   	*         useDisabled: boolean, //Allow disabled HTML form field values

   	*                      to be sent as part of the data.

	*       }

	*

	* on: This is a defined object used to create and handle specific

	*     events during a transaction lifecycle.  These events will fire in

	*     addition to the global io events. The events are:

	*	  start - This event is fired when a request is sent to a resource.

	*     complete - This event fires when the transaction is complete.

	*     success - This event fires when the response status resolves to

	*               HTTP 2xx.

	*     failure - This event fires when the response status resolves to

	*               HTTP 4xx, 5xx; and, for all transaction exceptions,

	*               including aborted transactions and transaction timeouts.

	*	  end -  This even is fired at the conclusion of the transaction

   	*			 lifecycle, after a success or failure resolution.

	*

	*     The properties are:

	*     {

   	*       start: function(id, args){},

   	*       complete: function(id, responseobject, args){},

   	*       success: function(id, responseobject, args){},

   	*       failure: function(id, responseobject, args){},

   	*       end: function(id, args){}

   	*     }

   	*	  Each property can reference a function or be written as an

   	*     inline function.

   	*

   	*     context: Object reference for an event handler when it is implemented

   	*              as a method of a base object. Defining "context" will preserve

   	*              the proper reference of "this" used in the event handler.

   	*     headers: This is a defined object of client headers, as many as.

   	*              desired for the transaction.  These headers are sentThe object

   	*              pattern is:

   	*              {

   	*		         header: value

   	*              }

   	*

   	* timeout: This value, defined as milliseconds, is a time threshold for the

   	*          transaction. When this threshold is reached, and the transaction's

   	*          Complete event has not yet fired, the transaction will be aborted.

   	* arguments: Object, array, string, or number passed to all registered

   	*            event handlers.  This value is available as the second

   	*            argument in the "start" and "abort" event handlers; and, it is

   	*            the third argument in the "complete", "success", and "failure"

   	*            event handlers.

   	*

   	* @method _io

   	* @private

   	* @static

	* @param {string} uri - qualified path to transaction resource.

	* @param {object} c - configuration object for the transaction.

	* @param {number} i - transaction id, if already set by queue.

	* @return object

   	*/

   	function _io(uri, c, i) {

   		var f, o, m;

   			c = c || {};

   			o = _create(c.xdr || c.form, i);

   			m = c.method ? c.method.toUpperCase() : 'GET';

   		if (c.form) {

   			if (c.form.upload) {

   				return Y.io._upload(o, uri, c);

   			}

   			else {

				f = Y.io._serialize(c.form, c.data);

				if (m === 'POST') {

					c.data = f;

					_setHeader('Content-Type', 'application/x-www-form-urlencoded');

				}

				else if (m === 'GET') {

					uri = _concat(uri, f);

				}

			}

		}

		else if (c.data && m === 'GET') {

			uri = _concat(uri, c.data);

		}

   		if (c.xdr) {

			if (c.xdr.use === 'native' && window.XDomainRequest || c.xdr.use === 'flash') {

   				return Y.io.xdr(uri, o, c);

			}

			if (c.xdr.credentials) {

				o.c.withCredentials = true;

			}

   		}

   		o.c.onreadystatechange = function() { _readyState(o, c); };

   		try {

			o.c.open(m, uri, true);

   		}

   		catch(e0){

			if (c.xdr) {

				// This exception is usually thrown by browsers

				// that do not support native XDR transactions.

				return _resend(o, uri, c);

			}

		}

   		if (c.data && m === 'POST') {

   			_setHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');

   		}

   		_setHeaders(o.c, c.headers || {});

		try {

			// Using "null" will result in a POST request with

			// no Content-Length defined.

	   		o.c.send(c.data || '');

		}

   		catch(e1) {

			if (c.xdr) {

				// This exception is usually thrown by browsers

				// that do not support native XDR transactions.

				return _resend(o, uri, c);

			}

		}

   		_ioStart(o.id, c);

   		// If config.timeout is defined, and the request is standard XHR,

   		// initialize timeout polling.

   		if (c.timeout) {

   			_startTimeout(o, c.timeout);

   		}

		return {

			id: o.id,

			abort: function() {

				return o.c ? _ioCancel(o, 'abort') : false;

			},

			isInProgress: function() {

				return o.c ? o.c.readyState !== 4 && o.c.readyState !== 0 : false;

	   		}

		}

   	}

   /**

   	* @description Method for creating and subscribing transaction events.

   	*

   	* @method _subscribe

   	* @private

   	* @static

   	* @param {string} e - event to be published

   	* @param {object} c - configuration data subset for event subscription.

   	*

	* @return void

   	*/

   	function _subscribe(e, c){

   		var evt = new Y.EventTarget().publish('transaction:' + e);

		evt.subscribe(c.on[e], (c.context || Y), c.arguments);

   		return evt;

   	}

   /**

   	* @description Fires event "io:start" and creates, fires a

   	* transaction-specific start event, if config.on.start is

   	* defined.

   	*

   	* @method _ioStart

   	* @private

   	* @static

   	* @param {number} id - transaction id

   	* @param {object} c - configuration object for the transaction.

   	*

    * @return void

   	*/

   	function _ioStart(id, c) {

   		var evt;

   			// Set default value of argument c, property "on" to Object if

   			// the property is null or undefined.

   			c.on = c.on || {};

   		Y.fire(E_START, id);

   		if (c.on.start) {

   			evt = _subscribe('start', c);

   			evt.fire(id);

   		}

   	}

   /**

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

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

   	* defined.

   	*

   	* @method _ioComplete

   	* @private

   	* @static

   	* @param {object} o - transaction object.

   	* @param {object} c - configuration object for the transaction.

   	*

    * @return void

   	*/

   	function _ioComplete(o, c) {

   		var evt,

			r = o.status ? { status: 0, statusText: o.status } : o.c;

   			// Set default value of argument c, property "on" to Object if

   			// the property is null or undefined.

   			c.on = c.on || {};

   		Y.fire(E_COMPLETE, o.id, r);

   		if (c.on.complete) {

   			evt = _subscribe('complete', c);

   			evt.fire(o.id, r);

   		}

   	}

   /**

   	* @description Fires event "io:success" and creates, fires a

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

   	* defined.

   	*

   	* @method _ioSuccess

   	* @private

   	* @static

   	* @param {object} o - transaction object.

   	* @param {object} c - configuration object for the transaction.

   	*

    * @return void

   	*/

   	function _ioSuccess(o, c) {

   		var evt;

   			// Set default value of argument c, property "on" to Object if

   			// the property is null or undefined.

   			c.on = c.on || {};

   		Y.fire(E_SUCCESS, o.id, o.c);

   		if (c.on.success) {

   			evt = _subscribe('success', c);

   			evt.fire(o.id, o.c);

   		}

   		_ioEnd(o, c);

   	}

   /**

   	* @description Fires event "io:failure" and creates, fires a

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

   	* defined.

   	*

   	* @method _ioFailure

   	* @private

   	* @static

   	* @param {object} o - transaction object.

   	* @param {object} c - configuration object for the transaction.

   	*

    * @return void

   	*/

   	function _ioFailure(o, c) {

   		var evt,

 			r = o.status ? { status: 0, statusText: o.status } : o.c;

   			// Set default value of argument c, property "on" to Object if

   			// the property is null or undefined.

   			c.on = c.on || {};

   		Y.fire(E_FAILURE, o.id, r);

   		if (c.on.failure) {

   			evt = _subscribe('failure', c);

   			evt.fire(o.id, r);

   		}

   		_ioEnd(o, c);

   	}

   /**

   	* @description Fires event "io:end" and creates, fires a

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

   	* defined.

   	*

   	* @method _ioEnd

   	* @private

   	* @static

   	* @param {object} o - transaction object.

   	* @param {object} c - configuration object for the transaction.

   	*

    * @return void

   	*/

   	function _ioEnd(o, c) {

   		var evt;

   			// Set default value of argument c, property "on" to Object if

   			// the property is null or undefined.

   			c.on = c.on || {};

   		Y.fire(E_END, o.id);

   		if (c.on.end) {

   			evt = _subscribe('end', c);

   			evt.fire(o.id);

   		}

   		_destroy(o, c.xdr ? true : false );

   	}