/*
    树形
    source: 除delete之外的所有
    view:   当前数据视图,用于配合table,tree显示
    
    数据存储是数组,但是可以体现树形逻辑
*/
/**
    @name Edo.data.DataTree
    @class 
    @typeName datatree
    @description 树形数据源
    @extend Edo.data.DataTable
    @example 
*/ 
Edo.data.DataTree = function(data){
    Edo.data.DataTree.superclass.constructor.call(this, data);
}
Edo.data.DataTree.extend(Edo.data.DataTable, {    
    /**
        @name Edo.data.DataTree#load
        @function
        @description 加载数据
        @param {Array} tree 树形数据
    */    
    load: function(tree, view){
        if(!tree) tree = [];
        if(!(tree instanceof Array)) tree = [tree];     
        
        this.children = tree;
        
        this.source = [];
        var data = [];
        this._createTable(tree, data);
        this.source = data;
        
        if(!view){
            view = [];
            this._createTree(this.children, -1, 0, view, this.filterFn);
        }
        
        Edo.data.DataTree.superclass.load.call(this, data, view);
    },
    //是不是在本方法内,重新排定table?
    syncTreeView: function(action, event){
        var view = [];
        this._createTree(this.children, -1, 0, view, this.filterFn);
        this.refresh(view, action, event);
    },
    //deep深度, stopNode截止的节点, 
    /**
        @name Edo.data.DataTree#collapse
        @function
        @description 收缩节点
        @param {Object} node 节点对象
        @param {Boolean} deep 是否影响子级
    */    
    collapse: function(node, deep){
        node.expanded = false;
        
        if(deep){
            this.iterateChildren(node, function(o){
                o.expanded = false;
            });
        }
        this.canFire = true;
        this.syncTreeView('collapse',{record: node});            
    },
    /**
        @name Edo.data.DataTree#expand
        @function
        @description 展开节点
        @param {Object} node 节点对象        
        @param {Boolean} deep 是否展开所有子节点
    */
    expand: function(node, deep){
        node.expanded = true;
        
        var p = this.findParent(node);
        while(p){
            p.expanded = true;
            p = this.findParent(p);
        }
        
        if(deep){
            this.iterateChildren(node, function(o){
                o.expanded = true;
            });
        }
        
        this.canFire = true;
        this.syncTreeView('expand',{record: node});            
    },
    /**
        @name Edo.data.DataTree#toggle
        @function
        @description 伸展节点
        @param {Object} node 节点对象
        @param {Boolean} deep 是否影响子级
    */    
    toggle: function(node, deep){
    
        if(node.expanded) this.collapse(node,deep);
        else this.expand(node,deep);
    },    
    /**
        @name Edo.data.DataTree#add
        @function
        @description 增加节点
        @param {Object} node 节点对象
        @param {Object} parentNode 父节点
    */    
    add: function(node, p){
        if(!p) p = this;
        if(!p.children) p.children = [];
        return this.insert(p.children.length, node, p);
    },
    /**
        @name Edo.data.DataTree#addRange
        @function
        @description 增加节点
        @param {Array} nodes 节点对象
        @param {Object} parentNode 父节点
    */
    addRange: function(nodes, p){
        if(!p) p = this;
        if(!p.children) p.children = [];
        return this.insertRange(p.children.length, nodes, p);
    },
    /**
        @name Edo.data.DataTree#insert
        @function
        @description 增加节点到索引处
        @param {Number} index 索引
        @param {Object} node 节点对象
        @param {Object} parentNode 父节点
    */
    insert: function(index, node, p){
        this.insertRange(index, [node], p);
    },
    /**
        @name Edo.data.DataTree#insertRange
        @function
        @description 增加节点到索引处
        @param {Number} index 索引
        @param {Array} nodes 节点对象
        @param {Object} parentNode 父节点
    */
    insertRange: function(index, records, p){    
        if(!records || !(records instanceof Array)) return;
        
        if(!p) p = this;
        if(!p.children) p.children = [];                        
        
        var cs = p.children;
        for(var i = 0, len = records.length; i < len; i++){
            var r = records[i];            
            cs.insert(index+i, r);            
            this._doAdd(r);
            
            this.iterateChildren(r, function(n){            
                this._doAdd(n);
            }, this);
        }                
        
        //重新生成表格, 这时候, 这个data应该是source, 没有任何过滤
        var data = [];
        this._createTable(this.children, data);
        this.source = data;
        
        this.syncTreeView('add',{
            records: records,
            index: index,
            parentNode: p
        });       
        this.changed = true;
    },
    /**
        @name Edo.data.DataTree#remove
        @function
        @description 删除节点        
        @param {Object} node 节点对象        
    */    
    remove: function(node){
        var p = this.findParent(node);
        if(p){
            p.children.remove(node);
            
            this._doRemove(node);
            
            var data = [];
            this._createTable(this.children, data);                     
            this.source = data;
            
            this.syncTreeView('remove',{
                
                records: [node],
                parent: p
            });
            this.changed = true;
        }                        
    },
    /**
        @name Edo.data.DataTree#removeAt
        @function
        @description 删除节点    
        @param {Number} index 删除索引号    
        @param {Object} parentNode 父节点对象        
    */        
    removeAt: function(index, p){
        if(!p) throw new Error("父节点为空");
        var node = p && p.children ? p.children[index] : null;
        if(node){
            this.remove(node, p);
        }
    },
    /**
        @name Edo.data.DataTree#removeRange
        @function
        @description 删除数据
        @param {Array} records 数据对象数组
        @params {Object} node 节点
    */
    removeRange: function(records, node){
    
        if(!records || !(records instanceof Array)) return;  
        records = records.clone();
        for(var i=0,l=records.length; i<l; i++){
            var record = records[i];
            
            node = this.findParent(record);
            if(node){
                node.children.remove(record);
                this._doRemove(record);
            }
        }
        
        this.changed = true;
        this.syncTreeView('remove',{
            records: records,
            parent: node
        });
        
    },
    /**
        @name Edo.data.DataTree#move
        @function
        @description 移动节点
        @param {Object} node 节点对象
        @param {Object} targetNode 目标节点对象
        @param {String} action 如何移动插入:数字,preend, append, add
    */
    move: function(nodes, target, action){    
        if(!nodes) return;
        if(!Edo.isArray(nodes)) nodes = [nodes];
        var p = this.findParent(target);
        if(!p) return;
        
        this.beginChange();
        for(var i=0,l=nodes.length; i<l; i++){
            var node = nodes[i];
            
            var index = p.children.indexOf(target);
        
            if(Edo.isNumber(action)){
                p = target;
                index = action;
            }else if(action == 'append') {
                index+=1;
            }else if(action == 'add'){
                p = target;
                if(!p.children) p.children = []
                index = p.children.length;
            }else if (action == "preend"){
                
            }
            
            //这里好像有点性能问题
            if(this.isAncestor(node, p) || node == p){
                return false;
            }            
            
            var p1 = this.findParent(node);
            if(p1 == p){
                var index2 = p1.children.indexOf(node);
                if(index2 <= index){
                    index -= 1;
                }
            }
            
            var status = node.__status;
            var status2 = p.__status;
            
            this.remove(node);
            this.insert(index, node, p);        
            
            
            node.__status = status;
            p.__status = status2;
        }
        
        this.endChange('move', {records: nodes, index: index, parentNode: p});        
        
        this.changed = true;
    },
    /**
        @name Edo.data.DataTree#filter
        @function
        @description 筛选过滤节点(树状方式遍历过滤)
        @param {Function} fn 过滤方法
        @param {Object} scope        
    */   
    filter: function(fn, scope){
        //遍历每一个节点,如果true,则生成
        var view = [];
        this.filterFn = fn;
        this._createTree(this.children, -1, 0, view, fn, scope);
        this.refresh(view, 'filter');
    },
    /**
        @name Edo.data.DataTree#findParent
        @function
        @description 查找父节点
        @param {Object} node 节点对象               
    */       
    findParent: function(node){
        //return findParent(this, node);
        var p = this.getById(node.__pid);
        if(!p && this.getById(node.__id)) p = this;
        return p;
    },
    findTop: function(node){        
        while(1){
            if(node.__pid == -1) return node;
            node = this.getById(node.__pid);            
        }        
    },
    /**
        @name Edo.data.DataTree#getChildAt
        @function
        @description 获得一个节点下children中index位置的节点
        @param {Object} parentNode 父节点对象               
        @param {Number} index               
        @return {Object}
    */       
    getChildAt: function(parentNode, index){
        if(parentNode.children){
            return parentNode.children[index];
        }
    },
    /**
        @name Edo.data.DataTree#indexOfChild
        @function
        @description 获得一个节点在父节点下的索引号
        @param {Object} parentNode 父节点对象               
        @param {Object} node               
        @return {Number}
    */           
    indexOfChild: function(parentNode, node){
        if(parentNode.children){
            return parentNode.indexOf(node);
        }
        return -1;
    },
    /**
        @name Edo.data.DataTree#isFirst
        @function
        @description 是否是第一个节点                
        @param {Object} node               
        @return {Boolean}
    */        
    isFirst: function(node){
        return !node.__preid;
    },
    /**
        @name Edo.data.DataTree#isLast
        @function
        @description 是否是最后一个节点                
        @param {Object} node               
        @return {Boolean}
    */
    isLast: function(node){
        return !node.__nextid;
    },
    /**
        @name Edo.data.DataTree#isLeaf
        @function
        @description 是否是叶子节点(没有子节点)               
        @param {Object} node               
        @return {Boolean}
    */
    isLeaf: function(node){
        return !node.children ||  node.children.length == 0;
    },
    getPrev: function(node){
        return this.getById(node.__preid);
    },
    getNext: function(node){
        return this.getById(node.__nextid);
    },
    //Returns the path for this node. The path can be used to expand or select this node programmatically.
    //attr: (可选) 默认的组成路径的属性,默认是__id.
    getPath: function(node, attr){
        
    },
    /**
        @name Edo.data.DataTree#getDepth
        @function
        @description 获得节点层次
        @param {Object} node               
        @return {Number}
    */
    getDepth: function(node){
        return node.__depth;
    },
    /**
        @name Edo.data.DataTree#eachChildren
        @function
        @description 遍历节点下一个子级
        @param {Object} node      
        @param {Function} fn                 
        @param {Object} scope
    */
    eachChildren: function(node, fn, scope){
        var cs = node.children;
        if(cs){
            cs.each(fn, scope);
        }
    },    
    /**
        @name Edo.data.DataTree#iterateChildren
        @function
        @description 遍历所有层次的子节点
        @param {Object} node      
        @param {Function} fn                 
        @param {Object} scope
    */    
    iterateChildren: function(p, fn, scope){
        if(!fn) return;
        p = p || this;
        var cs = p.children;
        if(cs){
            for(var i=0,l=cs.length; i<l; i++){
                var c = cs[i];
                if(fn.call( scope|| this, c, i) === false) return;
                this.iterateChildren(c, fn, scope);
            }
        }
    },
    /**
        @name Edo.data.DataTree#contains
        @function
        @description 是否包含子节点
        @param {Object} parentNode      
        @param {Object} childNode
    */     
    contains: function(parentNode, childNode){
        while(childNode.__pid != -1){
            if(childNode.__pid == parentNode.__id) return true;
            childNode = this.getById(childNode.__pid);
        }
        return false;        
    },
    /**
        @name Edo.data.DataTree#hasChildren
        @function
        @description 是否有子节点
        @param {Object} node
    */  
    hasChildren: function(node){
        return node.children && node.children.length > 0;
    },
    
    //将树形结构数据,转换为表格结构(其实是得到source源数据表格)
    _createTable: function(tree, data){       //是一个树结构的数组
        
        for(var i=0,l=tree.length; i<l; i++){
            var t = tree[i];
            
            if(!t.__id) t.__id =  Edo.data.DataTable.id++;
                        
            var cs = t.children;            
            
            data[data.length] = t;
                        
            if(cs && cs.length > 0){
                this._createTable(cs, data);
            }
        }
    },
    //得到树形的view数据视图表格
    _createTree: function(tree, pid, depth, data, fn, scope){
        if(!fn) fn = this.filterFn;
    
        var hasInView = false;  //是否有包含在视图内的节点
        for(var i=0,l=tree.length; i<l; i++){
            var t = tree[i];
            
            t.__pid = pid;
            t.__depth = depth;
            t.__hasChildren = t.children && t.children.length > 0;
                        
            if(typeof(t.expanded) === 'undefined') t.expanded = true;
            else t.expanded = !!t.expanded;            
            
            //__preid, __nextid
            t.__preid = t.__nextid = null;
            if(i != 0) t.__preid = tree[i-1].__id;
            if(i != l-1) t.__nextid = tree[i+1].__id;
            
            var next = fn ? fn.call(scope, t, i) : true;   //是否继续
            
            var index = data ? data.length : 0;    //保留索引
            
            if(next !== false){     //如果next不为false,则先加上了
                if(data) data[index] = t;
                
                hasInView = true;
            }
            var childInView = false;
                        
            if(t.__hasChildren){
                //如果确定是不是收缩的,则传递data, 否则传递null
                childInView = this._createTree(t.children, t.__id, depth+1, t.expanded !== false ? data : null, fn);
            }
            
            if(childInView && next === false){  //如果next为false,但是子元素内有符合条件的, 则插入
                if(data) data.insert(index, t);
                
                hasInView = true;
            }
        }
        return hasInView;
    },
    isAncestor: function(p, n){
        if(!p || !n) return false;
        while(n){
            n = this.findParent(n);
            if(n == p) return true;            
        }
        return false;        
    },
    isDisplay: function(record){
        var p = this.findParent(record);
        if(p == this) return true;
        if(!p.expanded) return false;
        return this.isDisplay(p);
    },
    /**
        @name Edo.data.DataTree#getChildren
        @function
        @description 获得节点的子节点(或者是深度子节点集合)
        @param {Object} node 节点对象
        @param {Boolean} deep 是否获取深度子节点集合
    */
    getChildren: function(node, deep){
        if(deep){
            var children = [];
            this.iterateChildren(record, function(node){
                children.add(node);
            });
            return children;
        }else{
            return node.children;
        }
    }
});

Edo.data.DataTree.regType('datatree');

//判断n是否是p的子节点
Edo.data.DataTree.isAncestor = function(p, n){                    
    if(!p || !n) return false;
    var cs = p.children;
    if(cs){
        for(var i=0,l=cs.length; i<l; i++){
            var c = cs[i];
            if(c == n) return true;
            var r = Edo.data.DataTree.isAncestor(c, n);
            if(r) return true;
        }
    }
    return false;
}