package com.chinaztt.mes.production.state.operationtask;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.chinaztt.mes.common.handler.StateMachineHandler;
import com.chinaztt.mes.common.util.StateResult;
import com.chinaztt.mes.plan.entity.ManufacturingOrder;
import com.chinaztt.mes.plan.mapper.ManufacturingOrderMapper;
import com.chinaztt.mes.plan.state.manufacturing.ManufacturingOrderStateMachineConfig;
import com.chinaztt.mes.plan.state.manufacturing.constant.ManufacturingOrderEvents;
import com.chinaztt.mes.plan.state.manufacturing.constant.ManufacturingOrderStateStringValues;
import com.chinaztt.mes.plan.state.manufacturing.constant.ManufacturingOrderStates;
import com.chinaztt.mes.production.entity.OperationTask;
import com.chinaztt.mes.production.entity.OperationTaskSupply;
import com.chinaztt.mes.production.mapper.OperationTaskMapper;
import com.chinaztt.mes.production.mapper.OperationTaskSupplyMapper;
import com.chinaztt.mes.production.service.OperationTaskService;
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskEvents;
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskStateStringValues;
import lombok.AllArgsConstructor;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.annotation.OnTransition;
import org.springframework.statemachine.annotation.WithStateMachine;
import org.springframework.statemachine.config.StateMachineFactory;
import org.springframework.statemachine.persist.StateMachinePersister;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;


/**
 * @Author: zhangxy
 * @Date: 2020-08-24 9:51
 */
@AllArgsConstructor
@Component
@WithStateMachine(id = "operationTaskStateMachine")
public class OperationTaskStateListener {

	private OperationTaskMapper operationTaskMapper;
	private OperationTaskService operationTaskService;
	private ManufacturingOrderMapper manufacturingOrderMapper;
	private OperationTaskSupplyMapper operationTaskSupplyMapper;
	private StateMachineFactory<ManufacturingOrderStates, ManufacturingOrderEvents> manufacturingOrderStateMachineFactory;
	private StateMachinePersister<ManufacturingOrderStates, ManufacturingOrderEvents, ManufacturingOrder> persister;



	/**
	 * 开始
	 */
	@OnTransition(target = OperationTaskStateStringValues.INPROGRESS)
	public boolean start(StateMachine stateMachine, Message<OperationTaskEvents> msg) {
		OperationTask operationTask = (OperationTask) msg.getHeaders().get("operationTask");
		if (!(OperationTaskStateStringValues.PENDING.equals(operationTask.getState()) || OperationTaskStateStringValues.INTERRUPTED.equals(operationTask.getState()) || OperationTaskStateStringValues.COMPLETED.equals(operationTask.getState()))) {
			stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "只有等待和暂停状态的才能开始");
			return false;
		}
		if (operationTask.getActualStartDate() == null) {
			operationTask.setActualStartDate(LocalDateTime.now());
		}
		if (OperationTaskStateStringValues.COMPLETED.equals(operationTask.getState())) {
			operationTaskMapper.removeActualFinishDateById(operationTask.getId());
		}
		operationTask.setState(OperationTaskStateStringValues.INPROGRESS);
		operationTaskMapper.updateById(operationTask);
		return true;
	}

	/**
	 * 暂停
	 */
	@OnTransition(target = OperationTaskStateStringValues.INTERRUPTED)
	public boolean interrupt(StateMachine stateMachine, Message<OperationTaskEvents> msg) {
		OperationTask operationTask = (OperationTask) msg.getHeaders().get("operationTask");
		if (!OperationTaskStateStringValues.INPROGRESS.equals(operationTask.getState())) {
			stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "只有进行状态的才能暂停");
			return false;
		}

		operationTask.setState(OperationTaskStateStringValues.INTERRUPTED);
		operationTaskMapper.updateById(operationTask);
		return true;
	}

	/**
	 * 完成
	 */
	@OnTransition(target = OperationTaskStateStringValues.COMPLETED)
	public boolean complete(StateMachine stateMachine, Message<OperationTaskEvents> msg) {
		OperationTask operationTask = (OperationTask) msg.getHeaders().get("operationTask");
		if (!OperationTaskStateStringValues.INPROGRESS.equals(operationTask.getState())) {
			stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "只有进行状态的才能完成");
			return false;
		}
		// 合并订单完成，将原有工单状态改为已完成
		if (operationTask.getCombineState().equals(OperationTask.COMBINE_STATE_MAIN)) {
			List<OperationTask> list = operationTaskService.list(Wrappers.<OperationTask>lambdaQuery().eq(OperationTask::getCombineTaskId, operationTask.getId()));
			for (OperationTask task : list) {
				task.setCompletedQuantity(operationTask.getCompletedQuantity().divide(operationTask.getPlannedQuantity(), 4, BigDecimal.ROUND_HALF_UP).multiply(task.getPlannedQuantity()));
				task.setActualFinishDate(LocalDateTime.now());
				task.setState(OperationTaskStateStringValues.COMPLETED);
			}
			operationTaskService.updateBatchById(list);
		}
		operationTask.setActualFinishDate(LocalDateTime.now());
		operationTask.setState(OperationTaskStateStringValues.COMPLETED);
		operationTaskMapper.updateById(operationTask);
		//如果所有工单都完成，则车间订单完成。调用车间订单状态机（完成状态）
/*		List<String> operationTaskList = operationTaskMapper.getAllTaskStateByTaskId(operationTask.getId());
		boolean match = operationTaskList.stream().allMatch(a -> a.equals(OperationTaskStateStringValues.COMPLETED));
		if(match){
			List<OperationTaskSupply> operationTaskSupplyList = operationTaskSupplyMapper.selectList(Wrappers.<OperationTaskSupply>lambdaQuery()
					.eq(OperationTaskSupply::getOperationTaskId, operationTask.getId()));
			ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(operationTaskSupplyList.get(0).getMoId());
			if(!ManufacturingOrderStateStringValues.COMPLETED.equals(manufacturingOrder.getState())) {
				Message<ManufacturingOrderEvents> message = MessageBuilder.withPayload(ManufacturingOrderEvents.valueOf("COMPLETE")).setHeader("manufacturingOrder", manufacturingOrder).build();
				StateMachineHandler handler = new StateMachineHandler(manufacturingOrderStateMachineFactory, persister, ManufacturingOrderStateMachineConfig.MACHINE_ID, manufacturingOrder);
				StateResult res = handler.sendEvent(message, manufacturingOrder.getId());
				if (!res.isSuccess()) {
					throw new RuntimeException(res.getMsg());
				}
			}
		}*/
		return true;
	}

	/**
	 * 取消
	 */
	@OnTransition(target = OperationTaskStateStringValues.CANCELED)
	public boolean cancel(StateMachine stateMachine, Message<OperationTaskEvents> msg) {
		OperationTask operationTask = (OperationTask) msg.getHeaders().get("operationTask");
		if (!(OperationTaskStateStringValues.INPROGRESS.equals(operationTask.getState()) ||
				OperationTaskStateStringValues.PENDING.equals(operationTask.getState()) ||
				OperationTaskStateStringValues.INTERRUPTED.equals(operationTask.getState()))) {
			stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "只有等待、进行和暂停状态的才能取消");
			return false;
		}
		operationTask.setActualFinishDate(LocalDateTime.now());
		operationTask.setState(OperationTaskStateStringValues.CANCELED);
		operationTaskMapper.updateById(operationTask);
		return true;
	}
}