package com.hotent.runtime.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StopWatch;

import com.hotent.base.exception.BaseException;
import com.hotent.base.exception.WorkFlowException;
import com.hotent.base.util.AppUtil;
import com.hotent.base.util.BeanUtils;
import com.hotent.base.util.StringUtil;
import com.hotent.base.util.string.StringPool;
import com.hotent.bpm.api.constant.NodeType;
import com.hotent.bpm.api.model.identity.BpmIdentity;
import com.hotent.bpm.api.model.process.def.BpmProcessDef;
import com.hotent.bpm.api.model.process.def.BpmProcessDefExt;
import com.hotent.bpm.api.model.process.def.NodeProperties;
import com.hotent.bpm.api.model.process.inst.BpmProcessInstance;
import com.hotent.bpm.api.model.process.nodedef.BpmNodeDef;
import com.hotent.bpm.api.model.process.nodedef.NodeInMulti;
import com.hotent.bpm.api.model.process.nodedef.ext.CallActivityNodeDef;
import com.hotent.bpm.api.model.process.nodedef.ext.SubProcessNodeDef;
import com.hotent.bpm.api.model.process.nodedef.ext.extmodel.Button;
import com.hotent.bpm.api.model.process.task.BpmTask;
import com.hotent.bpm.api.service.BpmDefinitionAccessor;
import com.hotent.bpm.api.service.BpmSignDataService;
import com.hotent.bpm.persistence.manager.BpmProStatusManager;
import com.hotent.bpm.persistence.manager.BpmProcessInstanceManager;
import com.hotent.bpm.persistence.manager.BpmTaskManager;
import com.hotent.bpm.persistence.model.DefaultBpmTask;
import com.hotent.bpm.persistence.util.BpmStackRelationUtil;
import com.hotent.bpm.util.BpmUtil;
import com.hotent.runtime.params.TaskToRejectVo;

/**
 * 驳回相关
 * @author jason
 */
public class RejectUtil {
    private static Logger logger = LoggerFactory.getLogger(RejectUtil.class);

    /**
     * 驳回构建  获取可驳回的节点需要按照顺序最近当前任务的节点放到数组中
     *
     * @param taskId
     * @param backMode
     * @return
     * @throws Exception
     */
    public static TaskToRejectVo toReject(String taskId, String backMode) throws Exception {
        BpmTaskManager bpmTaskManager = AppUtil.getBean(BpmTaskManager.class);
        BpmDefinitionAccessor bpmDefinitionAccessor = (BpmDefinitionAccessor) AppUtil.getBean("bpmDefinitionAccessor");
        boolean canRejectToStart = false; // 是否可以驳回发起人
        boolean canRejectToAnyNode = false; // 是否可以驳回指定节点
        boolean canReject = false; // 是否可以驳回
        boolean canRejectPreAct = false; // 是否可以驳回到上一步
        String rejectRecallMode = Button.REJECT_RECALL_MODE; // 驳回重提模式
        String defaultRejectMode = Button.DEFAULT_REJECT_MODE; // 默认选中的驳回模式
        String defaultRejectRecallMode = Button.DEFAULT_REJECT_RECALL_MODE; // 默认选中的驳回重提模式
        DefaultBpmTask task = bpmTaskManager.get(taskId);
        if (BeanUtils.isEmpty(task)) {
            throw new WorkFlowException("当前任务已办理，不可重复办理！");
        }
        checkTargetNode(null,task);
        String defId = task.getProcDefId();
        String nodeId = task.getNodeId();

        BpmNodeDef taskNodeDef = bpmDefinitionAccessor.getBpmNodeDef(defId, nodeId);
        BpmProcessDef<BpmProcessDefExt> bpmProcessDef = bpmDefinitionAccessor.getBpmProcessDef(defId);

        List<Button> buttons = BpmUtil.getButtons(taskNodeDef, task);
        String backNode = "";
        for (Button button : buttons) {
            if ("reject".equals(button.getAlias())) {
                // 驳回模式
                String rejectMode = button.getRejectMode();
                if (StringUtil.isNotEmpty(rejectMode)) {
                    List<String> rejectModeList = Arrays.asList(rejectMode.split(","));
                    if (rejectModeList.contains("backToStart")) {
                        canRejectToStart = true;
                    }
                    if (rejectModeList.contains("rejectPre")) {
                        canRejectPreAct = true;
                    }
                    if (rejectModeList.contains("reject")) {
                        canRejectToAnyNode = true;
                    }

                }
                // 可驳回节点
                backNode = button.getRejectNode();
                if (button.getRejectRecallMode() != null) {
                    // 驳回重提模式
                    rejectRecallMode = button.getRejectRecallMode();
                }
                if (button.getDefaultRejectMode() != null) {
                    // 默认选中的驳回模式
                    defaultRejectMode = button.getDefaultRejectMode();
                }
                if (button.getDefaultRejectRecallMode() != null) {
                    // 默认选中的驳回重提模式
                    defaultRejectRecallMode = button.getDefaultRejectRecallMode();
                }
            }
        }
        String procInstId = task.getProcInstId();

        String parentDefKey = "";
        BpmProcessInstanceManager processInstanceManager = AppUtil.getBean(BpmProcessInstanceManager.class);
        BpmProcessInstance topInstance = processInstanceManager.getTopBpmProcessInstance(procInstId);
        if (BeanUtils.isNotEmpty(topInstance) && !topInstance.getId().equals(procInstId)) {
        	parentDefKey = topInstance.getProcDefKey();
		}
        NodeProperties nodeProperties = taskNodeDef.getPropertiesByParentDefKey(parentDefKey);
        // 驳回模式
        if(StringUtil.isEmpty(backMode)){
            backMode = nodeProperties.getBackMode();
            if (StringUtil.isEmpty(backMode)){
                backMode = "normal";
            }
        }
        // 获取节点属性上设置的可驳回节点
        if (StringUtil.isEmpty(backNode)) {
            backNode = nodeProperties.getBackNode();
        }

        TaskToRejectVo taskToRejectVo = new TaskToRejectVo();
        taskToRejectVo.setTaskId(taskId);
        taskToRejectVo.setBackMode(backMode);
        taskToRejectVo.setBackNode(backNode);
        taskToRejectVo.setCanReject(canReject);
        // 是否允许驳回上一步
        taskToRejectVo.setCanRejectPreAct(canRejectPreAct);
        taskToRejectVo.setCanRejectToStart(canRejectToStart);
        taskToRejectVo.setCanRejectToAnyNode(canRejectToAnyNode);

        taskToRejectVo.setRejectRecallMode(rejectRecallMode);
        taskToRejectVo.setDefaultRejectMode(defaultRejectMode);
        taskToRejectVo.setDefaultRejectRecallMode(defaultRejectRecallMode);

        setAllowNodes(taskToRejectVo,defId,procInstId,nodeId,backNode);
        Map<String, Set<BpmIdentity>> signTaskHisAssignMap =  new HashMap<>();
        
        List<BpmNodeDef> allRejectNodes = new ArrayList<>();
        allRejectNodes.addAll(taskToRejectVo.getAllowDirectNode());
        allRejectNodes.addAll(taskToRejectVo.getAllowNormalNode());
        if (BeanUtils.isNotEmpty(allRejectNodes)) {
            BpmSignDataService bpmSignDataService =AppUtil.getBean(BpmSignDataService.class);
            for (BpmNodeDef n : allRejectNodes) {
                if (NodeType.SIGNTASK.equals(n.getType()) && "assignHistory".equals(n.getPropertiesByParentDefKey(parentDefKey).getBackUserMode())) {
                    signTaskHisAssignMap.put(n.getNodeId(), bpmSignDataService.getHistoryAuditorByInstId(task.getProcInstId(), n.getNodeId()));
                }
            }
        }
        taskToRejectVo.setSignTaskHisAssignMap(signTaskHisAssignMap);
        return taskToRejectVo;
    }

    /**
     * 获取可以驳回的节点
     *
     * @param taskToRejectVo
     * @param defId
     * @param procInstId
     * @param nodeId  如果当前任务是有targetNode  nodeId 应该是当前的任务的targetNode 如果是有targetNode 的还需要将当前的nodeId的节点过滤掉 或者禁用连续驳回的功能就不会有问题
     * @param backNode
     * @return
     */
    public static TaskToRejectVo setAllowNodes(TaskToRejectVo taskToRejectVo, String defId, String procInstId, String nodeId, String backNode) throws Exception {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("获取可驳回节点耗时");
        BpmDefinitionAccessor bpmDefinitionAccessor = (BpmDefinitionAccessor) AppUtil.getBean("bpmDefinitionAccessor");
        //List<BpmNodeDef> allNodeDef = bpmDefinitionAccessor.getAllNodeDef(defId);
        
        List<BpmNodeDef> bpmnNodeDefs = new ArrayList<>();
        BpmNodeDef taskNodeDef = bpmDefinitionAccessor.getBpmNodeDef(defId, nodeId);
        if (BeanUtils.isNotEmpty(taskNodeDef.getParentBpmNodeDef()) && taskNodeDef.getParentBpmNodeDef() instanceof SubProcessNodeDef ) {
        	SubProcessNodeDef subProcessNodeDef = (SubProcessNodeDef) taskNodeDef.getParentBpmNodeDef();
        	bpmnNodeDefs = subProcessNodeDef.getChildBpmProcessDef().getBpmnNodeDefs();
		}
        Set<String> innerSubNodeIds = bpmnNodeDefs.stream().map(n -> n.getNodeId()).collect(Collectors.toSet());
        BpmProStatusManager bpmProStatusManager = AppUtil.getBean(BpmProStatusManager.class);
        // 运行过的节点
        List<String> nodeIds = bpmProStatusManager.getByInstIdAndRecycleNode(procInstId, StringPool.ZERO);

        List<BpmNodeDef> beforeAllNodes = getBeforeAllNodes(defId, nodeId, nodeIds);
        //  不包含内部子流程中的节点
        List<BpmNodeDef> nodeDefs = bpmDefinitionAccessor.getNodeDefs(defId);
        // 判断当前节点的位置是否在网关内部
        List<NodeInMulti> nodeInMultis = BpmUtil.getNodeInMulti(nodeDefs);
        List<BpmNodeDef> allowNormalNode = new ArrayList<>();
        List<BpmNodeDef> allowDirectNode = new ArrayList<>();


        List<String> excludeNormalNode = new ArrayList<>();
        // 没有网关
        if(BeanUtils.isNotEmpty(nodeInMultis)){
            // 判断当前节点nodeId 是否在网关内 并且记录下来是那个网关内  当前的网关 允许按照流程图执行  其他并行的网关不允许
            nodeInMultis.stream().filter(nodeInMulti -> nodeInMulti != null).forEach(nodeInMulti->{
                if(nodeInMulti.getAllNodeIdInMulti().contains(nodeId)){
                    // 网关内也允许驳回上一步
//                    taskToRejectVo.setInGateway(true);
                }else{
                    excludeNormalNode.addAll(nodeInMulti.getAllNodeIdInMulti());
                }
            });
        }
        // 只保留指定的可驳回的节点
        List<String> backNodeList = new ArrayList<String>();
        if (StringUtil.isNotEmpty(backNode)) {
            String[] split = backNode.split(",");
            backNodeList = Arrays.asList(split);
        }

        List<String> finalBackNodeList = backNodeList;
        beforeAllNodes.stream().forEach(bpmNodeDef->{
            String rejectNodeId = bpmNodeDef.getNodeId();
            // 直来直往的节点
            addCanRejectNode(finalBackNodeList, rejectNodeId, allowDirectNode, bpmNodeDef);
            // 同步内驳回到其他并行的同步内 不允许按照流程图执行
            if(excludeNormalNode.contains(rejectNodeId)){
                return;
            }
            //  按流程图执行的节点
            addCanRejectNode(finalBackNodeList, rejectNodeId, allowNormalNode, bpmNodeDef);
        });

        taskToRejectVo.setAllowDirectNode(allowDirectNode);
        // 内部子流程，驳回按流程图走的话，只能驳回到内部子流程的节点
        if (BeanUtils.isNotEmpty(innerSubNodeIds)) {
        	taskToRejectVo.setAllowNormalNode(allowNormalNode.stream().filter(n-> innerSubNodeIds.contains(n.getNodeId())).collect(Collectors.toList()));
		}else {
			taskToRejectVo.setAllowNormalNode(allowNormalNode);
		}
        
        taskToRejectVo.setBackNode(backNode);

        canRejectPreAct(taskToRejectVo,taskNodeDef);



        // 没有可驳回的节点 不允许驳回到指定节点
        if(allowDirectNode.size()==0 && allowNormalNode.size()==0){
            taskToRejectVo.setCanRejectToAnyNode(false);
        }
        stopWatch.stop();
        logger.info(stopWatch.getLastTaskName() + "': running time = " + stopWatch.getTotalTimeMillis() + "毫秒");
        return taskToRejectVo;
    }

    /**
     *  1. 判断当前任务是否允许驳回上一步  当前节点的上一节点为 同步网关  条件同步  内部子流程 外部子流程的时候 如果配置允许驳回上一步，则需要改为不允许驳回上一步
     *
     *  修改:改为多实例子流程（内部子流程，外部子流程）内不支持驳回上一步  后续再支持  先支持主流程网关内驳回上一步  网关外驳回上一步
     * @param taskToRejectVo
     * @param taskNodeDef
     */
    private static void canRejectPreAct(TaskToRejectVo taskToRejectVo, BpmNodeDef taskNodeDef){
        //  配置上允许驳回上一步
        if(taskToRejectVo.isCanRejectPreAct()){
            //标记是不是内部子流程节点，如果是，则不允许驳回发起人不重走
            if (BeanUtils.isNotEmpty(taskNodeDef.getParentBpmNodeDef())) {
                taskToRejectVo.setInSubProcess(true);
                boolean canRejectPreAct = true;
                // 子流程多实例 不允许驳回上一步
                BpmNodeDef parentBpmNodeDef = taskNodeDef.getParentBpmNodeDef();
                // 内部子流程 多实例 设置为不允许驳回上一步
                if(parentBpmNodeDef instanceof  SubProcessNodeDef && ((SubProcessNodeDef) parentBpmNodeDef).isParallel() ){
                   // canRejectPreAct = false;
                }
                // 外部子流程 多实例 设置为不允许驳回上一步
                if(parentBpmNodeDef instanceof CallActivityNodeDef && ((CallActivityNodeDef) parentBpmNodeDef).isParallel() ){
                    canRejectPreAct = false;
                }

                taskToRejectVo.setCanRejectPreAct(canRejectPreAct);
            }
        }
    }

    /**
     * 添加可驳回的节点
     * @param finalBackNodeList
     * @param rejectNodeId
     * @param allowNode
     * @param bpmNodeDef
     */
    private static void addCanRejectNode(List<String> finalBackNodeList, String rejectNodeId, List<BpmNodeDef> allowNode, BpmNodeDef bpmNodeDef) {
        // 如果有设置了可驳回节点 获取可驳回节点 否则获取全部可驳回的节点
        if(BeanUtils.isEmpty(finalBackNodeList) || finalBackNodeList.contains(rejectNodeId)){
            try {
                allowNode.add((BpmNodeDef) BeanUtils.cloneBean(bpmNodeDef));
            } catch (Exception e) {
                e.printStackTrace();
                throw new BaseException("获取可驳回节点异常",e);
            }
        }
    }

    /**
     * 获取nodeId 的前面所有的节点 （用户任务节点和会签节点）
     * @param defId
     * @param nodeId
     * @param nodeIds
     * @return
     * @throws Exception
     */
    public static List<BpmNodeDef> getBeforeAllNodes(String defId,String nodeId,List<String> nodeIds) throws Exception {
        BpmDefinitionAccessor bpmDefinitionAccessor = (BpmDefinitionAccessor) AppUtil.getBean("bpmDefinitionAccessor");
        BpmNodeDef bpmNodeDef = bpmDefinitionAccessor.getBpmNodeDef(defId, nodeId);
        List<String> findNodeIds = new ArrayList<>();
        List<BpmNodeDef> resultBeforeNodes = new ArrayList<>();
        collectBeforeNodes(bpmNodeDef, resultBeforeNodes,findNodeIds,nodeIds);
        // 有些流程图会从后面节点指回前面节点。此处过滤当前节点
        resultBeforeNodes = resultBeforeNodes.stream().filter(n->!n.getNodeId().equals(nodeId)).collect(Collectors.toList());
        return reorderBeforeAllNodes(resultBeforeNodes,nodeIds);
    }

    /**
     * 重新排序  最新审批的排前面
     * @param resultBeforeNodes
     * @param nodeIds
     * @return
     */
    private static List<BpmNodeDef> reorderBeforeAllNodes(List<BpmNodeDef> resultBeforeNodes, List<String> nodeIds) {
        List<BpmNodeDef> reorderBeforeAllNodes = new ArrayList<>();
        Map<String, BpmNodeDef> nodeId2BpmNodeDef = resultBeforeNodes.stream().collect(Collectors.toMap(BpmNodeDef::getNodeId, Function.identity()));
        nodeIds.stream().forEach(nodeId->{
            if(nodeId2BpmNodeDef.containsKey(nodeId)){
                reorderBeforeAllNodes.add(nodeId2BpmNodeDef.get(nodeId));
            }
        });
        return reorderBeforeAllNodes;
    }

    /**
     * 收集前面的节点
     * @param bpmNodeDef
     * @param resultBeforeNodes
     * @param findNodeIds
     * @param nodeIds
     */
    private static void collectBeforeNodes(BpmNodeDef bpmNodeDef, List<BpmNodeDef> resultBeforeNodes, List<String> findNodeIds, List<String> nodeIds) {

        List<BpmNodeDef> incomeNodes = bpmNodeDef.getIncomeNodes();
        if(BeanUtils.isEmpty(incomeNodes)){
            return ;
        }
        List<String> userTaskTypes = new ArrayList<>();
        userTaskTypes.add(NodeType.USERTASK.getKey());
        userTaskTypes.add(NodeType.SIGNTASK.getKey());
        incomeNodes.stream().forEach(incomeNode->{
            if(userTaskTypes.contains(incomeNode.getType().getKey()) && !findNodeIds.contains(incomeNode.getNodeId()) && nodeIds.contains(incomeNode.getNodeId()) ){
                resultBeforeNodes.add(incomeNode);
            }
            if(!findNodeIds.contains(incomeNode.getNodeId())){
                findNodeIds.add(incomeNode.getNodeId());
                collectBeforeNodes(incomeNode,resultBeforeNodes,findNodeIds,nodeIds);
            }
            BpmNodeDef parentBpmNodeDef = incomeNode.getParentBpmNodeDef();
            // 上层内部子流程节点
            if(NodeType.START.equals(incomeNode.getType()) && BeanUtils.isNotEmpty(incomeNode.getParentBpmNodeDef())){
                collectBeforeNodes(parentBpmNodeDef,resultBeforeNodes,findNodeIds,nodeIds);
            }

        });
    }

    /**
     * 如果是驳回动作  之前已经有直来直往的驳回不允许再次驳回
     * @param actionName
     * @param bpmTask
     */
    public static void checkTargetNode(String actionName, BpmTask bpmTask){
        String targetNode = bpmTask.getTargetNode();
        if(StringUtil.isNotEmpty(targetNode) && ("reject".equals(actionName) || "backToStart".equals(actionName) || StringUtil.isEmpty(actionName)) ){
            throw new BaseException("当前任务不允许再次驳回");
        }
    }

    /**
     * 获取撤回节点的后续的任务
     * @param revokeId
     * @param runningTasks
     * @return
     * @throws Exception
     */
    public static BpmTask findTaskFromRevokeNodeId(String revokeId,List<DefaultBpmTask> runningTasks) throws Exception {
        DefaultBpmTask findTask = runningTasks.get(0);
        if(runningTasks.size()>1){
            // 目标节点之后的所有节点
            List<BpmNodeDef>  after = BpmStackRelationUtil.getAllAfterListNodeAndTargetNode(findTask.getProcDefId(), findTask.getProcInstId(),revokeId);
            Set<String> fromStartNodeIds = after.stream().map(BpmNodeDef::getNodeId).collect(Collectors.toSet());
            Optional<DefaultBpmTask> first = runningTasks.stream().filter(predicate -> {
                return fromStartNodeIds.contains(predicate.getNodeId());
            }).findFirst();

            if(first.isPresent()){
                findTask = first.get();
            }
        }
        return findTask;
    }


    /**
     *
     * 如果当前任务节点 往前 到 revokeNodeId  存在跨节点（用户节点，会签节点 外部子流程节点，内部子流程节点）的不允许撤回
     * @param node 当前任务节点
     * @param nodeIds 已经审批过的节点
     * @param revokeNodeId 撤回的节点
     */
    public static void canRevoke(BpmNodeDef node, List<String> nodeIds, String revokeNodeId) {
        HashMap<String,BpmNodeDef> nodeDefHashMap = new HashMap<>();
        BpmUtil.getBetweenNodes(node,nodeDefHashMap,revokeNodeId);
        if(nodeDefHashMap.isEmpty()){
            throw new BaseException("不允许撤回");
        }
        Set<Map.Entry<String, BpmNodeDef>> entries = nodeDefHashMap.entrySet();
        List<NodeType> nodeTypeList = new ArrayList<>();
        nodeTypeList.add(NodeType.USERTASK);
        nodeTypeList.add(NodeType.SIGNTASK);
        nodeTypeList.add(NodeType.SUBPROCESS);
        nodeTypeList.add(NodeType.CALLACTIVITY);
        Set<Map.Entry<String, BpmNodeDef>> collect = entries.stream().filter((e) -> {
            return nodeIds.contains(e.getKey()) && nodeTypeList.contains(e.getValue().getType()) &&  !e.getKey().equals(revokeNodeId);
        }).collect(Collectors.toSet());
        if(collect.size()>=1){
            // 不允许跨节点撤回
            throw new BaseException("只允许上一步撤回");
        }
    }

    /**
     * 获取可驳回上一步的节点
     *
     * @param taskId
     * @param backHandMode
     * @return
     */
    public static String getRejectPreDestination(String taskId, String backHandMode) throws Exception {
        TaskToRejectVo taskToRejectVo = RejectUtil.toReject(taskId, backHandMode);
        if ("direct".equals(taskToRejectVo.getBackMode())) {
            return taskToRejectVo.getAllowDirectNode().get(0).getNodeId();
        } else {
            return taskToRejectVo.getAllowNormalNode().get(0).getNodeId();
        }
    }
}