/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill 庄骞 (smallchill@163.com)
 */
package com.vci.ubcs.flow.engine.service.impl;

import com.vci.ubcs.flow.core.constant.ProcessConstant;
import com.vci.ubcs.flow.core.entity.BladeFlow;
import com.vci.ubcs.flow.core.utils.TaskUtil;
import com.vci.ubcs.flow.engine.entity.*;
import com.vci.ubcs.flow.engine.service.FlowEngineService;
import com.vci.ubcs.flow.engine.service.FlowTaskUserService;
import com.vci.ubcs.flow.engine.service.VICFlowService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.flowable.bpmn.model.*;
import org.flowable.engine.*;
import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.Task;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.support.Kv;
import org.springframework.stereotype.Service;
import java.util.*;

/**
 * 工作流服务实现类
 *
 * @author Chill
 */
@Slf4j
@Service
@AllArgsConstructor
public class VCIFlowserviceImpl implements VICFlowService {

	private final RuntimeService runtimeService;
	private final IdentityService identityService;
	private final RepositoryService repositoryService;
	private final TaskService taskService;
	private final FlowTaskUserService flowTaskUserService;
	private final FlowEngineService flowEngineService;
	private final HistoryService historyService;

	@Override
	public R<BladeFlow> startProcess(FlowTaskDTO flowTaskUserC){
		String modelKey = flowTaskUserC.getModelKey();
		String templateId = flowTaskUserC.getTemplateId();

		Kv kv = Kv.create()
			.set(ProcessConstant.TASK_VARIABLE_CREATE_USER, AuthUtil.getUserName());

		// 设置流程启动用户
		identityService.setAuthenticatedUserId(TaskUtil.getTaskUser());

		// 开启流程
		//查询最新的流程部署id
		ProcessDefinition latesDefinition = repositoryService.createProcessDefinitionQuery().latestVersion().processDefinitionKey(modelKey).singleResult();
		String processDefinitionId = latesDefinition.getId();

		//查询每一步审核人
		List<FlowTaskUser> taskUsers = flowTaskUserService.getTaskUserByTemplateAndModelKey(templateId,modelKey);
		Set<String> taskIdSet = new HashSet<>();
		for (FlowTaskUser taskUser:taskUsers){
			kv.put(taskUser.getTaskId(),TaskUtil.getTaskUser(taskUser.getUserId()));
			taskIdSet.add(taskUser.getTaskId());
		}

		//对比配置的审核人员和流程中节点是否一致，可能存在流程节点变更了，多了或者少了节点，但是配置审核人员的节点没有变
//		List<Map<String,String>> processTasks = flowEngineService.getNodeByFlowableKey(modelKey);
//		for (Map<String,String> mi:processTasks){
//			String taskId = mi.get(flowEngineService.getTaskIdString());
//			if(!taskIdSet.contains(taskId)){
//				throw new ServiceException("流程已重新部署，节点已改变，请设置审核人员！");
//			}
//		}
//		if(taskIdSet.size()!=processTasks.size()){
//			throw new ServiceException("流程已重新部署，节点已改变，请设置审核人员！");
//		}

		//流程中文件、变量等
		//do..

		ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefinitionId, modelKey, kv);
		// 组装流程通用类
		BladeFlow flow = new BladeFlow();
		flow.setProcessInstanceId(processInstance.getId());

		return R.data(flow);
	}

	public static String NODE_NOW = "now";
	public static String NODE_NEXT = "next";
	/**
	 * 获取任务节点
	 *
	 * @param node   查询节点选择
	 * @param processInstanceId 流程实例id
	 */
	public FlowTaskDTO nextFlowNode(String node, String processInstanceId) {
		FlowTaskDTO flowTaskDTO = new FlowTaskDTO();
		List<FlowTaskDTO> taskList = new ArrayList<>();//节点按钮
		flowTaskDTO.setToTasks(taskList);

		Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).active().singleResult();
		ExecutionEntity ee = (ExecutionEntity) runtimeService.createExecutionQuery()
			.executionId(task.getExecutionId()).singleResult();
		// 当前审批节点
		String crruentActivityId = ee.getActivityId();
		BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
		FlowNode flowNode = (FlowNode) bpmnModel.getFlowElement(crruentActivityId);

		//这个实例的所有节点
		ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
		Map<String, Object> processVariables = processInstance.getProcessVariables();//所有参数
		flowTaskDTO.setVars(processVariables);

		String modelKey = processInstance.getProcessDefinitionKey();
		List<FlowTaskDTO> mis = flowEngineService.getNodeByFlowableKey(modelKey);

		// 输出连线
		List<SequenceFlow> outFlows = flowNode.getOutgoingFlows();
		for (SequenceFlow sequenceFlow : outFlows) {
			//当前审批节点
			if (NODE_NOW.equals(node)) {
				FlowElement sourceFlowElement = sequenceFlow.getSourceFlowElement();
				System.out.println("当前节点: id=" + sourceFlowElement.getId() + ",name=" + sourceFlowElement.getName());
			} else if (NODE_NEXT.equals(node)) {
				// 下一个审批节点
				FlowElement targetFlow = sequenceFlow.getTargetFlowElement();
				if (targetFlow instanceof UserTask) {
					System.out.println("下一节点: id=" + targetFlow.getId() + ",name=" + targetFlow.getName());
				}
				// 如果下个审批节点为排他网关
				if (targetFlow instanceof ExclusiveGateway) {

					ExclusiveGateway exclusiveGateway = (ExclusiveGateway) targetFlow;
					List<SequenceFlow> exclusiveGatewayOutgoingFlows = exclusiveGateway.getOutgoingFlows();
					for (SequenceFlow nexti:exclusiveGatewayOutgoingFlows){
						String conditionExpression = nexti.getConditionExpression();//condition
						String taskId = nexti.getTargetRef();//taskId
						String name = nexti.getName();//toName,驳回、同意

						for (FlowTaskDTO flowTaskUserCi:mis){
							if(taskId.equals(flowTaskUserCi.getTaskId())){
								flowTaskUserCi.setCondition(conditionExpression);
								if(conditionExpression.split("=").length>1) {
									flowTaskUserCi.setConditionKey(conditionExpression.split("=")[0]);
									flowTaskUserCi.setConditionValue(conditionExpression.split("=")[1]);
								}
								flowTaskUserCi.setToName(name);
								flowTaskUserCi.setToTaskId(taskId);
								flowTaskUserCi.setToTaskName(flowTaskUserCi.getTaskName());
								taskList.add(flowTaskUserCi);
							}
						}
					}
				}
			}
		}
		return flowTaskDTO;
	}
}