/**
 * This class is the base for `Binding` and `MultiBinding`.
 * @private
 */
Ext.define('Ext.app.bind.BaseBinding', {
    extend: 'Ext.util.Schedulable',
 
    isBinding: true,
 
    calls: 0,
 
    kind: 20,
 
    defaultOptions: {},
 
    lastValue: undefined,
 
    /**
     * @cfg {Boolean} [single=false]
     * This option instructs the binding to call its `destroy` method immediately after
     * delivering the initial value.
     * @since 5.0.0
     */
 
    constructor: function (owner, callback, scope, options) {
        var me = this;
 
        me.options = options;
        me.owner = owner;
        me.scope = scope;
        me.callback = callback;
 
        //<debug>
        if (!callback) {
            Ext.raise('Callback is required');
        }
        //</debug>
 
        // If given a string callback name, preserve the late binding:
        me.lateBound = Ext.isString(callback);
        if (options && options.deep) {
            me.deep = true;
        }
 
        me.callParent();
    },
 
    destroy: function () {
        var me = this,
            owner = me.owner;
 
        if (owner) {
            owner.onBindDestroy(me);
        }
 
        me.callParent();
        
        me.scope = me.callback = me.owner = null;
    },
 
    isReadOnly: function() {
        return true;
    },
 
    privates: {
        getScheduler: function () {
            var owner = this.owner;
            return owner && owner.getScheduler();
        },
 
        getSession: function () {
            var owner = this.owner;
            return owner.isSession ? owner : owner.getSession();
        },
 
        notify: function (value) {
            var me = this,
                options = me.options || me.defaultOptions,
                previous = me.lastValue;
 
            // We want to deliver if:
            // 1) We've never been called
            // 2) We're a deep binding, which means that our object reference may not have changed,
            //    but something under us has changed. For example a link stub or a model field binding
            // 3) If the value has changed
            // 4) If the value is an array. It's difficult to tell if the underlying data changed
            if (!me.calls || me.deep || me.valueChanged(value, previous)) {
                ++me.calls;
                me.lastValue = value;
 
                if (me.lateBound) {
                    // Interestingly, lateBound-ness may be more efficient since it does
                    // not use the "call" method.
                    me.scope[me.callback](value, previous, me);
                } else {
                    me.callback.call(me.scope, value, previous, me);
                }
 
                if (options.single) {
                    me.destroy();
                }
            }
        },
 
        valueChanged: function(value, previous) {
            var ret = true;
 
            if (previous !== value) {
                if (value && previous && value instanceof Date && previous instanceof Date) {
                    ret = value.getTime() !== previous.getTime();
                }
            } else {
                ret = Ext.isArray(value);
            }
            return ret;
        }
    }
});