/*

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

*/

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

    /**

     * <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. This is done by default for 

     * the Base class, so developers extending Base or Widget don't need to do anything to enable plugin support.

     * </p>

     *

     * @class Plugin.Host

     */

    var L = Y.Lang;

    function PluginHost(config) {

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

            // Class Configuration

            var classes = this._getClasses(),

                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;

    /**

     * The base module provides the Base class, which objects requiring attribute and custom event support can extend. 

     * The module also provides two ways to reuse code - An augmentable Plugin.Host interface which provides plugin support 

     * (which is augmented to the Base class) and Base.build which provides a way to 

     * build custom classes using extensions.

     *

     * @module base

     */

    /**

     * The base-base submodule provides the Base class and augmentable Plugin.Host implementation, 

     * without the extension support provided by Base.build.

     *

     * @module base

     * @submodule base-base

     */

    var O = Y.Object,

        DOT = ".",

        DESTROY = "destroy",

        INIT = "init",

        INITIALIZED = "initialized",

        DESTROYED = "destroyed",

        INITIALIZER = "initializer",

        OBJECT_CONSTRUCTOR = Object.prototype.constructor,

        DEEP = "deep",

        SHALLOW = "shallow",

        VALUE = "value",

        DESTRUCTOR = "destructor";

    /**

     * <p>

     * A base class which objects requiring attributes and custom event support can 

     * extend. Base also handles the chaining of initializer and destructor methods across 

     * the hierarchy as part of object construction and destruction. Additionally, attributes configured 

     * through the static <a href="#property_Base.ATTRS">ATTRS</a> property for each class 

     * in the hierarchy will be initialized by Base.

     * </p>

     *

     * <p>

     * The static <a href="#property_Base.NAME">NAME</a> property of each class extending 

     * from Base will be used as the identifier for the class, and is used by Base to prefix 

     * all events fired by instances of that class.

     * </p>

     * @class Base

     * @constructor

     * @uses Attribute

     * @uses Plugin.Host

     *

     * @param {Object} config Object with configuration property name/value pairs

     */

    function Base() {

        Y.log('constructor called', 'life', 'base');

        Y.Attribute.call(this);

        Y.Plugin.Host.call(this);

        this._silentInit = this._silentInit || false;

        if (this._lazyAddAttrs !== false) { this._lazyAddAttrs = true; }

        this.init.apply(this, arguments);

    }

    /**

     * The list of properties which can be configured for 

     * each attribute (e.g. setter, getter, writeOnce, readOnly etc.)

     *

     * @property Base._ATTR_CFG

     * @type Array

     * @static

     * @private

     */

    Base._ATTR_CFG = Y.Attribute._ATTR_CFG.concat("cloneDefaultValue");

    /**

     * <p>

     * The string to be used to identify instances of 

     * this class, for example in prefixing events.

     * </p>

     * <p>

     * Classes extending Base, should define their own

     * static NAME property, which should be camelCase by

     * convention (e.g. MyClass.NAME = "myClass";).

     * </p>

     * @property Base.NAME

     * @type String

     * @static

     */

    Base.NAME = 'base';

    /**

     * The default set of attributes which will be available for instances of this class, and 

     * their configuration. In addition to the configuration properties listed by 

     * Attribute's <a href="Attribute.html#method_addAttr">addAttr</a> method, the attribute 

     * can also be configured with a "cloneDefaultValue" property, which defines how the statically

     * defined value field should be protected ("shallow", "deep" and false are supported values). 

     *

     * By default if the value is an object literal or an array it will be "shallow" cloned, to 

     * protect the default value.

     *

     * @property Base.ATTRS

     * @type Object

     * @static

     */

    Base.ATTRS = {

        /**

         * Flag indicating whether or not this object

         * has been through the init lifecycle phase.

         *

         * @attribute initialized

         * @readonly

         * @default false

         * @type boolean

         */

        initialized: {

            readOnly:true,

            value:false

        },

        /**

         * Flag indicating whether or not this object

         * has been through the destroy lifecycle phase.

         *

         * @attribute destroyed

         * @readonly

         * @default false

         * @type boolean

         */

        destroyed: {