package com.zy.core.utils.station;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.entity.FindCrnNoResult;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.utils.NavigateUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.dispatch.StationCommandDispatchResult;
import com.zy.core.dispatch.StationCommandDispatcher;
import com.zy.core.enums.RedisKeyType;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.StationCommandType;
import com.zy.core.enums.WrkIoType;
import com.zy.core.enums.WrkStsType;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.model.protocol.StationTaskBufferItem;
import com.zy.core.move.StationMoveCoordinator;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.station.model.OutOrderDispatchDecision;
import com.zy.core.utils.station.model.RerouteCommandPlan;
import com.zy.core.utils.station.model.RerouteContext;
import com.zy.core.utils.station.model.RerouteDecision;
import com.zy.core.utils.station.model.RerouteExecutionResult;
import com.zy.core.utils.station.model.RerouteSceneType;
import com.zy.core.utils.WmsOperateUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@Slf4j
@Component
public class StationRerouteProcessor {
    private static final int OUT_ORDER_DISPATCH_LIMIT_SECONDS = 2;
    private static final long STATION_MOVE_RESET_WAIT_MS = 1000L;
    private static final int RUN_BLOCK_DIRECT_REASSIGN_LIMIT_SECONDS = 8 * 60;
    private static final int RUN_BLOCK_DIRECT_REASSIGN_NEAREST_CACHE_SECONDS = 60 * 60 * 24;
    private static final long CHECK_STATION_OUT_ORDER_SLOW_THRESHOLD_MS = 200L;
    private static final long EXECUTE_REROUTE_PLAN_SLOW_THRESHOLD_MS = 200L;
    private static final String RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING_PREFIX = "堵塞重分配请求WMS失败";
    private static final String RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING =
            RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING_PREFIX + "，请检查WMS重新分配库位接口";

    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private WmsOperateUtils wmsOperateUtils;
    @Autowired
    private StationMoveCoordinator stationMoveCoordinator;
    @Autowired
    private StationCommandDispatcher stationCommandDispatcher;
    @Autowired
    private StationOutboundDecisionSupport stationOutboundDecisionSupport;
    @Autowired
    private StationDispatchRuntimeStateSupport stationDispatchRuntimeStateSupport;
    @Autowired
    private NavigateUtils navigateUtils;

    public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
                return;
            }
            if (shouldSkipRunBlockStation(basDevp, stationId)) {
                return;
            }
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                return;
            }

            Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationId);
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || !stationProtocol.isRunBlock()) {
                return;
            }

            List<Integer> runBlockReassignLocStationList = new ArrayList<>();
            for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
                runBlockReassignLocStationList.add(stationObjModel.getStationId());
            }
            List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();

            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            if (wrkMast == null) {
                News.info("输送站点号={} 运行阻塞，但无法找到对应任务，工作号={}", stationProtocol.getStationId(), stationProtocol.getTaskNo());
                return;
            }

            Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
            if (lock != null) {
                return;
            }
            redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 30);

            if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
                if (stationMoveCoordinator != null) {
                    stationMoveCoordinator.withTaskDispatchLock(stationProtocol.getTaskNo(),
                            () -> {
                                executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
                                return null;
                            });
                } else {
                    executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
                }
                return;
            }

            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            RerouteContext context = RerouteContext.create(
                    RerouteSceneType.RUN_BLOCK_REROUTE,
                    basDevp,
                    stationThread,
                    stationProtocol,
                    wrkMast,
                    outOrderStationIds,
                    pathLenFactor,
                    "checkStationRunBlock_reroute"
            ).withRunBlockCommand()
                    .withSuppressDispatchGuard()
                    .withCancelSessionBeforeDispatch()
                    .withResetSegmentCommandsBeforeDispatch();
            executeSharedReroute(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
        long totalStartMs = System.currentTimeMillis();
        try {
            if (basDevp == null || basDevp.getDevpNo() == null || stationObjModel == null || stationObjModel.getStationId() == null) {
                return;
            }
            long runtimeStartMs = System.currentTimeMillis();
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
            if (stationThread == null) {
                return;
            }
            Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationObjModel.getStationId());
            long runtimeCostMs = System.currentTimeMillis() - runtimeStartMs;
            if (stationProtocol == null
                    || !stationProtocol.isAutoing()
                    || !stationProtocol.isLoading()
                    || stationProtocol.getTaskNo() <= 0
                    || stationProtocol.isRunBlock()
                    || !stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
                return;
            }

            long loadWrkStartMs = System.currentTimeMillis();
            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            long loadWrkCostMs = System.currentTimeMillis() - loadWrkStartMs;
            if (wrkMast == null
                    || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
                    || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
                return;
            }
            long skipCheckStartMs = System.currentTimeMillis();
            boolean skipForExistingRoute = stationOutboundDecisionSupport
                    .shouldSkipOutOrderDispatchForExistingRoute(wrkMast.getWrkNo(), stationProtocol.getStationId());
            long skipCheckCostMs = System.currentTimeMillis() - skipCheckStartMs;
            if (skipForExistingRoute) {
                return;
            }

            long pathFactorStartMs = System.currentTimeMillis();
            Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
            long pathFactorCostMs = System.currentTimeMillis() - pathFactorStartMs;
            RerouteContext context = RerouteContext.create(
                    RerouteSceneType.OUT_ORDER,
                    basDevp,
                    stationThread,
                    stationProtocol,
                    wrkMast,
                    basDevp.getOutOrderIntList(),
                    pathLenFactor,
                    "checkStationOutOrder"
            ).withDispatchDeviceNo(stationObjModel.getDeviceNo())
                    .withSuppressDispatchGuard()
                    .withOutOrderDispatchLock()
                    .withResetSegmentCommandsBeforeDispatch();
            long rerouteStartMs = System.currentTimeMillis();
            RerouteExecutionResult result = executeSharedReroute(context);
            long rerouteCostMs = System.currentTimeMillis() - rerouteStartMs;
            long totalCostMs = System.currentTimeMillis() - totalStartMs;
            log.info("checkStationOutOrder profile, taskNo={}, stationId={}, deviceNo={}, batch={}, batchSeq={}, finalTargetStationId={}, pathLenFactor={}, runtimeCostMs={}ms, loadWrkCostMs={}ms, skipCheckCostMs={}ms, pathFactorCostMs={}ms, rerouteCostMs={}ms, totalCostMs={}ms, result={}",
                    stationProtocol.getTaskNo(),
                    stationProtocol.getStationId(),
                    stationObjModel.getDeviceNo(),
                    wrkMast.getBatch(),
                    wrkMast.getBatchSeq(),
                    wrkMast.getStaNo(),
                    pathLenFactor,
                    runtimeCostMs,
                    loadWrkCostMs,
                    skipCheckCostMs,
                    pathFactorCostMs,
                    rerouteCostMs,
                    totalCostMs,
                    result == null ? null : result.skipReason());
            if (totalCostMs > CHECK_STATION_OUT_ORDER_SLOW_THRESHOLD_MS) {
                log.warn("checkStationOutOrder slow, taskNo={}, stationId={}, totalCostMs={}ms, rerouteCostMs={}ms, loadWrkCostMs={}ms, pathFactorCostMs={}ms",
                        stationProtocol.getTaskNo(), stationProtocol.getStationId(), totalCostMs, rerouteCostMs, loadWrkCostMs, pathFactorCostMs);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
                                                      RerouteDecision decision) {
        if (context == null) {
            return RerouteCommandPlan.skip("missing-context");
        }
        if (decision == null) {
            return RerouteCommandPlan.skip("missing-decision");
        }
        if (decision.skip()) {
            return RerouteCommandPlan.skip(decision.skipReason());
        }
        if (context.stationThread() == null || context.stationProtocol() == null || context.wrkMast() == null) {
            return RerouteCommandPlan.skip("missing-runtime-dependency");
        }
        Integer currentStationId = context.stationProtocol().getStationId();
        Integer targetStationId = decision.targetStationId();
        if (currentStationId == null || targetStationId == null) {
            return RerouteCommandPlan.skip("missing-target-station");
        }
        if (Objects.equals(currentStationId, targetStationId)) {
            return RerouteCommandPlan.skip("same-station");
        }

        StationCommand command = context.useRunBlockCommand()
                ? context.stationThread().getRunBlockRerouteCommand(
                context.wrkMast().getWrkNo(),
                currentStationId,
                targetStationId,
                0,
                context.pathLenFactor()
        )
                : stationOutboundDecisionSupport.buildOutboundMoveCommand(
                context.stationThread(),
                context.wrkMast(),
                currentStationId,
                targetStationId,
                context.pathLenFactor()
        );
        if (command == null) {
            if (context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE) {
                News.taskInfo(context.wrkMast().getWrkNo(),
                        "输送站点堵塞重规划未找到可下发路线，当前站点={}，目标站点={}",
                        currentStationId,
                        targetStationId);
            } else if (context.sceneType() == RerouteSceneType.IDLE_RECOVER) {
                News.taskInfo(context.wrkMast().getWrkNo(),
                        "站点任务停留超时后重算路径失败，当前站点={}，目标站点={}",
                        currentStationId,
                        targetStationId);
            } else {
                News.taskInfo(context.wrkMast().getWrkNo(), "获取输送线命令失败");
            }
            return RerouteCommandPlan.skip("missing-command");
        }
        return RerouteCommandPlan.dispatch(command, decision, context.dispatchScene());
    }

    public RerouteExecutionResult executeReroutePlan(RerouteContext context,
                                                     RerouteCommandPlan plan) {
        if (context == null) {
            return RerouteExecutionResult.skip("missing-context");
        }
        if (plan == null) {
            return RerouteExecutionResult.skip("missing-plan");
        }
        if (plan.skip()) {
            return RerouteExecutionResult.skip(plan.skipReason());
        }
        StationProtocol stationProtocol = context.stationProtocol();
        if (stationProtocol == null) {
            return RerouteExecutionResult.skip("missing-station-protocol");
        }
        Integer taskNo = stationProtocol.getTaskNo();
        Integer stationId = stationProtocol.getStationId();
        if (taskNo == null || taskNo <= 0 || stationId == null) {
            return RerouteExecutionResult.skip("invalid-station-task");
        }
        if (stationMoveCoordinator != null) {
            return stationMoveCoordinator.withTaskDispatchLock(taskNo,
                    () -> executeReroutePlanWithTaskLock(context, plan, stationProtocol, taskNo, stationId));
        }
        return executeReroutePlanWithTaskLock(context, plan, stationProtocol, taskNo, stationId);
    }

    public RerouteDecision resolveSharedRerouteDecision(RerouteContext context) {
        long startMs = System.currentTimeMillis();
        if (context == null || context.wrkMast() == null || context.stationProtocol() == null) {
            return RerouteDecision.skip("missing-runtime-dependency");
        }
        Integer currentStationId = context.stationProtocol().getStationId();
        if (currentStationId == null) {
            return RerouteDecision.skip("missing-current-station");
        }

        if (context.sceneType() == RerouteSceneType.IDLE_RECOVER
                && !Objects.equals(context.wrkMast().getWrkSts(), WrkStsType.STATION_RUN.sts)) {
            Integer targetStationId = context.wrkMast().getStaNo();
            RerouteDecision decision = targetStationId == null || Objects.equals(targetStationId, currentStationId)
                    ? RerouteDecision.skip("same-station")
                    : RerouteDecision.proceed(targetStationId);
            log.info("resolveSharedRerouteDecision profile, sceneType={}, taskNo={}, currentStationId={}, targetStationId={}, decision={}, decisionCostMs={}ms",
                    context.sceneType(), context.wrkMast().getWrkNo(), currentStationId, targetStationId,
                    decision.skip() ? decision.skipReason() : "proceed", System.currentTimeMillis() - startMs);
            return decision;
        }

        OutOrderDispatchDecision dispatchDecision =
                stationOutboundDecisionSupport.resolveOutboundDispatchDecision(
                        currentStationId,
                        context.wrkMast(),
                        context.outOrderStationIds(),
                        context.pathLenFactor()
                );
        Integer targetStationId = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
        RerouteDecision decision = targetStationId == null || Objects.equals(targetStationId, currentStationId)
                ? RerouteDecision.skip("same-station")
                : RerouteDecision.proceed(targetStationId, dispatchDecision);
        log.info("resolveSharedRerouteDecision profile, sceneType={}, taskNo={}, currentStationId={}, targetStationId={}, decision={}, circle={}, decisionCostMs={}ms",
                context.sceneType(), context.wrkMast().getWrkNo(), currentStationId, targetStationId,
                decision.skip() ? decision.skipReason() : "proceed",
                dispatchDecision != null && dispatchDecision.isCircle(),
                System.currentTimeMillis() - startMs);
        return decision;
    }

    public boolean shouldUseRunBlockDirectReassign(WrkMast wrkMast,
                                                   Integer stationId,
                                                   List<Integer> runBlockReassignLocStationList) {
        if (wrkMast == null || stationId == null) {
            return false;
        }
        if (!Objects.equals(wrkMast.getIoType(), WrkIoType.IN.id)) {
            return false;
        }
        if (runBlockReassignLocStationList == null || !runBlockReassignLocStationList.contains(stationId)) {
            return false;
        }
        if (shouldForceRunBlockPathReroute(wrkMast, stationId, runBlockReassignLocStationList)) {
            return false;
        }
        return true;
    }

    private boolean shouldForceRunBlockPathReroute(WrkMast wrkMast,
                                                   Integer stationId,
                                                   List<Integer> runBlockReassignLocStationList) {
        if (wrkMast == null || stationId == null) {
            return false;
        }
        Integer nearestStationId = resolveNearestRunBlockDirectReassignStationId(wrkMast, runBlockReassignLocStationList);
        return nearestStationId != null && !Objects.equals(stationId, nearestStationId);
    }

    private Integer resolveNearestRunBlockDirectReassignStationId(WrkMast wrkMast,
                                                                  List<Integer> runBlockReassignLocStationList) {
        if (wrkMast == null
                || wrkMast.getStaNo() == null
                || navigateUtils == null
                || runBlockReassignLocStationList == null
                || runBlockReassignLocStationList.isEmpty()) {
            return null;
        }
        Integer targetStationId = wrkMast.getStaNo();
        Integer cachedStationId = loadCachedNearestRunBlockDirectReassignStationId(targetStationId, runBlockReassignLocStationList);
        if (cachedStationId != null) {
            return cachedStationId;
        }
        Integer nearestStationId = null;
        int nearestPathLen = Integer.MAX_VALUE;
        for (Integer candidateStationId : runBlockReassignLocStationList) {
            if (candidateStationId == null) {
                continue;
            }
            List<NavigateNode> path = navigateUtils.calcOptimalPathByStationId(candidateStationId, targetStationId, wrkMast.getWrkNo(), null);
            if (path == null || path.isEmpty()) {
                continue;
            }
            int pathLen = countStationNodes(path);
            if (pathLen <= 0) {
                continue;
            }
            if (pathLen < nearestPathLen
                    || (pathLen == nearestPathLen && nearestStationId != null && candidateStationId < nearestStationId)) {
                nearestStationId = candidateStationId;
                nearestPathLen = pathLen;
            }
        }
        cacheNearestRunBlockDirectReassignStationId(targetStationId, runBlockReassignLocStationList, nearestStationId);
        return nearestStationId;
    }

    private Integer loadCachedNearestRunBlockDirectReassignStationId(Integer targetStationId,
                                                                     List<Integer> runBlockReassignLocStationList) {
        String cacheKey = buildNearestRunBlockDirectReassignCacheKey(targetStationId, runBlockReassignLocStationList);
        if (cacheKey == null || redisUtil == null) {
            return null;
        }
        Object cacheValue = redisUtil.get(cacheKey);
        if (cacheValue == null) {
            return null;
        }
        try {
            Integer stationId = Integer.valueOf(String.valueOf(cacheValue));
            return runBlockReassignLocStationList.contains(stationId) ? stationId : null;
        } catch (Exception ignore) {
            return null;
        }
    }

    private void cacheNearestRunBlockDirectReassignStationId(Integer targetStationId,
                                                             List<Integer> runBlockReassignLocStationList,
                                                             Integer nearestStationId) {
        String cacheKey = buildNearestRunBlockDirectReassignCacheKey(targetStationId, runBlockReassignLocStationList);
        if (cacheKey == null || nearestStationId == null || redisUtil == null) {
            return;
        }
        redisUtil.set(cacheKey, nearestStationId, RUN_BLOCK_DIRECT_REASSIGN_NEAREST_CACHE_SECONDS);
    }

    private String buildNearestRunBlockDirectReassignCacheKey(Integer targetStationId,
                                                              List<Integer> runBlockReassignLocStationList) {
        if (targetStationId == null || runBlockReassignLocStationList == null || runBlockReassignLocStationList.isEmpty()) {
            return null;
        }
        List<Integer> normalizedStationIdList = new ArrayList<>();
        for (Integer stationId : runBlockReassignLocStationList) {
            if (stationId != null && !normalizedStationIdList.contains(stationId)) {
                normalizedStationIdList.add(stationId);
            }
        }
        if (normalizedStationIdList.isEmpty()) {
            return null;
        }
        Collections.sort(normalizedStationIdList);
        return RedisKeyType.STATION_RUN_BLOCK_DIRECT_REASSIGN_NEAREST_CACHE_.key
                + targetStationId
                + "_"
                + JSON.toJSONString(normalizedStationIdList);
    }

    private int countStationNodes(List<NavigateNode> path) {
        if (path == null || path.isEmpty()) {
            return 0;
        }
        int count = 0;
        for (NavigateNode node : path) {
            if (extractStationId(node) != null) {
                count++;
            }
        }
        return count;
    }

    private Integer extractStationId(NavigateNode node) {
        if (node == null || Cools.isEmpty(node.getNodeValue())) {
            return null;
        }
        try {
            JSONObject valueObject = JSONObject.parseObject(node.getNodeValue());
            return valueObject == null ? null : valueObject.getInteger("stationId");
        } catch (Exception ignore) {
            return null;
        }
    }

    private boolean shouldSkipRunBlockStation(BasDevp basDevp, Integer stationId) {
        if (basDevp == null || stationId == null) {
            return false;
        }
        return containsStation(basDevp.getBarcodeStationList$(), stationId)
                || containsStation(basDevp.getInStationList$(), stationId);
    }

    private boolean containsStation(List<StationObjModel> stationList, Integer stationId) {
        if (stationList == null || stationList.isEmpty() || stationId == null) {
            return false;
        }
        for (StationObjModel stationObjModel : stationList) {
            if (stationObjModel != null && Objects.equals(stationObjModel.getStationId(), stationId)) {
                return true;
            }
        }
        return false;
    }

    private RerouteExecutionResult executeReroutePlanWithTaskLock(RerouteContext context,
                                                                  RerouteCommandPlan plan,
                                                                  StationProtocol stationProtocol,
                                                                  Integer taskNo,
                                                                  Integer stationId) {
        long startMs = System.currentTimeMillis();
        boolean runBlockReroute = context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE;
        int currentTaskBufferCommandCount = countCurrentTaskBufferCommands(stationProtocol.getTaskBufferItems(), taskNo);
        if (currentTaskBufferCommandCount > 0 && !runBlockReroute) {
            return RerouteExecutionResult.skip("buffer-has-current-task");
        }
        if (currentTaskBufferCommandCount > 0 && runBlockReroute) {
            News.info("输送站点运行堵塞重规划检测到旧分段命令残留，已先清理本地状态后继续重发。站点号={}，工作号={}，当前任务命令数={}",
                    stationId,
                    taskNo,
                    currentTaskBufferCommandCount);
        }
        long suppressStartMs = System.currentTimeMillis();
        boolean suppressDispatch = !runBlockReroute
                && context.checkSuppressDispatch()
                && stationMoveCoordinator != null
                && stationMoveCoordinator.shouldSuppressDispatch(taskNo, stationId, plan.command());
        long suppressCostMs = System.currentTimeMillis() - suppressStartMs;
        if (suppressDispatch) {
            return RerouteExecutionResult.skip("dispatch-suppressed");
        }
        long outOrderLockStartMs = System.currentTimeMillis();
        boolean outOrderLockAcquired = !context.requireOutOrderDispatchLock()
                || stationDispatchRuntimeStateSupport.tryAcquireOutOrderDispatchLock(taskNo, stationId, OUT_ORDER_DISPATCH_LIMIT_SECONDS);
        long outOrderLockCostMs = System.currentTimeMillis() - outOrderLockStartMs;
        if (!outOrderLockAcquired) {
            return RerouteExecutionResult.skip("out-order-lock");
        }

        long sceneLockStartMs = System.currentTimeMillis();
        boolean sceneLockAcquired = isBlank(context.executionLockKey())
                || stationDispatchRuntimeStateSupport.tryAcquireLock(context.executionLockKey(), context.executionLockSeconds());
        long sceneLockCostMs = System.currentTimeMillis() - sceneLockStartMs;
        if (!sceneLockAcquired) {
            return RerouteExecutionResult.skip("scene-lock");
        }
        long resetCostMs = 0L;
        if (context.resetSegmentCommandsBeforeDispatch()) {
            long resetStartMs = System.currentTimeMillis();
            stationDispatchRuntimeStateSupport.signalSegmentReset(taskNo, STATION_MOVE_RESET_WAIT_MS);
            resetCostMs = System.currentTimeMillis() - resetStartMs;
        }

        int clearedCommandCount = 0;
        long cancelSessionCostMs = 0L;

        if (context.cancelSessionBeforeDispatch() && stationMoveCoordinator != null) {
            long cancelSessionStartMs = System.currentTimeMillis();
            stationMoveCoordinator.markCancelPending(taskNo, "reroute_pending");
            stationMoveCoordinator.cancelSession(taskNo);
            cancelSessionCostMs = System.currentTimeMillis() - cancelSessionStartMs;
        }
        long registerDispatchStartMs = System.currentTimeMillis();
        preRegisterDispatchSession(context, plan);
        long registerDispatchCostMs = System.currentTimeMillis() - registerDispatchStartMs;

        long offerDispatchStartMs = System.currentTimeMillis();
        boolean offered = offerDevpCommandWithDedup(context.dispatchDeviceNo(), plan.command(), plan.dispatchScene());
        long offerDispatchCostMs = System.currentTimeMillis() - offerDispatchStartMs;
        if (!offered) {
            return RerouteExecutionResult.skip("dispatch-dedup");
        }

        applyRerouteDispatchEffects(context, plan, clearedCommandCount);
        long totalCostMs = System.currentTimeMillis() - startMs;
        log.info("executeReroutePlanWithTaskLock profile, sceneType={}, taskNo={}, stationId={}, suppressCostMs={}ms, outOrderLockCostMs={}ms, sceneLockCostMs={}ms, resetCostMs={}ms, cancelSessionCostMs={}ms, registerDispatchCostMs={}ms, offerDispatchCostMs={}ms, totalCostMs={}ms",
                context.sceneType(), taskNo, stationId, suppressCostMs, outOrderLockCostMs, sceneLockCostMs, resetCostMs, cancelSessionCostMs, registerDispatchCostMs, offerDispatchCostMs, totalCostMs);
        if (totalCostMs > EXECUTE_REROUTE_PLAN_SLOW_THRESHOLD_MS) {
            log.warn("executeReroutePlanWithTaskLock slow, sceneType={}, taskNo={}, stationId={}, totalCostMs={}ms, resetCostMs={}ms, registerDispatchCostMs={}ms, offerDispatchCostMs={}ms",
                    context.sceneType(), taskNo, stationId, totalCostMs, resetCostMs, registerDispatchCostMs, offerDispatchCostMs);
        }
        return RerouteExecutionResult.dispatched(plan.command(), clearedCommandCount);
    }

    private RerouteExecutionResult executeSharedReroute(RerouteContext context) {
        RerouteDecision decision = resolveSharedRerouteDecision(context);
        if (decision.skip()) {
            return RerouteExecutionResult.skip(decision.skipReason());
        }
        RerouteCommandPlan plan = buildRerouteCommandPlan(context, decision);
        return executeReroutePlan(context, plan);
    }

    private void preRegisterDispatchSession(RerouteContext context, RerouteCommandPlan plan) {
        if (context == null || plan == null || plan.command() == null || context.wrkMast() == null || context.stationProtocol() == null) {
            return;
        }
        if (stationMoveCoordinator == null) {
            return;
        }
        OutOrderDispatchDecision dispatchDecision =
                plan.decision() == null ? null : plan.decision().dispatchDecision();
        stationMoveCoordinator.recordDispatch(
                context.wrkMast().getWrkNo(),
                context.stationProtocol().getStationId(),
                plan.dispatchScene(),
                plan.command(),
                dispatchDecision != null && dispatchDecision.isCircle()
        );
    }

    private void applyRerouteDispatchEffects(RerouteContext context,
                                             RerouteCommandPlan plan,
                                             int clearedCommandCount) {
        if (context == null || plan == null || plan.command() == null || context.wrkMast() == null || context.stationProtocol() == null) {
            return;
        }
        WrkMast wrkMast = context.wrkMast();
        StationProtocol stationProtocol = context.stationProtocol();
        OutOrderDispatchDecision dispatchDecision =
                plan.decision() == null ? null : plan.decision().dispatchDecision();

        stationOutboundDecisionSupport.syncOutOrderWatchState(
                wrkMast,
                stationProtocol.getStationId(),
                context.outOrderStationIds(),
                dispatchDecision,
                plan.command()
        );
        if (context.sceneType() == RerouteSceneType.RUN_BLOCK_REROUTE) {
            News.info("输送站点堵塞后重新计算路径命令下发成功，站点号={}，工作号={}，命令数据={}",
                    stationProtocol.getStationId(),
                    wrkMast.getWrkNo(),
                    JSON.toJSONString(plan.command()));
            return;
        }
        if (context.sceneType() == RerouteSceneType.OUT_ORDER) {
            News.info(dispatchDecision != null && dispatchDecision.isCircle() ? "{}任务进行绕圈" : "{}任务直接去目标点", wrkMast.getWrkNo());
        }
    }

    private void executeRunBlockDirectReassign(BasDevp basDevp,
                                               StationThread stationThread,
                                               StationProtocol stationProtocol,
                                               WrkMast wrkMast) {
        if (basDevp == null || stationThread == null || stationProtocol == null || wrkMast == null) {
            return;
        }
        int currentTaskBufferCommandCount = countCurrentTaskBufferCommands(
                stationProtocol.getTaskBufferItems(),
                stationProtocol.getTaskNo()
        );
        if (currentTaskBufferCommandCount > 0) {
            News.info("输送站点运行堵塞重分配检测到旧分段命令残留，将先重置本地分段状态后继续重发。站点号={}，工作号={}，当前任务命令数={}",
                    stationProtocol.getStationId(),
                    stationProtocol.getTaskNo(),
                    currentTaskBufferCommandCount);
        }
        if (stationDispatchRuntimeStateSupport.hasRunBlockDirectReassignLimit(
                wrkMast.getWrkNo(),
                stationProtocol.getStationId())) {
            News.info("输送站点运行堵塞重分配已跳过，8分钟内不允许重复申请。站点号={}，工作号={}",
                    stationProtocol.getStationId(),
                    wrkMast.getWrkNo());
            return;
        }
        String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationProtocol.getStationId());
        if (Cools.isEmpty(response)) {
            appendStationSystemWarning(stationProtocol, RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING);
            News.taskError(wrkMast.getWrkNo(), "请求WMS重新分配库位接口失败，接口未响应！！！response：{}", response);
            return;
        }
        JSONObject jsonObject;
        try {
            jsonObject = JSON.parseObject(response);
        } catch (Exception e) {
            appendStationSystemWarning(stationProtocol, RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING);
            News.taskError(wrkMast.getWrkNo(), "请求WMS重新分配库位接口响应解析异常！！！response：{}", response, e);
            return;
        }
        if (jsonObject == null || !Integer.valueOf(200).equals(jsonObject.getInteger("code"))) {
            appendStationSystemWarning(stationProtocol, RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING);
            News.taskError(wrkMast.getWrkNo(), "请求WMS接口失败！！！response：{}", response);
            return;
        }

        StartupDto dto = jsonObject.getObject("data", StartupDto.class);
        if (dto == null || Cools.isEmpty(dto.getLocNo())) {
            appendStationSystemWarning(stationProtocol, RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING);
            News.taskError(wrkMast.getWrkNo(), "请求WMS重新分配库位接口失败，WMS未返回目标库位！！！response：{}", response);
            return;
        }
        clearStationSystemWarningByPrefix(stationProtocol, RUN_BLOCK_DIRECT_REASSIGN_WMS_WARNING_PREFIX);
        String sourceLocNo = wrkMast.getLocNo();
        String locNo = dto.getLocNo();

        LocMast sourceLocMast = locMastService.queryByLoc(sourceLocNo);
        if (sourceLocMast == null) {
            News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 源库位信息不存在", sourceLocNo);
            return;
        }
        if (!sourceLocMast.getLocSts().equals("S")) {
            News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 源库位状态不处于入库预约", sourceLocNo);
            return;
        }

        LocMast locMast = locMastService.queryByLoc(locNo);
        if (locMast == null) {
            News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 目标库位信息不存在", locNo);
            return;
        }
        if (!locMast.getLocSts().equals("O")) {
            News.taskInfo(wrkMast.getWrkNo(), "库位号:{} 目标库位状态不处于空库位", locNo);
            return;
        }

        FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
        if (findCrnNoResult == null) {
            News.taskInfo(wrkMast.getWrkNo(), "{}工作,未匹配到堆垛机", wrkMast.getWrkNo());
            return;
        }
        Integer crnNo = findCrnNoResult.getCrnNo();

        Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationProtocol.getStationId());
        if (targetStationId == null) {
            News.taskInfo(wrkMast.getWrkNo(), "{}站点,搜索入库站点失败", stationProtocol.getStationId());
            return;
        }

        StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), targetStationId, 0);
        if (command == null) {
            News.taskInfo(wrkMast.getWrkNo(), "{}工作,获取输送线命令失败", wrkMast.getWrkNo());
            return;
        }

        sourceLocMast.setLocSts("O");
        sourceLocMast.setModiTime(new Date());
        locMastService.updateById(sourceLocMast);

        locMast.setLocSts("S");
        locMast.setModiTime(new Date());
        locMastService.updateById(locMast);

        wrkMast.setLocNo(locNo);
        wrkMast.setStaNo(targetStationId);

        if (findCrnNoResult.getCrnType().equals(SlaveType.Crn)) {
            wrkMast.setCrnNo(crnNo);
        } else if (findCrnNoResult.getCrnType().equals(SlaveType.DualCrn)) {
            wrkMast.setDualCrnNo(crnNo);
        } else {
            throw new CoolException("未知设备类型");
        }

        if (!wrkMastService.updateById(wrkMast)) {
            return;
        }
        stationDispatchRuntimeStateSupport.recordRunBlockDirectReassignLimit(
                wrkMast.getWrkNo(),
                stationProtocol.getStationId(),
                RUN_BLOCK_DIRECT_REASSIGN_LIMIT_SECONDS);
        stationDispatchRuntimeStateSupport.signalSegmentReset(wrkMast.getWrkNo(), STATION_MOVE_RESET_WAIT_MS);
        if (stationMoveCoordinator != null) {
            stationMoveCoordinator.markCancelPending(wrkMast.getWrkNo(), "reroute_pending");
            stationMoveCoordinator.cancelSession(wrkMast.getWrkNo());
            stationMoveCoordinator.recordDispatch(
                    wrkMast.getWrkNo(),
                    stationProtocol.getStationId(),
                    "checkStationRunBlock_direct",
                    command,
                    false
            );
        }
        boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "checkStationRunBlock_direct");
        if (!offered) {
            News.warn("输送站点堵塞直派命令入队被拒绝(可能重复)，站点号={}，工作号={}", stationProtocol.getStationId(), wrkMast.getWrkNo());
        }
    }

    private void appendStationSystemWarning(StationProtocol stationProtocol, String warning) {
        if (stationProtocol == null || Cools.isEmpty(warning)) {
            return;
        }
        String currentWarning = stationProtocol.getSystemWarning();
        if (Cools.isEmpty(currentWarning)) {
            stationProtocol.setSystemWarning(warning);
            return;
        }
        if (currentWarning.contains(warning)) {
            return;
        }
        stationProtocol.setSystemWarning(currentWarning + ";" + warning);
    }

    private void clearStationSystemWarningByPrefix(StationProtocol stationProtocol, String warningPrefix) {
        if (stationProtocol == null || Cools.isEmpty(warningPrefix) || Cools.isEmpty(stationProtocol.getSystemWarning())) {
            return;
        }
        String[] warningParts = stationProtocol.getSystemWarning().split(";");
        List<String> keepWarningList = new ArrayList<>();
        for (String warningPart : warningParts) {
            if (Cools.isEmpty(warningPart) || warningPart.startsWith(warningPrefix)) {
                continue;
            }
            keepWarningList.add(warningPart);
        }
        stationProtocol.setSystemWarning(String.join(";", keepWarningList));
    }

    private int countCurrentTaskBufferCommands(List<StationTaskBufferItem> taskBufferItems, Integer currentTaskNo) {
        if (taskBufferItems == null || taskBufferItems.isEmpty() || currentTaskNo == null || currentTaskNo <= 0) {
            return 0;
        }
        int count = 0;
        for (StationTaskBufferItem item : taskBufferItems) {
            if (item == null || item.getTaskNo() == null) {
                continue;
            }
            if (currentTaskNo.equals(item.getTaskNo())) {
                count++;
            }
        }
        return count;
    }

    private boolean offerDevpCommandWithDedup(Integer deviceNo, StationCommand command, String scene) {
        StationCommandDispatchResult dispatchResult = stationCommandDispatcher
                .dispatch(deviceNo, command, "station-operate-process", scene);
        return dispatchResult.isAccepted();
    }

    private boolean isBlank(String value) {
        return value == null || value.trim().isEmpty();
    }
}