/*

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

Code licensed under the BSD License:

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

version: 3.0.0b1

build: 1163

*/

(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 Optional configuration object.  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(o) {

        var Y = this;

        // Allow instantiation without the new operator

        if (!(Y instanceof YUI)) {

            return new YUI(o);

        } else {

            // set up the core environment

            Y._init(o);

            // 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 = {

    /**

     * Initialize this YUI instance

     * @param o config options

     * @private

     */

    _init: function(o) {

        o = o || {};

        // find targeted window/frame

        // @TODO create facades

        var v = '3.0.0b1', Y = this;

        o.win = o.win || window || {};

        o.win = o.win.contentWindow || o.win;

        o.doc = o.win.document;

        o.debug = ('debug' in o) ? o.debug : true;

        o.useBrowserConsole = ('useBrowserConsole' in o) ? o.useBrowserConsole : true;

        o.throwFail = ('throwFail' in o) ? o.throwFail : true;

        // add a reference to o for anything that needs it

        // before _setup is called.

        Y.config = o;

        Y.Env = {

            // @todo expand the new module metadata

            mods: {},

            _idx: 0,

            _used: {},

            _attached: {},

            _yidx: 0,

            _uidx: 0,

            _loaded: {}

        };

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

            v = 'test';

        }

        Y.version = v;

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

        if (YUI.Env) {

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

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

            Y.id = Y.stamp(Y);

            _instances[Y.id] = Y;

        }

        Y.constructor = YUI;

        // this.log(this.id + ') init ');

    },

    /**

     * 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");

        // @TODO eval the need to copy the config

        this.config = this.merge(this.config);

    },

    /**

     * 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 allow requires/supersedes

        // @todo may want to restore the build property

        // @todo fire moduleAvailable event

        var m = {

            name: name, 

            fn: fn,

            version: version,

            details: details || {}

        };

        YUI.Env.mods[name] = m;

        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.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]) {

                    return;

                }

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

                if (m) {

                    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]) {

                        missing.push(name);

                    } else {

                        // probably css

                        used[name] = true;

                    }

                }

                // make sure requirements are attached

                if (req) {

                    if (Y.Lang.isString(req)) {

                        f(req);

                    } else {

                        for (j = 0; j < req.length; j = j + 1) {

                            f(req[j]);

                        }

                    }

                }

                // add this module to full list of things to attach

                r.push(name);

            },

            onComplete = function(fromLoader) {

                fromLoader = fromLoader || {

                    success: true,

                    msg: 'not dynamic'

                };

                if (Y.Env._callback) {

                    var cb = Y.Env._callback;

                    Y.Env._callback = null;

                    cb(Y, fromLoader);

                }

                if (Y.fire) {

                    Y.fire('yui:load', Y, fromLoader);

                }

                // process queued use requests as long until done 

                // or dynamic load happens again.

                this._loading = false;

                while (this._useQueue && this._useQueue.size() && !this._loading) {

                    Y.use.apply(Y, this._useQueue.next());

                }

            };