package org.springblade.mdm.flow.excution.dispatch;

import lombok.extern.slf4j.Slf4j;
import org.springblade.core.tool.utils.Func;
import org.springblade.mdm.flow.constants.FlowContants;
import org.springblade.mdm.flow.entity.ApproveRecord;
import org.springblade.mdm.flow.entity.FlowProgramFile;
import org.springblade.mdm.flow.service.ApproveRecordService;
import org.springblade.mdm.flow.service.FlowProgramFileService;
import org.springblade.mdm.flow.service.FlowProgramProperties;
import org.springblade.mdm.program.entity.NcNode;
import org.springblade.mdm.program.entity.NcProgramApproved;
import org.springblade.mdm.program.service.NcNodeAutoCreateService;
import org.springblade.mdm.program.service.NcNodeService;
import org.springblade.mdm.program.service.NcProgramApprovedService;
import org.springblade.mdm.utils.EntityUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 普通派工完成数据处理器，功能：插入审批表数据，DispatchFinishListener调用
 */
@Slf4j
@Component("normalDispatchFinishDataHandler")
public class NormalFinishDataHandler implements FinishDataHandler{
	@Autowired
	private NcProgramApprovedService approvedService;
	@Autowired
	private ApproveRecordService approveRecordService;
	@Autowired
	private FlowProgramFileService flowProgramFileService;
	@Autowired
	private NcNodeService ncNodeService;
	@Autowired
	private NcNodeAutoCreateService ncNodeAutoCreateService;
	/**
	 * DispatchFinishListener中调用
	 * @param props 执行对象
	 */
	public void handleData(FlowProgramProperties props) {
		// 执行业务逻辑
		String instId = props.getProcessInstanceId();

		String programPkgName = NcNodeService.genProgramName(props.getDrawingNo(),props.getProcessNo());
		//NcNode packageNode =createProgramNodes(props);
		NcNode packageNode;// = ncNodeAutoCreateService.createNodeTreeWithProgram(props);
		if(FlowContants.Y.equals(props.getHasCuredProgram()) && FlowContants.Y.equals(props.getCureProgramUseable())){
			//有固化，且程序可用
			packageNode = ncNodeService.getById(props.getCuredNodeId());

		}else{
			packageNode = ncNodeAutoCreateService.createNodeTreeWithProgram(props);
		}

		if(FlowContants.Y.equals(props.getHasCuredProgram()) && FlowContants.N.equals(props.getCureProgramUseable())){
			//有固化 但不可用，试切节点的新节点 版本号为 固化版本号+1
			NcNode curedPackageNode = ncNodeService.getById(props.getCuredNodeId());
			packageNode.setVersionNumber(curedPackageNode.genNewVersionNumber());
			ncNodeService.updateById(packageNode);
		}
		//NcNode packageNode;
		/*
		if(FlowContants.Y.equals(props.getHasCuredProgram())){
			//有固化，且程序可用，从固化树查询节点.使用流程中保存的节点
			if(FlowContants.Y.equals(props.getCureProgramUseable())) {
				packageNode = ncNodeService.getById(props.getCuredNodeId());
			}else{
				//不可用，去试切找最新节点
				//packageNode = ncNodeService.getLastEditionCuredProgramPackage(programPkgName,props.getProcessEdition());
				packageNode = ncNodeService.getLastEditionTryingProgramPackage(programPkgName,props.getProcessEdition());
				//不可用的固化程序锁定
				packageNode.lock();
				ncNodeService.updateById(packageNode);
			}
		}else if(Func.isNotBlank(props.getDeviation())){
			//有偏离单
			packageNode = ncNodeService.getLastEditionDeviationProgramPackage(programPkgName,props.getProcessEdition());
		}else{
			//普通试切
			packageNode = ncNodeService.getLastEditionTryingProgramPackage(programPkgName,props.getProcessEdition());
		}
		*/
		addApproveTable(packageNode,props);
		updateApproveRecordNodeId(instId, packageNode.getId());
		log.info("普通流程已完成in DispatchFinishListener");
	}

	/**
	 * 自动创建程序节点
	 * @param progProperties 流程属性
	 */
	NcNode createProgramNodes(FlowProgramProperties progProperties){
		NcNode programPkgNode = null;
		if(FlowContants.N.equals(progProperties.getHasCuredProgram())) {
			//无固化:(试切或者偏离)
			programPkgNode = ncNodeAutoCreateService.createNodeTreeWithProgram(progProperties);
		}else{
			if(FlowContants.N.equals(progProperties.getCureProgramUseable())) {
				programPkgNode = ncNodeAutoCreateService.createNodeTreeWithProgram(progProperties);//暂时与上面使用相同代码，createNodeTreeWithProgram中区分了普通试切和不可用的情况
			}
			//有固化，程序不可用,应该去试切建立节点
			/*
			if(FlowContants.N.equals(progProperties.getCureProgramUseable())) {
				//固化程序不可用，需要重新建立程序包名和文件节点;可用情况在流程审批中已经升级过节点了
				NcNode curedProgramPackage = ncNodeService.getById(progProperties.getCuredNodeId());

				NcNode newCuredPkgNode = new NcNode();
				BeanUtils.copyProperties(curedProgramPackage, newCuredPkgNode);
				EntityUtil.clearBaseProperties(newCuredPkgNode);
				newCuredPkgNode.setIsLastEdition(1);
				newCuredPkgNode.setIsLocked(0);
				newCuredPkgNode.upgradeVersionNumber();
				ncNodeService.save(newCuredPkgNode);

				//新的流程对应的文件更新到新节点下
				List<FlowProgramFile> newFlowFileList = flowProgramFileService.listByProcessInstanceId(progProperties.getProcessInstanceId());
				for (FlowProgramFile newFlowFile : newFlowFileList) {
					NcNode newProgramNode = new NcNode();
					BeanUtils.copyProperties(newCuredPkgNode, newProgramNode);
					EntityUtil.clearBaseProperties(newProgramNode);

					newProgramNode.setName(newFlowFile.getName());
					newProgramNode.setNodeType(NcNode.TYPE_PROGRAM_FILE);
					newProgramNode.setParentId(newCuredPkgNode.getId());
					newProgramNode.setIsLastEdition(1);
					newProgramNode.setIsLocked(0);
					newProgramNode.setParentIds(newCuredPkgNode.getParentIds() + "," + newCuredPkgNode.getId());
					newProgramNode.setFlowProgramFileId(newFlowFile.getId());
					ncNodeService.save(newProgramNode);
				}

				//原节点更新为老版本，锁定
				curedProgramPackage.setIsLastEdition(0);
				curedProgramPackage.setIsLocked(1);
				ncNodeService.updateById(curedProgramPackage);
			}*/
		}

		return programPkgNode;
	}

	/**
	 * 保存审批完成的记录
	 * @param packageNode
	 * @param props
	 */
	void addApproveTable(NcNode packageNode,FlowProgramProperties props){
		NcProgramApproved approved = new NcProgramApproved();

		approved.setProgramName(packageNode.getName());
		approved.setNcNodeId(packageNode.getId());//程序包节点id
		approved.setTitle(props.getTitle());
		approved.setProgrammerId(props.getProgrammerId());
		approvedService.save(approved);

	}


	void updateApproveRecordNodeId(String processInstanceId,Long nodeId){
		//更新审批记录的ncNodeId
		approveRecordService.lambdaUpdate()
			.eq(ApproveRecord::getProcessInstanceId, processInstanceId)
			.set(ApproveRecord::getNcNodeId,nodeId).update();
	}
}