/*

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

    /**

     * Provides the augmentable PluginHost interface, which can be added to any class.

     * @module pluginhost

     */

    /**

     * <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(p, config) {

            if (p) {

                if (L.isFunction(p)) {

                    this._plug(p, config);

                } else if (L.isArray(p)) {

                    for (var i = 0, ln = p.length; i < ln; i++) {

                        this.plug(p[i]);

                    }

                } else {

                    this._plug(p.fn, p.cfg);

                }

            }

            return this;

        },

        /**

         * Removes a plugin from the host object. This will destroy the 

         * plugin instance and delete the namepsace 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) {

            if (plugin) {

                this._unplug(plugin);

            } else {

                var ns;

                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 {boolean} returns true, if the plugin has been plugged into this host, false otherwise.

         */

        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 {Config} config The configuration object with property name/value pairs.

         * @private

         */

        _initPlugins: function(config) {

            this._plugins = this._plugins || {};

            // Class Configuration

            var classes = (this._getClasses) ? this._getClasses() : [this.constructor],

                plug = [],

                unplug = {},

                constructor, i, classPlug, classUnplug, pluginClassName;

            //TODO: Room for optimization. Can we apply statically/unplug in same pass?

            for (i = classes.length - 1; i >= 0; i--) {

                constructor = classes[i];

                classUnplug = constructor._UNPLUG;

                if (classUnplug) {

                    // subclasses over-write

                    Y.mix(unplug, classUnplug, true);

                }

                classPlug = constructor._PLUG;

                if (classPlug) {

                    // subclasses over-write

                    Y.mix(plug, classPlug, true);

                }

            }

            for (pluginClassName in plug) {

                if (plug.hasOwnProperty(pluginClassName)) {

                    if (!unplug[pluginClassName]) {

                        this.plug(plug[pluginClassName]);

                    }

                }

            }

            // User Configuration

            if (config && config.plugins) {

                this.plug(config.plugins);

            }

        },

        /**

         * Unplugs and destroys all plugins on the host

         * @method _destroyPlugins

         * @private

         */

        _destroyPlugins: function() {

            this._unplug();

        },

        /**

         * Private method used to instantiate and attach plugins to the host

         *

         * @method _plug

         * @param {Function} PluginClass The plugin class to instantiate

         * @param {Object} config The configuration object for the plugin

         * @private

         */

        _plug: function(PluginClass, config) {

            if (PluginClass && PluginClass.NS) {

                var ns = PluginClass.NS;

                config = config || {};

                config.host = this;

                if (this.hasPlugin(ns)) {

                    // Update config

                    this[ns].setAttrs(config);

                } else {

                    // Create new instance

                    this[ns] = new PluginClass(config);

                    this._plugins[ns] = PluginClass;

                }

            }

        },

        /**

         * Unplugs and destroys a plugin already instantiated with the host.

         *

         * @method _unplug

         * @private

         * @param {String | Function} plugin The namespace for the plugin, or a plugin class with the static NS property defined.

         */

        _unplug : function(plugin) {

            var ns = plugin, 

                plugins = this._plugins;

            if (L.isFunction(plugin)) {

                ns = plugin.NS;

                if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {

                    ns = null;

                }

            }

            if (ns) {

                if (this[ns]) {

                    this[ns].destroy();

                    delete this[ns];

                }

                if (plugins[ns]) {

                    delete plugins[ns];

                }

            }

        }

    };

    /**

     * Registers plugins to be instantiated at the class level (plugins 

     * which should be plugged into every instance of the class by default).

     *

     * @method Plugin.Host.plug

     * @static

     *

     * @param {Function} hostClass The host class on which to register the plugins

     * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)

     * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin

     */

    PluginHost.plug = function(hostClass, plugin, config) {

        // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ]

        var p, i, l, name;

        if (hostClass !== Y.Base) {

            hostClass._PLUG = hostClass._PLUG || {};

            if (!L.isArray(plugin)) {

                if (config) {

                    plugin = {fn:plugin, cfg:config};

                }

                plugin = [plugin];

            }

            for (i = 0, l = plugin.length; i < l;i++) {

                p = plugin[i];

                name = p.NAME || p.fn.NAME;

                hostClass._PLUG[name] = p;

            }

        }

    };

    /**

     * Unregisters any class level plugins which have been registered by the host class, or any

     * other class in the hierarchy.

     *

     * @method Plugin.Host.unplug

     * @static

     *

     * @param {Function} hostClass The host class from which to unregister the plugins

     * @param {Function | Array} plugin The plugin class, or an array of plugin classes

     */

    PluginHost.unplug = function(hostClass, plugin) {

        var p, i, l, name;

        if (hostClass !== Y.Base) {

            hostClass._UNPLUG = hostClass._UNPLUG || {};

            if (!L.isArray(plugin)) {

                plugin = [plugin];

            }

            for (i = 0, l = plugin.length; i < l; i++) {

                p = plugin[i];

                name = p.NAME;

                if (!hostClass._PLUG[name]) {

                    hostClass._UNPLUG[name] = p;

                } else {

                    delete hostClass._PLUG[name];

                }

            }

        }

    };

    Y.namespace("Plugin").Host = PluginHost;

}, '3.0.0' ,{requires:['yui-base']});