package com.zy.core.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.NotifyMsgType;
import com.zy.asrs.domain.param.CreateLocMoveTaskParam;
import com.zy.asrs.entity.BasDualCrnp;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasDualCrnpService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.Task;
import com.zy.core.model.command.DualCrnCommand;
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.param.SendDualCrnCommandParam;
import com.zy.core.model.protocol.DualCrnProtocol;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.thread.DualCrnThread;
import com.zy.core.thread.StationThread;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
public class DualCrnOperateProcessUtils {

    @Value("${mainProcessPlugin}")
    private String mainProcessPlugin;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private BasDualCrnpService basDualCrnpService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private WmsOperateUtils wmsOperateUtils;
    @Autowired
    private CommonService commonService;
    @Autowired
    private NotifyUtils notifyUtils;

    //入出库  ===>>  双工位堆垛机入出库作业下发
    public synchronized void dualCrnIoExecute() {
        List<BasDualCrnp> basDualCrnps = basDualCrnpService.selectList(new EntityWrapper<>());
        for (BasDualCrnp basDualCrnp : basDualCrnps) {
            DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
            if(dualCrnThread == null){
                continue;
            }

            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            if(dualCrnProtocol == null){
                continue;
            }

            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .eq("dual_crn_no", basDualCrnp.getCrnNo())
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts)
            );
            if(wrkMasts.size() >= 2){
                continue;
            }

            if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
                continue;
            }

            if(dualCrnProtocol.getAlarm() != 0) {
                continue;
            }

            this.crnExecute(basDualCrnp, dualCrnThread);
        }
    }

    private synchronized void crnExecute(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread) {
        DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
        if(dualCrnProtocol == null){
            return;
        }

        if (!(dualCrnProtocol.getStatusType().equals(DualCrnStatusType.IDLE) && dualCrnProtocol.getStatusTypeTwo().equals(DualCrnStatusType.IDLE))) {
            return;
        }

        // 如果最近一次是出库模式
        if (dualCrnProtocol.getLastIo().equals("O")) {
            processLoveMove(basDualCrnp, dualCrnThread);
            processIn(basDualCrnp, dualCrnThread);
            processOut(basDualCrnp, dualCrnThread);
        }
        // 如果最近一次是入库模式
        else if (dualCrnProtocol.getLastIo().equals("I")) {
            processLoveMove(basDualCrnp, dualCrnThread);
            processOut(basDualCrnp, dualCrnThread);
            processIn(basDualCrnp, dualCrnThread);
        }
    }

    private void processIn(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread) {
        List<WrkMast> inTaskList = getInTaskList(basDualCrnp);
        if (inTaskList.isEmpty()) {
            return;
        }

        WrkMast stationOneWrkMast = inTaskList.get(0);
        WrkMast stationTwoWrkMast = null;

        if (inTaskList.size() >= 2) {
            stationTwoWrkMast = inTaskList.get(1);
        }

        SendDualCrnCommandParam oneResult = null;
        SendDualCrnCommandParam twoResult = null;

        if(stationOneWrkMast != null){
            oneResult = crnExecuteIn(basDualCrnp, dualCrnThread, stationOneWrkMast);
        }

        if(stationTwoWrkMast != null){
            twoResult = crnExecuteIn(basDualCrnp, dualCrnThread, stationTwoWrkMast);
        }

        List<SendDualCrnCommandParam> list = new ArrayList<>();
        if (oneResult != null) {
            list.add(oneResult);
        }

        if (twoResult != null) {
            list.add(twoResult);
        }

        if (!list.isEmpty()) {
            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            Integer crnNo = basDualCrnp.getCrnNo();
            MessageQueue.offer(SlaveType.DualCrn, crnNo, new Task(2, list));
            News.info("双工位堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(list));
            dualCrnProtocol.setLastIo("I");
        }
    }

    private void processOut(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread) {
        List<WrkMast> outTaskList = getOutTaskList(basDualCrnp);
        if (outTaskList.isEmpty()) {
            return;
        }

        WrkMast stationOneWrkMast = null;
        WrkMast stationTwoWrkMast = null;

        List<Integer> disableList = basDualCrnp.getDisableStationOneBays$();

        for (WrkMast wrkMast : outTaskList) {
            if (stationOneWrkMast == null) {
                if (!disableList.contains(Utils.getBay(wrkMast.getSourceLocNo()))) {
                    stationOneWrkMast = wrkMast;
                    continue;
                }
            }

            if (stationTwoWrkMast == null) {
                if (!disableList.contains(Utils.getBay(wrkMast.getSourceLocNo()))) {
                    stationTwoWrkMast = wrkMast;
                    continue;
                }
            }
        }

        SendDualCrnCommandParam oneResult = null;
        SendDualCrnCommandParam twoResult = null;

        if(stationOneWrkMast != null){
            oneResult = crnExecuteOut(basDualCrnp, dualCrnThread, stationOneWrkMast, 1);
        }

        if(stationTwoWrkMast != null){
            twoResult = crnExecuteOut(basDualCrnp, dualCrnThread, stationTwoWrkMast, 2);
        }

        List<SendDualCrnCommandParam> list = new ArrayList<>();
        if (oneResult != null) {
            list.add(oneResult);
        }

        if (twoResult != null) {
            list.add(twoResult);
        }

        if (!list.isEmpty()) {
            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            Integer crnNo = basDualCrnp.getCrnNo();
            MessageQueue.offer(SlaveType.DualCrn, crnNo, new Task(2, list));
            News.info("双工位堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(list));
            dualCrnProtocol.setLastIo("O");
        }
    }

    private void processLoveMove(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread) {
        List<WrkMast> locMoveTaskList = getLocMoveTaskList(basDualCrnp);
        if (locMoveTaskList.isEmpty()) {
            return;
        }

        WrkMast stationOneWrkMast = null;
        WrkMast stationTwoWrkMast = null;

        List<Integer> disableList = basDualCrnp.getDisableStationOneBays$();

        for (WrkMast wrkMast : locMoveTaskList) {
            if (stationOneWrkMast == null) {
                if (!disableList.contains(Utils.getBay(wrkMast.getSourceLocNo()))) {
                    stationOneWrkMast = wrkMast;
                    continue;
                }
            }

            if (stationTwoWrkMast == null) {
                if (!disableList.contains(Utils.getBay(wrkMast.getSourceLocNo()))) {
                    stationTwoWrkMast = wrkMast;
                    continue;
                }
            }
        }

        SendDualCrnCommandParam oneResult = null;
        SendDualCrnCommandParam twoResult = null;

        if(stationOneWrkMast != null){
            oneResult = crnExecuteLocMove(basDualCrnp, dualCrnThread, stationOneWrkMast, 1);
        }

        if(stationTwoWrkMast != null){
            twoResult = crnExecuteLocMove(basDualCrnp, dualCrnThread, stationTwoWrkMast, 2);
        }

        List<SendDualCrnCommandParam> list = new ArrayList<>();
        if (oneResult != null) {
            list.add(oneResult);
        }

        if (twoResult != null) {
            list.add(twoResult);
        }

        if (!list.isEmpty()) {
            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            Integer crnNo = basDualCrnp.getCrnNo();
            MessageQueue.offer(SlaveType.DualCrn, crnNo, new Task(2, list));
            News.info("双工位堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(list));
            dualCrnProtocol.setLastIo("O");
        }
    }

    private List<WrkMast> getInTaskList(BasDualCrnp basDualCrnp) {
        List<WrkMast> list = new ArrayList<>();
        if(!basDualCrnp.getInEnable().equals("Y")){
            News.info("双工位堆垛机:{} 可入信号不满足", basDualCrnp.getCrnNo());
            return list;
        }

        List<Integer> taskList = new ArrayList<>();
        List<StationObjModel> inStationList = basDualCrnp.getInStationList$();
        for (StationObjModel stationObjModel : inStationList) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
            if (stationThread == null) {
                continue;
            }

            Map<Integer, StationProtocol> map = stationThread.getStatusMap();
            StationProtocol stationProtocol = map.get(stationObjModel.getStationId());
            if (stationProtocol == null) {
                continue;
            }

            if (stationProtocol.isAutoing()
                    && stationProtocol.isLoading()
                    && stationProtocol.getTaskNo() > 0
            ) {
                taskList.add(stationProtocol.getTaskNo());
            }
        }

        // 获取任务
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .eq("dual_crn_no", basDualCrnp.getCrnNo())
                .in("wrk_no", taskList)
        );
        for (WrkMast wrkMast : wrkMasts) {
            if(wrkMast.getWrkSts() != WrkStsType.INBOUND_DEVICE_RUN.sts){
                continue;
            }
            list.add(wrkMast);
        }
        return list;
    }

    private List<WrkMast> getOutTaskList(BasDualCrnp basDualCrnp) {
        List<WrkMast> list = new ArrayList<>();
        if(!basDualCrnp.getOutEnable().equals("Y")){
            News.info("双工位堆垛机:{} 可出信号不满足", basDualCrnp.getCrnNo());
            return list;
        }

        List<StationObjModel> outStationList = basDualCrnp.getOutStationList$();
        if(outStationList.isEmpty()){
            News.info("双工位堆垛机:{} 出库站点未设置", basDualCrnp.getCrnNo());
            return list;
        }

        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .eq("dual_crn_no", basDualCrnp.getCrnNo())
                .eq("wrk_sts", WrkStsType.NEW_OUTBOUND.sts)
        );
        list.addAll(wrkMasts);
        return list;
    }

    private List<WrkMast> getLocMoveTaskList(BasDualCrnp basDualCrnp) {
        List<WrkMast> list = new ArrayList<>();
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .eq("dual_crn_no", basDualCrnp.getCrnNo())
                .eq("wrk_sts", WrkStsType.NEW_LOC_MOVE.sts)
        );
        list.addAll(wrkMasts);
        return list;
    }

    private synchronized SendDualCrnCommandParam crnExecuteIn(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread, WrkMast wrkMast) {
        DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
        if (dualCrnProtocol == null) {
            return null;
        }

        if (!basDualCrnp.getInEnable().equals("Y")) {
            News.info("双工位堆垛机:{} 可入信号不满足", basDualCrnp.getCrnNo());
            return null;
        }

        List<StationObjModel> inStationList = basDualCrnp.getInStationList$();
        if(inStationList.isEmpty()){
            News.info("双工位堆垛机:{} 入库站点未设置", basDualCrnp.getCrnNo());
            return null;
        }

        Integer crnNo = basDualCrnp.getCrnNo();

        if (wrkMast.getWrkSts() != WrkStsType.INBOUND_DEVICE_RUN.sts) {
            return null;
        }

        // 获取库位信息
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        if (locMast == null) {
            News.taskInfo(wrkMast.getWrkNo(), "目标库位:{} 信息不存在", wrkMast.getLocNo());
            return null;
        }

        if (!locMast.getLocSts().equals("S")) {
            News.taskInfo(wrkMast.getWrkNo(), "目标库位:{} 状态异常", wrkMast.getLocNo());
            return null;
        }

        //检测浅库位状态
        boolean checkStatus = checkShallowLocStatus(locMast.getLocNo(), wrkMast.getWrkNo());
        if (!checkStatus) {
            News.taskInfo(wrkMast.getWrkNo(), "因浅库位堵塞无法执行");
            return null;
        }

        StationObjModel inStationObjModel = null;
        for (StationObjModel stationObjModel : inStationList) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
            if (stationThread == null) {
                continue;
            }

            Map<Integer, StationProtocol> stationProtocolMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = stationProtocolMap.get(stationObjModel.getStationId());
            if (stationProtocol == null) {
                continue;
            }

            if (!stationProtocol.isAutoing()) {
                continue;
            }

            if (!stationProtocol.isLoading()) {
                continue;
            }

            if (stationProtocol.getTaskNo() <= 0) {
                continue;
            }

            if (!stationProtocol.isInEnable()) {
                News.taskInfo(stationProtocol.getTaskNo(), "取货站点:{} 没有可入信号", stationObjModel.getStationId());
                continue;
            }

            if (stationProtocol.getTaskNo().equals(wrkMast.getWrkNo())) {
                inStationObjModel = stationObjModel;
                break;
            }
        }

        if (inStationObjModel == null) {
            News.taskInfo(wrkMast.getWrkNo(), "未搜索到取货站点");
            return null;
        }

        Integer station = inStationObjModel.getDualCrnExecuteStation();
        if (station == 1) {
            List<Integer> basList = basDualCrnp.getDisableStationOneBays$();
            if (basList.contains(Utils.getBay(wrkMast.getLocNo()))) {
                //禁止放货列，申请重新分配
                reassignTaskLocNo(wrkMast, inStationObjModel);
                return null;
            }
        }else {
            List<Integer> basList = basDualCrnp.getDisableStationTwoBays$();
            if (basList.contains(Utils.getBay(wrkMast.getLocNo()))) {
                //禁止放货列，申请重新分配
                reassignTaskLocNo(wrkMast, inStationObjModel);
                return null;
            }
        }

        String sourceLocNo = Utils.getLocNo(inStationObjModel.getDeviceRow(), inStationObjModel.getDeviceBay(), inStationObjModel.getDeviceLev());

        List<DualCrnCommand> commandList = new ArrayList<>();
        DualCrnCommand pickCommand = dualCrnThread.getPickCommand(sourceLocNo, wrkMast.getWrkNo(), crnNo, station);
        DualCrnCommand putCommand = dualCrnThread.getPutCommand(wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo, station);
        commandList.add(pickCommand);
        commandList.add(putCommand);

        wrkMast.setWrkSts(WrkStsType.INBOUND_RUN.sts);
        wrkMast.setDualCrnNo(crnNo);
        wrkMast.setSystemMsg("");
        wrkMast.setIoTime(new Date());
        if (wrkMastService.updateById(wrkMast)) {
            SendDualCrnCommandParam sendDualCrnCommandParam = new SendDualCrnCommandParam();
            sendDualCrnCommandParam.setCrnNo(crnNo);
            sendDualCrnCommandParam.setStation(station);
            sendDualCrnCommandParam.setCommands(commandList);
            sendDualCrnCommandParam.setCommandIdx(0);

            notifyUtils.notify(String.valueOf(SlaveType.DualCrn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.DUAL_CRN_IN_TASK_RUN, null);
            return sendDualCrnCommandParam;
        }
        return null;
    }

    private synchronized SendDualCrnCommandParam crnExecuteOut(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread, WrkMast wrkMast, int station) {
        DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
        if (dualCrnProtocol == null) {
            return null;
        }

        if (!basDualCrnp.getOutEnable().equals("Y")) {
            News.info("双工位堆垛机:{} 可出信号不满足", basDualCrnp.getCrnNo());
            return null;
        }

        List<StationObjModel> outStationList = basDualCrnp.getOutStationList$();
        if (outStationList.isEmpty()) {
            News.info("双工位堆垛机:{} 出库站点未设置", basDualCrnp.getCrnNo());
            return null;
        }

        Integer crnNo = basDualCrnp.getCrnNo();

        for (StationObjModel stationObjModel : outStationList) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
            if (stationThread == null) {
                continue;
            }

            if (stationObjModel.getDualCrnExecuteStation() != station) {
                continue;
            }

            Map<Integer, StationProtocol> stationProtocolMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = stationProtocolMap.get(stationObjModel.getStationId());
            if (stationProtocol == null) {
                continue;
            }

            if (!stationProtocol.isAutoing()) {
                continue;
            }

            if (stationProtocol.isLoading()) {
                continue;
            }

            if (stationProtocol.getTaskNo() != 0) {
                continue;
            }

            if (!stationProtocol.isOutEnable()) {
                News.info("放货站点:{} 没有可出信号", stationObjModel.getStationId());
                continue;
            }

            // 获取库位信息
            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
            if (locMast == null) {
                News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 信息不存在", wrkMast.getSourceLocNo());
                continue;
            }

            if (!locMast.getLocSts().equals("R")) {
                News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 状态异常", wrkMast.getSourceLocNo());
                continue;
            }

            //检测浅库位状态
            boolean checkStatus = checkShallowLocStatus(locMast.getLocNo(), wrkMast.getWrkNo());
            if (!checkStatus) {
                News.taskInfo(wrkMast.getWrkNo(), "因浅库位堵塞无法执行");
                continue;
            }

            String targetLocNo = Utils.getLocNo(stationObjModel.getDeviceRow(), stationObjModel.getDeviceBay(), stationObjModel.getDeviceLev());

            List<DualCrnCommand> commandList = new ArrayList<>();
            DualCrnCommand pickCommand = dualCrnThread.getPickCommand(wrkMast.getSourceLocNo(), wrkMast.getWrkNo(), crnNo, station);
            DualCrnCommand putCommand = dualCrnThread.getPutCommand(targetLocNo, wrkMast.getWrkNo(), crnNo, station);
            commandList.add(pickCommand);
            commandList.add(putCommand);

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_RUN.sts);
            wrkMast.setDualCrnNo(crnNo);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                redisUtil.set(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(stationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);

                SendDualCrnCommandParam sendDualCrnCommandParam = new SendDualCrnCommandParam();
                sendDualCrnCommandParam.setCrnNo(crnNo);
                sendDualCrnCommandParam.setStation(station);
                sendDualCrnCommandParam.setCommands(commandList);
                sendDualCrnCommandParam.setCommandIdx(0);

                notifyUtils.notify(String.valueOf(SlaveType.DualCrn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.DUAL_CRN_OUT_TASK_RUN, null);
                return sendDualCrnCommandParam;
            }
        }
        return null;
    }

    private synchronized SendDualCrnCommandParam crnExecuteLocMove(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread, WrkMast wrkMast, int station) {
        DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
        if (dualCrnProtocol == null) {
            return null;
        }

        Integer crnNo = basDualCrnp.getCrnNo();

        // 获取源库位信息
        LocMast sourceLocMast = locMastService.selectById(wrkMast.getSourceLocNo());
        if (sourceLocMast == null) {
            News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 信息不存在", wrkMast.getSourceLocNo());
            return null;
        }

        if (!sourceLocMast.getLocSts().equals("R")) {
            News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 状态异常，不属于出库预约状态", wrkMast.getSourceLocNo());
            return null;
        }

        // 获取库位信息
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        if (locMast == null) {
            News.taskInfo(wrkMast.getWrkNo(), "库位:{} 信息不存在", wrkMast.getLocNo());
            return null;
        }

        if (!locMast.getLocSts().equals("S")) {
            News.taskInfo(wrkMast.getWrkNo(), "库位:{} 状态异常，不属于入库预约状态", wrkMast.getLocNo());
            return null;
        }

        //检测浅库位状态
        boolean checkStatus = checkShallowLocStatus(locMast.getLocNo(), wrkMast.getWrkNo());
        if (!checkStatus) {
            News.taskInfo(wrkMast.getWrkNo(), "因浅库位堵塞无法执行");
            return null;
        }

        List<DualCrnCommand> commandList = new ArrayList<>();
        DualCrnCommand pickCommand = dualCrnThread.getPickCommand(wrkMast.getSourceLocNo(), wrkMast.getWrkNo(), crnNo, station);
        DualCrnCommand putCommand = dualCrnThread.getPutCommand(wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo, station);
        commandList.add(pickCommand);
        commandList.add(putCommand);

        wrkMast.setWrkSts(WrkStsType.LOC_MOVE_RUN.sts);
        wrkMast.setDualCrnNo(crnNo);
        wrkMast.setSystemMsg("");
        wrkMast.setIoTime(new Date());
        if (wrkMastService.updateById(wrkMast)) {
            SendDualCrnCommandParam sendDualCrnCommandParam = new SendDualCrnCommandParam();
            sendDualCrnCommandParam.setCrnNo(crnNo);
            sendDualCrnCommandParam.setStation(station);
            sendDualCrnCommandParam.setCommands(commandList);
            sendDualCrnCommandParam.setCommandIdx(0);

            notifyUtils.notify(String.valueOf(SlaveType.DualCrn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.DUAL_CRN_TRANSFER_TASK_RUN, null);
            return sendDualCrnCommandParam;
        }
        return null;
    }

    //双工位堆垛机任务执行完成
    public synchronized void dualCrnIoExecuteFinish() {
        List<BasDualCrnp> basDualCrnps = basDualCrnpService.selectList(new EntityWrapper<>());
        for (BasDualCrnp basDualCrnp : basDualCrnps) {
            DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
            if(dualCrnThread == null){
                continue;
            }

            DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
            if(dualCrnProtocol == null){
                continue;
            }

            if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
                continue;
            }

            if(dualCrnProtocol.getAlarm() != 0) {
                continue;
            }

            if(dualCrnProtocol.getTaskNo() > 0 && dualCrnProtocol.getStatus() == DualCrnStatusType.WAITING.id) {
                executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNo(), 1);
            }

            if(dualCrnProtocol.getTaskNoTwo() > 0 && dualCrnProtocol.getStatusTwo() == DualCrnStatusType.WAITING.id) {
                executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNoTwo(), 2);
            }
        }
    }

    private void executeFinish(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread, DualCrnProtocol dualCrnProtocol, int taskNo, int station) {
        Object lock = redisUtil.get(RedisKeyType.DUAL_CRN_IO_EXECUTE_FINISH_LIMIT.key + basDualCrnp.getCrnNo() + "_" + taskNo);
        if (lock != null) {
            return;
        }

        // 获取待确认工作档
        WrkMast wrkMast = wrkMastService.selectByWorkNo(taskNo);
        if (wrkMast == null) {
            News.error("双工位堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", basDualCrnp.getCrnNo(), taskNo);
            return;
        }

        Object commandListObj = redisUtil.get(RedisKeyType.DUAL_CRN_COMMAND_.key + basDualCrnp.getCrnNo());
        if (commandListObj == null) {
            News.error("双工位堆垛机处于等待确认且任务完成状态，但未找到命令。堆垛机号={}，工作号={}", basDualCrnp.getCrnNo(), taskNo);
            return;
        }
        List<SendDualCrnCommandParam> dualCrnCommandParamList = JSON.parseArray(commandListObj.toString(), SendDualCrnCommandParam.class);
        SendDualCrnCommandParam taskCommand = null;
        for (SendDualCrnCommandParam sendDualCrnCommandParam : dualCrnCommandParamList) {
            DualCrnCommand dualCrnCommand = sendDualCrnCommandParam.getCommands().get(0);
            if(dualCrnCommand.getTaskNo() == taskNo){
                taskCommand = sendDualCrnCommandParam;
                break;
            }
        }
        if (taskCommand == null) {
            News.error("双工位堆垛机处于等待确认且任务完成状态，但未找到命令。堆垛机号={}，工作号={}", basDualCrnp.getCrnNo(), taskNo);
            return;
        }

        Integer idx = taskCommand.getCommandIdx();
        List<DualCrnCommand> commandList = taskCommand.getCommands();
        if (idx >= commandList.size()) {
            Long updateWrkSts = null;
            if (wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts) {
                updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
                notifyUtils.notify(String.valueOf(SlaveType.DualCrn), basDualCrnp.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.DUAL_CRN_IN_TASK_COMPLETE, null);
            } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts) {
                updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
                notifyUtils.notify(String.valueOf(SlaveType.DualCrn), basDualCrnp.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.DUAL_CRN_OUT_TASK_COMPLETE, null);

                List<StationObjModel> outStationList = basDualCrnp.getOutStationList$();
                if(outStationList.isEmpty()){
                    News.info("双工位堆垛机:{} 出库站点未设置", basDualCrnp.getCrnNo());
                    return;
                }

                if(mainProcessPlugin.contains("Fake")) {
                    //生成仿真站点数据
                    for (StationObjModel stationObjModel : outStationList) {
                        if (!stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
                            continue;
                        }

                        StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
                        if (stationThread == null) {
                            continue;
                        }
                        //生成仿真站点数据
                        StationCommand command = stationThread.getCommand(StationCommandType.WRITE_INFO, 9998, wrkMast.getSourceStaNo(), 0, 0);
                        MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
                    }
                }

            } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts) {
                updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
                notifyUtils.notify(String.valueOf(SlaveType.DualCrn), basDualCrnp.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.DUAL_CRN_TRANSFER_TASK_COMPLETE, null);
            } else {
                News.error("双工位堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basDualCrnp.getCrnNo(), taskNo);
                return;
            }

            DualCrnCommand resetCommand = dualCrnThread.getResetCommand(dualCrnProtocol.getCrnNo(), station);
            boolean offer = MessageQueue.offer(SlaveType.DualCrn, dualCrnProtocol.getCrnNo(), new Task(3, resetCommand));
            if (offer) {
                wrkMast.setWrkSts(updateWrkSts);
                wrkMast.setSystemMsg("");
                wrkMast.setIoTime(new Date());
                if (wrkMastService.updateById(wrkMast)) {
                    News.info("双工位堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basDualCrnp.getCrnNo(), taskNo);
                }
                redisUtil.set(RedisKeyType.DUAL_CRN_IO_EXECUTE_FINISH_LIMIT.key + basDualCrnp.getCrnNo() + "_" + taskNo, "lock", 10);
            }
        }else {
            DualCrnCommand resetCommand = dualCrnThread.getResetCommand(dualCrnProtocol.getCrnNo(), station);
            MessageQueue.offer(SlaveType.DualCrn, dualCrnProtocol.getCrnNo(), new Task(3, resetCommand));
            News.info("双工位堆垛机命令完成确认成功，堆垛机号={}，工作号={}", basDualCrnp.getCrnNo(), taskNo);
        }
    }

    //检测浅库位状态
    public synchronized boolean checkShallowLocStatus(String locNo, Integer taskNo) {
        String checkDeepLocOutTaskBlockReport = "Y";
        Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
        if (systemConfigMapObj != null) {
            HashMap<String, String> systemConfigMap = (HashMap<String, String>) systemConfigMapObj;
            checkDeepLocOutTaskBlockReport = systemConfigMap.get("checkDeepLocOutTaskBlockReport");
        }

        if (!checkDeepLocOutTaskBlockReport.equals("Y")) {
            return true;
        }

        Object lock = redisUtil.get(RedisKeyType.CHECK_SHALLOW_LOC_STATUS_LIMIT.key + taskNo);
        if (lock != null) {
            return false;
        }

        Integer shallowRow = Utils.getShallowRowByDeepRow(Utils.getRow(locNo));
        if (shallowRow == null) {
            return true;
        }

        redisUtil.set(RedisKeyType.CHECK_SHALLOW_LOC_STATUS_LIMIT.key + taskNo, "lock", 5);
        String shallowLocNo = Utils.getLocNo(shallowRow, Utils.getBay(locNo), Utils.getLev(locNo));
        LocMast shallowLocMast = locMastService.queryByLoc(shallowLocNo);
        if (shallowLocMast == null) {
            News.taskInfo(taskNo, "浅库位:{} 数据不存在", shallowLocNo);
            return false;
        }

        if (shallowLocMast.getLocSts().equals("O")) {
            return true;
        }

        if (shallowLocMast.getLocSts().equals("F")) {
            //浅库位状态有货,申请更换库位
            String response = wmsOperateUtils.applyChangeLocNo(shallowLocNo);
            if (response == null) {
                News.taskError(taskNo, "WCS申请在库库位更换库位失败，WMS接口未响应！！！response：{}", response);
                return false;
            }
            JSONObject jsonObject = JSON.parseObject(response);
            if (jsonObject.getInteger("code").equals(200)) {
                StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                String moveLocNo = dto.getLocNo();

                CreateLocMoveTaskParam moveTaskParam = new CreateLocMoveTaskParam();
                moveTaskParam.setTaskNo(dto.getTaskNo());
                moveTaskParam.setSourceLocNo(shallowLocNo);
                moveTaskParam.setLocNo(moveLocNo);
                try {
                    boolean result = commonService.createLocMoveTask(moveTaskParam);
                } catch (CoolException e) {
                    News.taskInfo(taskNo, e.getMessage());
                }
            } else {
                News.error("请求WMS申请更换库位接口失败！！！response：{}", response);
            }
        }
        return false;
    }

    private boolean reassignTaskLocNo(WrkMast wrkMast, StationObjModel stationObjModel) {
        StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
        if (stationThread == null) {
            return false;
        }

        Map<Integer, StationProtocol> stationProtocolMap = stationThread.getStatusMap();
        StationProtocol stationProtocol = stationProtocolMap.get(stationObjModel.getStationId());
        if (stationProtocol == null) {
            return false;
        }

        String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationObjModel.getStationId());
        if (response == null) {
            News.taskError(wrkMast.getWrkNo(), "请求WMS重新分配入库库位接口失败，接口未响应！！！response：{}", response);
            return false;
        }

        JSONObject jsonObject = JSON.parseObject(response);
        if (jsonObject.getInteger("code").equals(200)) {
            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

            String sourceLocNo = wrkMast.getLocNo();
            String locNo = dto.getLocNo();

            LocMast sourceLocMast = locMastService.queryByLoc(sourceLocNo);
            if (sourceLocMast == null) {
                News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 源库位信息不存在", sourceLocNo);
                return false;
            }

            if (!sourceLocMast.getLocSts().equals("S")) {
                News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 源库位状态不处于入库预约", sourceLocNo);
                return false;
            }

            LocMast locMast = locMastService.queryByLoc(locNo);
            if (locMast == null) {
                News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 目标库位信息不存在", locNo);
                return false;
            }

            if (!locMast.getLocSts().equals("O")) {
                News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 目标库位状态不处于空库位", locNo);
                return false;
            }
            //更新源库位
            sourceLocMast.setLocSts("O");
            sourceLocMast.setModiTime(new Date());
            locMastService.updateById(sourceLocMast);

            //更新目标库位
            locMast.setLocSts("S");
            locMast.setModiTime(new Date());
            locMastService.updateById(locMast);

            //更新工作档数据
            wrkMast.setLocNo(locNo);
            wrkMastService.updateById(wrkMast);
            return true;
        } else {
            News.error("请求WMS更换双工位库位接口失败！！！response：{}", response);
        }
        return false;
    }

}