/**
                                 * Provides the augmentable PluginHost interface, which can be added to any class.
                                 * @module pluginhost
                                 */
                            
                                /**
                                 * Provides the augmentable PluginHost interface, which can be added to any class.
                                 * @module pluginhost-base
                                 */
                            
                                /**
                                 * <p>
                                 * An augmentable class, which provides the augmented class with the ability to host plugins.
                                 * It adds <a href="#method_plug">plug</a> and <a href="#method_unplug">unplug</a> methods to the augmented class, which can
                                 * be used to add or remove plugins from instances of the class.
                                 * </p>
                                 *
                                 * <p>Plugins can also be added through the constructor configuration object passed to the host class' constructor using
                                 * the "plugins" property. Supported values for the "plugins" property are those defined by the <a href="#method_plug">plug</a> method.
                                 *
                                 * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host):
                                 * <xmp>
                                 * var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]});
                                 * </xmp>
                                 * </p>
                                 * <p>
                                 * Plug.Host's protected <a href="#method_initPlugins">_initPlugins</a> and <a href="#method_destroyPlugins">_destroyPlugins</a>
                                 * methods should be invoked by the host class at the appropriate point in the host's lifecyle.
                                 * </p>
                                 *
                                 * @class Plugin.Host
                                 */
                            
                                var L = Y.Lang;
                            
                                function PluginHost() {
                                    this._plugins = {};
                                }
                            
                                PluginHost.prototype = {
                            
                                    /**
                                     * Adds a plugin to the host object. This will instantiate the
                                     * plugin and attach it to the configured namespace on the host object.
                                     *
                                     * @method plug
                                     * @chainable
                                     * @param P {Function | Object |Array} Accepts the plugin class, or an
                                     * object with a "fn" property specifying the plugin class and
                                     * a "cfg" property specifying the configuration for the Plugin.
                                     * <p>
                                     * Additionally an Array can also be passed in, with the above function or
                                     * object values, allowing the user to add multiple plugins in a single call.
                                     * </p>
                                     * @param config (Optional) If the first argument is the plugin class, the second argument
                                     * can be the configuration for the plugin.
                                     * @return {Base} A reference to the host object
                                     */
                                    plug: function(Plugin, config) {
                                        var i, ln, ns;
                            
                                        if (L.isArray(Plugin)) {
                                            for (i = 0, ln = Plugin.length; i < ln; i++) {
                                                this.plug(Plugin[i]);
                                            }
                                        } else {
                                            if (Plugin && !L.isFunction(Plugin)) {
                                                config = Plugin.cfg;
                                                Plugin = Plugin.fn;
                                            }
                            
                                            // Plugin should be fn by now
                                            if (Plugin && Plugin.NS) {
                                                ns = Plugin.NS;
                            
                                                config = config || {};
                                                config.host = this;
                            
                                                if (this.hasPlugin(ns)) {
                                                    // Update config
                                                    if (this[ns].setAttrs) {
                                                        this[ns].setAttrs(config);
                                                    }
                                                    else {
                                                        Y.log("Attempt to replug an already attached plugin, and we can't setAttrs, because it's not Attribute based: " + ns, "warn", "PluginHost");
                                                    }
                                                } else {
                                                    // Create new instance
                                                    this[ns] = new Plugin(config);
                                                    this._plugins[ns] = Plugin;
                                                }
                                            }
                                            else {
                                                Y.log("Attempt to plug in an invalid plugin. Host:" + this + ", Plugin:" + Plugin, "error", "PluginHost");
                                            }
                                        }
                                        return this;
                                    },
                            
                                    /**
                                     * Removes a plugin from the host object. This will destroy the
                                     * plugin instance and delete the namespace from the host object.
                                     *
                                     * @method unplug
                                     * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided,
                                     * all registered plugins are unplugged.
                                     * @return {Base} A reference to the host object
                                     * @chainable
                                     */
                                    unplug: function(plugin) {
                                        var ns = plugin,
                                            plugins = this._plugins;
                            
                                        if (plugin) {
                                            if (L.isFunction(plugin)) {
                                                ns = plugin.NS;
                                                if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
                                                    ns = null;
                                                }
                                            }
                            
                                            if (ns) {
                                                if (this[ns]) {
                                                    if (this[ns].destroy) {
                                                        this[ns].destroy();
                                                    }
                                                    delete this[ns];
                                                }
                                                if (plugins[ns]) {
                                                    delete plugins[ns];
                                                }
                                            }
                                        } else {
                                            for (ns in this._plugins) {
                                                if (this._plugins.hasOwnProperty(ns)) {
                                                    this.unplug(ns);
                                                }
                                            }
                                        }
                                        return this;
                                    },
                            
                                    /**
                                     * Determines if a plugin has plugged into this host.
                                     *
                                     * @method hasPlugin
                                     * @param {String} ns The plugin's namespace
                                     * @return {Plugin} Returns a truthy value (the plugin instance) if present, or undefined if not.
                                     */
                                    hasPlugin : function(ns) {
                                        return (this._plugins[ns] && this[ns]);
                                    },
                            
                                    /**
                                     * Initializes static plugins registered on the host (using the
                                     * Base.plug static method) and any plugins passed to the
                                     * instance through the "plugins" configuration property.
                                     *
                                     * @method _initPlugins
                                     * @param {Object} config The configuration object with property name/value pairs.
                                     * @private
                                     */
                            
                                    _initPlugins: function(config) {
                                        this._plugins = this._plugins || {};
                            
                                        if (this._initConfigPlugins) {
                                            this._initConfigPlugins(config);
                                        }
                                    },
                            
                                    /**
                                     * Unplugs and destroys all plugins on the host
                                     * @method _destroyPlugins
                                     * @private
                                     */
                                    _destroyPlugins: function() {
                                        this.unplug();
                                    }
                                };
                            
                                Y.namespace("Plugin").Host = PluginHost;