package com.tlsq.service.workflow.business.template;

import com.alibaba.fastjson.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * @explain: 构建JSON树
 * @author: Lu Yang
 * @data: 2019-04-18 10:06
 */
@SuppressWarnings("all")
public class JsonBuilder {
        // 注：自己bean模板集合
    List<NodeTemplateBean> nodes = new ArrayList<>();

    public JsonBuilder () {

    }

    public JsonBuilder (List<NodeTemplateBean> nodes) {
        super();
        this.nodes = nodes;
    }

    /**
     * 判断是否为根节点
     * @author: Lu Yang
     * @date: 2019-04-18 15:54
     * @param node
     * @return: java.lang.Boolean
     */
    public Boolean isRootNode (NodeTemplateBean node) {
        Boolean isParentNode = Boolean.TRUE;
        if (StringUtil.isEmpty(node)) {
            return null;
        }

        for (NodeTemplateBean w : nodes) {
            // 当前节点父ID是否等于节点模板中的ID 如果等于则为子节点
            if (StringUtil.notEmpty(node.getParentId())) {
                if (node.getParentId().equals(w.getId())) {
                    isParentNode = Boolean.FALSE;
                    break;
                }
            }
        }

        return isParentNode;
    }

    /**
     * 收集模板中所有父节点
     * @author: Lu Yang
     * @date: 2019-04-18 15:59
     * @param
     */
    public List<NodeTemplateBean> getRootNodes () {
        List<NodeTemplateBean> rootNodes = new ArrayList<>();
        nodes.forEach( w -> {
            if (isRootNode(w)) {
                rootNodes.add(w);
            }
        });

        return rootNodes;
    }

    /**
     * 收集模板中所有的子节点
     * @author: Lu Yang
     * @date: 2019-04-18 16:04
     * @param node 父节点Bean
     */
    public List<NodeTemplateBean> getChildNodes (NodeTemplateBean node) {
        List<NodeTemplateBean> childNodes = new ArrayList<>();
        nodes.forEach( w -> {
            // 当前节点ID 是否等于模板节点的父ID 如果等于则为子节点
            if (node.getId().equals(w.getParentId())) {
                childNodes.add(w);
            }
        });

        return childNodes;
    }

    /**
     * 递归子节点
     * @author: Lu Yang
     * @date: 2019-04-18 16:07
     * @param node
     * @return: void
     */
    public void recursivegChildNodes (NodeTemplateBean node) {
        List<NodeTemplateBean> children = getChildNodes(node);
        if (!children.isEmpty()) {
            children.forEach( w -> {
                recursivegChildNodes(w);
            });
            // TODO
            node.setChildNode(children);
        }
    }

    /**
     * 构建模型树结构
     * @author: Lu Yang
     * @date: 2019-04-18 16:16
     * @param
     */
    public List<NodeTemplateBean> buildModelTree () {
        List<NodeTemplateBean> modeNodes = new ArrayList<>();
        // 父节点模型
        List<NodeTemplateBean> rootNodes = getRootNodes();

        rootNodes.forEach( w -> {
            recursivegChildNodes(w);
            modeNodes.add(w);
        });

        return modeNodes;
    }

    /**
     * 构建JSON
     * @author: Lu Yang
     * @date: 2019-04-18 16:24
     * @param
     * @return: java.lang.String
     */
    public JSONArray buildJson () {
        List<NodeTemplateBean> nodeModelTree =  buildModelTree();
        JSONArray jsonArray = null;
        try {
            jsonArray = JSONArray.fromObject(nodeModelTree);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return jsonArray;
    }
}