/**
 * Abstract base class for filter implementations.
 */
Ext.define('Ext.grid.filters.filter.Base', {
    mixins: [
        'Ext.mixin.Factoryable'
    ],
 
    factoryConfig: {
        type: 'grid.filter'
    },
 
    $configPrefixed: false,
    $configStrict: false,
 
    config: {
        /**
         * @cfg {Object} [itemDefaults]
         * The default configuration options for any menu items created by this filter.
         *
         * Example usage:
         *
         *      itemDefaults: {
         *          width: 150
         *      },
         */
        itemDefaults: null,
 
        menuDefaults: {
            xtype: 'menu'
        },
 
        /**
         * @cfg {Number} updateBuffer
         * Number of milliseconds to wait after user interaction to fire an update. Only supported
         * by filters: 'list', 'numeric', and 'string'.
         */
        updateBuffer: 500,
 
        /**
         * @cfg {Function} [serializer]
         * A function to post-process any serialization. Accepts a filter state object
         * containing `property`, `value` and `operator` properties, and may either
         * mutate it, or return a completely new representation.
         * @since 6.2.0
         */
        serializer: null
    },
 
    /**
     * @property {Boolean} active
     * True if this filter is active. Use setActive() to alter after configuration. If
     * you set a value, the filter will be actived automatically.
     */
    /**
     * @cfg {Boolean} active
     * Indicates the initial status of the filter (defaults to false).
     */
    active: false,
 
    /**
     * @property {String} type
     * The filter type. Used by the filters.Feature class when adding filters and applying state.
     */
    type: 'string',
 
    /**
     * @cfg {String} dataIndex
     * The {@link Ext.data.Store} dataIndex of the field this filter represents.
     * The dataIndex does not actually have to exist in the store.
     */
    dataIndex: null,
 
    /**
     * @property {Ext.menu.Menu} menu
     * The filter configuration menu that will be installed into the filter submenu
     * of a column menu.
     */
    menu: null,
 
    isGridFilter: true,
 
    defaultRoot: 'data',
 
    /**
     * The prefix for id's used to track stateful Store filters.
     * @private
     */
    filterIdPrefix: Ext.baseCSSPrefix + 'gridfilter',
 
    /**
     * @event filteractivate
     * Fires when an inactive filter becomes active
     * @param {Ext.grid.filters.Filters} this 
     * @param {Ext.grid.column.Column} column This filter's assigned column
     * @since 6.5.0
     * @member Ext.panel.Table
     */
 
    /**
     * @event filterdeactivate
     * Fires when an active filter becomes inactive
     * @param {Ext.grid.filters.Filters} this 
     * @param {Ext.grid.column.Column} column This filter's assigned column
     * @since 6.5.0
     * @member Ext.panel.Table
     */
 
    /**
     * Initializes the filter given its configuration.
     * @param {Object} config 
     */
    constructor: function(config) {
        var me = this,
            column;
 
        // Calling Base constructor is very desirable for testing
        //<debug>
        me.callParent([config]);
        //</debug>
 
        me.initConfig(config);
 
        column = me.column;
        me.columnListeners = column.on('destroy', me.destroy, me, { destroyable: true });
        me.dataIndex = me.dataIndex || column.dataIndex;
 
        me.task = new Ext.util.DelayedTask(me.setValue, me);
    },
 
    /**
     * Destroys this filter by purging any event listeners, and removing any menus.
     */
    destroy: function() {
        var me = this;
 
        if (me.task) {
            me.task.cancel();
            me.task = null;
        }
 
        me.columnListeners = me.columnListeners.destroy();
        me.grid = me.menu = Ext.destroy(me.menu);
 
        me.callParent();
    },
 
    addStoreFilter: function(filter) {
        var filters = this.getGridStore().getFilters(),
            idx = filters.indexOf(filter),
            existing = idx !== -1 ? filters.getAt(idx) : null;
 
        // If the filter being added doesn't exist in the collection we should add it.
        // But if there is a filter with the same id (indexOf tests for the same id), we should
        // check if the filter being added has the same properties as the existing one
        if (!existing || !Ext.util.Filter.isEqual(existing, filter)) {
            filters.add(filter);
        }
    },
 
    createFilter: function(config, key) {
        var filter = new Ext.util.Filter(this.getFilterConfig(config, key));
 
        filter.isGridFilter = true;
 
        return filter;
    },
 
    // Note that some derived classes may need to do specific processing
    // and will have its own version of this method before calling parent (see the List filter).
    getFilterConfig: function(config, key) {
        config.id = this.getBaseIdPrefix();
 
        if (!config.property) {
            config.property = this.dataIndex;
        }
 
        if (!config.root) {
            config.root = this.defaultRoot;
        }
 
        if (key) {
            config.id += '-' + key;
        }
 
        config.serializer = this.getSerializer();
 
        return config;
    },
 
    /**
     * @private
     * Creates the Menu for this filter.
     * @param {Object} config Filter configuration
     * @return {Ext.menu.Menu} 
     */
    createMenu: function() {
        this.menu = Ext.widget(this.getMenuConfig());
    },
 
    getActiveState: function(config, value) {
        // An `active` config must take precedence over a `value` config.
        var active = config.active;
 
        return (active !== undefined) ? active : value !== undefined;
    },
 
    getBaseIdPrefix: function() {
        return this.filterIdPrefix + '-' + this.dataIndex;
    },
 
    getMenuConfig: function() {
        return Ext.apply({}, this.getMenuDefaults());
    },
 
    getGridStore: function() {
        return this.grid.getStore();
    },
 
    getStoreFilter: function(key) {
        var id = this.getBaseIdPrefix();
 
        if (key) {
            id += '-' + key;
        }
 
        return this.getGridStore().getFilters().get(id);
    },
 
    /**
     * @private
     * Handler method called when there is a significant event on an input item.
     */
    onValueChange: function(field, e) {
        var me = this,
            keyCode = e.getKey(),
            updateBuffer = me.updateBuffer,
            value;
 
        // Don't process tabs!
        if (keyCode === e.TAB) {
            return;
        }
 
        //<debug>
        if (!field.isFormField) {
            Ext.raise('`field` should be a form field instance.');
        }
        //</debug>
 
        if (field.isValid()) {
            if (keyCode === e.RETURN) {
                me.menu.hide();
 
                return;
            }
 
            value = me.getValue(field);
 
            if (value === me.value) {
                return;
            }
 
            if (updateBuffer) {
                me.task.delay(updateBuffer, null, null, [value]);
            }
            else {
                me.setValue(value);
            }
        }
    },
 
    /**
     * @private
     * @method preprocess
     * Template method to be implemented by all subclasses that need to perform
     * any operations before the column filter has finished construction.
     * @template
     */
    preprocess: Ext.emptyFn,
 
    removeStoreFilter: function(filter) {
        this.getGridStore().getFilters().remove(filter);
    },
 
    /**
     * @private
     * @method getValue
     * Template method to be implemented by all subclasses that is to
     * get and return the value of the filter.
     * @return {Object} The 'serialized' form of this filter
     * @template
     */
    getValue: Ext.emptyFn,
 
    /**
     * @private
     * @method setValue
     * Template method to be implemented by all subclasses that is to
     * set the value of the filter and fire the grid's 'filterchange' event.
     * @param {Object} data The value to set the filter
     * @template
     */
 
    /**
     * Sets the status of the filter and fires the appropriate events.
     * @param {Boolean} active The new filter state.
     */
    setActive: function(active) {
        var me = this,
            menuItem = me.owner.activeFilterMenuItem,
            filterCollection;
 
        if (me.active !== active) {
            me.active = active;
 
            filterCollection = me.getGridStore().getFilters();
            filterCollection.beginUpdate();
 
            if (active) {
                me.activate();
            }
            else {
                me.deactivate();
            }
 
            filterCollection.endUpdate();
 
            // Make sure we update the 'Filters' menu item.
            if (menuItem && menuItem.activeFilter === me) {
                menuItem.setChecked(active);
            }
 
            me.setColumnActive(active);
            me.grid.fireEventArgs(active ? 'filteractivate' : 'filterdeactivate', [me, me.column]);
        }
    },
 
    setColumnActive: function(active) {
        this.column[active ? 'addCls' : 'removeCls'](this.owner.filterCls);
    },
 
    showMenu: function(menuItem) {
        var me = this;
 
        if (!me.menu) {
            me.createMenu();
        }
 
        menuItem.activeFilter = me;
 
        menuItem.setMenu(me.menu, false);
        menuItem.setChecked(me.active);
 
        // Disable the menu if filter.disabled explicitly set to true.
        menuItem.setDisabled(me.disabled === true);
 
        me.activate(/* showingMenu */ true);
    },
 
    updateStoreFilter: function() {
        this.getGridStore().getFilters().notify('endupdate');
    }
});