/*

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('get', function(Y) {

(function() {

/**

 * Provides a mechanism to fetch remote resources and

 * insert them into a document.

 * @module yui

 * @submodule get

 */

var ua         = Y.UA, 

    L          = Y.Lang,

    // PREFIX     = Y.guid(),

    TYPE_JS    = "text/javascript",

    TYPE_CSS   = "text/css",

    STYLESHEET = "stylesheet";

/**

 * Fetches and inserts one or more script or link nodes into the document 

 * @class Get

 * @static

 */

Y.Get = function() {

    /**

     * hash of queues to manage multiple requests

     * @property queues

     * @private

     */

    var queues={}, 

    /**

     * queue index used to generate transaction ids

     * @property qidx

     * @type int

     * @private

     */

        qidx=0, 

    /**

     * interal property used to prevent multiple simultaneous purge 

     * processes

     * @property purging

     * @type boolean

     * @private

     */

        purging=false,

    /** 

     * Generates an HTML element, this is not appended to a document

     * @method _node

     * @param type {string} the type of element

     * @param attr {string} the attributes

     * @param win {Window} optional window to create the element in

     * @return {HTMLElement} the generated node

     * @private

     */

    _node = function(type, attr, win) {

        var w = win || Y.config.win, d=w.document, n=d.createElement(type),

            i;

        for (i in attr) {

            if (attr[i] && attr.hasOwnProperty(i)) {

                n.setAttribute(i, attr[i]);

            }

        }

        return n;

    },

    /**

     * Generates a link node

     * @method _linkNode

     * @param url {string} the url for the css file

     * @param win {Window} optional window to create the node in

     * @param attributes optional attributes collection to apply to the new node

     * @return {HTMLElement} the generated node

     * @private

     */

    _linkNode = function(url, win, attributes) {

        var o = {

            id:   Y.guid(),

            type: TYPE_CSS,

            rel:  STYLESHEET,

            href: url

        };

        if (attributes) {

            Y.mix(o, attributes);

        }

        return _node("link", o, win);

    },

    /**

     * Generates a script node

     * @method _scriptNode

     * @param url {string} the url for the script file

     * @param win {Window} optional window to create the node in

     * @param attributes optional attributes collection to apply to the new node

     * @return {HTMLElement} the generated node

     * @private

     */

    _scriptNode = function(url, win, attributes) {

        var o = {

            id:   Y.guid(),

            type: TYPE_JS,

            src:  url

        };

        if (attributes) {

            Y.mix(o, attributes);

        }

        return _node("script", o, win);

    },

    /**

     * Removes the nodes for the specified queue

     * @method _purge

     * @private

     */

    _purge = function(tId) {

        var q=queues[tId], n, l, d, h, s, i, node, attr;

        if (q) {

            n = q.nodes; 

            l = n.length;

            d = q.win.document;

            h = d.getElementsByTagName("head")[0];

            if (q.insertBefore) {

                s = _get(q.insertBefore, tId);

                if (s) {

                    h = s.parentNode;

                }

            }

            for (i=0; i<l; i=i+1) {

                node = n[i];

                if (node.clearAttributes) {

                    node.clearAttributes();

                } else {

                    // This is a hostile delete

                    // operation attempting to improve

                    // memory performance.  As such, the

                    // hasOwnProperty check is intentionally

                    // ommitted.

                    for (attr in node) {

                        delete node[attr];

                    }

                }

                h.removeChild(node);

            }

        }

        q.nodes = [];

    },

    /**

     * Returns the data payload for callback functions

     * @method _returnData

     * @private

     */

    _returnData = function(q, msg, result) {

        return {

                tId: q.tId,

                win: q.win,

                data: q.data,

                nodes: q.nodes,

                msg: msg,

                statusText: result,

                purge: function() {

                    _purge(this.tId);

                }

            };

    },

    /**

     * The transaction is finished

     * @method _end

     * @param id {string} the id of the request

     * @private

     */

    _end = function(id, msg, result) {

        var q = queues[id], sc;

        if (q && q.onEnd) {

            sc = q.context || q;

            q.onEnd.call(sc, _returnData(q, msg, result));

        }

    },

    /*

     * The request failed, execute fail handler with whatever

     * was accomplished.  There isn't a failure case at the

     * moment unless you count aborted transactions

     * @method _fail

     * @param id {string} the id of the request

     * @private

     */

    _fail = function(id, msg) {

        var q = queues[id], sc;

        if (q.timer) {

            // q.timer.cancel();

            clearTimeout(q.timer);

        }

        // execute failure callback

        if (q.onFailure) {

            sc = q.context || q;

            q.onFailure.call(sc, _returnData(q, msg));

        }

        _end(id, msg, 'failure');

    },

    _get = function(nId, tId) {

        var q = queues[tId],

            n = (L.isString(nId)) ? q.win.document.getElementById(nId) : nId;

        if (!n) {

            _fail(tId, "target node not found: " + nId);

        }

        return n;

    },

    /**

     * The request is complete, so executing the requester's callback

     * @method _finish

     * @param id {string} the id of the request

     * @private

     */

    _finish = function(id) {

        var q = queues[id], msg, sc;

        if (q.timer) {

            // q.timer.cancel();

            clearTimeout(q.timer);

        }

        q.finished = true;

        if (q.aborted) {

            msg = "transaction " + id + " was aborted";

            _fail(id, msg);

            return;

        }

        // execute success callback

        if (q.onSuccess) {

            sc = q.context || q;

            q.onSuccess.call(sc, _returnData(q));

        }

        _end(id, msg, 'OK');

    },

    /**

     * Timeout detected

     * @method _timeout

     * @param id {string} the id of the request

     * @private

     */

    _timeout = function(id) {

        var q = queues[id], sc;

        if (q.onTimeout) {

            sc = q.context || q;

            q.onTimeout.call(sc, _returnData(q));

        }

        _end(id, 'timeout', 'timeout');

    },

    /**

     * Loads the next item for a given request

     * @method _next

     * @param id {string} the id of the request

     * @param loaded {string} the url that was just loaded, if any

     * @private

     */

    _next = function(id, loaded) {

        var q = queues[id], msg, w, d, h, n, url, s;

        if (q.timer) {

            // q.timer.cancel();

            clearTimeout(q.timer);

        }

        if (q.aborted) {

            msg = "transaction " + id + " was aborted";

            _fail(id, msg);

            return;

        }

        if (loaded) {

            q.url.shift(); 

            if (q.varName) {

                q.varName.shift(); 

            }

        } else {

            // This is the first pass: make sure the url is an array

            q.url = (L.isString(q.url)) ? [q.url] : q.url;

            if (q.varName) {

                q.varName = (L.isString(q.varName)) ? [q.varName] : q.varName;

            }

        }

        w = q.win; 

        d = w.document; 

        h = d.getElementsByTagName("head")[0];

        if (q.url.length === 0) {

            _finish(id);

            return;

        } 

        url = q.url[0];

        // if the url is undefined, this is probably a trailing comma problem in IE

        if (!url) {

            q.url.shift(); 

            return _next(id);

        }

        if (q.timeout) {

            // q.timer = L.later(q.timeout, q, _timeout, id);

            q.timer = setTimeout(function() { 

                _timeout(id);

            }, q.timeout);

        }

        if (q.type === "script") {

            n = _scriptNode(url, w, q.attributes);

        } else {

            n = _linkNode(url, w, q.attributes);

        }

        // track this node's load progress

        _track(q.type, n, id, url, w, q.url.length);

        // add the node to the queue so we can return it to the user supplied callback

        q.nodes.push(n);

        // add it to the head or insert it before 'insertBefore'

        if (q.insertBefore) {

            s = _get(q.insertBefore, id);

            if (s) {

                s.parentNode.insertBefore(n, s);

            }

        } else {

            h.appendChild(n);

        }

        // FireFox does not support the onload event for link nodes, so there is

        // no way to make the css requests synchronous. This means that the css 

        // rules in multiple files could be applied out of order in this browser

        // if a later request returns before an earlier one.  Safari too.

        if ((ua.webkit || ua.gecko) && q.type === "css") {

            _next(id, url);

        }

    },

    /**

     * Removes processed queues and corresponding nodes

     * @method _autoPurge

     * @private

     */

    _autoPurge = function() {

        if (purging) {

            return;

        }

        purging = true;

        var i, q;

        for (i in queues) {

            if (queues.hasOwnProperty(i)) {

                q = queues[i];

                if (q.autopurge && q.finished) {

                    _purge(q.tId);

                    delete queues[i];

                }

            }