// 遍历节点
function ergodicNode(nodes) {
    if (nodes && nodes.length) {
        nodes.forEach((item) => {
            item.rename = false;
            item.children && ergodicNode(item.children);
        });
    }
}

/**
 * 图层树数据
 */
export default {
    namespaced: true,
    state: {
        // 工程树数据
        treeData: [],
    },
    mutations: {
        // 定义工程树数据
        setTreeData(state, data = []) {
            ergodicNode(data);
            state.treeData = data;
        },
        // 树指定位置增加子节点（必须标识为key）
        addTreeChildren({ treeData }, { parentNode, pid, item }) {
            if (!pid) {
                treeData.push(item)
                return;
            }
            (parentNode || treeData).forEach(ele => {
                if (ele.id === pid) {
                    if (ele.children) {
                        ele.children.push(item)
                    } else {
                        (parentNode || treeData).push(item)
                    }

                    return;
                } else {
                    if (ele.children) {
                        this.commit('layerTree/addTreeChildren', {
                            parentNode: ele.children,
                            pid,
                            item
                        })
                    }
                }
            })
        },
        // 勾选节点
        checkTreeNode({ treeData }, { parentNode, id, checked }) {
            (parentNode || treeData).forEach(ele => {
                if (!id || (id && ele.id === id)) {
                    // id不存，勾选所有子节点，id存在，勾选当前节点
                    ele.checked = checked;
                    if (ele.children) {
                        this.commit('layerTree/checkTreeNode', { parentNode: ele.children, checked });
                    } else if (ele._children) {
                        this.commit('layerTree/checkTreeNode', { parentNode: ele._children, checked });
                    }
                    if (id) {
                        return;
                    }
                } else {
                    // 递归
                    if (ele.children) {
                        this.commit('layerTree/checkTreeNode', {
                            parentNode: ele.children,
                            id,
                            checked
                        })
                    }
                }
            })
        },
        // 更新节点数据
        updataTreeNode({ treeData }, { parentNode, id, nodeValue, key, value }) {
            (parentNode || treeData).forEach(ele => {
                if (ele.id === id) {
                    if (nodeValue) {
                        for (let _key in nodeValue) {
                            if (nodeValue[_key] === undefined) {
                                delete ele[_key];
                            } else {
                                ele[_key] = nodeValue[_key];
                            }
                        }
                    } else {
                        ele[key] = value;
                    }
                    return;
                } else {
                    if (ele.children) {
                        this.commit('layerTree/updataTreeNode', {
                            parentNode: ele.children,
                            id,
                            nodeValue,
                            key,
                            value
                        })
                    }
                }
            })
        },
        // 移除节点
        removeTreeNode({ treeData }, { id, parentNode }) {
            (parentNode || treeData).forEach((ele, index) => {
                if (ele.id === id) {
                    (parentNode || treeData).splice(index, 1)
                    return;
                } else {
                    if (ele.children) {
                        this.commit('layerTree/removeTreeNode', { id, parentNode: ele.children })
                    }
                }
            })
        }
    }
}