package org.springblade.mdm.flow.controller;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.TaskService;
import org.flowable.engine.runtime.ProcessInstance;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.tool.api.IResultCode;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.Func;
import org.springblade.mdm.flow.constants.FlowContants;
import org.springblade.mdm.flow.constants.FlowVariableContants;
import org.springblade.mdm.flow.entity.TaskDispatch;
import org.springblade.mdm.flow.excution.StartDispatcher;
import org.springblade.mdm.flow.service.FlowProgramFileService;
import org.springblade.mdm.flow.service.TaskDispatchService;
import org.springblade.mdm.flow.service.execute.*;
import org.springblade.mdm.flow.vo.BatchDispatchVO;
import org.springblade.mdm.flow.vo.FlowStartResult;
import org.springblade.mdm.flow.vo.TaskAssignVO;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;

@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/flow/dispatch")
@Tag(name = "派工流程", description = "派工流程")
public class DispatchController {

	private final StartDispatcher dispatcher;

	private final RuntimeService runtimeService;


	private final TryFlowCompleteService tryFlowCompleteService;
	private final DefaultFlowCompleteService defaultFlowCompleteService;
	private final TaskDispatchService taskDispatchService;
	private final BatchDispatchService dispatchService;
	private final ReplaceFlowCompleteService replaceFlowCompleteService;
	private final TempFlowCompleteService tempFlowCompleteService;
	private final CureFlowCompleteService  cureFlowCompleteService;
	/**
	 * 发起派工流程
	 */
	@PostMapping("/start")
	@Operation(summary = "任务计划(派工流程)", description = "启动派工流程")
	public R<Boolean> start(@RequestBody TaskAssignVO startVO) {
		try {
			boolean isDuplicate = taskDispatchService.checkIsDuplicate(startVO);

			TaskDispatch dispatch = taskDispatchService.saveTask(startVO,isDuplicate);
			startVO.setCreateUser(dispatch.getCreateUser());
			if(isDuplicate){
				throw new ServiceException("重复派工");
			}

			try {
				FlowStartResult result = dispatcher.start(startVO);
				dispatch.setStatus(TaskDispatch.STATUS_STARTED);
				dispatch.setProcessInstanceId(result.getProcessInstanceId());
				dispatch.setProgramNo(result.getProgramNo());
				taskDispatchService.updateById(dispatch);
				return R.data(true);
			} catch (Exception e) {
				dispatch.setStatus(TaskDispatch.STATUS_EXCEPTION);
				dispatch.setErrMsg(e.getMessage());
				taskDispatchService.updateById(dispatch);
				return R.fail(new IResultCode() {
					@Override
					public String getMessage() {
						return e.getMessage();
					}

					@Override
					public int getCode() {
						return 201;
					}
				});
			}
		}catch(Exception e){
			return R.fail(new IResultCode() {
				@Override
				public String getMessage() {
					return e.getMessage();
				}

				@Override
				public int getCode() {
					return 201;
				}
			});
		}

	}

	/**
	 * 获取实际审批流程执行服务
	 * @param processInstanceId
	 * @return
	 */
	AbstractFlowCompleteService getActualService(String processInstanceId){
		ProcessInstance inst = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).includeProcessVariables().singleResult();
		if(inst.getProcessDefinitionKey().equals(FlowContants.TRY_PROCESS_KEY)
			|| inst.getProcessDefinitionKey().equals(FlowContants.UNLOCK_PROCESS_KEY)){
			String isTempFlow = Func.toStr(inst.getProcessVariables().get(FlowVariableContants.IS_TEMP_FLOW));
			if(FlowContants.N.equals(isTempFlow)){
				return tryFlowCompleteService;
			}else{
				return tempFlowCompleteService;
			}
		}else if(inst.getProcessDefinitionKey().equals(FlowContants.CURE_PROCESS_KEY)){
			return cureFlowCompleteService;
		}else if(inst.getProcessDefinitionKey().equals(FlowContants.REPLACE_PROCESS_KEY)){
			return replaceFlowCompleteService;
		}else{
			return defaultFlowCompleteService;
		}
	}
	@Operation(summary = "完成任务", description = "流向下一个节点")
	@PostMapping("completeTask")
	public R<Void> completeTask(String taskId, String processInstanceId, String comment,@Parameter(name = "variables", description = "任务变量") @RequestBody Map<String, Object> variables) {
		try {
			AbstractFlowCompleteService completeService = getActualService(processInstanceId);
			completeService.completeTask(taskId, processInstanceId, comment, variables);

			return R.success("流程提交成功");
		}catch(Exception e){
			return R.fail(e.getMessage());
		}


	}

	@Operation(summary = "手动批量派工", description = "组长手动批量派工")
	@PostMapping("batchDispatch")
	public R<Void> batchDispatch(@RequestBody BatchDispatchVO batchDispatchVO) {
		try {
			dispatchService.batchDispatchTask(batchDispatchVO);
			return R.success("流程提交成功");
		}catch(Exception e){
			return R.fail(e.getMessage());
		}

	}

	@Operation(summary = "自动批量派工", description = "组长批量派工，后端自动查找处理人")
	@PostMapping("batchDispatchAuto")
	public R<Void> batchDispatchAuto(@RequestBody BatchDispatchVO batchDispatchVO) {
		try {
			dispatchService.batchAutoDispatchTask(batchDispatchVO);
			return R.success("流程提交成功");
		}catch(Exception e){
			return R.fail(e.getMessage());
		}

	}

	@Operation(summary = "批量审批", description = "高师批量审批")
	@PostMapping("batchApprove")
	public R<Void> batchApprove(@RequestBody BatchDispatchVO batchDispatchVO) {
		try {
			dispatchService.batchApprove(batchDispatchVO);
			return R.success("流程提交成功");
		}catch(Exception e){
			return R.fail(e.getMessage());
		}
	}

	@Operation(summary = "编程员现场编制批量处理", description = "编程员现场编制批量处理")
	@PostMapping("batch-program-on-machine")
	public R<Void> batchProgramOnMachine(@RequestBody BatchDispatchVO batchDispatchVO) {
		try {
			dispatchService.batchProgramOnMachine(batchDispatchVO);
			return R.success("流程提交成功");
		}catch(Exception e){
			return R.fail(e.getMessage());
		}

	}

}