/*

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

*/

(function() {

    var _instances = {}, 

        _startTime = new Date().getTime(), 

        p, 

        i,

        add = function () {

            if (window.addEventListener) {

                return function(el, type, fn, capture) {

                    el.addEventListener(type, fn, (!!capture));

                };

            } else if (window.attachEvent) {

                return function(el, type, fn) {

                    el.attachEvent("on" + type, fn);

                };

            } else {

                return function(){};

            }

        }(),

        remove = function() {

            if (window.removeEventListener) {

                return function (el, type, fn, capture) {

                    el.removeEventListener(type, fn, !!capture);

                };

            } else if (window.detachEvent) {

                return function (el, type, fn) {

                    el.detachEvent("on" + type, fn);

                };

            } else {

                return function(){};

            }

        }(),

        globalListener = function() {

            YUI.Env.windowLoaded = true;

            YUI.Env.DOMReady = true;

            remove(window, 'load', globalListener);

        },

// @TODO: this needs to be created at build time from module metadata

        _APPLY_TO_WHITE_LIST = {

            'io.xdrReady': 1,

            'io.start': 1,

            'io.success': 1,

            'io.failure': 1

        },

        SLICE = Array.prototype.slice;

// reduce to one or the other

if (typeof YUI === 'undefined' || !YUI) {

    /**

     * The YUI global namespace object.  If YUI is already defined, the

     * existing YUI object will not be overwritten so that defined

     * namespaces are preserved.  

     *

     * @class YUI

     * @constructor

     * @global

     * @uses EventTarget

     * @param o* Up to five optional configuration objects.  This object is stored

     * in YUI.config.  See config for the list of supported properties.

     */

    /*global YUI*/

    // Make a function, disallow direct instantiation

    YUI = function(o1, o2, o3, o4, o5) {

        var Y = this, a = arguments, i, l = a.length;

        // Allow instantiation without the new operator

        if (!(Y instanceof YUI)) {

            return new YUI(o1, o2, o3, o4, o5);

        } else {

            // set up the core environment

            Y._init();

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

                Y._config(a[i]);

            }

            // bind the specified additional modules for this instance

            Y._setup();

            return Y;

        }

    };

}

// The prototype contains the functions that are required to allow the external

// modules to be registered and for the instance to be initialized.

YUI.prototype = {

    _config: function(o) {

        o = o || {};

        var c = this.config, i, j, m, mods;

        mods = c.modules;

        for (i in o) {

            if (mods && i == 'modules') {

                m = o[i];

                for (j in m) {

                    if (m.hasOwnProperty(j)) {

                        mods[j] = m[j];

                    }

                }

            } else if (i == 'win') {

                c[i] = o[i].contentWindow || o[i];

                c.doc = c[i].document;

            } else {

                c[i] = o[i];

            }

        }

    },

    /**

     * Initialize this YUI instance

     * @param o config options

     * @private

     */

    _init: function(o) {

        // find targeted window/frame

        // @TODO create facades

        var v = '3.0.0', Y = this;

        if (v.indexOf('@') > -1) {

            v = 'test';

        }

        Y.version = v;

        Y.Env = {

            // @todo expand the new module metadata

            mods: {},

            cdn: 'http://yui.yahooapis.com/' + v + '/build/',

            bootstrapped: false,

            _idx: 0,

            _used: {},

            _attached: {},

            _yidx: 0,

            _uidx: 0,

            _loaded: {}

        };

        Y.Env._loaded[v] = {};

        if (YUI.Env) {

            Y.Env._yidx = (++YUI.Env._yidx);

            Y.Env._guidp = ('yui_' + v + '-' + Y.Env._yidx + '-' + _startTime).replace(/\./g, '_');

            Y.id = Y.stamp(Y);

            _instances[Y.id] = Y;

        }

        Y.constructor = YUI;

        // configuration defaults

        Y.config = {

            win: window || {},

            doc: document,

            debug: true,

            useBrowserConsole: true,

            throwFail: true,

            base: function() {

                var b, nodes, i, match;

                // get from querystring

                nodes = document.getElementsByTagName('script');

                for (i=0; i<nodes.length; i=i+1) {

                    match = nodes[i].src.match(/^(.*)yui\/yui[\.\-].*js(\?.*)?$/);

                    b = match && match[1];

                    if (b) {

                        break;

                    }

                }

                // use CDN default

                return b || this.Env.cdn;

            }(),

            loaderPath: 'loader/loader-min.js'

        };

    },

    /**

     * Finishes the instance setup. Attaches whatever modules were defined

     * when the yui modules was registered.

     * @method _setup

     * @private

     */

    _setup: function(o) {

        this.use("yui-base");

    },

    /**

     * Executes a method on a YUI instance with

     * the specified id if the specified method is whitelisted.

     * @method applyTo

     * @param id {string} the YUI instance id

     * @param method {string} the name of the method to exectute.

     * Ex: 'Object.keys'

     * @param args {Array} the arguments to apply to the method

     * @return {object} the return value from the applied method or null

     */

    applyTo: function(id, method, args) {

        if (!(method in _APPLY_TO_WHITE_LIST)) {

            this.error(method + ': applyTo not allowed');

            return null;

        }

        var instance = _instances[id], nest, m, i;

        if (instance) {

            nest = method.split('.'); 

            m = instance;

            for (i=0; i<nest.length; i=i+1) {

                m = m[nest[i]];

                if (!m) {

                    this.error('applyTo not found: ' + method);

                }

            }

            return m.apply(instance, args);

        }

        return null;

    }, 

    /**

     * Register a module

     * @method add

     * @param name {string} module name

     * @param fn {Function} entry point into the module that

     * is used to bind module to the YUI instance

     * @param version {string} version string

     * @param details optional config data: 

     * requires   - features that should be present before loading

     * optional   - optional features that should be present if load optional defined

     * use  - features that should be attached automatically

     * skinnable  -

     * rollup

     * omit - features that should not be loaded if this module is present

     * @return {YUI} the YUI instance

     *

     */

    add: function(name, fn, version, details) {

        // this.log('Adding a new component ' + name);

        // @todo expand this to include version mapping

        // @todo may want to restore the build property

        // @todo fire moduleAvailable event

        YUI.Env.mods[name] = {

            name: name, 

            fn: fn,

            version: version,

            details: details || {}

        };

        return this; // chain support

    },

    _attach: function(r, fromLoader) {

        var mods = YUI.Env.mods,

            attached = this.Env._attached,

            i, l = r.length, name, m, d, req, use;

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

            name = r[i]; 

            m    = mods[name];

            if (!attached[name] && m) {

                attached[name] = true;

                d   = m.details; 

                req = d.requires; 

                use = d.use;

                if (req) {

                    this._attach(this.Array(req));

                }

                // this.log('attaching ' + name, 'info', 'yui');

                if (m.fn) {

                    m.fn(this);

                }

                if (use) {

                    this._attach(this.Array(use));

                }

            }

        }

    },

    /**

     * Bind a module to a YUI instance

     * @param modules* {string} 1-n modules to bind (uses arguments array)

     * @param *callback {function} callback function executed when 

     * the instance has the required functionality.  If included, it

     * must be the last parameter.

     *

     * @TODO 

     * Implement versioning?  loader can load different versions?

     * Should sub-modules/plugins be normal modules, or do

     * we add syntax for specifying these?

     *

     * YUI().use('dragdrop')

     * YUI().use('dragdrop:2.4.0'); // specific version

     * YUI().use('dragdrop:2.4.0-'); // at least this version

     * YUI().use('dragdrop:2.4.0-2.9999.9999'); // version range

     * YUI().use('*'); // use all available modules

     * YUI().use('lang+dump+substitute'); // use lang and some plugins

     * YUI().use('lang+*'); // use lang and all known plugins

     *

     *

     * @return {YUI} the YUI instance

     */

    use: function() {

        if (this._loading) {

            this._useQueue = this._useQueue || new this.Queue();

            this._useQueue.add(SLICE.call(arguments, 0));

            return this;

        }

        var Y = this, 

            a=SLICE.call(arguments, 0), 

            mods = YUI.Env.mods, 

            used = Y.Env._used,

            loader, 

            firstArg = a[0], 

            dynamic = false,

            callback = a[a.length-1],

            k, i, l, missing = [], 

            r = [], 

            f = function(name) {

                // only attach a module once

                if (used[name]) {

                    // Y.log(name + ' already used', 'info', 'yui');

                    return;

                }

                var m = mods[name], j, req, use;

                if (m) {

                    // Y.log('USING ' + name, 'info', 'yui');

                    used[name] = true;

                    req = m.details.requires;

                    use = m.details.use;

                } else {

                    // CSS files don't register themselves, see if it has been loaded

                    if (!YUI.Env._loaded[Y.version][name]) {

                        Y.log('module not found: ' + name, 'info', 'yui');

                        missing.push(name);

                    } else {

                        // probably css

                        // Y.log('module not found BUT HAS BEEN LOADED: ' + name, 'info', 'yui');

                        used[name] = true;