package com.zkqy.execution.produce.dispersed.runbpm;

import com.zkqy.common.constant.HttpStatus;
import com.zkqy.common.core.domain.AjaxResult;
import com.zkqy.common.utils.bpm.XmlDataParserUtils;
import com.zkqy.common.utils.uuid.IdUtils;
import com.zkqy.execution.produce.dispersed.entity.BpmExecuteNode;
import com.zkqy.execution.produce.dispersed.entity.BpmExecuteNodeForm;
import com.zkqy.execution.produce.dispersed.entity.BpmExecuteNodeMiddle;
import com.zkqy.execution.produce.dispersed.entity.BpmExecuteProcess;
import com.zkqy.execution.produce.dispersed.entity.runbpm.*;
import com.zkqy.execution.produce.dispersed.mapper.BpmExecuteNodeFormMapper;
import com.zkqy.execution.produce.dispersed.mapper.BpmExecuteNodeMapper;
import com.zkqy.execution.produce.dispersed.mapper.BpmExecuteNodeMiddleMapper;
import com.zkqy.execution.produce.dispersed.mapper.BpmExecuteProcessMapper;
import com.zkqy.execution.produce.dispersed.service.IBpmExecuteNodeFormService;
import com.zkqy.execution.produce.dispersed.service.IBpmExecuteProcessService;
import com.zkqy.execution.produce.utils.VerifyExecutionProcess;
import com.zkqy.system.entity.*;
import com.zkqy.system.mapper.BpmNodeHandleUserMapper;
import com.zkqy.system.mapper.BpmNodeScriptRelevanceMapper;
import com.zkqy.system.mapper.BpmProcessConfigurationMapper;
import com.zkqy.system.mapper.BpmProcessMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;


/**
 * 预备执行流程工具类
 *
 * @author hanzihang
 * @date 2023/11/15
 */
@Component
@EnableAsync  // 异步
public class PreExecutionToolClass<R> {

    @Autowired // 执行流程
    private BpmExecuteProcessMapper runBpmExecuteProcessMapper;

    @Autowired  // 执行流程中间表
    private BpmExecuteNodeMiddleMapper runBpmExecuteNodeMiddleMapper;

    @Autowired  // 执行流程节点表
    private BpmExecuteNodeMapper runBpmExecuteNodeMapper;

    @Autowired // 节点脚本表单中间表
    private IBpmExecuteNodeFormService iBpmExecuteNodeFormService;

    @Autowired // 执行流程service
    private IBpmExecuteProcessService iBpmExecuteProcessService;

    @Autowired  // 定义流程
    private BpmProcessMapper bpmProcessMapper;

    @Autowired  // 定义流程节点详细信息
    private BpmProcessConfigurationMapper bpmProcessConfigurationMapper;

    @Autowired  // 节点执行用户
    private BpmNodeHandleUserMapper bpmNodeHandleUserMapper;

    @Autowired  // 节点执行脚本
    private BpmNodeScriptRelevanceMapper bpmNodeScriptRelevanceMapper;

    @Autowired  // 真正执行脚本
    private RunImplementationClass iRunImplementationClass;

    @Autowired // 校验执行流程的数据
    private VerifyExecutionProcess iVerifyExecutionProcess;


    @Autowired
    private BpmExecuteNodeFormMapper executeNodeFormMapper;

    /**
     * 预执行流程自动执行开始节点
     *
     * @param commonEntity
     * @return
     */
    @Transactional
    public AjaxResult ReadyToExecute(CommonEntity commonEntity) {
        // 获取发起流程所需数据
        IntoProduction intoProduction = this.obtainData(commonEntity);
        /**
         * 根据流程key校验当前流程数据的完整性，是否可以运行
         */
//        if (!iVerifyExecutionProcess.VerifyProcessData(intoProduction.getTaskProcessKey())) {
//            return AjaxResult.error(HttpStatus.EXECUTEPROCESS, "流程数据验证失败！");
//        }
        /**1️⃣1️⃣1️⃣ 得到当前投产需要执行的流程详细信息*/
        //--得到当前流程的详细信息
        BpmProcess bpmProcess = bpmProcessMapper.selectBpmProcessByProcessKey(intoProduction.getTaskProcessKey());
        //---根据流程key得到当前流程的所有节点信息
        List<BpmProcessConfiguration> bpmProcessConfigurationList = bpmProcessConfigurationMapper.selectBpmProcessConfigurationList(new BpmProcessConfiguration(intoProduction.getTaskProcessKey()));
        //----根据节点得到所有节点执行用户以及执行脚本的数据 ⬇⬇⬇⬇⬇⬇
        List<String> nodekeyList = new ArrayList<>(); // 当前流程所有节点
        // 根据节点表示得到所有脚本以及所有执行用户信息
        bpmProcessConfigurationList.forEach(item -> nodekeyList.add(item.getNodeKey()));
        // 当前流程的所有节点详细信息
        List<BpmUserScriptVo> bpmUserScriptVoList = new ArrayList<>();
        // 得到当前流程所有脚本数据
        List<BpmNodeScriptRelevance> bpmNodeScriptRelevanceList = new ArrayList<>();

        bpmProcessConfigurationList.forEach(item -> {
            BpmUserScriptVo bpmUserScriptVo = new BpmUserScriptVo();
            bpmUserScriptVo.setNodeKey(item.getNodeKey());
            bpmUserScriptVo.setBpmNodeHandleUserList(bpmNodeHandleUserMapper.selectBpmNodeHandleUserList(new BpmNodeHandleUser(item.getNodeRolePermission())));
            bpmUserScriptVo.setBpmNodeScriptRelevanceList(bpmNodeScriptRelevanceMapper.selectBpmNodeScriptRelevanceList(new BpmNodeScriptRelevance(item.getNodeKey())));
            bpmNodeScriptRelevanceList.addAll(bpmUserScriptVo.getBpmNodeScriptRelevanceList());
            bpmUserScriptVoList.add(bpmUserScriptVo);
        });

        Map<String, String> shunxu = XmlDataParserUtils.getStartNodeAndNextNode(bpmProcess.getProcessXmlContent());
        /**2️⃣2️⃣2️⃣ 新增执行流程表数据*/
        BpmExecuteProcess runBpmExecuteProcess = new BpmExecuteProcess();
        // 当前流程启动的唯一标识
        runBpmExecuteProcess.setTaskKey(IdUtils.fastSimpleUUID());
        // 投产数据条的唯一标识
        runBpmExecuteProcess.setTaskPlanKey(intoProduction.getGuid().split("=")[1]);
        // 当前流程任务名称
        runBpmExecuteProcess.setTaskName("");
        // 定义表中的流程别名
        runBpmExecuteProcess.setTaskProcessKey(bpmProcess.getProcessKey());
        // 定义表中的流程xml标签内容
        runBpmExecuteProcess.setTaskProcessXmlContent(bpmProcess.getProcessXmlContent());
        // 启动流程的状态 默认：0 正常 1暂停 2弃用
        runBpmExecuteProcess.setTaskProcessState(0L);
        // 当前任务流程的版本注释
        runBpmExecuteProcess.setTaskProcessNote(bpmProcess.getNote());
        // 流程类型
        runBpmExecuteProcess.setTaskProcessType(bpmProcess.getProcessType().toString());
        // 当前流程执行节点
        runBpmExecuteProcess.setTaskNodeKey(shunxu.get("startNode"));
        // 当前流程需要执行的下一个节点
        runBpmExecuteProcess.setTaskNodeNextKey(shunxu.get("nextNode"));
        // 执行默认值
        runBpmExecuteProcess.setDelFlag("0");
        // *****替换当前执行流程的任务唯一标识
        intoProduction.setTaskProcessKey(runBpmExecuteProcess.getTaskKey());
        // 执行新增方法
        runBpmExecuteProcessMapper.insertBpmExecuteProcess(runBpmExecuteProcess);
        /**3️⃣3️⃣3️⃣ 插入所有预执行节点*/
        List<BpmExecuteNode> runBpmExecuteNodeList = new ArrayList<>();
        bpmProcessConfigurationList.forEach(item -> {
            BpmExecuteNode bpmExecuteNode = new BpmExecuteNode();
            bpmExecuteNode.setTaskProcessKey(runBpmExecuteProcess.getTaskKey());
            bpmExecuteNode.setTaskNodeKey(item.getNodeKey());
            bpmExecuteNode.setTaskNodeName(item.getNodeName());
            bpmExecuteNode.setTaskNodeFormType(item.getNodeFormType());
            bpmExecuteNode.setTaskNodeFormKey(item.getNodeFormKey()); // 单前节点绑定的表单
            bpmExecuteNode.setTaskNodeType(item.getNodeType());
            bpmExecuteNode.setTaskNodeBefore(item.getNodeBefore());
            bpmExecuteNode.setTaskNodeAfter(item.getNodeAfter());
            bpmExecuteNode.setTaskNodeRolePermission(item.getNodeRolePermission());
            bpmExecuteNode.setTaskRemark(item.getRemark());
            bpmExecuteNode.setTaskNodeState("0");  // 状态默认未执行
            bpmExecuteNode.setTaskPriority("1");   // 任务优先级 设计是从排产操作时选中的任务优先级
            bpmExecuteNode.setTaskNodeExecuteType(item.getNodeExecuteType());  // 当前节点上是手动执行还是自动执行 true || false
            runBpmExecuteNodeList.add(bpmExecuteNode);
        });
        runBpmExecuteNodeMapper.insertBpmExecuteNodeList(runBpmExecuteNodeList);
        /**3️⃣3️⃣3️⃣ 执行流程任务所有关联数据执行用户、执行脚本等*/
        List<BpmExecuteNodeMiddle> runBpmExecuteNodeMiddleList = new ArrayList<>();
        int index = 0;
        // bpmUserScriptVoList  当前节点的所有执行用户脚本
        bpmUserScriptVoList.forEach(item -> {
            BpmExecuteNodeMiddle bpmExecuteNodeMiddle = new BpmExecuteNodeMiddle();
            // 任务流程编码
            bpmExecuteNodeMiddle.setTaskProcessKey(runBpmExecuteProcess.getTaskKey());
            // 节点标识
            bpmExecuteNodeMiddle.setTaskNodeKey(item.getNodeKey());
            // 节点执行角色编码
            bpmExecuteNodeMiddle.setTaskRealRole(item.getBpmNodeHandleUserList().get(index).getRealRole());
            // 节点执行用户id
            bpmExecuteNodeMiddle.setTaskExecuteUserNo(item.getBpmNodeHandleUserList().get(index).getExecuteUserNo());
            // 节点手动触发脚本
            List<String> script0 = new ArrayList<>(), script1 = new ArrayList<>(), script2 = new ArrayList<>();// 异常手动触发 // 正常自动触发 // 节点前后自动触发
            item.getBpmNodeScriptRelevanceList().forEach(stem -> {
                if (stem.getNodeKey().contains(item.getNodeKey())) {
                    // ⚠️⚠️⚠️ 0L 异常手动触发 1L 正常自动触发 2L 节点前后自动触发
                    if (stem.getScriptTriggerType() == 0L) {
                        script0.add(stem.getScriptKey());
                    } else if (stem.getScriptTriggerType() == 1L) {
                        script1.add(stem.getScriptKey());
                    } else if (stem.getScriptTriggerType() == 2L) {
                        script1.add(stem.getScriptKey());
                    }
                }
            });
            // 手动异常触发脚本
            bpmExecuteNodeMiddle.setTaskArtificialScriptKey(script0.toString().replaceAll("\\[", "").replaceAll("\\]", ""));
            // 正常节点自动触发脚本
            bpmExecuteNodeMiddle.setTaskAutomaticScriptTriggerType(script1.toString().replaceAll("\\[", "").replaceAll("\\]", ""));
            // 节点前后触发脚本
            bpmExecuteNodeMiddle.setTaskNodeAroundScriptKey(script2.toString().replaceAll("\\[", "").replaceAll("\\]", ""));
            // 追加节点中间表list
            runBpmExecuteNodeMiddleList.add(bpmExecuteNodeMiddle);
        });
        runBpmExecuteNodeMiddleMapper.insertBpmExecuteNodeMiddleList(runBpmExecuteNodeMiddleList);
        //**3️⃣⚡️5️⃣ 流程任务当中的所有节点关联的表单信息 得到当前流程的所有节点以及当前节点脚本绑定的异常脚本-》处理当前节点脚本、异常脚本绑定的表单到中间表信息 */
        List<BpmExecuteNodeForm> bpmExecuteNodeFormList = new ArrayList<>();
        // 当前流程的正常节点、异常节点（理论上无论什么节点都会绑定一个表单）
        Map<String, String> nodeMap = new HashMap<>();
        Map<String, BpmProcessConfiguration> nodeInfo = new HashMap<>();
        bpmProcessConfigurationList.forEach(item -> {
            if (item.getNodeType().equals("startEvent")) {
                nodeMap.put("startNodeKey", item.getNodeKey());
            } else if (item.getNodeType().equals("endEvent")) {
                nodeMap.put("endNodeKey", item.getNodeKey());
            }
            nodeInfo.put(item.getNodeKey(), item);
        });
        bpmNodeScriptRelevanceList.forEach(item -> {

            if (item.getNodeKey().equals(nodeMap.get("startNodeKey")) || item.getNodeKey().equals(nodeMap.get("endNodeKey"))) {
                //  开始结束节点不做记录
            } else

                // 0=：异常脚本；1：正常脚本 2：节点前后自动  节点前后执行的脚本是没有表单的
                if (item.getScriptTriggerType() != 2L) {
                    BpmExecuteNodeForm bpmExecuteNodeForm = new BpmExecuteNodeForm();
                    bpmExecuteNodeForm.setTaskProcessKey(intoProduction.getTaskProcessKey());
                    bpmExecuteNodeForm.setTaskNodeKey(item.getNodeKey());
                    bpmExecuteNodeForm.setTaskScriptKey(item.getScriptKey());
                    if (item.getScriptTriggerType() == 1L) { // 正常节点脚本
                        // bpmProcessConfigurationList
                        bpmExecuteNodeForm.setTaskNodeFormKey(nodeInfo.get(item.getNodeKey()).getNodeFormKey());
                        bpmExecuteNodeForm.setTaskNodeFromType(nodeInfo.get(item.getNodeKey()).getNodeFormType());
                        // bpmExecuteNodeForm.setTaskNodeFromContent();
                    } else if (item.getScriptTriggerType() == 0L) { // 异常脚本
                        bpmExecuteNodeForm.setTaskNodeFormKey(item.getFormKey());
                        bpmExecuteNodeForm.setTaskNodeFromType(item.getScriptNodeFormType());
                        // bpmExecuteNodeForm.setTaskNodeFromContent();
                    }
                    bpmExecuteNodeFormList.add(bpmExecuteNodeForm);
                }
        });
        // 得到当前流程所有的表单类型
        Map<String, String> nodeFrom = iBpmExecuteNodeFormService.selectNodeFromInfos(commonEntity.getCommMap().get("process_key").toString());
        // 得到当前表单的所有信息
        Map<String, Object> nodeFromInfoMap = this.getNodeFormInfos(nodeFrom);
        bpmExecuteNodeFormList.forEach(item -> {
            item.setTaskNodeFromContent(nodeFromInfoMap.get(item.getTaskNodeFormKey()).toString());
        });
        // 最终提交新增 bpmExecuteNodeFormList
        bpmExecuteNodeFormList.forEach(item -> {
            iBpmExecuteNodeFormService.insertBpmExecuteNodeForm(item);
        });
        // iBpmExecuteNodeFormService
        /**4️⃣4️⃣4️⃣ 调用执行节点接口 预执行当前投产流程的开始节点，执行开始节点*/
        // bpmUserScriptVoList  节点key对应的脚本
        // 根据节点类型startEvent 筛选得到当前流程的开始节点，进行自动执行    // startEvent  开始节点类型
        Optional<BpmProcessConfiguration> optionalStartNode = bpmProcessConfigurationList.stream().filter(item -> item.getNodeType().equals("startEvent")).findFirst();
        if (optionalStartNode.isPresent()) {
            // optionalStartNode.get().getNodeKey();  当前流程开始节点key
            Optional<BpmUserScriptVo> optionalBpmUserScriptVo = bpmUserScriptVoList.stream().filter(item -> item.getNodeKey().equals(optionalStartNode.get().getNodeKey())).findFirst();
            if (optionalBpmUserScriptVo.isPresent()) {
                // 得到当前节点需要执行的脚本  只需执行自动执行的脚本即可
                List<BpmNodeScriptRelevance> scriptAutoList = optionalBpmUserScriptVo.get().getBpmNodeScriptRelevanceList();
                scriptAutoList.removeIf(item -> item.getScriptTriggerType() == 0L);  // 删除异常脚本
                IScriptEntity iScriptEntity = new IScriptEntity();
                iScriptEntity.setImplementationName(scriptAutoList.get(0).getScriptKey());
                iScriptEntity.setScriptNodeKey(optionalBpmUserScriptVo.get().getNodeKey());
                if (!iRunImplementationClass.RunScriptImplementationClassLogicCode(iScriptEntity, intoProduction)) {
                    // 判断脚本执行状态
                    return AjaxResult.error(HttpStatus.SCRIPTEXCEPTION, "脚本执行异常！");
                }
            }
        } else {
            // 数据出现问题
            return AjaxResult.error(HttpStatus.EXECUTEPROCESS, "流程开始节点数据异常！");
        }
        /**5️⃣5️⃣5️⃣ 执行结果返回前端*/
        return AjaxResult.success();
    }

    /**
     * 执行流程节点共通接口
     *
     * @param bpmRunNodeVo
     * @return
     */
    @Transactional
    @Async
    public AjaxResult executionNode(BpmRunNodeVo bpmRunNodeVo) {
        System.err.println(bpmRunNodeVo.getTaskNodeKey());
        System.err.println(bpmRunNodeVo.getNextNodeKey());
        String taskProcessKey = bpmRunNodeVo.getTaskProcessKey(); // 任务流程编码
        String taskNodeKey = bpmRunNodeVo.getTaskNodeKey(); // 任务节点编码
        // 得到当前节点的所有信息-》用于执行节点前后绑定的自动运行的脚本
        BpmExecuteNode currentBpmExecuteNode = runBpmExecuteNodeMapper.queryBpmExecuteNodeBytaskNodeKey(taskProcessKey, taskNodeKey);
        // 在执行节时得到除当前节点绑定的正常脚本外，有可能会绑定自动执行的脚本（这些自动执行的脚本参数不能确定，无法传递）
        BpmExecuteNodeMiddle bpmExecuteNodeMiddle = runBpmExecuteNodeMiddleMapper.queryBpmExecuteNodeMiddleByTaskNodeKey(taskProcessKey, taskNodeKey);
        String script[] = bpmExecuteNodeMiddle.getTaskNodeAroundScriptKey().split(",");  // 得到当前节点需要自动执行的脚本
        //--- 1️⃣1️⃣1️⃣执行节点前绑定的脚本🚀🚀🚀～！！！
        System.err.println("--- 1️⃣1️⃣1️⃣执行节点前绑定的脚本🚀🚀🚀～！！！");
        if (currentBpmExecuteNode.getTaskNodeBefore().equals("true")) {
            // 调用执行脚本接口
            if (script != null && script.length != 0 && !script[0].isEmpty()) {
                for (int i = 0; i < script.length; i++) {
                    //  节点执行必要的参数
                    IScriptEntity iScriptEntity = new IScriptEntity();
                    iScriptEntity.setScriptFlowKey(taskProcessKey);
                    iScriptEntity.setScriptNodeKey(taskNodeKey);
                    iScriptEntity.setImplementationName(script[i]);
                    // 调用执行脚本方法
                    if (!iRunImplementationClass.RunScriptImplementationClassLogicCode(iScriptEntity, bpmRunNodeVo)) {
                        // 判断脚本执行状态
                        return AjaxResult.error(HttpStatus.SCRIPTEXCEPTION, "节点前脚本执行失败！");
                    }
                }
            }
        }
        //--- 2️⃣2️⃣2️⃣执行节点绑定的正常脚本🚀🚀🚀～！！！
        System.err.println("--- 2️⃣2️⃣2️⃣执行节点绑定的正常脚本🚀🚀🚀～！！！");
        IRunBPMEntity iRunBPMEntity = new IRunBPMEntity();
        iRunBPMEntity.setImplementationName(bpmRunNodeVo.getImplementationName());
        iRunBPMEntity.setExecutionFlowKey(taskProcessKey);
        iRunBPMEntity.setExecutionNodeKey(taskNodeKey);
        iRunBPMEntity.setExecutionMap(bpmRunNodeVo.getFormDataMap());
        iRunBPMEntity.setTableName(bpmRunNodeVo.getTableName());
        AjaxResult ajaxResult = iRunImplementationClass.RunBPMImplementationClassLogicCode(iRunBPMEntity);  //  调用节点绑定逻辑代码
        if (!ajaxResult.get("code").equals("200")) {
            return ajaxResult;
        }
        //--- 2️⃣⚡️5️⃣ 当节点执行完成后修改节点的状态
        System.err.println("--- 2️⃣⚡️5️⃣ 当节点执行完成后修改节点的状态");
        BpmExecuteNode updateNodeStateEn = new BpmExecuteNode();
        updateNodeStateEn.setTaskProcessKey(taskProcessKey);
        updateNodeStateEn.setTaskNodeKey(taskNodeKey);
        updateNodeStateEn.setTaskNodeState("1");      // 状态标识已经执行
        // 修改当前节点的状态
        runBpmExecuteNodeMapper.updateNodeState(updateNodeStateEn);
        //--- 3️⃣3️⃣3️⃣执行节点后绑定的脚本🚀🚀🚀～！！！
        System.err.println("--- 3️⃣3️⃣3️⃣执行节点后绑定的脚本🚀🚀🚀～！！！");
        if (currentBpmExecuteNode.getTaskNodeAfter().equals("true")) {
            // 调用执行脚本接口
            if (script != null && script.length != 0 && !script[0].isEmpty()) {
                for (int i = 0; i < script.length; i++) {
                    //  节点执行必要的参数
                    IScriptEntity iScriptEntity = new IScriptEntity();
                    iScriptEntity.setScriptFlowKey(taskProcessKey);
                    iScriptEntity.setScriptNodeKey(taskNodeKey);
                    iScriptEntity.setImplementationName(script[i]);
                    // 调用执行节点
                    if (!iRunImplementationClass.RunScriptImplementationClassLogicCode(iScriptEntity, bpmRunNodeVo)) {
                        // 判断脚本执行状态
                        return AjaxResult.error(HttpStatus.SCRIPTEXCEPTION, "节点后执行脚本失败！");
                    }
                }
            }
        }
        BpmExecuteNode bpmExecuteNode = runBpmExecuteNodeMapper.queryBpmExecuteNodeBytaskNodeKey(bpmRunNodeVo.getTaskProcessKey(), bpmRunNodeVo.getNextNodeKey());
        // 4️⃣4️⃣4️⃣ 校验当前节点是否为结束节点
        System.err.println("--- 4️⃣4️⃣4️⃣ 校验当前节点是否为结束节点");
        if (bpmExecuteNode.getTaskNodeType().equals("endEvent")) {
            //  节点执行必要的参数
            IScriptEntity iScriptEntity = new IScriptEntity();
            iScriptEntity.setScriptFlowKey(taskProcessKey);
            iScriptEntity.setScriptNodeKey(taskNodeKey);
            iScriptEntity.setImplementationName("commonEndEvent");  // 直接调用结束节点执行逻辑
            // 调用执行结束节点
            if (!iRunImplementationClass.RunScriptImplementationClassLogicCode(iScriptEntity, iScriptEntity)) {
                // 判断脚本执行状态
                return AjaxResult.error(HttpStatus.SCRIPTEXCEPTION, "流程结束失败！");
            }
            // 结束当前流程 更新流程状态
            if (runBpmExecuteProcessMapper.endProcess(bpmRunNodeVo.getTaskProcessKey()) > 1) {
                AjaxResult.success("流程执行成功！");
            } else {
                AjaxResult.error(HttpStatus.PROCESSERROR, "流程结束失败！");
            }
        }
        /**
         * *** ⤴️🔄♾️❗️校验下一个节点是否需要自动执行
         *  主动调用的执行接口一定是手动触发的节点
         *  当手动触发节点后的下一个节点需要判断节点类型是否是自动执行的节点
         *
         *
         *  自动执行节点程序自己调用 自动执行节点绑定的脚本。（递归执行）
         *  ！！！ 调用自动执行的脚本无法传递除特定参数外的其他用户业务表中的参数
         */
        System.err.println("*** ⤴️🔄♾️❗️校验下一个节点是否需要自动执行");
        if (bpmExecuteNode.getTaskNodeExecuteType().equals("true")) {  // 当前节点的下一个节点，。。。。。。，，。是自动执行
            // 处理数据
            BpmRunNodeVo bpmRunNodeVo1 = new BpmRunNodeVo();
            bpmRunNodeVo1.setTaskNodeKey(bpmExecuteNode.getTaskNodeKey());
            bpmRunNodeVo1.setTaskProcessKey(bpmExecuteNode.getTaskProcessKey());
            // 当前节点的下一个节点的编码
            bpmRunNodeVo1.setNextNodeKey(XmlDataParserUtils.getNextNodeKey(bpmRunNodeVo.getTaskProcessXmlContent(), bpmRunNodeVo.getNextNodeKey()));
            // 当前节点执行的脚本
            BpmExecuteNodeMiddle nextBpmExecuteNodeMiddle = runBpmExecuteNodeMiddleMapper.queryBpmExecuteNodeMiddleByTaskNodeKey(bpmRunNodeVo.getTaskProcessKey(), bpmRunNodeVo.getNextNodeKey());
            bpmRunNodeVo1.setImplementationName(nextBpmExecuteNodeMiddle.getTaskArtificialScriptKey());
            BpmExecuteProcess bpmExecuteProcess = new BpmExecuteProcess();
            bpmExecuteProcess.setTaskKey(bpmRunNodeVo.getTaskProcessKey());
            bpmExecuteProcess.setTaskNodeKey(bpmRunNodeVo.getTaskNodeKey());
            bpmExecuteProcess.setTaskNodeNextKey(bpmRunNodeVo.getNextNodeKey());
            runBpmExecuteProcessMapper.updateProcessNode(bpmExecuteProcess);
            this.executionNode(bpmRunNodeVo1);
        } else if (bpmExecuteNode.getTaskNodeExecuteType().equals("false")) {
            System.err.println("✅✅✅节点执行完成！！！");
            BpmExecuteProcess bpmExecuteProcess = new BpmExecuteProcess();
            bpmExecuteProcess.setTaskKey(bpmRunNodeVo.getTaskProcessKey());
            bpmExecuteProcess.setTaskNodeKey(bpmRunNodeVo.getTaskNodeKey());
            bpmExecuteProcess.setTaskNodeNextKey(bpmRunNodeVo.getNextNodeKey());
            runBpmExecuteProcessMapper.updateProcessNode(bpmExecuteProcess);
            return AjaxResult.success();
        }
        return AjaxResult.success();
    }

    /**
     * 获取发起流程数据
     *
     * @param commonEntity
     * @return
     */
    public IntoProduction obtainData(CommonEntity commonEntity) {
        IntoProduction intoProduction = new IntoProduction();  // 启动流程所需参数实体
        commonEntity.getConditionMap().entrySet().forEach(item -> {
            // 得到当前表的主键字段 // 得到当前表的主键值
            intoProduction.setGuid(item.getKey() + "=" + item.getValue().toString());
        });
        // 得到当前表名
        intoProduction.setTableName(commonEntity.getBasicMap().get("tableName").toString());
        // 得到需要执行的流程编码
        intoProduction.setTaskProcessKey(commonEntity.getCommMap().get("process_key").toString());
        // 得到单前表所需的状态字段，启动流程所需kv
        intoProduction.setStateMap(commonEntity.getConditionMap());
        intoProduction.getStateMap().putAll(commonEntity.getBtnParametersMap());
        return intoProduction;
    }

    /**
     * * 执行表单查询详情接口,得到当前节点展示表单的数据
     */
    public CommonEntity processNodeFormInfoData(BpmRunNodeFromVo bpmRunNodeFromVo) {
        return iRunImplementationClass.getNodeFormData(bpmRunNodeFromVo);
    }

    /**
     * 查询节点对应的表单信息
     *
     * @param nodeForm
     * @return
     */
    public Map<String, Object> getNodeFormInfos(Map<String, String> nodeForm) {
        Set<String> nodeKey = nodeForm.keySet();
        Map resultMap = new HashMap();
        nodeKey.forEach(item -> {
            if (nodeForm.get(item).equals("dragForm")) {  // 拖拽类型的表单
                String fromInfo = iBpmExecuteProcessService.getFromInfo(item);
                resultMap.put(item, fromInfo);
            } else if (nodeForm.get(item).equals("composeForm")) { // 组合类型的表单
                String groupTableInfo = iBpmExecuteProcessService.getGroupTableInfo(item);
                resultMap.put(item, groupTableInfo);
            } else if (nodeForm.get(item).equals("designForm")) {  // 自定义类型表单
                resultMap.put(item, "");
            }
        });
        return resultMap;
    }

    public CommonEntity getProcessNodeFormTemplate(BpmRunNodeFromVo bpmRunNodeFromVo) {
        CommonEntity commonEntity = new CommonEntity();

        return commonEntity;
    }


//    /**
//     * 共通执行节点表单模版接口
//     */
//    public List<Map> getProcessNodeFormTemplate(BpmRunNodePlusVo bpmRunNodeV) {
//        //任务流程key
//        String taskProcessKey = bpmRunNodeV.getTaskProcessKey();
//        //任务节点key
//        String taskNodeKey = bpmRunNodeV.getTaskNodeKey();
//        //脚本名称
//        String taskScriptKey = bpmRunNodeV.getTaskScriptKey();
//        //根据流程key和节点key查询节点表单关系表【bpm_execute_node_form】
//        BpmExecuteNodeForm bpmExecuteNodeForm = iBpmExecuteNodeFormService.getBpmExecuteNodeForm(taskProcessKey, taskNodeKey, taskScriptKey);
//        //存放返回结果
//        List<Map> mapList = new ArrayList<>();
//        //节点对应的表单信息不能为空
//        if (bpmExecuteNodeForm != null) {
//            String taskNodeFromContent = bpmExecuteNodeForm.getTaskNodeFromContent();
//            //拿到当前节点对应的表单类型
//            String taskNodeFromType = bpmExecuteNodeForm.getTaskNodeFromType();
//            if (taskNodeFromType.equals("dragForm")) {
//                HashMap hashMap = new HashMap();
//                //解析存进去的表单信息【task_node_from_content】
//                JSONObject taskNodeFromContentJson = JSONObject.parseObject(taskNodeFromContent);
//                //得到sqlKey
//                String sqlKey = taskNodeFromContentJson.get("sqlKey").toString();
//                //根据sqlKey查询表单数据
//                if (!sqlKey.isEmpty()) {
//                    Map<String, String> tableSqlBySqlKey = executeNodeFormMapper.getTableSqlBySqlKey(sqlKey);
//                    hashMap.put("resultMap", tableSqlBySqlKey);
//                }
//                //得到【df_form_sql】
//                String dfFormSql = taskNodeFromContentJson.get("dfFormSql").toString();
//                ObjectMapper objectMapper = new ObjectMapper();
//                Map<String, Object> sqlMap = null;
//                try {
//                    sqlMap = objectMapper.readValue(dfFormSql, Map.class);
//                    //循环得到每一个sql语句返回结果
//                    for (Map.Entry<String, Object> entry : sqlMap.entrySet()) {
//                        List<Map<String, Object>> resultMap = executeNodeFormMapper.executeSql(entry.getValue().toString());
//                        sqlMap.put(entry.getKey(), resultMap);
//                    }
//                    //把原来的sql语句替换成下拉框数据
//                    taskNodeFromContentJson.put("dfFormSql", JSONObject.toJSONString(sqlMap));
//                } catch (JsonProcessingException e) {
//                    e.printStackTrace();
//                }
//                //表单结构信息
//                hashMap.put("template", taskNodeFromContentJson);
//                //添加到返回集合中
//                mapList.add(hashMap);
//            } else if (taskNodeFromType.equals("composeForm")) {
//                //参数为一个数组
//                JSONArray objects = JSON.parseArray(taskNodeFromContent);
//
//                //循环数组元素
//                objects.forEach(item -> {
//                    String s = item.toString();
//                    JSONObject jsonObject = JSONObject.parseObject(s);
//                    String tableSql = jsonObject.get("tableSql").toString();
//                    String conditionArrayJson = jsonObject.get("condition").toString();
//                    JSONArray jsonArray = JSON.parseArray(conditionArrayJson);
//
//                    jsonArray.forEach(conditionItem -> {
//                        //处理下这个条件 去掉 #{ 去掉.
//                        String conditionString = conditionItem.toString().replace("#{", "").replace(".", "_");
//                        //转驼峰
//                        String CamelConditionString = CamelCaseConverterUtil.toCamelCase(conditionString);
//                        //
//                    });
//
//                    Map<String, String> stringHashMap = executeNodeFormMapper.tableSql(tableSql);
//                    jsonObject.put("tableList", stringHashMap);
//                    mapList.add(jsonObject);
//                });
//            } else if (taskNodeFromContent.equals("designForm")) {
//                HashMap hashMap = new HashMap();
//                hashMap.put("resultMap", "");
//                hashMap.put("template", "");
//                mapList.add(hashMap);
//            }
//        }
//        return mapList;
//    }
}
