design/designer-base/src/main/java/com/fr/design/data/datapane/TableDataTree.java

package com.fr.design.data.datapane;

import com.fr.base.svg.IconUtils;
import com.fr.data.MultiResultTableData;
import com.fr.design.constants.UIConstants;
import com.fr.design.data.datapane.management.search.TableDataTreeSearchManager;
import com.fr.design.data.tabledata.wrapper.TableDataWrapper;
import com.fr.design.gui.itree.refreshabletree.ExpandMutableTreeNode;
import com.fr.design.gui.itree.refreshabletree.UserObjectRefreshJTree;
import com.fr.design.icon.IconPathConstants;
import com.fr.general.ComparatorUtils;
import com.fr.general.NameObject;

import javax.swing.BorderFactory;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import java.awt.Color;
import java.awt.Component;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * TableData Tree
 */
public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
    private static final long serialVersionUID = 1L;

    private static final String TABLE_DATA_NODE = "tableData";

    private static final String COLUMN_NODE = "column";

    /**
     * Constructor.
     */
    public TableDataTree() {
        super();
        this.setCellRenderer(tableDataTreeCellRenderer);
        this.setEditable(false);
    }

    // CellRenderer
    private DefaultTreeCellRenderer tableDataTreeCellRenderer = new DefaultTreeCellRenderer() {
        private static final long serialVersionUID = 1L;

        @Override
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
            super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
            ExpandMutableTreeNode treeNode = (ExpandMutableTreeNode) value;
            Object userObj = treeNode.getUserObject();
            if (userObj instanceof String) {
                // p:这个是column field.
                this.setIcon(IconUtils.readIcon("/com/fr/design/standard/field"));
                this.setText((String) userObj);
            } else if (userObj instanceof NameObject) {
                NameObject nameObject = (NameObject) userObj;
                this.setText(nameObject.getName());
                if (nameObject.getObject() instanceof TableDataWrapper) {
                    TableDataWrapper tableDataWrappe = (TableDataWrapper) nameObject.getObject();
                    this.setIcon(tableDataWrappe.getIcon());
                } else if (nameObject.getObject() instanceof Integer) {
                    int num = (Integer) nameObject.getObject();
                    if (num == TableDataSourceOP.SERVER_TABLE_DATA) {
                        this.setIcon(IconUtils.readIcon(IconPathConstants.STD_SHOW_ICON_PATH));
                    } else if (num == TableDataSourceOP.STORE_PRECEDURE_DATA) {
                        this.setIcon(IconUtils.readIcon(IconPathConstants.SP_SHOW_ICON_PATH));
                    } else {
                        this.setIcon(IconUtils.readIcon(IconPathConstants.DS_QUERY_ICON_PATH));
                    }
                } else {
                    this.setIcon(IconUtils.readIcon("/com/fr/design/images/data/store_procedure.png"));
                }
            } else if (userObj == PENDING) {
                this.setIcon(null);
                this.setText(PENDING.toString());
            }
            this.setBorder(BorderFactory.createEmptyBorder(1, 0, 1, 0));
            this.setBackgroundNonSelectionColor(UIConstants.TREE_BACKGROUND);
            this.setTextSelectionColor(Color.WHITE);
            this.setBackgroundSelectionColor(UIConstants.FLESH_BLUE);
            return this;
        }
    };

    public DefaultTreeCellRenderer getTableDataTreeCellRenderer() {
        return tableDataTreeCellRenderer;
    }

    public void setTableDataTreeCellRenderer(DefaultTreeCellRenderer tableDataTreeCellRenderer) {
        this.tableDataTreeCellRenderer = tableDataTreeCellRenderer;
    }

    @Override
    protected void refreshTreeNode(ExpandMutableTreeNode eTreeNode, String childName) {
        if (interceptRefresh(eTreeNode)) {
            return;
        }
        boolean refreshall = childName.isEmpty();
        ExpandMutableTreeNode[] newNodes = loadChildTreeNodes(eTreeNode);

        java.util.List<DefaultMutableTreeNode> childTreeNodeList = new java.util.ArrayList<DefaultMutableTreeNode>();
        for (int i = 0, len = eTreeNode.getChildCount(); i < len; i++) {
            if (eTreeNode.getChildAt(i) instanceof ExpandMutableTreeNode) {
                childTreeNodeList.add((ExpandMutableTreeNode) eTreeNode.getChildAt(i));
            } else {
                childTreeNodeList.add((DefaultMutableTreeNode) eTreeNode.getChildAt(i));
            }
        }

        eTreeNode.removeAllChildren();

        for (int ci = 0; ci < newNodes.length; ci++) {
            Object cUserObject = newNodes[ci].getUserObject();
            ExpandMutableTreeNode cTreeNode = null;
            for (int ni = 0, nlen = childTreeNodeList.size(); ni < nlen; ni++) {
                cTreeNode = (ExpandMutableTreeNode) childTreeNodeList.get(ni);
                if (ComparatorUtils.equals(cTreeNode.getUserObject(), cUserObject)) {
                    if (!refreshall && !ComparatorUtils.equals(childName, ((NameObject) cUserObject).getName())) {
                        newNodes[ci] = cTreeNode;
                        break;
                    }
                    newNodes[ci].setExpanded(cTreeNode.isExpanded());
                    // REPORT-41299 如果建立的是错误的数据集(没有Child的情况)且这个错误数据集处于isExpanded状态，会在后面的if语句中调用getFirstChild()产生异常，因此这里判断一下
                    if (cTreeNode.getChildCount() == 0) {
                        newNodes[ci].setExpanded(false);
                        break;
                    }
                    if (cTreeNode.getFirstChild() instanceof ExpandMutableTreeNode && cTreeNode.isExpanded()) {
                        checkChildNodes(cTreeNode, newNodes[ci]);
                    }
                    break;
                }
            }

            eTreeNode.add(newNodes[ci]);
        }
    }


    protected void checkChildNodes(ExpandMutableTreeNode oldNode, ExpandMutableTreeNode newNode) {
        for (int i = 0; i < oldNode.getChildCount(); i++) {
            ExpandMutableTreeNode oldChild = (ExpandMutableTreeNode) oldNode.getChildAt(i);
            for (int j = 0; j < newNode.getChildCount(); j++) {
                ExpandMutableTreeNode newChild = (ExpandMutableTreeNode) newNode.getChildAt(j);
                newChild.removeAllChildren();
                ExpandMutableTreeNode[] nodes = TableDataTree.this.loadChildTreeNodes(newChild);
                for (int k = 0; k < nodes.length; k++) {
                    newChild.add(nodes[k]);
                }
                removePending(newChild);
                if (ComparatorUtils.equals(oldChild.getUserObject(), newChild.getUserObject())) {
                    newChild.setExpanded(oldChild.isExpanded());
                }
            }
        }
    }

    private void removePending(ExpandMutableTreeNode treeNode) {
        if (treeNode.getChildCount() > 1 && ((ExpandMutableTreeNode) treeNode.getFirstChild()).getUserObject() == PENDING) {
            treeNode.remove(0);
        }
    }

    @Override
    public void refresh4TreeSearch() {
        ExpandMutableTreeNode root = (ExpandMutableTreeNode) this.getModel().getRoot();
        refreshTreeNode4TreeSearch(root);
        ((DefaultTreeModel) this.getModel()).reload(root);
        root.expandCurrentTreeNode(this);
    }

    /**
     * 主要是处理节点是否应该添加为搜索结果，以及节点是否需要展开
     *
     * @param root
     */
    private void refreshTreeNode4TreeSearch(ExpandMutableTreeNode root) {
        if (interceptRefresh(root)) {
            return;
        }
        // 获取数据集子节点
        ExpandMutableTreeNode[] dsTreeNodes = loadChildTreeNodes(root);
        root.removeAllChildren();
        for (ExpandMutableTreeNode dsTreeNode : dsTreeNodes) {
            if (TableDataTreeSearchManager.getInstance().nodeNameMatches(dsTreeNode.getUserObject().toString())) {
                // 加载数据列节点
                loadAndAddChildTreeChild(dsTreeNode);
                // 处理子节点的展开
                dealWithNodeExpand(dsTreeNode);
                // 添加数据集子节点
                root.add(dsTreeNode);
            }
        }
    }

    /**
     * 加载所有子节点，并添加到父节点中
     *
     * @param treeNode
     * @return
     */
    private ExpandMutableTreeNode loadAndAddChildTreeChild(ExpandMutableTreeNode treeNode) {
        if (isTreeNodeStoreProcedure(treeNode)) {
            // 如果是存储过程，则再加载一次其子表节点，这里比较坑的就是存储过程不能使用loadChildTreeNodes
            int tableChildCounts = treeNode.getChildCount();
            ExpandMutableTreeNode[] childs = new ExpandMutableTreeNode[tableChildCounts];
            for (int i = 0; i < tableChildCounts; i++) {
                ExpandMutableTreeNode tableChild = (ExpandMutableTreeNode) treeNode.getChildAt(i);
                loadAndAddChildTreeChild(tableChild);
                childs[i] = tableChild;
                removePending(tableChild);
            }
            treeNode.addChildTreeNodes(childs);
        } else {
            ExpandMutableTreeNode[] expandMutableTreeNodes = loadChildTreeNodes(treeNode);
            treeNode.addChildTreeNodes(expandMutableTreeNodes);
        }
        removePending(treeNode);
        return treeNode;
    }

    /**
     * 处理节点的展开，如果此节点是存储过程，还会处理其子表节点的展开
     * 只针对数据集节点
     *
     * @param treeNode
     * @return
     */
    public ExpandMutableTreeNode dealWithNodeExpand(ExpandMutableTreeNode treeNode) {
        String tableDataName = treeNode.getUserObject().toString();
        // 主要还是处理存储过程
        if (isTreeNodeStoreProcedure(treeNode)) {
            int childCount = treeNode.getChildCount();
            for (int i = 0; i < childCount; i++) {
                ExpandMutableTreeNode child = (ExpandMutableTreeNode) treeNode.getChildAt(i);
                String nodeName = tableDataName + "_" + child.getUserObject().toString();
                if (TableDataTreeSearchManager.getInstance().nodeCanExpand(nodeName)) {
                    child.setExpanded(true);
                }
            }
        }
        if (TableDataTreeSearchManager.getInstance().nodeCanExpand(treeNode.getUserObject().toString())) {
            treeNode.setExpanded(true);
        }
        return treeNode;
    }

    /*
     * p:获得选中的NameObject = name + tabledata.
     */
    @Override
    public NameObject getSelectedNameObject() {
        TreePath selectedTreePath = this.getSelectionPath();
        if (selectedTreePath == null) {
            return null;
        }
        ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
        Object selectedUserObject = selectedTreeNode.getUserObject();
        ExpandMutableTreeNode parentTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
        Object parentUserObject = parentTreeNode.getUserObject();
        if (parentUserObject instanceof NameObject && ((NameObject) parentUserObject).getObject() instanceof Integer) {
            if (selectedUserObject instanceof NameObject) {
                return (NameObject) selectedUserObject;
            }
        } else {
            parentTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
            parentUserObject = parentTreeNode.getUserObject();

            if (parentUserObject != null) {
                if (!(parentUserObject instanceof NameObject)) {
                    return (NameObject) selectedUserObject;
                } else {
                    return (NameObject) parentUserObject;
                }
            }
        }
        return null;

    }

    /**
     * 获得选中的数据集节点的NameObject的数组，只会返回数据集节点的NameObject
     * 当多选了数据集或数据列时，也只返回选中的数据集
     */
    public NameObject[] getSelectedTableDataNameObjects() {
        Map<String, List<ExpandMutableTreeNode>> tableDataNodesAndColumnNodes = getSelectedTableDataNodesAndColumnNodes();
        List<ExpandMutableTreeNode> tableDataNodes = tableDataNodesAndColumnNodes.get(TABLE_DATA_NODE);
        if (tableDataNodes == null) {
            return new NameObject[0];
        }
        return tableDataNodes.stream().map(node -> (NameObject) node.getUserObject()).toArray(NameObject[]::new);
    }

    /**
     * 获取选中的数据集节点和列名节点
     * 其中存储过程的子表节点不计入数据集节点中，仅存储过程节点本身计入数据集节点
     * @return
     */
    private Map<String, List<ExpandMutableTreeNode>> getSelectedTableDataNodesAndColumnNodes() {
        TreePath[] selectedTreePaths = this.getSelectionPaths();
        if (selectedTreePaths == null) {
            return new HashMap<>();
        }
        Map<String, List<ExpandMutableTreeNode>> resultMap = new HashMap<>();
        List<ExpandMutableTreeNode> tableDataNodes = new ArrayList<>();
        List<ExpandMutableTreeNode> columnNodes = new ArrayList<>();
        resultMap.put(TABLE_DATA_NODE, tableDataNodes);
        resultMap.put(COLUMN_NODE, columnNodes);
        for (TreePath selectedTreePath : selectedTreePaths) {
            if (selectedTreePath == null) {
                continue;
            }
            ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
            if (isTableDataNodes(selectedTreeNode)) {
                // 数据集节点
                tableDataNodes.add(selectedTreeNode);
            } else {
                // 列名节点
                columnNodes.add(selectedTreeNode);
            }
        }
        return resultMap;
    }

    /**
     * 获取选中的数据集数量，选中数据列则不计入
     *
     * @return
     */
    public int getSelectedTableDataCounts() {
        return getSelectedTableDataNameObjects().length;
    }

    /**
     * 是否存在单独选了数据列节点，但没选其对应数据集的情况
     * @return
     */
    public boolean hasSelectedIndependentColumns() {
        Map<String, List<ExpandMutableTreeNode>> tableDataNodesAndColumnNodes = getSelectedTableDataNodesAndColumnNodes();
        List<ExpandMutableTreeNode> tableDataNodes = tableDataNodesAndColumnNodes.get(TABLE_DATA_NODE);
        List<ExpandMutableTreeNode> columnNodes = tableDataNodesAndColumnNodes.get(COLUMN_NODE);
        if (columnNodes == null || columnNodes.size() == 0) {
            // 未选中数据列
            return false;
        }
        if (tableDataNodes == null || tableDataNodes.size() == 0) {
            // 选中数据列而未选中数据集
            return true;
        }
        boolean result = false;
        for (ExpandMutableTreeNode columnNode : columnNodes) {
            ExpandMutableTreeNode tableDataNode = getBelongedTableDataNodes(columnNode);
            if (!tableDataNodes.contains(tableDataNode)) {
                result = true;
            }
        }
        return result;
    }

    /**
     * 获取一个节点归属的数据集层级父节点
     * @param treeNode
     * @return
     */
    private ExpandMutableTreeNode getBelongedTableDataNodes(ExpandMutableTreeNode treeNode) {
        if (isTableDataNodes(treeNode)) {
            return treeNode;
        }
        return getBelongedTableDataNodes((ExpandMutableTreeNode) treeNode.getParent());
    }

    private boolean isTableDataNodes(ExpandMutableTreeNode treeNode) {
        if (treeNode == null) {
            return false;
        }
        Object userObject = treeNode.getUserObject();
        if (userObject instanceof NameObject && ((NameObject) userObject).getObject() instanceof TableDataWrapper) {
            return true;
        }
        return false;
    }

    public TableDataWrapper[] getSelectedDatas() {
        TreePath[] selectedTreePaths = this.getSelectionPaths();
        if (selectedTreePaths == null || selectedTreePaths.length == 0) {
            return null;
        }
        TableDataWrapper[] nameobjs = new TableDataWrapper[selectedTreePaths.length];
        for (int i = 0; i < selectedTreePaths.length; i++) {
            TreePath selectedTreePath = selectedTreePaths[i];
            ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
            Object selectedUserObject = selectedTreeNode.getUserObject();
            ExpandMutableTreeNode parentTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
            Object parentUserObject = parentTreeNode.getUserObject();
            if (parentUserObject instanceof NameObject && ((NameObject) parentUserObject).getObject() instanceof Integer) {
                if (selectedUserObject instanceof NameObject) {
                    Object obj = ((NameObject) selectedUserObject).getObject();
                    if (obj instanceof TableDataWrapper) {
                        nameobjs[i] = (TableDataWrapper) obj;
                    }
                }
            } else {
                return new TableDataWrapper[0];
            }
        }

        return nameobjs;
    }

    public NameObject getRealSelectedNameObject() {
        TreePath selectedTreePath = this.getSelectionPath();
        if (selectedTreePath == null) {
            return null;
        }

        ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
        Object selectedUserObject = selectedTreeNode.getUserObject();
        if (selectedUserObject instanceof NameObject) {
            return (NameObject) selectedUserObject;
        }

        selectedTreeNode = (ExpandMutableTreeNode) selectedTreeNode.getParent();
        selectedUserObject = selectedTreeNode.getUserObject();
        if (selectedUserObject instanceof NameObject) {
            return (NameObject) selectedUserObject;
        }
        return null;
    }

    /**
     * p:添加一个NameObject节点.
     */
    public void addNameObject(NameObject no) {
        if (no == null) {
            return;
        }
        DefaultTreeModel treeModel = (DefaultTreeModel) this.getModel();

        // 新建一个放着NameObject的newChildTreeNode,加到Root下面
        ExpandMutableTreeNode root = (ExpandMutableTreeNode) treeModel.getRoot();

        ExpandMutableTreeNode newChildTreeNode = new ExpandMutableTreeNode(no);
        root.add(newChildTreeNode);
        newChildTreeNode.add(new ExpandMutableTreeNode());

        treeModel.reload(root);
    }

    /**
     * 判断此节点是否为存储过程
     *
     * @param treeNode
     * @return
     */
    public boolean isTreeNodeStoreProcedure(ExpandMutableTreeNode treeNode) {
        Object userObject = treeNode.getUserObject();
        if (userObject instanceof NameObject) {
            NameObject nameObject = (NameObject) userObject;
            TableDataWrapper tableDataWrapper = (TableDataWrapper) nameObject.getObject();
            return tableDataWrapper.getTableData() instanceof MultiResultTableData<?>;
        }
        return false;
    }
}