/**
 * Base class for data object.
 */
Ext.define('Ext.exporter.data.Base', {
    requires: [
        'Ext.util.Collection'
    ],
 
    config: {
        /**
         * @cfg {String} idPrefix
         *
         * Prefix to use when generating the id.
         *
         * @private
         */
        idPrefix: 'id',
 
        /**
         * @cfg {String} id
         *
         * Unique id for this object. Auto generated when missing.
         */
        id: null,
 
        /**
         * @cfg {Boolean} autoGenerateId
         *
         * Set to `true` to auto generate an id if none is defined.
         */
        autoGenerateId: true,
 
        /**
         * @cfg {String[]} autoGenerateKey
         *
         * Set an array of config names available on this class that will
         * be used to generate a key. This key is useful when instances
         * of this class are used in a {@link Ext.util.Collection}.
         *
         * The key is generated by combining the values of those configs.
         * If a config value is an instance of a class then it will look
         * for a getKey function on that class and use it.
         *
         * Set to false if you don't want to generate they key
         */
        autoGenerateKey: {
            $value: false,
            merge: function(newValue, oldValue) {
                return newValue ? Ext.concat(newValue, oldValue || null) : false;
            }
        }
    },
 
    // keep references to internal collections to easily destroy them
    internalCols: null,
    clearPropertiesOnDestroy: false,
 
    constructor: function(config) {
        var me = this;
 
        me.internalCols = [];
        me.initConfig(config);
 
        if (!me._id) {
            me.setId(null);
        }
 
        return me.callParent([config]);
    },
 
    destroy: function() {
        this.destroyCollections();
        this.callParent();
        this.internalCols = null;
    },
 
    destroyCollections: function() {
        var cols = this.internalCols,
            len = cols.length,
            i, j, length, col;
 
        for (i = 0; i < len; i++) {
            col = cols[i];
            length = col.length;
 
            for (j = 0; j < length; j++) {
                col.items[j].destroy();
            }
 
            col.destroy();
        }
 
        cols.length = 0;
    },
 
    clearCollections: function(cols) {
        var i, len, col;
 
        cols = cols ? Ext.Array.from(cols) : this.internalCols;
        len = cols.length;
 
        for (i = len - 1; i >= 0; i--) {
            col = cols[i];
 
            if (col) {
                col.destroy();
            }
 
            Ext.Array.remove(this.internalCols, col);
        }
    },
 
    applyId: function(data) {
        var id;
 
        if (!data && this._autoGenerateId) {
            id = this._idPrefix + (++Ext.idSeed);
        }
        else {
            id = data;
        }
 
        return id;
    },
 
    /**
     * This method could be used in config appliers that need to initialize a
     * Collection that has items of type className.
     *
     * @param data
     * @param dataCollection
     * @param className
     * @return {Ext.util.Collection} 
     */
    checkCollection: function(data, dataCollection, className) {
        var col;
 
        if (data) {
            col = this.constructCollection(className);
            col.add(data);
        }
 
        if (dataCollection) {
            Ext.Array.remove(this.internalCols, dataCollection);
            Ext.destroy(dataCollection.items, dataCollection);
        }
 
        return col;
    },
 
    /**
     * Create a new Collection with a decoder for the specified className.
     *
     * @param className
     * @returns {Ext.util.Collection} 
     *
     * @private
     */
    constructCollection: function(className) {
        var cls = Ext.ClassManager.get(className),
            cfg = {
                decoder: this.getCollectionDecoder(cls)
            },
            col;
 
        if (typeof cls.prototype.getKey === 'function') {
            cfg.keyFn = this.getCollectionItemKey;
        }
 
        col = new Ext.util.Collection(cfg);
 
        this.internalCols.push(col);
 
        return col;
    },
 
    /**
     * Builds a Collection decoder for the specified className.
     *
     * @param klass
     * @returns {Function} 
     *
     * @private
     */
    getCollectionDecoder: function(klass) {
        return function(config) {
            return (config && config.isInstance) ? config : new klass(config || {});
        };
    },
 
    /**
     * Returns a collection item key
     *
     * @param item
     * @return {String} 
     *
     * @private
     */
    getCollectionItemKey: function(item) {
        return item.getKey ? item.getKey() : (item._id || item.getId());
    },
 
    getKey: function() {
        var generate = this.getAutoGenerateKey(),
            key = '',
            config = this.getConfig(),
            len, i;
 
        if (!Ext.isArray(generate) || !generate.length) {
            return this.getId();
        }
 
        len = generate.length;
 
        for (i = 0; i < len; i++) {
            key += this.serializeKeyValue(config[generate[i]]);
        }
 
        return key;
    },
 
    serializeKeyValue: function(value) {
        var key = '',
            keys, len, i;
 
        if (value === null) {
            key = '_';
        }
        else if (Ext.isDate(value)) {
            key = value.getTime();
        }
        else if (Ext.isArray(value)) {
            len = value.length;
 
            for (i = 0; i < len; i++) {
                key += this.serializeKeyValue(value[i]);
            }
        }
        else if (typeof value === 'object') {
            if (value.isInstance) {
                key = value.getKey ? value.getKey() : '_';
            }
            else {
                keys = Ext.Object.getAllKeys(value);
                keys = Ext.Array.sort(keys);
                len = keys.length;
 
                for (i = 0; i < len; i++) {
                    key += this.serializeKeyValue(value[keys[i]]);
                }
            }
        }
        else {
            key = value;
        }
 
        return key;
    }
});