/**
Provides the implementation of view transitions for `Y.App.Transitions` in
browsers which support native CSS3 transitions.
 
@module app
@submodule app-transitions-native
@since 3.5.0
**/
 
var AppTransitions = Y.App.Transitions;
 
/**
Provides the implementation of view transitions for `Y.App.Transitions` in
browsers which support native CSS3 transitions.
 
When this module is used, `Y.App.TransitionsNative` will automatically mix
itself in to `Y.App`.
 
@class App.TransitionsNative
@extensionfor App
@since 3.5.0
**/
function AppTransitionsNative() {}
 
AppTransitionsNative.prototype = {
    // -- Protected Properties -------------------------------------------------
 
    /**
    Whether this app is currently transitioning its `activeView`.
 
    @property _transitioning
    @type Boolean
    @default false
    @protected
    @since 3.5.0
    **/
 
    /**
    A queue that holds pending calls to this app's `_uiTransitionActiveView()`
    method.
 
    @property _viewTransitionQueue
    @type Array
    @default []
    @protected
    @since 3.5.0
    **/
 
    // -- Lifecycle Methods ----------------------------------------------------
 
    initializer: function () {
        this._transitioning       = false;
        this._viewTransitionQueue = [];
 
        // TODO: Consider the AOP approach that `Plugin.WidgetAnim` uses.
        Y.Do.before(this._queueActiveView, this, '_uiSetActiveView');
    },
 
    // -- Protected Methods ----------------------------------------------------
 
    /**
    Dequeues any pending calls to `_uiTransitionActiveView()`.
 
    **Note:** When there is more than one queued transition, only the most
    recent `activeView` change will be visually transitioned, while the others
    will have their `transition` option overridden to `false`.
 
    @method _dequeueActiveView
    @protected
    @since 3.5.0
    **/
    _dequeueActiveView: function () {
        var queue      = this._viewTransitionQueue,
            transition = queue.shift(),
            options;
 
        if (transition) {
            // When items are still left in the queue, override the transition
            // so it does not run.
            if (queue.length) {
                // Overrides `transition` option and splices in the new options.
                options = Y.merge(transition[2], {transition: false});
                transition.splice(2, 1, options);
            }
 
            this._uiTransitionActiveView.apply(this, transition);
        }
    },
 
    /**
    Returns an object containing a named fx for both `viewIn` and `viewOut`
    based on the relationship between the specified `newView` and `oldView`.
 
    @method _getFx
    @param {View} newView The view being transitioned-in.
    @param {View} oldView The view being transitioned-out.
    @param {String} [transition] The preferred transition to use.
    @return {Object} An object containing a named fx for both `viewIn` and
        `viewOut`.
    @protected
    @since 3.5.0
    **/
    _getFx: function (newView, oldView, transition) {
        var fx          = AppTransitions.FX,
            transitions = this.get('transitions');
 
        if (transition === false || !transitions) {
            return null;
        }
 
        if (transition) {
            return fx[transition];
        }
 
        if (this._isChildView(newView, oldView)) {
            return fx[transitions.toChild];
        }
 
        if (this._isParentView(newView, oldView)) {
            return fx[transitions.toParent];
        }
 
        return fx[transitions.navigate];
    },
 
    /**
    Queues calls to `_uiTransitionActiveView()` to make sure a currently running
    transition isn't interrupted.
 
    **Note:** This method prevents the default `_uiSetActiveView()` method from
    running.
 
    @method _queueActiveView
    @protected
    @since 3.5.0
    **/
    _queueActiveView: function () {
        var args = Y.Array(arguments, 0, true);
 
        this._viewTransitionQueue.push(args);
 
        if (!this._transitioning) {
            this._dequeueActiveView();
        }
 
        return new Y.Do.Prevent();
    },
 
    /**
    Performs the actual change of this app's `activeView` by visually
    transitioning between the `newView` and `oldView` using any specified
    `options`.
 
    The `newView` is attached to the app by rendering it to the `viewContainer`,
    and making this app a bubble target of its events.
 
    The `oldView` is detached from the app by removing it from the
    `viewContainer`, and removing this app as a bubble target for its events.
    The `oldView` will either be preserved or properly destroyed.
 
    **Note:** This method overrides `_uiSetActiveView()` and provides all of its
    functionality plus supports visual transitions. Also, the `activeView`
    attribute is read-only and can be changed by calling the `showView()`
    method.
 
    @method _uiTransitionActiveView
    @param {View} newView The View which is now this app's `activeView`.
    @param {View} [oldView] The View which was this app's `activeView`.
    @param {Object} [options] Optional object containing any of the following
        properties:
      @param {Function} [options.callback] Optional callback function to call
        after new `activeView` is ready to use, the function will be passed:
          @param {View} options.callback.view A reference to the new
            `activeView`.
      @param {Boolean} [options.prepend=false] Whether the `view` should be
        prepended instead of appended to the `viewContainer`.
      @param {Boolean} [options.render] Whether the `view` should be rendered.
        **Note:** If no value is specified, a view instance will only be
        rendered if it's newly created by this method.
      @param {Boolean|String} [options.transition] Optional transition override.
        A transition can be specified which will override the default, or
        `false` for no transition.
      @param {Boolean} [options.update=false] Whether an existing view should
        have its attributes updated by passing the `config` object to its
        `setAttrs()` method. **Note:** This option does not have an effect if
        the `view` instance is created as a result of calling this method.
    @protected
    @since 3.5.0
    **/
    _uiTransitionActiveView: function (newView, oldView, options) {
        options || (options = {});
 
        var callback = options.callback,
            container, transitioning, isChild, isParent, prepend,
            fx, fxConfig, transitions;
 
        // Quits early when to new and old views are the same.
        if (newView === oldView) {
            callback && callback.call(this, newView);
 
            this._transitioning = false;
            return this._dequeueActiveView();
        }
 
        fx       = this._getFx(newView, oldView, options.transition);
        isChild  = this._isChildView(newView, oldView);
        isParent = !isChild && this._isParentView(newView, oldView);
        prepend  = !!options.prepend || isParent;
 
        // Preforms simply attach/detach of the new and old view respectively
        // when there's no transition to perform.
        if (!fx) {
            this._attachView(newView, prepend);
            this._detachView(oldView);
            callback && callback.call(this, newView);
 
            this._transitioning = false;
            return this._dequeueActiveView();
        }
 
        this._transitioning = true;
 
        container     = this.get('container');
        transitioning = Y.App.CLASS_NAMES.transitioning;
 
        container.addClass(transitioning);
 
        this._attachView(newView, prepend);
 
        // Called when view transitions completed, if none were added this will
        // run right away.
        function complete() {
            this._detachView(oldView);
            container.removeClass(transitioning);
            callback && callback.call(this, newView);
 
            this._transitioning = false;
            return this._dequeueActiveView();
        }
 
        // Setup a new stack to run the view transitions in parallel.
        transitions = new Y.Parallel({context: this});
        fxConfig    = {
            crossView: !!oldView && !!newView,
            prepended: prepend
        };
 
        // Transition the new view first to prevent a gap when sliding.
        if (newView && fx.viewIn) {
            newView.get('container')
                .transition(fx.viewIn, fxConfig, transitions.add());
        }
 
        if (oldView && fx.viewOut) {
            oldView.get('container')
                .transition(fx.viewOut, fxConfig, transitions.add());
        }
 
        transitions.done(complete);
    }
};
 
// -- Transition fx ------------------------------------------------------------
Y.mix(Y.Transition.fx, {
    'app:fadeIn': {
        opacity : 1,
        duration: 0.3,
 
        on: {
            start: function (data) {
                var styles = {opacity: 0},
                    config = data.config;
 
                if (config.crossView && !config.prepended) {
                    styles.transform = 'translateX(-100%)';
                }
 
                this.setStyles(styles);
            },
 
            end: function () {
                this.setStyle('transform', 'translateX(0)');
            }
        }
    },
 
    'app:fadeOut': {
        opacity : 0,
        duration: 0.3,
 
        on: {
            start: function (data) {
                var styles = {opacity: 1},
                    config = data.config;
 
                if (config.crossView && config.prepended) {
                    styles.transform = 'translateX(-100%)';
                }
 
                this.setStyles(styles);
            },
 
            end: function () {
                this.setStyle('transform', 'translateX(0)');
            }
        }
    },
 
    'app:slideLeft': {
        duration : 0.3,
        transform: 'translateX(-100%)',
 
        on: {
            start: function () {
                this.setStyles({
                    opacity  : 1,
                    transform: 'translateX(0%)'
                });
            },
 
            end: function () {
                this.setStyle('transform', 'translateX(0)');
            }
        }
    },
 
    'app:slideRight': {
        duration : 0.3,
        transform: 'translateX(0)',
 
        on: {
            start: function () {
                this.setStyles({
                    opacity  : 1,
                    transform: 'translateX(-100%)'
                });
            },
 
            end: function () {
                this.setStyle('transform', 'translateX(0)');
            }
        }
    }
});
 
// -- Namespacae ---------------------------------------------------------------
Y.App.TransitionsNative = AppTransitionsNative;
Y.Base.mix(Y.App, [AppTransitionsNative]);