YUI.add('event-custom-complex', function (Y, NAME) {

/**

 * Adds event facades, preventable default behavior, and bubbling.

 * events.

 * @module event-custom

 * @submodule event-custom-complex

 */

var FACADE,

    FACADE_KEYS,

    YObject = Y.Object,

    key,

    EMPTY = {},

    CEProto = Y.CustomEvent.prototype,

    ETProto = Y.EventTarget.prototype,

    mixFacadeProps = function(facade, payload) {

        var p;

        for (p in payload) {

            if (!(FACADE_KEYS.hasOwnProperty(p))) {

                facade[p] = payload[p];

            }

        }

    };

/**

 * Wraps and protects a custom event for use when emitFacade is set to true.

 * Requires the event-custom-complex module

 * @class EventFacade

 * @param e {Event} the custom event

 * @param currentTarget {HTMLElement} the element the listener was attached to

 */

Y.EventFacade = function(e, currentTarget) {

    if (!e) {

        e = EMPTY;

    }

    this._event = e;

    /**

     * The arguments passed to fire

     * @property details

     * @type Array

     */

    this.details = e.details;

    /**

     * The event type, this can be overridden by the fire() payload

     * @property type

     * @type string

     */

    this.type = e.type;

    /**

     * The real event type

     * @property _type

     * @type string

     * @private

     */

    this._type = e.type;

    //////////////////////////////////////////////////////

    /**

     * Node reference for the targeted eventtarget

     * @property target

     * @type Node

     */

    this.target = e.target;

    /**

     * Node reference for the element that the listener was attached to.

     * @property currentTarget

     * @type Node

     */

    this.currentTarget = currentTarget;

    /**

     * Node reference to the relatedTarget

     * @property relatedTarget

     * @type Node

     */

    this.relatedTarget = e.relatedTarget;

};

Y.mix(Y.EventFacade.prototype, {

    /**

     * Stops the propagation to the next bubble target

     * @method stopPropagation

     */

    stopPropagation: function() {

        this._event.stopPropagation();

        this.stopped = 1;

    },

    /**

     * Stops the propagation to the next bubble target and

     * prevents any additional listeners from being exectued

     * on the current target.

     * @method stopImmediatePropagation

     */

    stopImmediatePropagation: function() {

        this._event.stopImmediatePropagation();

        this.stopped = 2;

    },

    /**

     * Prevents the event's default behavior

     * @method preventDefault

     */

    preventDefault: function() {

        this._event.preventDefault();

        this.prevented = 1;

    },

    /**

     * Stops the event propagation and prevents the default

     * event behavior.

     * @method halt

     * @param immediate {boolean} if true additional listeners

     * on the current target will not be executed

     */

    halt: function(immediate) {

        this._event.halt(immediate);

        this.prevented = 1;

        this.stopped = (immediate) ? 2 : 1;

    }

});

CEProto.fireComplex = function(args) {

    var es,

        ef,

        q,

        queue,

        ce,

        ret = true,

        events,

        subs,

        ons,

        afters,

        afterQueue,

        postponed,

        prevented,

        preventedFn,

        defaultFn,

        self = this,

        host = self.host || self,

        next,

        oldbubble,

        stack = self.stack,

        yuievt = host._yuievt,

        hasPotentialSubscribers;

    if (stack) {

        // queue this event if the current item in the queue bubbles

        if (self.queuable && self.type !== stack.next.type) {

            self.log('queue ' + self.type);

            if (!stack.queue) {

                stack.queue = [];

            }

            stack.queue.push([self, args]);

            return true;

        }

    }

    hasPotentialSubscribers = self.hasSubs() || yuievt.hasTargets || self.broadcast;

    self.target = self.target || host;

    self.currentTarget = host;

    self.details = args.concat();

    if (hasPotentialSubscribers) {

        es = stack || {

           id: self.id, // id of the first event in the stack

           next: self,

           silent: self.silent,

           stopped: 0,

           prevented: 0,

           bubbling: null,

           type: self.type,

           // defaultFnQueue: new Y.Queue(),

           defaultTargetOnly: self.defaultTargetOnly

        };

        subs = self.getSubs();

        ons = subs[0];

        afters = subs[1];

        self.stopped = (self.type !== es.type) ? 0 : es.stopped;

        self.prevented = (self.type !== es.type) ? 0 : es.prevented;

        if (self.stoppedFn) {

            // PERF TODO: Can we replace with callback, like preventedFn. Look into history

            events = new Y.EventTarget({

                fireOnce: true,

                context: host

            });

            self.events = events;

            events.on('stopped', self.stoppedFn);

        }

        // self.log("Firing " + self  + ", " + "args: " + args);

        self.log("Firing " + self.type);

        self._facade = null; // kill facade to eliminate stale properties

        ef = self._createFacade(args);

        if (ons) {

            self._procSubs(ons, args, ef);

        }

        // bubble if this is hosted in an event target and propagation has not been stopped

        if (self.bubbles && host.bubble && !self.stopped) {

            oldbubble = es.bubbling;

            es.bubbling = self.type;

            if (es.type !== self.type) {

                es.stopped = 0;

                es.prevented = 0;

            }

            ret = host.bubble(self, args, null, es);

            self.stopped = Math.max(self.stopped, es.stopped);

            self.prevented = Math.max(self.prevented, es.prevented);

            es.bubbling = oldbubble;

        }

        prevented = self.prevented;

        if (prevented) {

            preventedFn = self.preventedFn;

            if (preventedFn) {

                preventedFn.apply(host, args);

            }

        } else {

            defaultFn = self.defaultFn;

            if (defaultFn && ((!self.defaultTargetOnly && !es.defaultTargetOnly) || host === ef.target)) {

                defaultFn.apply(host, args);

            }

        }

        // broadcast listeners are fired as discreet events on the

        // YUI instance and potentially the YUI global.

        if (self.broadcast) {

            self._broadcast(args);

        }

        if (afters && !self.prevented && self.stopped < 2) {

            // Queue the after

            afterQueue = es.afterQueue;

            if (es.id === self.id || self.type !== yuievt.bubbling) {

                self._procSubs(afters, args, ef);

                if (afterQueue) {

                    while ((next = afterQueue.last())) {

                        next();

                    }

                }

            } else {

                postponed = afters;

                if (es.execDefaultCnt) {

                    postponed = Y.merge(postponed);

                    Y.each(postponed, function(s) {

                        s.postponed = true;

                    });

                }

                if (!afterQueue) {

                    es.afterQueue = new Y.Queue();

                }

                es.afterQueue.add(function() {

                    self._procSubs(postponed, args, ef);

                });

            }

        }

        self.target = null;

        if (es.id === self.id) {

            queue = es.queue;

            if (queue) {

                while (queue.length) {

                    q = queue.pop();

                    ce = q[0];

                    // set up stack to allow the next item to be processed

                    es.next = ce;

                    ce._fire(q[1]);

                }

            }

            self.stack = null;

        }

        ret = !(self.stopped);

        if (self.type !== yuievt.bubbling) {

            es.stopped = 0;

            es.prevented = 0;

            self.stopped = 0;

            self.prevented = 0;

        }

    } else {

        defaultFn = self.defaultFn;

        if(defaultFn) {

            ef = self._createFacade(args);

            if ((!self.defaultTargetOnly) || (host === ef.target)) {

                defaultFn.apply(host, args);

            }

        }

    }

    // Kill the cached facade to free up memory.

    // Otherwise we have the facade from the last fire, sitting around forever.

    self._facade = null;

    return ret;

};

/**

 * @method _hasPotentialSubscribers

 * @for CustomEvent

 * @private

 * @return {boolean} Whether the event has potential subscribers or not

 */

CEProto._hasPotentialSubscribers = function() {

    return this.hasSubs() || this.host._yuievt.hasTargets || this.broadcast;

};

/**

 * Internal utility method to create a new facade instance and

 * insert it into the fire argument list, accounting for any payload

 * merging which needs to happen.

 *

 * This used to be called `_getFacade`, but the name seemed inappropriate

 * when it was used without a need for the return value.

 *

 * @method _createFacade

 * @private

 * @param fireArgs {Array} The arguments passed to "fire", which need to be

 * shifted (and potentially merged) when the facade is added.

 * @return {EventFacade} The event facade created.

 */

// TODO: Remove (private) _getFacade alias, once synthetic.js is updated.

CEProto._createFacade = CEProto._getFacade = function(fireArgs) {

    var userArgs = this.details,

        firstArg = userArgs && userArgs[0],

        firstArgIsObj = (firstArg && (typeof firstArg === "object")),

        ef = this._facade;

    if (!ef) {

        ef = new Y.EventFacade(this, this.currentTarget);

    }

    if (firstArgIsObj) {

        // protect the event facade properties

        mixFacadeProps(ef, firstArg);

        // Allow the event type to be faked http://yuilibrary.com/projects/yui3/ticket/2528376

        if (firstArg.type) {

            ef.type = firstArg.type;

        }

        if (fireArgs) {