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

    /**

    The `base-observable` submodule adds observability to Base's lifecycle and

    attributes, and also make it an `EventTarget`.

    @module base

    @submodule base-observable

    **/

    var L = Y.Lang,

        DESTROY = "destroy",

        INIT = "init",

        BUBBLETARGETS = "bubbleTargets",

        _BUBBLETARGETS = "_bubbleTargets",

        AttributeObservable = Y.AttributeObservable,

        BaseCore            = Y.BaseCore;

    /**

    Provides an augmentable implementation of lifecycle and attribute events for

    `BaseCore`.

    @class BaseObservable

    @extensionfor BaseCore

    @uses AttributeObservable

    @uses EventTarget

    @since 3.8.0

    **/

    function BaseObservable() {}

    BaseObservable._ATTR_CFG      = AttributeObservable._ATTR_CFG.concat();

    BaseObservable._NON_ATTRS_CFG = ["on", "after", "bubbleTargets"];

    BaseObservable.prototype = {

        /**

         * Initializes Attribute

         *

         * @method _initAttribute

         * @private

         */

        _initAttribute: function() {

            BaseCore.prototype._initAttribute.apply(this, arguments);

            AttributeObservable.call(this);

            this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME;

            this._yuievt.config.prefix = this._eventPrefix;

        },

        /**

         * Init lifecycle method, invoked during construction.

         * Fires the init event prior to setting up attributes and

         * invoking initializers for the class hierarchy.

         *

         * @method init

         * @chainable

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

         * @return {Base} A reference to this object

         */

        init: function(config) {

            /**

             * <p>

             * Lifecycle event for the init phase, fired prior to initialization.

             * Invoking the preventDefault() method on the event object provided

             * to subscribers will prevent initialization from occuring.

             * </p>

             * <p>

             * Subscribers to the "after" momemt of this event, will be notified

             * after initialization of the object is complete (and therefore

             * cannot prevent initialization).

             * </p>

             *

             * @event init

             * @preventable _defInitFn

             * @param {EventFacade} e Event object, with a cfg property which

             * refers to the configuration object passed to the constructor.

             */

            // PERF: Using lower level _publish() for

            // critical path performance

            var type = this._getFullType(INIT),

                e = this._publish(type);

            e.emitFacade = true;

            e.fireOnce = true;

            e.defaultTargetOnly = true;

            e.defaultFn = this._defInitFn;

            this._preInitEventCfg(config);

            if (e._hasPotentialSubscribers()) {

                this.fire(type, {cfg: config});

            } else {

                this._baseInit(config);

                // HACK. Major hack actually. But really fast for no-listeners.

                // Since it's fireOnce, subscribers may come along later, so since we're

                // bypassing the event stack the first time, we need to tell the published

                // event that it's been "fired". Could extract it into a CE method?

                e.fired = true;

                e.firedWith = [{cfg:config}];

            }

            return this;

        },

        /**

         * Handles the special on, after and target properties which allow the user to

         * easily configure on and after listeners as well as bubble targets during

         * construction, prior to init.

         *

         * @private

         * @method _preInitEventCfg

         * @param {Object} config The user configuration object

         */

        _preInitEventCfg : function(config) {

            if (config) {

                if (config.on) {

                    this.on(config.on);

                }

                if (config.after) {

                    this.after(config.after);

                }

            }

            var i, l, target,

                userTargets = (config && BUBBLETARGETS in config);

            if (userTargets || _BUBBLETARGETS in this) {

                target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets;

                if (L.isArray(target)) {

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

                        this.addTarget(target[i]);

                    }

                } else if (target) {

                    this.addTarget(target);

                }

            }

        },

        /**

         * <p>

         * Destroy lifecycle method. Fires the destroy

         * event, prior to invoking destructors for the

         * class hierarchy.

         * </p>

         * <p>

         * Subscribers to the destroy

         * event can invoke preventDefault on the event object, to prevent destruction

         * from proceeding.

         * </p>

         * @method destroy

         * @return {Base} A reference to this object

         * @chainable

         */

        destroy: function() {

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

            /**

             * <p>

             * Lifecycle event for the destroy phase,

             * fired prior to destruction. Invoking the preventDefault

             * method on the event object provided to subscribers will

             * prevent destruction from proceeding.

             * </p>

             * <p>

             * Subscribers to the "after" moment of this event, will be notified

             * after destruction is complete (and as a result cannot prevent

             * destruction).

             * </p>

             * @event destroy

             * @preventable _defDestroyFn

             * @param {EventFacade} e Event object

             */

            this.publish(DESTROY, {

                fireOnce:true,

                defaultTargetOnly:true,

                defaultFn: this._defDestroyFn

            });

            this.fire(DESTROY);

            this.detachAll();

            return this;

        },

        /**

         * Default init event handler

         *

         * @method _defInitFn

         * @param {EventFacade} e Event object, with a cfg property which

         * refers to the configuration object passed to the constructor.

         * @protected

         */

        _defInitFn : function(e) {

            this._baseInit(e.cfg);

        },

        /**

         * Default destroy event handler

         *

         * @method _defDestroyFn

         * @param {EventFacade} e Event object

         * @protected

         */

        _defDestroyFn : function(e) {

            this._baseDestroy(e.cfg);

        }

    };

    Y.mix(BaseObservable, AttributeObservable, false, null, 1);

    Y.BaseObservable = BaseObservable;

}, '@VERSION@', {"requires": ["attribute-observable", "base-core"]});