package com.zy.asrs.service.impl;

import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.LiftUtils;
import com.zy.common.utils.ShuttleOperaUtils;
import com.zy.core.News;
import com.zy.core.action.LiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.dispatcher.ShuttleDispatchUtils;
import com.zy.core.enums.LiftCommandModeType;
import com.zy.core.enums.ShuttleTaskModeType;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkStsType;
import com.zy.core.model.command.LiftAssignCommand;
import com.zy.core.model.command.LiftCommand;
import com.zy.core.model.command.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.protocol.LiftProtocol;
import com.zy.core.model.protocol.ShuttleProtocol;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.thread.DevpThread;
import com.zy.core.thread.LiftThread;
import com.zy.core.thread.ShuttleThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Slf4j
@Service("noLiftOutService")
public class NoLiftOutServiceImpl {

    @Autowired
    private WrkMastService wrkMastService;

    @Autowired
    private CommonService commonService;

    @Autowired
    private ShuttleDispatchUtils shuttleDispatchUtils;

    @Autowired
    private ShuttleOperaUtils shuttleOperaUtils;

    @Autowired
    private ShuttleAction shuttleAction;

    @Autowired
    private NotifyUtils notifyUtils;

    @Autowired
    private LiftAction liftAction;

    @Autowired
    private MainServiceImpl mainService;

    /**
     * 从没有提升机侧出库，有两种情况，一种1，5库到同层，一种非1，5库到1，5，则需要提升机
     * @param wrkMast
     */
    public void shuttleMoveExecute(WrkMast wrkMast, Integer staNo, Integer lev) {
        //判断目标库位是否在1层或5层
        if ((lev == 1 & staNo == 1013) || (lev == 5 && staNo == 1024)) {
            boolean stepMoveSta = this.shuttleMoveExecuteTransportLiftStepCallShuttle2(wrkMast);//呼叫小车至取货点
            if (!stepMoveSta) {
                return;
            }
            boolean stepMoveLoc = this.shuttleMoveExecuteTransportLiftStepMoveLoc2(wrkMast);//小车移动到目标库位中
            if (!stepMoveLoc) {
                return;
            }
        } else {
            boolean stepMoveSta = this.shuttleMoveExecuteTransportLiftStepCallShuttle(wrkMast);//呼叫小车至取货点
            if (!stepMoveSta) {
                return;
            }
            boolean stepTransportLiftOutStepMoveSta = this.shuttleMoveExecuteTransportLiftOutStepMoveSta(wrkMast);//小车移动到待机点
            if (!stepTransportLiftOutStepMoveSta) {
                return;
            }

            boolean stepLiftToShuttleLev = this.shuttleMoveExecuteTransportLiftOutStepLiftToShuttleLev(wrkMast);//提升机到小车层
            if (!stepLiftToShuttleLev) {
                return;
            }

            boolean stepIntoLift = this.shuttleMoveExecuteTransportLiftOutStepIntoLift(wrkMast);//小车迁入提升机
            if (!stepIntoLift) {
                return;
            }

            boolean stepLiftToTargetLev = this.shuttleMoveExecuteTransportLiftStepLiftToTargetLev(wrkMast);//提升机到放货层
            if (!stepLiftToTargetLev) {
                return;
            }

            boolean stepOutLift = this.shuttleMoveExecuteTransportLiftOutStepOutLift(wrkMast);//小车移动至输送线处
            if (!stepOutLift) {
                return;
            }
            boolean stepMoveLoc = this.shuttleMoveExecuteTransportLiftStepMoveLoc(wrkMast);//小车移动到目标库位中
            if (!stepMoveLoc) {
                return;
            }
        }

    }

    /**
     * 小车迁移-呼叫小车至取货点
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftStepCallShuttle(WrkMast wrkMast) {
        Date now = new Date();
        //小车移动至站点  301.生成小车移库任务 ==> 呼叫小车至取货点
        if (wrkMast.getWrkSts() == WrkStsType.NEW_MOVE.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }

            WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
            if (wrkMast1 != null) {
                if (!mainService.isOutEnable(devpThread, wrkMast1.getStaNo())) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线不可出111", wrkMast.getWrkNo(), wrkMast1.getStaNo());
                    return false;
                }
                StaProtocol staProtocol = devpThread.getStation().get(wrkMast1.getStaNo() + 2);
                if (staProtocol.isLoading()) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线有物111", wrkMast.getWrkNo(), wrkMast1.getStaNo() + 1);
                    return false;
                }
            }

            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车在取货点
                wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_1.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 呼叫小车至取货点
                wrkMast.setModiTime(now);
                wrkMast.setSystemMsg("");//清空消息
                wrkMastService.updateById(wrkMast);
                return false;
            }

            boolean dispatchShuttle = shuttleDispatchUtils.shuttleMoveGenerate(wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo(), null, true);
            if (!dispatchShuttle) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，调度至取货点失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_1.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 呼叫小车至取货点
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            wrkMastService.updateById(wrkMast);
            return false;
        }
        return true;
    }

    /**
     * 小车迁移-小车移动到站点
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftOutStepMoveSta(WrkMast wrkMast) {
        //--------------------------------------小车移动至站点-----------------------------------------//
        Date now = new Date();

        //小车移动至站点  呼叫小车至取货点 ==> 小车移动至站点中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_1.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，未到达取货点", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //获取穿梭车最近且空闲的提升机
            LiftThread liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
            if (liftThread == null) {
                News.info("{}号小车，{}小车库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                return false;//没有可用且空闲的提升机
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

            //获取提升机待机位
            String liftStandByLocNo = liftThread.getLiftStandByLocNo(Utils.getLev(shuttleProtocol.getCurrentLocNo()), true);

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            List<ShuttleCommand> commands = new ArrayList<>();
            Integer mapType = NavigationMapType.DFX.id;

            //获取小车到提升机待机位行走命令
            List<ShuttleCommand> moveCommands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftStandByLocNo, mapType, assignCommand, shuttleThread);
            if (moveCommands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径解锁失败
            }
            commands.addAll(moveCommands);

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(0, liftCommand);

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_2.sts);//小车移动到提升机中  呼叫小车至取货点 ==> 小车移动至站点中
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                return false;
            }
            return false;
        }
        return true;
    }

    /**
     * 小车迁移-提升机到小车层
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftOutStepLiftToShuttleLev(WrkMast wrkMast) {
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_3.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            LiftThread liftThread = null;
            LiftProtocol liftProtocol = null;


            //获取穿梭车最近且空闲的提升机
            liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
            if (liftThread == null) {
                News.info("{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                return false;//没有可用且空闲的提升机
            }

            liftProtocol = liftThread.getStatus();
            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            //判断提升机内是否有托盘
            if (liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }


            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //判断提升机内是否有托盘
            if (liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //判断提升机楼层
            if (liftProtocol.getLev() == Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
                //提升机在小车楼层
                wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_5.sts);//小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层完成
                wrkMast.setModiTime(now);
                wrkMastService.updateById(wrkMast);
                return false;
            }

            //调度提升机
            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getMoveCommand(wrkMast.getWrkNo(), liftProtocol.getLev(), Utils.getLev(shuttleProtocol.getCurrentLocNo()), LiftCommandModeType.MOVE);
            LiftCommand liftCommand = liftCommands.get(0);

            int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
            liftCommand.setTaskNo(deviceWrk);//更换随机任务号

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo((short) 1);
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.MOVE.id.shortValue());


            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(wrkMast.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_4.sts);//小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }

    /**
     * 小车迁移-小车迁入提升机
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftOutStepIntoLift(WrkMast wrkMast) {
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  提升机至小车层完成 ==> 小车迁入提升机中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_5.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getShuttleNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getShuttleNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", 1);
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(wrkMast.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), 1);
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), 1);
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //判断提升机内是否有托盘
            if (liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //判断提升机楼层
            if (liftProtocol.getLev() != Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
                //提升机不在小车楼层
                News.info("{}任务，{}号提升机，提升机与小车不在同一层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//等待提升机到小车楼层
            }

            //判断提升机是否有其他任务
            WrkMast w = wrkMastService.selectLiftWrkMastAndWrkNo(1, wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (w != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在别的绑定任务out，禁止派发", wrkMast.getWrkNo(), 1);
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //获取小车到提升机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftThread.getLiftLocNo(Utils.getLev(shuttleProtocol.getCurrentLocNo())), NavigationMapType.DFX.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_6.sts);//小车移动到提升机中  提升机至小车层完成 ==> 小车迁入提升机中
            wrkMast.setModiTime(now);
            wrkMast.setLiftNo(1);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }


    /**
     * 小车迁移-提升机到放货层
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftStepLiftToTargetLev(WrkMast wrkMast) {
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  小车迁入提升机完成 ==> 提升机至放货层
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_7.sts) {
            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务未绑定提升机", wrkMast.getWrkNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}号提升机不存在", wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(wrkMast.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            //判断提升机内是否有小车
            if (!liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内无小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //判断提升机内是否有托盘
            if (!liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }


            //调度提升机
            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getMoveWithShuttleCommand(wrkMast.getWrkNo(), liftProtocol.getLev(), Utils.getLev(wrkMast.getLocNo()), LiftCommandModeType.MOVE);
            LiftCommand liftCommand = liftCommands.get(0);

            int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
            liftCommand.setTaskNo(deviceWrk);//更换随机任务号

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(wrkMast.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.MOVE.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_8.sts);//小车移动到提升机中  小车迁入提升机完成 ==> 提升机至放货层
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
//                //触发通知
//                notifyUtils.notify(String.valueOf(SlaveType.Lift), liftProtocol.getLiftNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_MOVING_IN_LIFT);
                return false;
            }
            return false;
        }

        return true;
    }


    /**
     * 小车迁移-小车迁出提升机
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftOutStepOutLift(WrkMast wrkMast) {
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  小车迁入提升机完成 ==> 小车迁出提升机中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_9.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务，提升机未绑定，禁止派发", wrkMast.getWrkNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(wrkMast.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}任务，{}号提升机，提升机线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}任务，{}号提升机，提升机对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断提升机内是否有小车
            if (!liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内无小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //判断提升机内是否有托盘
            if (!liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
                assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//更新坐标
                assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
                assignCommand.setAuto(true);//自动模式
                assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
                assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

                //更新小车坐标
                ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
                ArrayList<ShuttleCommand> commands = new ArrayList<>();
                commands.add(command);

                assignCommand.setCommands(commands);
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //获取提升机待机位
            String liftStandByLocNo = liftThread.getLiftStandByLocNo(Utils.getLev(shuttleProtocol.getCurrentLocNo()), false);

            //获取小车到提升机待机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftStandByLocNo, NavigationMapType.DFX.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }


            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_10.sts);//小车移动到提升机中  提升机至放货层完成 ==> 小车迁出提升机中
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }

    /**
     * 小车迁移-小车移动到目标库位中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftStepMoveLoc(WrkMast wrkMast) {
        //--------------------------------------小车移动到目标库位中-----------------------------------------//
        Date now = new Date();

        //小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_11.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

//            if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
//                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
//                assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//更新坐标
//                assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
//                assignCommand.setAuto(true);//自动模式
//                assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
//                assignCommand.setLocNo(wrkMast.getLocNo());//目标库位
//
//                //更新小车坐标
//                ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
//                ArrayList<ShuttleCommand> commands = new ArrayList<>();
//                commands.add(command);
//
//                assignCommand.setCommands(commands);
//                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
//                return false;
//            }


            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

            List<ShuttleCommand> commands = new ArrayList<>();
            Integer mapType = NavigationMapType.DFX.id;

            List<ShuttleCommand> moveCommands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), mapType, assignCommand, shuttleThread);
            if (moveCommands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径计算失败
            }
            commands.addAll(moveCommands);

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(liftCommand);

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_12.sts);//小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            }
            WrkMast wrkMast1 = wrkMastService.selectByMainWrkNo(wrkMast.getWrkNo());
            if (wrkMast1 != null) {
                wrkMast.setLiftNo(null);//释放提升机
                wrkMast.setModiTime(now);
                if (!wrkMastService.updateById(wrkMast1)) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}解锁提升机", wrkMast1.getWrkNo());
                }
            }
        }
        return true;
    }


    /**
     * 小车迁移-呼叫小车至取货点
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftStepCallShuttle2(WrkMast wrkMast) {
        Date now = new Date();
        //小车移动至站点  301.生成小车移库任务 ==> 呼叫小车至取货点
        if (wrkMast.getWrkSts() == WrkStsType.NEW_MOVE.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }
            WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
            if (wrkMast1 != null) {
                if (!mainService.isOutEnable(devpThread, wrkMast1.getStaNo())) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线不可出222", wrkMast.getWrkNo(), wrkMast1.getStaNo());
                    return false;
                }
                StaProtocol staProtocol = devpThread.getStation().get(wrkMast1.getStaNo() + 2);
                if (staProtocol.isLoading()) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线有物222", wrkMast.getWrkNo(), wrkMast1.getStaNo());
                    return false;
                }
            }

            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车在取货点
                wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_1.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 呼叫小车至取货点
                wrkMast.setModiTime(now);
                wrkMast.setSystemMsg("");//清空消息
                wrkMastService.updateById(wrkMast);
                return false;
            }

            boolean dispatchShuttle = shuttleDispatchUtils.shuttleMoveGenerate(wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo(), null, true);
            if (!dispatchShuttle) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，调度至取货点失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_1.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 呼叫小车至取货点
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            wrkMastService.updateById(wrkMast);
            return false;
        }
        return true;
    }


    /**
     * 小车迁移-小车移动到目标库位中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteTransportLiftStepMoveLoc2(WrkMast wrkMast) {
        //--------------------------------------小车移动到目标库位中-----------------------------------------//
        Date now = new Date();

        //小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_NO_LIFT_1.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

            List<ShuttleCommand> commands = new ArrayList<>();
            Integer mapType = NavigationMapType.DFX.id;


            List<ShuttleCommand> moveCommands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), mapType, assignCommand, shuttleThread);
            if (moveCommands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径计算失败
            }
            commands.addAll(moveCommands);

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(0, liftCommand);

            List<ShuttleCommand> liftCommandDown = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
            if (liftCommandDown == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取fangxia命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(liftCommandDown);

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_NO_LIFT_12.sts);//小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            }
        }
        return true;
    }
}