/**
 * Ext.Anim is used to execute simple animations defined in {@link Ext.anims}. The {@link #run}
 * method can take any of the properties defined below.
 *
 *     Ext.Anim.run(this, 'fade', {
 *         out: false,
 *         autoClear: true
 *     });
 *
 * When using {@link Ext.Anim#run}, ensure you require {@link Ext.Anim} in your application.
 * Either do this using {@link Ext#require}:
 *
 *     Ext.requires('Ext.Anim');
 *
 * when using {@link Ext#setup}:
 *
 *     Ext.setup({
 *         requires: ['Ext.Anim'],
 *         onReady: function() {
 *             //do something
 *         }
 *     });
 *
 * or when using {@link Ext#application}:
 *
 *     Ext.application({
 *         requires: ['Ext.Anim'],
 *         launch: function() {
 *             //do something
 *         }
 *     });
 *
 * @singleton
 */
Ext.define('Ext.Anim', {
    isAnim: true,
 
    /**
     * @cfg {Boolean} disableAnimations
     * `true` to disable animations.
     */
    disableAnimations: false,
 
    defaultConfig: {
        /**
         * @cfg {Object} from
         * An object of CSS values which the animation begins with. If you define a CSS property
         * here, you must also define it in the {@link #to} config.
         */
        from: {},
 
        /**
         * @cfg {Object} to
         * An object of CSS values which the animation ends with. If you define a CSS property
         * here, you must also define it in the {@link #from} config.
         */
        to: {},
 
        /**
         * @cfg {Number} duration
         * Time in milliseconds for the animation to last.
         */
        duration: 250,
 
        /**
         * @cfg {Number} delay Time to delay before starting the animation.
         */
        delay: 0,
 
        /**
         * @cfg {String} easing
         * Valid values are 'ease', 'linear', ease-in', 'ease-out', 'ease-in-out', or a
         * cubic-bezier curve as defined by CSS.
         */
        easing: 'ease-in-out',
 
        /**
         * @cfg {Boolean} autoClear
         * `true` to remove all custom CSS defined in the {@link #to} config when the animation
         * is over.
         */
        autoClear: true,
 
        /**
         * @cfg {Boolean} out
         * `true` if you want the animation to slide out of the screen.
         */
        out: true,
 
        /**
         * @cfg {String} direction
         * Valid values are: 'left', 'right', 'up', 'down', and `null`.
         */
        direction: null,
 
        /**
         * @cfg {Boolean} reverse
         * `true` to reverse the animation direction. For example, if the animation direction was
         * set to 'left', it would then use 'right'.
         */
        reverse: false
    },
 
    /**
     * @cfg {Function} before
     * Code to execute before starting the animation.
     */
 
    /**
     * @cfg {Function} after
     * Code to execute after the animation ends.
     */
 
    /**
     * @cfg {Object} scope
     * Scope to run the {@link #before} function in.
     */
 
    opposites: {
        'left': 'right',
        'right': 'left',
        'up': 'down',
        'down': 'up'
    },
 
    /**
     * @private
     */
    constructor: function(config) {
        config = Ext.apply({}, config || {}, this.defaultConfig);
        this.config = config;
 
        this.callParent([config]);
 
        this.running = [];
    },
 
    initConfig: function(el, runConfig) {
        var me = this,
            config = Ext.apply({}, runConfig || {}, me.config);
 
        config.el = el = Ext.get(el);
 
        if (config.reverse && me.opposites[config.direction]) {
            config.direction = me.opposites[config.direction];
        }
 
        if (me.config.before) {
            me.config.before.call(config, el, config);
        }
 
        if (runConfig.before) {
            runConfig.before.call(config.scope || config, el, config);
        }
 
        return config;
    },
 
    /**
     * @ignore
     */
    run: function(el, config) {
        var me = this,
            style, property, after;
 
        el = Ext.get(el);
        config = config || {};
 
 
        style = el.dom.style;
        after = config.after;
 
        if (me.running[el.id]) {
            me.onTransitionEnd(null, el, {
                config: config,
                after: after
            });
        }
 
        config = this.initConfig(el, config);
 
        if (this.disableAnimations) {
            for (property in config.to) {
                if (!config.to.hasOwnProperty(property)) {
                    continue;
                }
 
                style[property] = config.to[property];
            }
 
            this.onTransitionEnd(null, el, {
                config: config,
                after: after
            });
 
            return me;
        }
 
        el.un('transitionend', me.onTransitionEnd, me);
 
        style.webkitTransitionDuration = '0ms';
        style.transitionDuration = '0ms';
 
        for (property in config.from) {
            if (!config.from.hasOwnProperty(property)) {
                continue;
            }
 
            style[property] = config.from[property];
        }
 
        Ext.defer(function() {
            // If this element has been destroyed since the timeout started, do nothing
            if (!el.dom) {
                return;
            }
 
            // If this is a 3d animation we have to set the perspective on the parent
            if (config.is3d === true) {
                el.parent().setStyle({
                    // See https://sencha.jira.com/browse/TOUCH-1498
                    '-webkit-perspective': '1200',
                    '-webkit-transform-style': 'preserve-3d'
                });
            }
 
            style.webkitTransitionDuration = config.duration + 'ms';
            style.webkitTransitionProperty = 'all';
            style.webkitTransitionTimingFunction = config.easing;
            // for IE
            style.transitionDuration = config.duration + 'ms';
            style.transitionProperty = 'all';
            style.transitionTimingFunction = config.easing;
 
            // Bind our listener that fires after the animation ends
            el.on('transitionend', me.onTransitionEnd, me, {
                single: true,
                config: config,
                after: after
            });
 
            for (property in config.to) {
                if (!config.to.hasOwnProperty(property)) {
                    continue;
                }
 
                style[property] = config.to[property];
            }
        }, config.delay || 5);
 
        me.running[el.id] = config;
 
        return me;
    },
 
    onTransitionEnd: function(ev, el, o) {
        var me = this,
            config = o.config,
            style, property;
 
        el = Ext.get(el);
 
        if (this.running[el.id] === undefined) {
            return;
        }
 
        style = el.dom.style;
 
        if (config.autoClear) {
            for (property in config.to) {
                if (!config.to.hasOwnProperty(property) || config[property] === false) {
                    continue;
                }
 
                style[property] = '';
            }
        }
 
        style.webkitTransitionDuration = null;
        style.webkitTransitionProperty = null;
        style.webkitTransitionTimingFunction = null;
        style.transitionDuration = '';
        style.transitionProperty = '';
        style.transitionTimingFunction = '';
 
        if (config.is3d) {
            el.parent().setStyle({
                '-webkit-perspective': '',
                '-webkit-transform-style': ''
            });
        }
 
        if (me.config.after) {
            me.config.after.call(config, el, config);
        }
 
        if (o.after) {
            o.after.call(config.scope || me, el, config);
        }
 
        delete me.running[el.id];
    }
}, function() {
 
    Ext.Anim.seed = 1000;
 
    /**
     * Used to run an animation on a specific element. Use the config argument to customize
     * the animation.
     * @param {Ext.Element/HTMLElement} el The element to animate.
     * @param {String} anim The animation type, defined in {@link Ext.anims}.
     * @param {Object} config The config object for the animation.
     * @method run
     */
    Ext.Anim.run = function(el, anim, config) {
        if (el.isComponent) {
            el = el.element;
        }
        else {
            el = Ext.get(el);
        }
 
        config = config || {};
 
        if (anim.isAnim) {
            anim.run(el, config);
        }
        else {
            if (Ext.isObject(anim)) {
                if (config.before && anim.before) {
                    config.before = Ext.createInterceptor(config.before, anim.before, anim.scope);
                }
 
                if (config.after && anim.after) {
                    config.after = Ext.createInterceptor(config.after, anim.after, anim.scope);
                }
 
                config = Ext.apply({}, config, anim);
                anim = anim.type || 'raw';
            }
 
            if (!Ext.anims[anim]) {
                throw anim + ' is not a valid animation type.';
            }
            else {
                // add el check to make sure dom exists.
                if (el && el.dom) {
                    Ext.anims[anim].run(el, config);
                }
            }
        }
    };
 
    /**
     * @class Ext.anims
     * Defines different types of animations.
     *
     * __Note:__ _flip_, _cube_, and _wipe_ animations do not work on Android.
     *
     * Please refer to {@link Ext.Anim} on how to use animations.
     * @singleton
     */
    Ext.anims = {
        /**
         * Fade Animation
         */
        fade: new Ext.Anim({
            type: 'fade',
            before: function(el) {
                var fromOpacity = 1,
                    toOpacity = 1,
                    curZ = el.getStyle('z-index') === 'auto' ? 0 : el.getStyle('z-index'),
                    zIndex = curZ;
 
                if (this.out) {
                    toOpacity = 0;
                }
                else {
                    zIndex = Math.abs(curZ) + 1;
                    fromOpacity = 0;
                }
 
                this.from = {
                    'opacity': fromOpacity,
                    'z-index': zIndex
                };
                this.to = {
                    'opacity': toOpacity,
                    'z-index': zIndex
                };
            }
        }),
 
        /**
         * Slide Animation
         */
        slide: new Ext.Anim({
            direction: 'left',
            cover: false,
            reveal: false,
            opacity: false,
            'z-index': false,
 
            before: function(el) {
                var currentZIndex = el.getStyle('z-index') === 'auto' ? 0 : el.getStyle('z-index'),
                    currentOpacity = el.getStyle('opacity'),
                    zIndex = currentZIndex + 1,
                    out = this.out,
                    direction = this.direction,
                    toX = 0,
                    toY = 0,
                    fromX = 0,
                    fromY = 0,
                    elH = el.getHeight(),
                    elW = el.getWidth();
 
                if (direction === 'left' || direction === 'right') {
                    if (out) {
                        toX = -elW;
                    }
                    else {
                        fromX = elW;
                    }
                }
                else if (direction === 'up' || direction === 'down') {
                    if (out) {
                        toY = -elH;
                    }
                    else {
                        fromY = elH;
                    }
                }
 
                if (direction === 'right' || direction === 'down') {
                    toY *= -1;
                    toX *= -1;
                    fromY *= -1;
                    fromX *= -1;
                }
 
                if (this.cover && out) {
                    toX = 0;
                    toY = 0;
                    zIndex = currentZIndex;
                }
                else if (this.reveal && !out) {
                    fromX = 0;
                    fromY = 0;
                    zIndex = currentZIndex;
                }
 
                this.from = {
                    '-webkit-transform': 'translate3d(' + fromX + 'px, ' + fromY + 'px, 0)',
                    'z-index': zIndex,
                    'opacity': currentOpacity - 0.01
                };
                this.to = {
                    '-webkit-transform': 'translate3d(' + toX + 'px, ' + toY + 'px, 0)',
                    'z-index': zIndex,
                    'opacity': currentOpacity
                };
            }
        }),
 
        /**
         * Pop Animation
         */
        pop: new Ext.Anim({
            scaleOnExit: true,
            before: function(el) {
                var fromScale = 1,
                    toScale = 1,
                    fromOpacity = 1,
                    toOpacity = 1,
                    curZ = el.getStyle('z-index') === 'auto' ? 0 : el.getStyle('z-index'),
                    fromZ = curZ,
                    toZ = curZ;
 
                if (!this.out) {
                    fromScale = 0.01;
                    fromZ = curZ + 1;
                    toZ = curZ + 1;
                    fromOpacity = 0;
                }
                else {
                    if (this.scaleOnExit) {
                        toScale = 0.01;
                        toOpacity = 0;
                    }
                    else {
                        toOpacity = 0.8;
                    }
                }
 
                this.from = {
                    '-webkit-transform': 'scale(' + fromScale + ')',
                    '-webkit-transform-origin': '50% 50%',
                    'opacity': fromOpacity,
                    'z-index': fromZ
                };
 
                this.to = {
                    '-webkit-transform': 'scale(' + toScale + ')',
                    '-webkit-transform-origin': '50% 50%',
                    'opacity': toOpacity,
                    'z-index': toZ
                };
            }
        }),
 
        /**
         * Flip Animation
         */
        flip: new Ext.Anim({
            is3d: true,
            direction: 'left',
            before: function() {
                var rotateProp = 'Y',
                    fromScale = 1,
                    toScale = 1,
                    fromRotate = 0,
                    toRotate = 0;
 
                if (this.out) {
                    toRotate = -180;
                    toScale = 0.8;
                }
                else {
                    fromRotate = 180;
                    fromScale = 0.8;
                }
 
                if (this.direction === 'up' || this.direction === 'down') {
                    rotateProp = 'X';
                }
 
                if (this.direction === 'right' || this.direction === 'left') {
                    toRotate *= -1;
                    fromRotate *= -1;
                }
 
                this.from = {
                    '-webkit-transform': 'rotate' + rotateProp + '(' + fromRotate + 'deg) scale(' +
                        fromScale + ')',
                    '-webkit-backface-visibility': 'hidden'
                };
                this.to = {
                    '-webkit-transform': 'rotate' + rotateProp + '(' + toRotate + 'deg) scale(' +
                        toScale + ')',
                    '-webkit-backface-visibility': 'hidden'
                };
            }
        }),
 
        /**
         * Cube Animation
         */
        cube: new Ext.Anim({
            is3d: true,
            direction: 'left',
            style: 'outer',
            before: function(el) {
                var origin = '0% 0%',
                    fromRotate = 0,
                    toRotate = 0,
                    rotateProp = 'Y',
                    fromZ = 0,
                    toZ = 0,
                    elW = el.getWidth(),
                    elH = el.getHeight(),
                    showTranslateZ = true,
                    fromTranslate = ' translateX(0)',
                    toTranslate = '';
 
                if (this.direction === 'left' || this.direction === 'right') {
                    if (this.out) {
                        origin = '100% 100%';
                        toZ = elW;
                        toRotate = -90;
                    }
                    else {
                        origin = '0% 0%';
                        fromZ = elW;
                        fromRotate = 90;
                    }
                }
                else if (this.direction === 'up' || this.direction === 'down') {
                    rotateProp = 'X';
 
                    if (this.out) {
                        origin = '100% 100%';
                        toZ = elH;
                        toRotate = 90;
                    }
                    else {
                        origin = '0% 0%';
                        fromZ = elH;
                        fromRotate = -90;
                    }
                }
 
                if (this.direction === 'down' || this.direction === 'right') {
                    fromRotate *= -1;
                    toRotate *= -1;
                    origin = (origin === '0% 0%') ? '100% 100%' : '0% 0%';
                }
 
                if (this.style === 'inner') {
                    fromZ *= -1;
                    toZ *= -1;
                    fromRotate *= -1;
                    toRotate *= -1;
 
                    if (!this.out) {
                        toTranslate = ' translateX(0px)';
                        origin = '0% 50%';
                    }
                    else {
                        toTranslate = fromTranslate;
                        origin = '100% 50%';
                    }
                }
 
                this.from = {
                    '-webkit-transform': 'rotate' + rotateProp + '(' + fromRotate + 'deg)' +
                        (showTranslateZ ? ' translateZ(' + fromZ + 'px)' : '') + fromTranslate,
                    '-webkit-transform-origin': origin
                };
                this.to = {
                    '-webkit-transform': 'rotate' + rotateProp + '(' + toRotate +
                        'deg) translateZ(' + toZ + 'px)' + toTranslate,
                    '-webkit-transform-origin': origin
                };
            },
            duration: 250
        }),
 
 
        /**
         * Wipe Animation.
         * Because of the amount of calculations involved, this animation is best used on small
         * display changes or specifically for phone environments. Does not currently accept any
         * parameters.
         */
        wipe: new Ext.Anim({
            before: function(el) {
                var curZ = el.getStyle('z-index'),
                    zIndex,
                    mask = '';
 
                if (!this.out) {
                    zIndex = curZ + 1;
                    mask = '-webkit-gradient(linear, left bottom, right bottom, ' +
                        'from(transparent), to(#000), color-stop(66%, #000), color-stop(33%, ' +
                        'transparent))';
 
                    this.from = {
                        '-webkit-mask-image': mask,
                        '-webkit-mask-size': el.getWidth() * 3 + 'px ' + el.getHeight() + 'px',
                        'z-index': zIndex,
                        '-webkit-mask-position-x': 0
                    };
                    this.to = {
                        '-webkit-mask-image': mask,
                        '-webkit-mask-size': el.getWidth() * 3 + 'px ' + el.getHeight() + 'px',
                        'z-index': zIndex,
                        '-webkit-mask-position-x': -el.getWidth() * 2 + 'px'
                    };
                }
            },
            duration: 500
        }),
 
        /**
         * Raw Animation.
         * Best used when the other types do not suite your needs. Set `from` and `to` as needed.
         */
        raw: new Ext.Anim({
            duration: 250
        })
    };
});