baiyue-firstleg/lastleg-service/src/main/java/com/baiyue/lastleg/service/LastlegOrderService.java

package com.baiyue.lastleg.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baiyue.common.core.api.PageResult;
import com.baiyue.common.event.ContainerNumbers;
import com.baiyue.lastleg.dto.LastlegOrderDetailResponse;
import com.baiyue.lastleg.dto.LastlegOrderCommandDtos;
import com.baiyue.lastleg.dto.LastlegOrderRequests;
import com.baiyue.lastleg.dto.LastlegOrderSummary;
import com.baiyue.lastleg.dto.ContainerPlanProgressDetail;
import com.baiyue.lastleg.dto.ContainerPlanProgressSummary;
import com.baiyue.lastleg.dto.ContainerArrivalTimeView;
import com.baiyue.lastleg.entity.LastlegOrder;
import com.baiyue.lastleg.entity.LastlegOrderDetail;
import com.baiyue.lastleg.entity.LastlegOrderStatusHistory;
import com.baiyue.lastleg.entity.LastlegOrderOperationLog;
import com.baiyue.lastleg.entity.LastlegOrderManualNode;
import com.baiyue.lastleg.entity.ReceivingWarehouseOperation;
import com.baiyue.lastleg.entity.ContainerArrivalTimeOperation;
import com.baiyue.lastleg.inboundplan.pda.gateway.WarehouseResourceGateway;
import com.baiyue.lastleg.inboundplan.entity.InboundPlanCarton;
import com.baiyue.lastleg.inboundplan.mapper.InboundPlanCartonMapper;
import com.baiyue.lastleg.inventory.command.service.InventoryCommandService;
import com.baiyue.lastleg.mapper.LastlegOrderDetailMapper;
import com.baiyue.lastleg.mapper.LastlegOrderMapper;
import com.baiyue.lastleg.mapper.LastlegOrderStatusHistoryMapper;
import com.baiyue.lastleg.financefee.dto.OverseasFeeSourceDtos;
import com.baiyue.lastleg.financefee.entity.OverseasFeeSource;
import com.baiyue.lastleg.financefee.service.OverseasFeeSourceService;
import com.baiyue.lastleg.mapper.LastlegOrderOperationLogMapper;
import com.baiyue.lastleg.mapper.LastlegOrderManualNodeMapper;
import com.baiyue.lastleg.mapper.ReceivingWarehouseOperationMapper;
import com.baiyue.lastleg.mapper.ContainerArrivalTimeOperationMapper;
import com.baiyue.lastleg.model.LastlegOrderType;
import com.baiyue.lastleg.model.LastlegOrderStatus;
import com.baiyue.lastleg.shipping.entity.ContainerShippingGate;
import com.baiyue.lastleg.shipping.mapper.ContainerShippingGateMapper;
import jakarta.annotation.Resource;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ResponseStatusException;

import java.nio.charset.StandardCharsets;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class LastlegOrderService {
    public static final String PENDING_ASSIGNMENT = "PENDING_ASSIGNMENT";
    public static final String DESTINATION_ASSIGNED = "DESTINATION_ASSIGNED";
    public static final String INBOUND_PLANNED = "INBOUND_PLANNED";
    public static final String PALLET_MERGE_REQUIRED = "REQUIRED";
    public static final String PALLET_MERGED = "MERGED";
    private static final List<String> MANUAL_NODE_CODES = List.of(
        "DOMESTIC_CUSTOMS_COMPLETED", "ESTIMATED_DEPARTURE", "ACTUAL_DEPARTURE", "ESTIMATED_ARRIVAL",
        "OVERSEAS_CUSTOMS_COMPLETED", "ACTUAL_ARRIVAL_WAITING_UNLOAD", "PICKUP_APPOINTED", "UNLOADED");

    @Resource private LastlegOrderMapper orderMapper;
    @Resource private com.baiyue.lastleg.returnreceipt.service.ReturnReceiptService returnReceipts;
    @Resource private LastlegOrderDetailMapper detailMapper;
    @Resource private LastlegOrderStatusHistoryMapper historyMapper;
    @Resource private OverseasFeeSourceService feeSources;
    @Resource private LastlegOrderOperationLogMapper operationLogMapper;
    @Resource private LastlegOrderManualNodeMapper manualNodeMapper;
    @Resource private InboundPlanCartonMapper cartonMapper;
    @Resource private FbaWarehouseValidator fbaWarehouseValidator;
    @Resource private InventoryCommandService inventory;
    @Resource private ReceivingWarehouseOperationMapper receivingWarehouseOperations;
    @Resource private ContainerArrivalTimeOperationMapper containerArrivalTimeOperations;
    @Resource private WarehouseResourceGateway warehouseResourceGateway;
    @Resource private ContainerShippingGateMapper containerShippingGates;
    @Resource private ReturnOrderReferenceResolver returnOrderReferences;

    public PageResult<LastlegOrderSummary> page(String customerId, LastlegOrderRequests.Query query) {
        return page(customerId, query, null);
    }

    public PageResult<LastlegOrderSummary> page(String customerId, LastlegOrderRequests.Query query, String relabelNo) {
        Page<LastlegOrder> page = orderMapper.selectPage(
            new Page<>(query.page(), query.size()), filter(customerId, query, relabelNo).orderByDesc(LastlegOrder::getCreatedAt).orderByDesc(LastlegOrder::getId));
        Map<Long, List<LastlegOrderMapper.PalletMergeRelationRow>> mergeRelations = palletMergeRelations(page.getRecords());
        returnOrderReferences.populateForRead(page.getRecords());
        refreshReturnVolumes(page.getRecords());
        Map<String, String> containerNodes = containerNodes(page.getRecords());
        Map<Long, String> dispatchStatuses = dispatchStatuses(page.getRecords());
        Map<Long, LastlegOrderMapper.OrderWeightRow> weights = orderWeights(page.getRecords());
        Map<Long, List<com.baiyue.lastleg.dto.RelabelSubOrder>> relabels = relabelSubOrders(page.getRecords());
        Map<Long, LastlegOrderSummary.BusinessSource> businessSources = businessSources(page.getRecords());
        return new PageResult<>(page.getRecords().stream().map(order -> summary(order, mergeRelations.get(order.getId()),
                StringUtils.hasText(order.getSourceContainerBookingId())
                    ? containerNodes.get(order.getSourceContainerBookingId()) : null,
                dispatchStatuses.getOrDefault(order.getId(), "UNSCHEDULED"), weights.get(order.getId()),
                relabels.getOrDefault(order.getId(), List.of()), businessSources.get(order.getId()))).toList(),
            page.getCurrent(), page.getSize(), page.getTotal(), page.getPages());
    }

    @Transactional(readOnly = true)
    public PageResult<ContainerPlanProgressSummary> containerProgressPage(
        LastlegOrderRequests.ContainerProgressQuery query) {
        if (query.createdFrom() != null && query.createdTo() != null
            && query.createdFrom().isAfter(query.createdTo())) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST,
                "createdFrom must not be after createdTo");
        }
        long total = orderMapper.countContainerProgress(query);
        List<ContainerPlanProgressSummary> records = total == 0 ? List.of()
            : orderMapper.pageContainerProgress(query, (query.page() - 1) * query.size(), query.size())
                .stream().map(this::containerSummaryForRead).toList();
        long pages = total == 0 ? 0 : (total + query.size() - 1) / query.size();
        return new PageResult<>(records, query.page(), query.size(), total, pages);
    }

    @Transactional(readOnly = true)
    public ContainerPlanProgressDetail containerProgressDetail(String sourceContainerBookingId) {
        String bookingId = sourceContainerBookingId == null ? null : sourceContainerBookingId.trim();
        if (!StringUtils.hasText(bookingId)) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "来源柜预订ID不能为空");
        }
        ContainerPlanProgressSummary summary = orderMapper.findContainerProgress(bookingId);
        if (summary == null) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "来源柜不存在");
        }
        return new ContainerPlanProgressDetail(containerSummaryForRead(summary),
            orderMapper.findContainerProgressItems(bookingId));
    }

    @Transactional(readOnly = true)
    public List<ContainerArrivalTimeView> containerArrivalTimes(
        LastlegOrderRequests.ContainerArrivalTimeQuery request) {
        LinkedHashSet<String> bookingIds = new LinkedHashSet<>();
        for (String value : request.sourceContainerBookingIds()) bookingIds.add(normalizeBookingId(value));
        if (bookingIds.size() != request.sourceContainerBookingIds().size()) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "来源柜预订ID不能重复");
        }
        return orderMapper.findContainerArrivalTimes(List.copyOf(bookingIds));
    }

    @Transactional
    public ContainerArrivalTimeView changeExpectedWarehouseArrival(String sourceContainerBookingId,
        String idempotencyKey, LastlegOrderRequests.ChangeExpectedWarehouseArrival request,
        String operatorName) {
        String bookingId = normalizeBookingId(sourceContainerBookingId);
        String key = normalizeIdempotencyKey(idempotencyKey);
        String requestHash = hash(bookingId + "\n" + request.estimatedWarehouseArrivalAt() + "\n"
            + request.expectedVersion() + "\n" + Objects.toString(request.remark(), ""));
        ContainerArrivalTimeOperation replay = containerArrivalTimeOperations.findByKey(key);
        if (replay != null) {
            if (!bookingId.equals(replay.getSourceContainerBookingId())
                || !requestHash.equals(replay.getRequestHash())) {
                throw new ResponseStatusException(HttpStatus.CONFLICT,
                    "Idempotency-Key 已用于其他预计到仓时间修改请求");
            }
            return requireContainerArrivalTime(bookingId);
        }

        List<LastlegOrder> orders = orderMapper.lockContainerOrders(bookingId);
        if (orders.isEmpty()) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "来源柜不存在");
        int version = requireSingleArrivalTimeVersion(orders);
        if (version != request.expectedVersion()) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "预计到仓时间版本已变化，请刷新后重试");
        }
        if (orderMapper.countContainerPlans(bookingId) > 0) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "该柜已生成入库计划，预计到仓时间不可修改");
        }
        int updated = orderMapper.updateContainerExpectedWarehouseArrival(bookingId,
            request.estimatedWarehouseArrivalAt(), version);
        if (updated != orders.size()) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "柜内预计到仓时间发生并发变化");
        }
        ContainerArrivalTimeOperation operation = new ContainerArrivalTimeOperation();
        operation.setId(IdWorker.getId()); operation.setSourceContainerBookingId(bookingId);
        operation.setIdempotencyKey(key); operation.setRequestHash(requestHash);
        operation.setResultVersion(version + 1); operation.setOperatorName(operatorName);
        operation.setRemark(request.remark() == null ? null : request.remark().trim());
        operation.setCreatedAt(LocalDateTime.now()); containerArrivalTimeOperations.insert(operation);
        return requireContainerArrivalTime(bookingId);
    }

    private ContainerArrivalTimeView requireContainerArrivalTime(String bookingId) {
        List<ContainerArrivalTimeView> values = orderMapper.findContainerArrivalTimes(List.of(bookingId));
        if (values.size() != 1) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "来源柜不存在");
        if (values.get(0).version() < 0) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "柜内预计到仓时间版本不一致");
        }
        return values.get(0);
    }

    private int requireSingleArrivalTimeVersion(List<LastlegOrder> orders) {
        Set<Integer> versions = orders.stream().map(LastlegOrder::getArrivalTimeVersion)
            .map(value -> value == null ? 0 : value).collect(Collectors.toSet());
        if (versions.size() != 1) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "柜内预计到仓时间版本不一致");
        }
        return versions.iterator().next();
    }

    @Transactional
    public ContainerPlanProgressSummary changeReceivingWarehouse(String sourceContainerBookingId,
        String idempotencyKey, LastlegOrderRequests.ChangeReceivingWarehouse request, String operatorName) {
        String bookingId = normalizeBookingId(sourceContainerBookingId);
        String key = normalizeIdempotencyKey(idempotencyKey);
        String requestHash = hash(bookingId + "\n" + request.overseasWarehouseId() + "\n"
            + request.expectedVersion() + "\n" + Objects.toString(request.remark(), ""));
        ReceivingWarehouseOperation replay = receivingWarehouseOperations.findByKey(key);
        if (replay != null) {
            if (!bookingId.equals(replay.getSourceContainerBookingId()) || !requestHash.equals(replay.getRequestHash())) {
                throw new ResponseStatusException(HttpStatus.CONFLICT,
                    "Idempotency-Key 已用于其他接柜仓修改请求");
            }
            return requireFrozenContainer(orderMapper.findContainerProgress(bookingId));
        }

        List<LastlegOrder> orders = orderMapper.lockContainerOrders(bookingId);
        if (orders.isEmpty()) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "来源柜不存在");
        int version = requireSingleAssignmentVersion(orders);
        if (version != request.expectedVersion()) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "接柜仓分配版本已变化，请刷新后重试");
        }
        if (orderMapper.countReceivingSessions(bookingId) > 0) {
            throw new ResponseStatusException(HttpStatus.CONFLICT,
                "海外PDA已建立接柜会话，接柜仓已永久锁定");
        }
        WarehouseResourceGateway.WarehouseReference warehouse =
            warehouseResourceGateway.requireActiveSharedWarehouse(request.overseasWarehouseId());
        for (LastlegOrder order : orders) {
            inventory.rebindReceivingWarehouse(order.getCustomerId(), order.getId(), warehouse.warehouseId(),
                warehouse.warehouseCode(), warehouse.warehouseName(), operatorName, key);
        }
        int updated = orderMapper.updateContainerReceivingWarehouse(bookingId,
            Long.toString(warehouse.warehouseId()), warehouse.warehouseCode(), warehouse.warehouseName(), version);
        if (updated != orders.size()) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "柜内接柜仓分配发生并发变化");
        }
        orderMapper.updateContainerPlanReceivingWarehouse(bookingId, warehouse.warehouseId());
        ReceivingWarehouseOperation operation = new ReceivingWarehouseOperation();
        operation.setId(IdWorker.getId()); operation.setSourceContainerBookingId(bookingId);
        operation.setIdempotencyKey(key); operation.setRequestHash(requestHash);
        operation.setResultVersion(version + 1); operation.setOperatorName(operatorName);
        operation.setRemark(request.remark() == null ? null : request.remark().trim());
        operation.setCreatedAt(LocalDateTime.now()); receivingWarehouseOperations.insert(operation);
        return requireFrozenContainer(orderMapper.findContainerProgress(bookingId));
    }

    private ContainerPlanProgressSummary requireFrozenContainer(ContainerPlanProgressSummary summary) {
        if (summary == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "来源柜不存在");
        String issue = containerSnapshotIssue(summary);
        if (issue != null) throw new ResponseStatusException(HttpStatus.CONFLICT, issue);
        return summary;
    }

    private ContainerPlanProgressSummary containerSummaryForRead(ContainerPlanProgressSummary summary) {
        String issue = containerSnapshotIssue(summary);
        if (issue == null) return summary;
        boolean invalidContainer = !hasCanonicalContainerNo(summary.containerNo());
        return new ContainerPlanProgressSummary(summary.sourceContainerBookingId(), summary.containerNo(),
            summary.overseasWarehouseId(), summary.overseasWarehouseCode(), summary.overseasWarehouseName(),
            summary.assignmentVersion(), invalidContainer ? false : summary.canChangeReceivingWarehouse(),
            invalidContainer ? issue : summary.receivingWarehouseLockReason(), summary.totalOrderCount(),
            summary.inboundCodeCount(), summary.missingInboundCodeCount(), summary.planCount(),
            summary.plannedInboundCodeCount(), summary.pendingPlanCount(), summary.resourcePendingPlanCount(), summary.plannedArrivalAt(),
            false, issue);
    }

    private String containerSnapshotIssue(ContainerPlanProgressSummary summary) {
        if (!hasCanonicalContainerNo(summary.containerNo())) {
            return "来源柜真实集装箱号缺失、格式无效或存在漂移";
        }
        if (!StringUtils.hasText(summary.overseasWarehouseId())
            || !StringUtils.hasText(summary.overseasWarehouseCode())
            || !StringUtils.hasText(summary.overseasWarehouseName()) || summary.assignmentVersion() < 0) {
            return "柜内接柜仓业务快照不一致";
        }
        return null;
    }

    private boolean hasCanonicalContainerNo(String containerNo) {
        try {
            ContainerNumbers.requireCanonical(containerNo);
            return true;
        } catch (IllegalArgumentException exception) {
            return false;
        }
    }

    private String normalizeBookingId(String value) {
        String result = value == null ? null : value.trim();
        if (!StringUtils.hasText(result) || result.length() > 128) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "来源柜预订ID不能为空");
        }
        return result;
    }

    private String normalizeIdempotencyKey(String value) {
        String result = value == null ? null : value.trim();
        if (!StringUtils.hasText(result) || result.length() > 255) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Idempotency-Key 必填且不得超过255字符");
        }
        return result;
    }

    private int requireSingleAssignmentVersion(List<LastlegOrder> orders) {
        Integer version = orders.get(0).getReceivingWarehouseVersion();
        if (version == null || orders.stream().anyMatch(order -> !Objects.equals(version,
            order.getReceivingWarehouseVersion()) || !StringUtils.hasText(order.getOverseasWarehouseId())
            || !StringUtils.hasText(order.getOverseasWarehouseCode())
            || !StringUtils.hasText(order.getOverseasWarehouseName()))) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "柜内接柜仓分配事实不一致");
        }
        return version;
    }

    private String hash(String value) {
        try {
            return java.util.HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256")
                .digest(value.getBytes(StandardCharsets.UTF_8)));
        } catch (Exception exception) {
            throw new IllegalStateException(exception);
        }
    }

    public LastlegOrderDetailResponse detail(String customerId, long orderId) {
        LastlegOrder order = findOwned(customerId, orderId);
        returnOrderReferences.populateForRead(List.of(order));
        refreshReturnVolumes(List.of(order));
        List<LastlegOrderDetail> cargo = detailMapper.selectList(new LambdaQueryWrapper<LastlegOrderDetail>()
            .eq(LastlegOrderDetail::getCustomerId, order.getCustomerId())
            .eq(LastlegOrderDetail::getOrderId, orderId).orderByAsc(LastlegOrderDetail::getId));
        List<LastlegOrderStatusHistory> history = historyMapper.selectList(
            new LambdaQueryWrapper<LastlegOrderStatusHistory>()
                .eq(LastlegOrderStatusHistory::getCustomerId, order.getCustomerId())
                .eq(LastlegOrderStatusHistory::getOrderId, orderId)
                .orderByAsc(LastlegOrderStatusHistory::getCreatedAt));
        List<OverseasFeeSource> fees = feeSources.listForBusiness(order.getCustomerId(), "LASTLEG_ORDER", orderId);
        List<LastlegOrderOperationLog> operations = operationLogMapper.selectList(
            new LambdaQueryWrapper<LastlegOrderOperationLog>()
                .eq(LastlegOrderOperationLog::getCustomerId, order.getCustomerId())
                .eq(LastlegOrderOperationLog::getOrderId, orderId)
                .orderByAsc(LastlegOrderOperationLog::getCreatedAt));
        List<LastlegOrderCommandDtos.ManualNodeView> manualNodes = manualNodeMapper.selectList(
            new LambdaQueryWrapper<LastlegOrderManualNode>()
                .eq(LastlegOrderManualNode::getCustomerId, order.getCustomerId())
                .eq(LastlegOrderManualNode::getOrderId, orderId)
                .orderByAsc(LastlegOrderManualNode::getId)).stream()
            .map(value -> new LastlegOrderCommandDtos.ManualNodeView(
                value.getNodeCode(), value.getNodeAt(), value.getSource()))
            .sorted(java.util.Comparator.comparingInt(value -> MANUAL_NODE_CODES.indexOf(value.nodeCode()))).toList();
        return new LastlegOrderDetailResponse(summary(order, palletMergeRelations(List.of(order)).get(order.getId()),
            containerNode(order), dispatchStatuses(List.of(order)).getOrDefault(order.getId(), "UNSCHEDULED"),
            orderWeights(List.of(order)).get(order.getId()), relabelSubOrders(List.of(order)).getOrDefault(order.getId(), List.of()),
            businessSources(List.of(order)).get(order.getId())), manualNodes, cargo, history.stream()
            .map(value -> new LastlegOrderDetailResponse.History(value.getId(), value.getFromStatus(),
                value.getToStatus(), value.getRemark(), value.getCreatedAt())).toList(), fees, operations.stream()
            .map(value -> new LastlegOrderDetailResponse.Operation(value.getId(), value.getOperationNode(),
                value.getOperatorName(), value.getResult(), value.getCreatedAt())).toList(),
            "RETURN_RELABEL".equals(order.getOrderType()) && StringUtils.hasText(order.getSourceOrderNo())
                ? returnReceipts.detail(order.getCustomerId(), order.getSourceOrderNo()) : null);
    }

    @Transactional
    public OverseasFeeSource createFee(String customerId, long orderId, LastlegOrderRequests.CreateFee request,
                                       String operatorName, String idempotencyKey) {
        LastlegOrder order = findOwned(customerId, orderId);
        LocalDateTime now = LocalDateTime.now();
        OverseasFeeSource fee = feeSources.create(operatorName, idempotencyKey,
            new OverseasFeeSourceDtos.SaveRequest(order.getCustomerId(), order.getCustomerName(),
                "OVERSEAS_ORDER_FEE", "LASTLEG_ORDER", orderId, order.getOrderNo(), orderId,
                null, order.getInboundCode(), null, parseLong(order.getSourceContainerBookingId()),
                order.getContainerNo(), parseLong(order.getOverseasWarehouseId()), request.feeItemCode(),
                request.feeItemName(), request.direction(), request.supplierId(), request.supplierName(),
                request.supplierCategory(), request.settlementMode(), request.paidAt(), request.paymentMethod(),
                request.paymentReferenceNo(), request.paymentVoucherFileIds(), request.businessDate(),
                request.currency(), request.amount(), request.chargeableQuantity(), request.quantityUnit(),
                request.unitPrice(), request.periodStart(), request.periodEnd()));
        fee = feeSources.submit(fee.getSourceFeeId(), operatorName, childKey(idempotencyKey, "submit"));

        LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
        operation.setId(IdWorker.getId());
        operation.setCustomerId(order.getCustomerId());
        operation.setOrderId(orderId);
        operation.setOperationNode("新增费用");
        operation.setOperatorName(operatorName);
        operation.setResult("新增" + fee.getFeeItemName() + "：" + fee.getOriginalCurrency() + " "
            + fee.getOriginalAmount().toPlainString() + "，已提交财务审核");
        operation.setCreatedAt(now);
        operationLogMapper.insert(operation);
        return fee;
    }

    @Transactional
    public void setPalletMergeRequired(String customerId, long orderId,
                                       LastlegOrderRequests.SetPalletMergeRequired request,
                                       String operatorName) {
        LastlegOrder current = findOwned(customerId, orderId);
        LastlegOrder order = orderMapper.lockById(current.getCustomerId(), orderId);
        if (order == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Tail-leg order not found");
        if ("INBOUND_COMPLETED".equals(order.getCurrentStatus())) {
            throw new ResponseStatusException(HttpStatus.CONFLICT,
                "Completed inbound orders cannot change the pallet merge mark");
        }
        if (PALLET_MERGED.equals(order.getPalletMergeFlag())) {
            throw new ResponseStatusException(HttpStatus.CONFLICT,
                "A completed pallet merge cannot be unmarked");
        }
        String target = request.palletMergeRequired() ? PALLET_MERGE_REQUIRED : null;
        if (Objects.equals(target, order.getPalletMergeFlag())) return;
        LocalDateTime now = LocalDateTime.now();
        if (orderMapper.updatePalletMergeFlag(order.getCustomerId(), orderId, target, now) != 1) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "Pallet merge mark was not updated");
        }
        LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
        operation.setId(IdWorker.getId());
        operation.setCustomerId(order.getCustomerId());
        operation.setOrderId(orderId);
        operation.setOperationNode(request.palletMergeRequired() ? "标记合托" : "取消合托标记");
        operation.setOperatorName(operatorName);
        operation.setResult(request.palletMergeRequired()
            ? "PDA扫描本单箱唛时提示需要合托" : "已取消PDA合托提示");
        operation.setCreatedAt(now);
        operationLogMapper.insert(operation);
    }

    @Transactional
    public void setPalletMergeBatch(String customerId, LastlegOrderRequests.SetPalletMergeBatch request,
                                    String operatorName) {
        List<Long> ids = request.orderIds().stream().filter(Objects::nonNull).distinct().toList();
        if (ids.isEmpty()) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "At least one order is required");
        List<LastlegOrder> orders = orderMapper.selectList(new LambdaQueryWrapper<LastlegOrder>()
            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
            .in(LastlegOrder::getId, ids).last("FOR UPDATE"));
        if (orders.size() != ids.size()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "One or more tail-leg orders were not found");
        }
        if (orders.stream().map(LastlegOrder::getCustomerId).distinct().count() != 1) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Pallet merge orders must belong to one customer");
        }
        if (orders.stream().map(order -> StringUtils.hasText(order.getTransferWarehouseCode())
            ? order.getTransferWarehouseCode() : order.getFbaWarehouseCode()).filter(Objects::nonNull).distinct().count() > 1) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Pallet merge orders must have one destination warehouse");
        }
        if (orders.stream().anyMatch(order -> "INBOUND_COMPLETED".equals(order.getCurrentStatus())
            || PALLET_MERGED.equals(order.getPalletMergeFlag()))) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "Completed pallet merge orders cannot be changed");
        }
        String batchId = request.palletMergeRequired()
            ? "PMG-" + java.util.UUID.randomUUID().toString().replace("-", "") : null;
        String flag = request.palletMergeRequired() ? PALLET_MERGE_REQUIRED : null;
        LocalDateTime now = LocalDateTime.now();
        for (LastlegOrder order : orders) {
            if (orderMapper.updatePalletMergeBatch(order.getCustomerId(), order.getId(), flag, batchId, now) != 1) {
                throw new ResponseStatusException(HttpStatus.CONFLICT, "Pallet merge group was not updated");
            }
            LastlegOrderOperationLog operation = new LastlegOrderOperationLog();
            operation.setId(IdWorker.getId()); operation.setCustomerId(order.getCustomerId());
            operation.setOrderId(order.getId());
            operation.setOperationNode(request.palletMergeRequired() ? "批量标记合托" : "取消合托标记");
            operation.setOperatorName(operatorName);
            operation.setResult(request.palletMergeRequired() ? "PDA合托分组 " + batchId : "已取消PDA合托分组");
            operation.setCreatedAt(now); operationLogMapper.insert(operation);
        }
    }

    @Transactional
    public int transferDestination(String customerId, LastlegOrderRequests.TransferDestination request) {
        List<Long> ids = request.orderIds().stream().filter(Objects::nonNull).distinct().toList();
        if (ids.isEmpty()) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "At least one order is required");
        }
        FbaWarehouseValidator.VerifiedFbaWarehouse target = fbaWarehouseValidator.required(
            request.warehouseId(), request.warehouseCode(), request.warehouseName());
        String warehouseId = Long.toString(target.id());
        List<LastlegOrder> orders = orderMapper.selectList(new LambdaQueryWrapper<LastlegOrder>()
            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
            .in(LastlegOrder::getId, ids).last("FOR UPDATE"));
        if (orders.size() != ids.size()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "One or more tail-leg orders were not found");
        }
        for (LastlegOrder order : orders) {
            ensureTransferable(order);
        }
        LocalDateTime now = LocalDateTime.now();
        for (LastlegOrder order : orders) {
            String fromStatus = order.getCurrentStatus();
            order.setTransferWarehouseId(warehouseId);
            order.setTransferWarehouseCode(target.code());
            order.setTransferWarehouseName(target.name());
            order.setCurrentStatus(DESTINATION_ASSIGNED);
            order.setUpdatedAt(now);
            orderMapper.updateById(order);

            LastlegOrderDetail detailUpdate = new LastlegOrderDetail();
            detailUpdate.setDestinationWarehouseId(warehouseId);
            detailUpdate.setDestinationWarehouseCode(target.code());
            detailUpdate.setDestinationWarehouseName(target.name());
            detailMapper.update(detailUpdate, new LambdaQueryWrapper<LastlegOrderDetail>()
                .eq(LastlegOrderDetail::getCustomerId, order.getCustomerId())
                .eq(LastlegOrderDetail::getOrderId, order.getId()));

            InboundPlanCarton cartonUpdate = new InboundPlanCarton();
            cartonUpdate.setDestinationWarehouseId(warehouseId);
            cartonUpdate.setDestinationWarehouseCode(target.code());
            cartonUpdate.setDestinationWarehouseName(target.name());
            cartonMapper.update(cartonUpdate, new LambdaQueryWrapper<InboundPlanCarton>()
                .eq(InboundPlanCarton::getCustomerId, order.getCustomerId())
                .eq(InboundPlanCarton::getOrderId, order.getId()));

            LastlegOrderStatusHistory history = new LastlegOrderStatusHistory();
            history.setCustomerId(order.getCustomerId());
            history.setOrderId(order.getId());
            history.setFromStatus(fromStatus);
            history.setToStatus(DESTINATION_ASSIGNED);
            history.setRemark(StringUtils.hasText(request.remark())
                ? request.remark() : "Destination warehouse assigned: " + target.code());
            history.setCreatedAt(now);
            historyMapper.insert(history);
        }
        return orders.size();
    }

    private LambdaQueryWrapper<LastlegOrder> filter(String customerId, LastlegOrderRequests.Query query) {
        return filter(customerId, query, null);
    }

    private LambdaQueryWrapper<LastlegOrder> filter(String customerId, LastlegOrderRequests.Query query, String relabelNo) {
        if (query.createdFrom() != null && query.createdTo() != null && query.createdFrom().isAfter(query.createdTo())) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "createdFrom must not be after createdTo");
        }
        String currentStatus = StringUtils.hasText(query.currentStatus()) ? query.currentStatus() : query.status();
        String warehouse = StringUtils.hasText(query.warehouse()) ? query.warehouse().trim() : null;
        return new LambdaQueryWrapper<LastlegOrder>()
            .ne(LastlegOrder::getOrderType, "CARGO_DISCARD")
            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
            .and(StringUtils.hasText(query.orderNo()), nested -> nested
                .like(LastlegOrder::getOrderNo, query.orderNo())
                .or()
                .like(LastlegOrder::getSourceOrderNo, query.orderNo()))
            .and(StringUtils.hasText(relabelNo), nested -> nested
                .like(LastlegOrder::getRelabelOrderNo, relabelNo)
                .or().apply("EXISTS (SELECT 1 FROM ll_relabel_application r WHERE r.lastleg_order_id=ll_order.id " +
                    "AND r.customer_id=ll_order.customer_id AND r.relabel_no LIKE CONCAT('%',{0},'%'))", relabelNo))
            .eq(StringUtils.hasText(query.orderType()), LastlegOrder::getOrderType, query.orderType())
            .apply(StringUtils.hasText(query.businessType()), LastlegOrderMapper.BUSINESS_TYPE_FILTER_SQL, query.businessType())
            .apply(StringUtils.hasText(query.businessOrderNo()), LastlegOrderMapper.BUSINESS_ORDER_NO_FILTER_SQL, query.businessOrderNo())
            .apply(StringUtils.hasText(query.externalBookingNo()), LastlegOrderMapper.EXTERNAL_BOOKING_NO_SQL + " LIKE CONCAT('%',{0},'%')", query.externalBookingNo())
            .apply(query.sailingStage() != null, LastlegOrderMapper.SAILING_STAGE_FILTER_SQL,
                query.sailingStage() == LastlegOrderRequests.SailingStage.AFTER_DEPARTURE ? 1 : 0)
            .like(StringUtils.hasText(query.inboundCode()), LastlegOrder::getInboundCode, query.inboundCode())
            .like(StringUtils.hasText(query.lxCode()), LastlegOrder::getLxCode, query.lxCode())
            .like(StringUtils.hasText(query.sourceOrderNo()), LastlegOrder::getSourceOrderNo, query.sourceOrderNo())
            .like(StringUtils.hasText(query.containerNo()), LastlegOrder::getContainerNo, query.containerNo())
            .eq(StringUtils.hasText(currentStatus), LastlegOrder::getCurrentStatus, currentStatus)
            .apply(StringUtils.hasText(warehouse), LastlegOrderMapper.WAREHOUSE_FILTER_SQL, warehouse)
            .eq(StringUtils.hasText(query.transferWarehouseCode()), LastlegOrder::getTransferWarehouseCode,
                query.transferWarehouseCode())
            .eq(query.abnormal() != null, LastlegOrder::getAbnormal, query.abnormal())
            .eq(query.detained() != null, LastlegOrder::getDetained, query.detained())
            .ge(query.createdFrom() != null, LastlegOrder::getCreatedAt, query.createdFrom())
            .le(query.createdTo() != null, LastlegOrder::getCreatedAt, query.createdTo());
    }

    private LastlegOrder findOwned(String customerId, long orderId) {
        LastlegOrder order = orderMapper.selectOne(new LambdaQueryWrapper<LastlegOrder>()
            .eq(StringUtils.hasText(customerId), LastlegOrder::getCustomerId, customerId)
            .eq(LastlegOrder::getId, orderId));
        if (order == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Tail-leg order not found");
        return order;
    }

    private void ensureTransferable(LastlegOrder order) {
        if (StringUtils.hasText(order.getInboundOrderNo()) || INBOUND_PLANNED.equals(order.getCurrentStatus())) {
            throw new ResponseStatusException(HttpStatus.CONFLICT,
                "Destination warehouse cannot be changed after inbound plan creation: " + order.getId());
        }
    }

    private Map<Long, List<LastlegOrderMapper.PalletMergeRelationRow>> palletMergeRelations(List<LastlegOrder> orders) {
        if (orders.isEmpty()) return Map.of();
        Map<Long, List<LastlegOrderMapper.PalletMergeRelationRow>> result = new LinkedHashMap<>();
        List<LastlegOrderMapper.PalletMergeRelationRow> rows = orderMapper.findPalletMergeRelations(
            orders.stream().map(LastlegOrder::getId).toList());
        if (rows == null) return Map.of();
        for (LastlegOrderMapper.PalletMergeRelationRow row : rows) {
            result.computeIfAbsent(row.orderId(), ignored -> new ArrayList<>()).add(row);
        }
        return result;
    }

    private Map<Long, String> dispatchStatuses(List<LastlegOrder> orders) {
        if (orders.isEmpty()) return Map.of();
        List<LastlegOrderMapper.DispatchStatusRow> rows = orderMapper.findDispatchStatuses(
            orders.stream().map(LastlegOrder::getId).toList());
        if (rows == null) return Map.of();
        return rows.stream().collect(Collectors.toMap(LastlegOrderMapper.DispatchStatusRow::orderId,
            LastlegOrderMapper.DispatchStatusRow::dispatchStatus));
    }

    private void refreshReturnVolumes(List<LastlegOrder> orders) {
        List<Long> ids = orders.stream().filter(order -> "RETURN_RELABEL".equals(order.getOrderType())).map(LastlegOrder::getId).toList();
        if (ids.isEmpty()) return;
        Map<Long, BigDecimal> volumes = orderMapper.findReturnVolumes(ids).stream()
            .collect(Collectors.toMap(LastlegOrderMapper.ReturnVolumeRow::orderId, LastlegOrderMapper.ReturnVolumeRow::volumeCbm));
        for (LastlegOrder order : orders) if (volumes.containsKey(order.getId())) order.setVolumeCbm(volumes.get(order.getId()));
    }

    private Map<Long, LastlegOrderMapper.OrderWeightRow> orderWeights(List<LastlegOrder> orders) {
        if (orders.isEmpty()) return Map.of();
        List<LastlegOrderMapper.OrderWeightRow> rows = orderMapper.findOrderWeights(
            orders.stream().map(LastlegOrder::getId).toList());
        if (rows == null) return Map.of();
        return rows.stream().collect(Collectors.toMap(LastlegOrderMapper.OrderWeightRow::orderId, row -> row));
    }

    private Map<Long, List<com.baiyue.lastleg.dto.RelabelSubOrder>> relabelSubOrders(List<LastlegOrder> orders) {
        if (orders.isEmpty()) return Map.of();
        var rows = orderMapper.findRelabelSubOrders(orders.stream().map(LastlegOrder::getId).toList());
        return rows == null ? Map.of() : rows.stream().collect(Collectors.groupingBy(com.baiyue.lastleg.dto.RelabelSubOrder::lastlegOrderId));
    }

    private Map<Long, LastlegOrderSummary.BusinessSource> businessSources(List<LastlegOrder> orders) {
        if (orders.isEmpty()) return Map.of();
        return orderMapper.findBusinessSources(orders.stream().map(LastlegOrder::getId).toList()).stream()
            .collect(Collectors.toMap(LastlegOrderMapper.BusinessSourceRow::orderId, row -> {
                String label = "US_TRUCK".equals(row.businessType()) ? "本土卡车" : LastlegOrderType.labelOf(row.businessType());
                if (row.poolSource()) label += " · 拼车需求池";
                else if ("LOCAL_LOOSEBOARD".equals(row.businessType())) label += " · 独立下单";
                else if (StringUtils.hasText(row.externalBookingNo())) label += " · 外接来货";
                return new LastlegOrderSummary.BusinessSource(row.businessType(), label, row.businessOrderNo(), row.externalBookingNo());
            }));
    }

    private LastlegOrderSummary summary(LastlegOrder o, List<LastlegOrderMapper.PalletMergeRelationRow> relations,
                                         String containerNode, String dispatchStatus,
                                         LastlegOrderMapper.OrderWeightRow weight,
                                         List<com.baiyue.lastleg.dto.RelabelSubOrder> relabelApplications,
                                         LastlegOrderSummary.BusinessSource businessSource) {
        List<LastlegOrderMapper.PalletMergeRelationRow> related = relations == null ? List.of() : relations;
        return new LastlegOrderSummary(o.getId(), displayOrderNo(o), o.getOrderType(),
            LastlegOrderType.labelOf(o.getOrderType()), o.getDestinationType(), o.getSourceInboundId(),
            displayInboundCode(o), o.getLxCode(), o.getSourceOrderNo(), o.getCustomerId(), o.getCustomerName(),
            o.getSourceContainerBookingId(), o.getOverseasWarehouseId(),
            o.getOverseasWarehouseCode(), o.getOverseasWarehouseName(), o.getTransferWarehouseId(), o.getTransferWarehouseCode(),
            o.getTransferWarehouseName(), o.getFbaWarehouseCode(), o.getContainerNo(), containerNode,
            o.getAbnormal(), o.getDetained(), o.getHoldChargeable(), o.getHoldReason(),
            Boolean.TRUE.equals(o.getManualNodeOverride()), Boolean.TRUE.equals(o.getManualNodeOverride()) ? "MANUAL" : "CONTAINER",
            o.getVersion() == null ? 0 : o.getVersion(), o.getPalletCount(), o.getPackageCount(),
            o.getReceivedPackageCount(), packageDifference(o), weight == null ? BigDecimal.ZERO : weight.grossWeightKg(),
            weight == null ? BigDecimal.ZERO : weight.netWeightKg(), o.getVolumeCbm(),
            o.getProductQuantity(), o.getVolumeWeightKg(), o.getEstimatedArrivalAt(), o.getActualArrivalAt(),
            o.getEstimatedWarehouseAt(), o.getInboundOrderNo(), dispatchStatus, o.getRelabelOrderNo(), relabelBusinessStatus(o.getRelabelStatus()),
            o.getPalletMergeFlag(), related.stream().map(LastlegOrderMapper.PalletMergeRelationRow::mergeGroupNo).distinct().findFirst().orElse(null),
            related.stream().map(LastlegOrderMapper.PalletMergeRelationRow::relatedInboundNo).filter(Objects::nonNull).distinct().toList(),
            o.getCurrentStatus(), o.getSubOrderStatus(), o.getPrivateRemark(),
            o.getCustomerRemark(), o.getWarehouseRemark(), o.getCreatedAt(), o.getUpdatedAt(), relabelApplications, businessSource);
    }

    private static Integer packageDifference(LastlegOrder order) {
        if (order.getReceivedPackageCount() == null) return null;
        return order.getReceivedPackageCount() - java.util.Objects.requireNonNullElse(order.getPackageCount(), 0);
    }

    static String displayOrderNo(LastlegOrder order) {
        return ("WAREHOUSE_TRANSFER".equals(order.getOrderType()) || "RETURN_RELABEL".equals(order.getOrderType())) && StringUtils.hasText(order.getSourceOrderNo())
            ? order.getSourceOrderNo() : order.getOrderNo();
    }

    private String containerNode(LastlegOrder order) {
        if (!StringUtils.hasText(order.getSourceContainerBookingId())) return null;
        ContainerShippingGate gate = containerShippingGates.selectById(order.getSourceContainerBookingId());
        return gate == null ? null : gate.getStandardNode();
    }

    private Map<String, String> containerNodes(List<LastlegOrder> orders) {
        List<String> bookingIds = orders.stream().map(LastlegOrder::getSourceContainerBookingId)
            .filter(StringUtils::hasText).distinct().toList();
        if (bookingIds.isEmpty()) return Map.of();
        Map<String, String> result = new LinkedHashMap<>();
        containerShippingGates.selectBatchIds(bookingIds).forEach(gate -> {
            if (StringUtils.hasText(gate.getStandardNode())) {
                result.put(gate.getContainerBookingId(), gate.getStandardNode());
            }
        });
        return result;
    }

    private static String displayInboundCode(LastlegOrder order) {
        String orderType = order.getOrderType();
        return "RELABEL_APPLICATION".equals(orderType) || "LOCAL_LOOSEBOARD".equals(orderType)
            ? null : order.getInboundCode();
    }

    private static String relabelBusinessStatus(String workflowStatus) {
        if ("PROCESSING".equals(workflowStatus)) return "PROCESSING";
        if (!StringUtils.hasText(workflowStatus) || "NOT_REQUIRED".equals(workflowStatus)) return workflowStatus;
        return Set.of("READY_FOR_OUTBOUND", "COMPLETED").contains(workflowStatus)
            ? "COMPLETED" : "PENDING_PROCESSING";
    }

    private static Long parseLong(String value) {
        try { return StringUtils.hasText(value) ? Long.parseLong(value.trim()) : null; }
        catch (NumberFormatException ignored) { return null; }
    }

    private static String childKey(String key, String suffix) {
        String prefix = key == null ? "" : key.trim();
        int maxPrefix = Math.max(0, 128 - suffix.length() - 1);
        return prefix.substring(0, Math.min(prefix.length(), maxPrefix)) + ':' + suffix;
    }

}