package org.springblade.mdm.flow.service;

import lombok.AllArgsConstructor;
import org.flowable.engine.HistoryService;
import org.flowable.engine.IdentityService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.history.HistoricTaskInstance;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.mdm.basesetting.machine.MachineService;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.flow.excution.AutoAssignUsersService;
import org.springblade.mdm.flow.vo.TaskAssignVO;
import org.springblade.mdm.program.entity.NcNode;
import org.springblade.mdm.program.entity.NcProgram;
import org.springblade.mdm.program.entity.ProcessProgRef;
import org.springblade.mdm.program.service.NcNodeService;
import org.springblade.mdm.program.service.NcProgramService;
import org.springblade.mdm.program.service.ProcessProgRefService;
import org.springblade.mdm.program.vo.DncSendBackData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 固化流程服务
 */
@Service
@AllArgsConstructor
public class CureFlowService {

	private final RuntimeService runtimeService;

	private final HistoryService historyService;

	private final IdentityService identityService;

	private final NcProgramService ncProgramService;

	private final MachineService machineService;

	private final ProcessProgRefService processProgRefService;
	/**
	 * 固化流程的key
	 */
	private static final String PROCESS_KEY = "program-cure";



	@Transactional
	public void startCure(List<NcProgram> programs) {
		//DncSendBackData sendBackData;
		//List<Long> ncProgramIdList = dataList.stream().map(DncSendBackData::getId).toList();
		//Map<String,List<NcProgram>> groupedProgram = groupProgramsByMachineCode(ncProgramIdList);
		//List<NcProgram> programs = ncProgramService.listByIds(ncProgramIdList);
		//根据分组启动流程，并插入关联表
		programs.forEach(this::startOne);
	}

	/**
	 * 启动一个数控程序的固化流程
	 * @param prog 数控程序实体
	 */
	public void startOne(NcProgram prog){

		Map<String, Object> vars = null;
			//该程序在计划任务时 获取编制，校对，审批的人员，作为默认用户，其中编制时第一个固定的用户
		ProcessProgRef preRef = processProgRefService.lastDispatchDataByNcProgramId(prog.getId());
		if(preRef != null) {
			//获取审批用户
			/*
			List<HistoricTaskInstance> historicTasks = historyService.createHistoricTaskInstanceQuery().includeProcessVariables()
				.processInstanceId(preRef.getProcessInstanceId())
				.orderByHistoricTaskInstanceEndTime().desc()
				.list();*/
			HistoricProcessInstance instance = historyService.createHistoricProcessInstanceQuery()
				.processInstanceId(preRef.getProcessInstanceId()).includeProcessVariables()
				.singleResult();
			if(instance != null) {//使用任务派工流程的变量
				vars = new HashMap<>(instance.getProcessVariables());
			}

		}
		if(vars == null){
			vars = new HashMap<>();
		}
		/*
		String programmer = null;
		String checker = null;
		String senior = null;

		for (HistoricTaskInstance task : historicTasks) {
			// 获取任务的办理人
			if(task.getTaskDefinitionKey().equals("programmingTask")){
				//编制
				programmer = task.getAssignee();
			}else if(task.getTaskDefinitionKey().equals("check")){
				//校对
				checker = task.getAssignee();
			}else if(task.getTaskDefinitionKey().equals("senior")){
				//审核
				senior = task.getAssignee();
			}

		}*/
		//vars.put("programmer",programmer);
		//vars.put("checker",checker);
		//vars.put("senior",senior);

		String businessKey = "0";//业务表key

		identityService.setAuthenticatedUserId(String.valueOf(AuthUtil.getUserId()));//设置流程发起人
		ProcessInstance pinst = runtimeService.startProcessInstanceByKey(PROCESS_KEY,businessKey,vars);

		ProcessProgRef ref = new ProcessProgRef();
		ref.setProcessInstanceId(pinst.getId());
		ref.setNcProgramId(prog.getId());

		processProgRefService.save(ref);
	}

	/**
	 * 将程序按照机器代码分组
	 * @param ncProgramIdList
	 * @return
	 */
	/*
	Map<String,List<NcProgram>> groupProgramsByMachineCode(List<Long> ncProgramIdList){
		List<NcProgram> programs = ncProgramService.listByIds(ncProgramIdList);
		return programs.stream().collect(Collectors.groupingBy(NcProgram::getMachineCode));
	}*/
}