/**
 * Base implementation of a pivot axis. You may customize multiple dimensions
 * on an axis. Basically this class stores all labels that were generated
 * for the configured dimensions.
 *
 * Example:
 *
 *      leftAxis: [{
 *          dataIndex:  'person',
 *          header:     'Person',
 *          sortable:   false
 *      },{
 *          dataIndex:  'country',
 *          header:     'Country',
 *          direction:  'DESC'
 *      }]
 *
 */
Ext.define('Ext.pivot.axis.Base', {
    alternateClassName: [
        'Mz.aggregate.axis.Abstract'
    ],
 
    alias: 'pivotaxis.base',
 
    mixins: [
        'Ext.mixin.Factoryable'
    ],
 
    requires: [
        'Ext.pivot.MixedCollection',
        'Ext.pivot.dimension.Item',
        'Ext.pivot.axis.Item'
    ],
    
    /**
     * @cfg {Ext.pivot.dimension.Item[]} dimensions All dimensions configured for this axis.
     *
     */
    dimensions: null,
 
    /**
     * @property {Ext.pivot.matrix.Base} matrix Matrix instance this axis belongs to.
     *
     */
    matrix:     null,
    
    /**
     * @property {Ext.pivot.MixedCollection} items All items generated for this axis are stored in this collection.
     *
     */
    items:      null,
    
    /**
     * When the tree is built for this axis it is stored in this property.
     *
     * @private
     */
    tree:       null,
    
    /**
     * @property {Number} levels No of levels this axis tree has
     * @readonly
     *
     */
    levels:     0,
    
    /**
     * @property {Boolean} isLeftAxis Internal flag to know which axis is this one
     * @readonly
     */
    isLeftAxis:   false,
    
    constructor: function(config){
        var me = this, 
            i, sorter;
        
        if(!config || !config.matrix){
            //<debug> 
            Ext.log('Wrong initialization of the axis!');
            //</debug> 
            return;
        }
        
        me.isLeftAxis = config.isLeftAxis || me.isLeftAxis;
        me.matrix = config.matrix;
        me.tree = [];
        
        // init dimensions 
        me.dimensions = new Ext.pivot.MixedCollection();
        me.dimensions.getKey = function(item){
            return item.getId();
        };
        
        me.items = new Ext.pivot.MixedCollection();
        me.items.getKey = function(item){
            return item.key;
        };
        
        Ext.Array.each(Ext.Array.from(config.dimensions || []), me.addDimension, me);
    },
    
    destroy: function(){
        var me = this;
 
        Ext.destroyMembers(me, 'dimensions', 'items', 'tree');
        me.matrix = me.dimensions = me.items = me.tree = null;
    },
    
    /**
     * Create an {@link Ext.pivot.dimension.Item} object with the specified config and add it to the
     * internal collection of dimensions.
     *
     * @param {Object} config Config object for the {@link Ext.pivot.dimension.Item} that is created.
     */
    addDimension: function(config){
        var item = config;
 
        if(!config){
            return;
        }
        if(!config.isInstance){
            item = new Ext.pivot.dimension.Item(config);
        }
        item.matrix = this.matrix;
        this.dimensions.add(item);
    },
    
    /**
     * Add the specified item to the internal collection of items.
     *
     * @param {Object} item Config object for the {@link Ext.pivot.axis.Item} that is added
     */
    addItem: function(item){
        var me = this;
        
        if(!Ext.isObject(item) || Ext.isEmpty(item.key) || Ext.isEmpty(item.value) || Ext.isEmpty(item.dimensionId)){
            return false;
        }
        
        item.key = String(item.key);
        item.dimension = me.dimensions.getByKey(item.dimensionId);
        item.name = item.name || Ext.callback(item.dimension.labelRenderer, item.dimension.scope || 'self.controller', [item.value], 0, me.matrix.cmp) || item.value;
 
        item.dimension.addValue(item.value, item.name);
        item.axis = me;
        if(!me.items.map[item.key] && item.dimension){
            me.items.add(new Ext.pivot.axis.Item(item));
            return true;
        }
        
        return false;
    },
    
    /**
     * Clear all items and the tree.
     *
     */
    clear: function(){
        this.items.clear();
        this.tree = null;
    },
    
    /**
     * This function parses the internal collection of items and builds a tree.
     * This tree is used by the Matrix class to generate the pivot store and column headers.
     *
     */
    getTree: function(){
        if(!this.tree){
            this.buildTree();
        }
        return this.tree;
    },
 
    /**
     * Expand all groups
     */
    expandAll: function(){
        var me = this,
            items = me.getTree(),
            len = items.length,
            i;
 
        for(i = 0; i < len; i++){
            items[i].expandCollapseChildrenTree(true);
        }
        // we fire a single groupexpand event without any item 
        me.matrix.fireEvent('groupexpand', me.matrix, (me.isLeftAxis ? 'row' : 'col'), null);
    },
 
    /**
     * Collapse all groups
     */
    collapseAll: function(){
        var me = this,
            items = me.getTree(),
            len = items.length,
            i;
 
        for(i = 0; i < len; i++){
            items[i].expandCollapseChildrenTree(false);
        }
        // we fire a single groupcollapse event without any item 
        me.matrix.fireEvent('groupcollapse', me.matrix, (me.isLeftAxis ? 'row' : 'col'), null);
    },
    
    /**
     * Find the first element in the tree that matches the criteria (attribute = value).
     *
     * It returns an object with the tree element and depth level.
     *
     * @return {Object}
     */
    findTreeElement: function(attribute, value){
        var items = this.items,
            len = items.getCount(),
            found = false,
            i, item;
 
        for(i = 0; i < len; i++){
            item = items.items[i];
            if(Ext.isDate(value) ? Ext.Date.isEqual(item[attribute], value) : item[attribute] === value){
                found = true;
                break;
            }
        }
 
        return found ? { level: item.level, node: item } : null;
    },
 
    /**
     * This function builds the internal tree after all records were processed
     *
     * @private
     */
    buildTree: function(){
        var me = this,
            items = me.dimensions.items,
            len = items.length,
            i, item, keys, parentKey, el;
 
        for(i = 0; i < len; i++) {
            // sort unique values for each dimension on this axis 
            items[i].sortValues();
        }
 
        me.tree = [];
        
        // transform the flat items collection into a tree 
        items = me.items.items;
        len = items.length;
        for(i = 0; i < len; i++){
            item = items[i];
            keys = String(item.key).split(me.matrix.keysSeparator);
            keys = Ext.Array.slice(keys, 0, keys.length - 1);
            parentKey = keys.join(me.matrix.keysSeparator);
 
            el = me.items.map[parentKey];
            if(el){
                item.level = el.level + 1;
                item.data = Ext.clone(el.data || {});
                el.children = el.children || [];
                el.children.push(item);
            }else{
                item.level = 0;
                item.data = {};
                me.tree.push(item);
            }
            item.data[item.dimension.getId()] = item.name;
            //item.data[item.dimension.getId()] = item.value; 
            me.levels = Math.max(me.levels, item.level);
        }
 
        me.sortTree();
    },
 
    rebuildTree: function(){
        var items = this.items.items,
            len = items.length,
            i;
 
        this.tree = null;
        for(i = 0; i < len; i++){
            items[i].children = null;
        }
        this.buildTree();
    },
    
    /**
     * Sort the tree using the sorters defined on the axis dimensions
     *
     * @private
     */
    sortTree: function(){
        var tree = arguments[0] || this.tree,
            len = tree.length,
            dimension, i, item;
        
        if(tree.length > 0){
            dimension = tree[0].dimension;
        }
 
        if(dimension){
            // let's sort this array 
            Ext.Array.sort(tree, dimension.sortFn);
        }
 
        for(i = 0; i < len; i++){
            item = tree[i];
            if(item.children){
                this.sortTree(item.children);
            }
        }
    },
    
    /**
     * Sort the tree by the specified field and direction.
     *
     * If the field is one of the axis dimension then sort by that otherwise go to the records and sort
     * them by that field.
     *
     * @param field
     * @param direction
     *
     * @returns {Boolean}
     * @private
     */
    sortTreeByField: function(field, direction){
        var me = this,
            sorted = false,
            dimension, len, i;
 
        if(field == me.matrix.compactViewKey){
            // in compact view we need to sort by all axis dimensions 
            sorted = me.sortTreeByDimension(me.tree, me.dimensions.items, direction);
            len = me.dimensions.items.length;
            for(i = 0; i < len; i++){
                me.dimensions.items[i].direction = direction;
            }
        }else{
            direction = direction || 'ASC';
            dimension = me.dimensions.getByKey(field);
 
            if(dimension){
                // we need to sort the tree level where this dimension exists 
                sorted = me.sortTreeByDimension(me.tree, dimension, direction);
                dimension.direction = direction;
            }else{
                // the field is not a dimension defined on the axis, so it's probably a generated field on the 
                // pivot record which means we need to sort by calculated values 
                sorted = me.sortTreeByRecords(me.tree, field, direction);
            }
        }
 
        return sorted;
    },
 
    /**
     * Sort tree by a specified dimension. The dimension's sorter function is used for sorting.
     *
     * @param tree
     * @param dimension
     * @param direction
     * @returns {Boolean}
     *
     * @private
     */
    sortTreeByDimension: function(tree, dimension, direction){
        var sorted = false,
            dimensions = Ext.Array.from(dimension),
            aDimension, len, i, temp;
 
        tree = tree || [];
        len = tree.length;
 
        if(len > 0){
            aDimension = tree[0].dimension;
        }
 
        if(Ext.Array.indexOf(dimensions, aDimension) >= 0) {
            if(aDimension.sortable) {
                // we have to sort this tree items by the dimension sortFn 
                temp = aDimension.direction;
                aDimension.direction = direction;
                Ext.Array.sort(tree, aDimension.sortFn);
                aDimension.direction = temp;
                // we do not change the dimension direction now since we didn't finish yet 
            }
            sorted = aDimension.sortable;
        }
 
        // the dimension we want to sort may be on leaves 
        // in compact view mode we need to sort everything 
        for(i = 0; i < len; i++){
            sorted = this.sortTreeByDimension(tree[i].children, dimension, direction) || sorted;
        }
        // ready now so exit 
        return sorted;
    },
 
    /**
     * Sort tree by values on a generated field on the pivot model.
     *
     * @param tree
     * @param field
     * @param direction
     * @returns {boolean}
     *
     * @private
     */
    sortTreeByRecords: function(tree, field, direction){
        var i, len;
 
        tree = tree || [];
        len = tree.length;
 
        if(len <= 0){
            return false;
        }
 
        if(tree[0].record){
            this.sortTreeRecords(tree, field, direction);
        }else{
            this.sortTreeLeaves(tree, field, direction);
        }
 
        for(i = 0; i < len; i++){
            this.sortTreeByRecords(tree[i].children, field, direction);
        }
 
        return true;
    },
    
    /**
     * Sort the records array of each item in the tree
     *
     * @param tree
     * @param field
     * @param direction
     *
     * @private
     */
    sortTreeRecords: function(tree, field, direction){
        var sortFn = this.matrix.naturalSort;
        
        direction = direction || 'ASC';
        
        // let's sort the records of this item 
        Ext.Array.sort(tree || [], function(a, b){
            var result,
                o1 = a.record, o2 = b.record;
            
            if(!(o1 && o1.isModel && o2 && o2.isModel)){
                return 0;
            }
            
            result = sortFn(o1.get(field) || '', o2.get(field) || '');
            
            if(result < 0 && direction === 'DESC'){
                return 1;
            }
            if(result > 0 && direction === 'DESC'){
                return -1;
            }
            return result;
        });
    },
    
    /**
     * Sort tree leaves by their group summary.
     *
     * @param tree
     * @param field
     * @param direction
     *
     * @returns {Boolean}
     *
     * @private
     */
    sortTreeLeaves: function(tree, field, direction){
        var sortFn = this.matrix.naturalSort,
            results = this.matrix.results,
            matrixModel = this.matrix.model,
            idx = Ext.Array.indexOf(Ext.Array.pluck(matrixModel, 'name'), field),
            col, agg;
        
        if(idx < 0){
            return false;
        }
        col = matrixModel[idx]['col'];
        agg = matrixModel[idx]['agg'];
 
        direction = direction || 'ASC';
        
        // let's sort the records of this item 
        Ext.Array.sort(tree || [], function(a, b){
            var result,
                o1, o2;
            
            o1 = results.get(a.key, col);
            if(o1){
                o1 = o1.getValue(agg);
            }else{
                o1 = 0;
            }
            o2 = results.get(b.key, col);
            if(o2){
                o2 = o2.getValue(agg);
            }else{
                o2 = 0;
            }
            
            result = sortFn(o1, o2);
            
            if(result < 0 && direction === 'DESC'){
                return 1;
            }
            if(result > 0 && direction === 'DESC'){
                return -1;
            }
            return result;
        });
    }
    
    
});