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

    /**

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

                    } 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); }

            }

            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;

}, '@VERSION@', {"requires": ["yui-base"]});