/**
 * @private
 *
 * The abstract class. Sub-classes are expected, at the very least, to implement translation logics
 * inside the 'translate' method
 */
Ext.define('Ext.util.translatable.Abstract', {
    extend: 'Ext.Evented',

    mixins: [
        'Ext.mixin.Factoryable'
    ],

    factoryConfig: {
        type: 'translatable',
        defaultType: 'csstransform'
    },

    requires: ['Ext.fx.easing.Linear'],

    config: {
        easing: null,

        easingX: {
            duration: 300
        },

        easingY: {
            duration: 300
        },

        offsetX: 0,

        offsetY: 0
    },

    /**
     * @event animationstart
     * Fires whenever the animation is started
     * @param {Ext.util.translatable.Abstract} this
     * @param {Number} x The current translation on the x axis
     * @param {Number} y The current translation on the y axis
     */

    /**
     * @event animationframe
     * Fires for each animation frame
     * @param {Ext.util.translatable.Abstract} this
     * @param {Number} x The new translation on the x axis
     * @param {Number} y The new translation on the y axis
     */

    /**
     * @event animationend
     * Fires whenever the animation is ended
     * @param {Ext.util.translatable.Abstract} this
     * @param {Number} x The current translation on the x axis
     * @param {Number} y The current translation on the y axis
     */

    /**
     * @property {Number} x
     * @private
     * The last translated x value
     */
    x: 0,

    /**
     * @property {Number} y
     * @private
     * The last translated y value
     */
    y: 0,

    activeEasingX: null,

    activeEasingY: null,

    isAnimating: false,

    isTranslatable: true,

    constructor: function(config) {
        this.callParent([config]);

        // this.position is simply an internal reusable object for GC purposes and should
        // not be accessed directly as it's values are not kept in sync.  always use
        // getPosition() to get the position
        this.position = { x: 0, y: 0 };
    },

    factoryEasing: function(easing) {
        return Ext.factory(easing, Ext.fx.easing.Linear, null, 'easing');
    },

    applyEasing: function(easing) {
        if (!this.getEasingX()) {
            this.setEasingX(this.factoryEasing(easing));
        }

        if (!this.getEasingY()) {
            this.setEasingY(this.factoryEasing(easing));
        }
    },

    applyEasingX: function(easing) {
        return this.factoryEasing(easing);
    },

    applyEasingY: function(easing) {
        return this.factoryEasing(easing);
    },

    updateOffsetX: function() {
        var me = this;

        if (!me.isConfiguring && !me.isAnimating) {
            me.translateXY(me.x, me.y);
        }
    },

    updateOffsetY: function() {
        var me = this;

        if (!me.isConfiguring && !me.isAnimating) {
            me.translateXY(me.x, me.y);
        }
    },

    translate: function(x, y, animation) {
        var me = this;

        if (animation) {
            return me.translateAnimated(x, y, animation);
        }

        if (me.isAnimating) {
            me.stopAnimation();
        }

        if (!isNaN(x) && typeof x === 'number') {
            me.x = x;
        }
        else {
            x = me.x;
        }

        if (!isNaN(y) && typeof y === 'number') {
            me.y = y;
        }
        else {
            y = me.y;
        }

        me.translateXY(x, y);
    },

    translateXY: function(x, y) {
        var me = this;

        if (!me.destroyed) {
            me.doTranslate(x + me.getOffsetX(), y + me.getOffsetY());

            if (me.hasListeners.translate) {
                me.fireEvent('translate', me, x, y);
            }
        }
    },

    translateAxis: function(axis, value, animation) {
        var x, y;

        if (axis === 'x') {
            x = value;
        }
        else {
            y = value;
        }

        return this.translate(x, y, animation);
    },

    /**
     * Returns the translatable object's current position.
     * @return {Object} position An object with x and y properties
     */
    getPosition: function() {
        var me = this,
            position = me.position;

        position.x = -me.x;
        position.y = -me.y;

        return position;
    },

    animate: function(easingX, easingY) {
        var me = this;

        me.activeEasingX = easingX;
        me.activeEasingY = easingY;

        me.isAnimating = true;

        if (me.ownerCmp) {
            me.ownerCmp.isTranslating = true;
        }

        me.lastX = null;
        me.lastY = null;

        Ext.AnimationQueue.start(me.doAnimationFrame, me);

        me.fireEvent('animationstart', me, me.x, me.y);

        return me;
    },

    translateAnimated: function(x, y, animation) {
        var me = this,
            now, easing, easingX, easingY;

        if (!Ext.isObject(animation)) {
            animation = {};
        }

        if (me.isAnimating) {
            me.stopAnimation();
        }

        // Callback must be called in stopAnimation
        me.callback = animation.callback;
        me.callbackScope = animation.scope;

        now = Ext.Date.now();
        easing = animation.easing;

        easingX = (typeof x === 'number')
            ? (animation.easingX || easing || me.getEasingX() || true)
            : null;

        easingY = (typeof y === 'number')
            ? (animation.easingY || easing || me.getEasingY() || true)
            : null;

        if (easingX) {
            easingX = me.factoryEasing(easingX);
            easingX.setStartTime(now);
            easingX.setStartValue(me.x);
            easingX.setEndValue(x);

            if ('duration' in animation) {
                easingX.setDuration(animation.duration);
            }
        }

        if (easingY) {
            easingY = me.factoryEasing(easingY);
            easingY.setStartTime(now);
            easingY.setStartValue(me.y);
            easingY.setEndValue(y);

            if ('duration' in animation) {
                easingY.setDuration(animation.duration);
            }
        }

        return me.animate(easingX, easingY);
    },

    doAnimationFrame: function() {
        var me = this,
            easingX = me.activeEasingX,
            easingY = me.activeEasingY,
            now = Date.now(),
            x, y;

        if (!me.isAnimating) {
            return;
        }

        me.lastRun = now;

        if (easingX === null && easingY === null) {
            me.stopAnimation();

            return;
        }

        if (easingX !== null) {
            me.x = x = Math.round(easingX.getValue());

            if (easingX.isEnded) {
                me.activeEasingX = null;
                me.fireEvent('axisanimationend', me, 'x', x);
            }
        }
        else {
            x = me.x;
        }

        if (easingY !== null) {
            me.y = y = Math.round(easingY.getValue());

            if (easingY.isEnded) {
                me.activeEasingY = null;
                me.fireEvent('axisanimationend', me, 'y', y);
            }
        }
        else {
            y = me.y;
        }

        if (me.lastX !== x || me.lastY !== y) {
            me.translateXY(x, y);

            me.lastX = x;
            me.lastY = y;
        }

        me.fireEvent('animationframe', me, x, y);
    },

    stopAnimation: function() {
        var me = this;

        if (!me.isAnimating) {
            return;
        }

        me.activeEasingX = null;
        me.activeEasingY = null;

        me.isAnimating = false;

        if (me.ownerCmp) {
            me.ownerCmp.isTranslating = false;
        }

        Ext.AnimationQueue.stop(me.doAnimationFrame, me);

        me.fireEvent('animationend', me, me.x, me.y);

        if (me.callback) {
            me.callback.call(me.callbackScope);
            me.callback = null;
        }
    },

    refresh: function() {
        this.translate(this.x, this.y);
    },

    resolveListenerScope: function() {
        var ownerCmp = this.ownerCmp,
            a = arguments;

        if (ownerCmp) {
            return ownerCmp.resolveListenerScope.apply(ownerCmp, a);
        }

        return this.callParent(a);
    },

    destroy: function() {
        var me = this;

        me.destroying = true;

        if (me.isAnimating) {
            me.stopAnimation();
        }

        me.callParent();

        // This just makes it hard to ask "was destroy() called?":
        // me.destroying = false; // removed in 7.0
        me.destroyed = true;
    }
});