/**
 * This mixin provides a `dirty` config that tracks the modified state of an object. If
 * the class using this mixin is {@link Ext.mixin.Observable observable}, changes to the
 * `dirty` config will fire the `dirtychange` event.
 * @protected
 * @since 6.2.0
 */
Ext.define('Ext.mixin.Dirty', {
    mixinId: 'dirty',

    /**
     * @event dirtychange
     * Fires when a change in the object's {@link #cfg-dirty} state is detected.
     *
     * **Note:** In order for this event to fire, the class that mixes in this mixin
     * must be `{@link Ext.mixin.Observable Observable}`.
     *
     * @param {Ext.Base} this
     * @param {Boolean} dirty Whether or not the object is now dirty.
     */

    config: {
        /**
         * @cfg {Boolean} dirty
         * This config property describes the modified state of this object. In most
         * cases this config's value is maintained by the object and should be considered
         * readonly. The class implementor should be the only one to call the setter.
         */
        dirty: {
            $value: false,
            lazy: true
        }
    },

    dirty: false,  // on the prototype as false (not undefined)

    /**
     * @property {Number} _dirtyRecordCount
     * The number of newly created, modified or dropped records.
     * @private
     * @readonly
     */
    _dirtyRecordCount: 0,

    /**
     * @cfg {Boolean} ignoreDirty
     * This config property indicates that the `dirty` state of this object should be
     * ignored. Because this capability is mixed in at a class level, this config can
     * be helpful when some instances do not participate in dirty state tracking.
     *
     * This option should be set at construction time. When set to `true`, the object
     * will always have `dirty` value of `false`.
     */
    ignoreDirty: false,

    /**
     * @cfg {Boolean} recordStateIsDirtyState
     * Set this config at construction time (or on the class body) to automatically set
     * the `dirty` state based on the records passed to `trackRecordState`.
     *
     * This config defaults to `true` but only has an effect when the record tracking
     * methods are called (`trackRecordState`, `untrackRecordState` and `clearRecordStates`).
     * @protected
     */
    recordStateIsDirtyState: true,

    /**
     * Returns `true` if this object is `dirty`.
     */
    isDirty: function() {
        // This alias matches the Ext.form.field.* family.
        return this.getDirty();
    },

    applyDirty: function(dirty) {
        return this.ignoreDirty ? false : dirty;
    },

    updateDirty: function(dirty) {
        var me = this;

        // Store the property directly in case we are used in an "_dirty" world.
        me.dirty = dirty;

        if (me.fireEvent && !me.isDirtyInitializing) {
            me.fireDirtyChange();
        }
    },

    /**
     * Clears all record state tracking. This state is maintained by `trackRecordState`
     * and `untrackRecordState`.
     * @protected
     */
    clearRecordStates: function() {
        var me = this,
            counters = me._crudCounters;

        if (counters) {
            counters.C = counters.U = counters.D = 0;
        }

        me._dirtyRecordCount = 0;

        if (me.recordStateIsDirtyState) {
            me.setDirty(false);
        }
    },

    fireDirtyChange: function() {
        var me = this;

        if (!me.ignoreDirty && me.hasListeners.dirtychange) {
            me.fireEvent('dirtychange', me, me.dirty);
        }
    },

    /**
     * This method is called to track a given record in the total number of dirty records
     * (modified, created or dropped). See `untrackRecordState` and `clearRecordStates`.
     *
     * @param {Ext.data.Model} record The record to track.
     * @param {Boolean} initial Pass `true` the first time a record is introduced.
     * @return {Boolean} Returns `true` if the state of dirty records has changed.
     * @protected
     */
    trackRecordState: function(record, initial) {
        var me = this,
            counters = me._crudCounters || (me._crudCounters = { C: 0, R: 0, U: 0, D: 0 }),
            dirtyRecordCountWas = me._dirtyRecordCount,
            state = record.crudState,
            stateWas = record.crudStateWas,
            changed, dirtyRecordCount;

        if (initial || state !== stateWas) {
            if (!initial && stateWas) {
                --counters[stateWas];
            }

            if (!(record.phantom && state === 'D')) {
                ++counters[state];
            }

            //<debug>
            me.checkCounters();
            //</debug>

            me._dirtyRecordCount = dirtyRecordCount = counters.C + counters.U + counters.D;

            changed = !dirtyRecordCount !== !dirtyRecordCountWas;

            if (changed && me.recordStateIsDirtyState) {
                me.setDirty(dirtyRecordCount > 0);
            }
        }

        return changed;
    },

    /**
     * This method is called to remove the tracking of a given record from the total number
     * of dirty records (modified, created or dropped). The record passed to this method
     * must have been previously passed to `trackRecordState`.
     *
     * @param {Ext.data.Model} record The record to stop tracking.
     * @return {Boolean} Returns `true` if the state of dirty records has changed.
     * @protected
     */
    untrackRecordState: function(record) {
        var me = this,
            counters = me._crudCounters,
            dirtyRecordCountWas = me._dirtyRecordCount,
            state = record.crudState,
            changed, dirtyRecordCount;

        // If it's erased and dropped, it will have already been tracked
        if (counters && state !== 'D' && !record.erased) {
            --counters[state];

            //<debug>
            me.checkCounters();
            //</debug>

            me._dirtyRecordCount = dirtyRecordCount = counters.C + counters.U + counters.D;

            changed = !dirtyRecordCount !== !dirtyRecordCountWas;

            if (changed && me.recordStateIsDirtyState) {
                me.setDirty(dirtyRecordCount > 0);
            }
        }

        return changed;
    }

    //<debug>
    , checkCounters: function() { // eslint-disable-line comma-style
        var counters = this._crudCounters,
            key;

        for (key in counters) {
            if (counters[key] < 0) {
                Ext.raise('Invalid state for ' + key);
            }
        }
    }
    //</debug>
});