package org.springblade.mdm.flow.service;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.mp.base.BizServiceImpl;
import org.springblade.mdm.commons.service.ParamService;
import org.springblade.mdm.flow.entity.TaskDispatch;
import org.springblade.mdm.flow.mapper.TaskDispatchMapper;
import org.springblade.mdm.flow.vo.TaskAssignVO;
import org.springblade.mdm.program.entity.DrawingNos;
import org.springblade.mdm.program.entity.NcNode;
import org.springblade.mdm.program.entity.NcNodeHis;
import org.springblade.mdm.program.mapper.DrawingNosMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

/**
 * 任务派工数据 处理服务
 *
 * @author yangys
 */
@Slf4j
@Service
public class TaskDispatchService  extends BizServiceImpl<TaskDispatchMapper, TaskDispatch> {
	@Autowired
	private ParamService paramService;
	@Autowired
	private DrawingNosMapper drawingNosMapper;


	@Transactional(rollbackFor = Exception.class)
	public TaskDispatch saveTask(TaskAssignVO startVO,boolean isDup) {
		TaskDispatch taskDispatch = new TaskDispatch();
		BeanUtils.copyProperties(startVO, taskDispatch);
		if(isDup){
			taskDispatch.setStatus(TaskDispatch.STATUS_DUP);
		}
		this.save(taskDispatch);

		addDrawingNos(taskDispatch.getDrawingNo());
		return taskDispatch;
	}

	/**
	 * 加u人下拉数据
	 * @param drawingNo
	 */
	public void addDrawingNos(String drawingNo){
		DrawingNos data = drawingNosMapper.selectById(drawingNo);
		if(data == null){
			data = new DrawingNos();
			data.setDrawingNo(drawingNo);
			try {
				drawingNosMapper.insert(data);
			}catch (Exception e){
				log.error("加入零组件号下拉数据错误");
			}
		}
	}
	/*
	public void updateSuccess(long id, String instId) {
		TaskDispatch taskDispatch = getById(id);
		taskDispatch.setProcessInstanceId(instId);
		taskDispatch.setStatus(TaskDispatch.STATUS_STARTED);
		this.updateById(taskDispatch);
	}

	 */


	/**
	 * 检查是否重复派工
	 * @param startVO
	 * @return
	 */
	public boolean checkIsDuplicate(TaskAssignVO startVO) {
		if(startVO.isTemporaryFlow()){
			//试切补充，不验证重复
			return false;
		}

		int taskDupDays = paramService.taskDuplicateCheckDays();
		LocalDateTime checkStartDate = LocalDateTime.now().minusDays(taskDupDays);
		LambdaQueryChainWrapper<TaskDispatch> q = lambdaQuery().eq(TaskDispatch::getDrawingNo,startVO.getDrawingNo())
			.eq(TaskDispatch::getProcessNo,startVO.getProcessNo())
			//.eq(TaskDispatch::getProcessEdition,startVO.getProcessEdition())
			.eq(TaskDispatch::getMachineCode,startVO.getMachineCode())
			.gt(TaskDispatch::getCreateTime,checkStartDate);

		long cnt = q.count();

		return cnt > 0;
	}
	@Transactional(readOnly = true)
	public List<String> drawingNoSeletDropList(String drawingNo){
		return drawingNosMapper.selectDropDownList(drawingNo);
	}

	@Transactional
	public void resetDrawingNos() {
		drawingNosMapper.delete(Wrappers.emptyWrapper());//
		List<String> dnoList =  baseMapper.distinctAllDrawingNo();
		for(String dno : dnoList){
			DrawingNos drawingNos = new DrawingNos();
			drawingNos.setDrawingNo(dno);
			drawingNosMapper.insert(drawingNos);
		}

	}

	/**
	 * 清理过期的异常任务计划
	 */
	@Transactional
    public void cleanExpiredExceptionTask() {
		int expireDays = paramService.getTaskExpireDays();
		LocalDateTime expiredTime = LocalDateTime.now().minusDays(expireDays);
		baseMapper.deleteExpiredExceptionTasks(expiredTime);
    }

	/**
	 * 根据工序唯一码获取派工数据
	 * @param operationId 工序唯一码
	 * @return
	 */
	public TaskDispatch getByOperationId(String operationId) {
		Optional<TaskDispatch> opt = lambdaQuery().eq(TaskDispatch::getOperationId, operationId).oneOpt();
		return opt.orElse(null);
	}

	/**
	 * 根据程序内部编号获取实体
	 * @param programNo 内部编号
	 * @return 实体
	 */
    public TaskDispatch getByProgramNo(String programNo) {
		return lambdaQuery().eq(TaskDispatch::getProgramNo, programNo).one();
    }


	/**
	 * 查询偏离单的序号
	 * @param programNo 偏离单的程序包名节点
	 * @return 序号
	 */
	public long getDeviationSerial(String programNo) {
		TaskDispatch dispatch = this.getByProgramNo(programNo);

		return lambdaQuery()
			.eq(TaskDispatch::getDrawingNo,dispatch.getDrawingNo())
			.eq(TaskDispatch::getProcessNo,dispatch.getProcessNo())
			.eq(TaskDispatch::getProcessEdition,dispatch.getProcessEdition())
			.eq(TaskDispatch::getDeviation,dispatch.getDeviation())
			.le(TaskDispatch::getCreateTime,dispatch.getCreateTime())  //时间小于等于当前节点
			.count();
	}
}