最小可行模型：一笔跨境交易的完整推演

/**
 * 订单推送海关服务
 */
@Service
public class CustomsDeclarationService {

    @Autowired
    private CustomsApiClient customsClient;

    /**
     * 推送订单到海关
     *
     * @param order 订单信息
     * @return 推送结果
     */
    @Transactional
    public DeclarationResult declareOrder(Order order) {
        // 1. 数据校验
        validateOrder(order);

        // 2. 构建海关报文
        CustomsMessage message = buildCustomsMessage(order);

        // 3. 推送到海关
        CustomsResponse response = customsClient.submitOrder(message);

        // 4. 保存推送记录
        saveDeclarationLog(order, message, response);

        // 5. 更新订单状态
        if (response.isSuccess()) {
            order.setCustomsStatus("SUBMITTED");
            order.setCustomsNo(response.getCustomsNo());
        } else {
            order.setCustomsStatus("FAILED");
            order.setCustomsError(response.getErrorMsg());
        }
        orderRepository.save(order);

        return DeclarationResult.builder()
            .success(response.isSuccess())
            .customsNo(response.getCustomsNo())
            .message(response.getMessage())
            .build();
    }

    /**
     * 数据校验
     */
    private void validateOrder(Order order) {
        // 必填字段校验
        Assert.notNull(order.getOrderNo(), "订单号不能为空");
        Assert.notNull(order.getConsignee(), "收货人不能为空");
        Assert.notNull(order.getIdCard(), "身份证号不能为空");

        // 格式校验
        if (!IdCardValidator.isValid(order.getIdCard())) {
            throw new BusinessException("身份证号格式不正确");
        }

        if (!PhoneValidator.isValid(order.getPhone())) {
            throw new BusinessException("手机号格式不正确");
        }

        // 商品校验
        for (OrderItem item : order.getItems()) {
            // 商品必须已备案
            if (!productService.isRegistered(item.getProductCode())) {
                throw new BusinessException(
                    "商品未备案：" + item.getProductName()
                );
            }

            // 商品在正面清单内
            if (!productService.isInWhiteList(item.getHsCode())) {
                throw new BusinessException(
                    "商品不在跨境电商进口清单内：" + item.getProductName()
                );
            }
        }

        // 金额校验
        BigDecimal calculatedTotal = calculateTotal(order);
        if (!calculatedTotal.equals(order.getTotalAmount())) {
            throw new BusinessException(
                "订单金额不一致，计算值：" + calculatedTotal +
                "，实际值：" + order.getTotalAmount()
            );
        }

        // 额度校验
        if (!checkUserQuota(order)) {
            throw new BusinessException("用户年度额度不足");
        }
    }

    /**
     * 构建海关报文
     */
    private CustomsMessage buildCustomsMessage(Order order) {
        CustomsMessage message = new CustomsMessage();

        // 订单信息
        message.setOrderNo(order.getOrderNo());
        message.setOrderTime(order.getCreateTime());
        message.setGoodsValue(order.getGoodsAmount());
        message.setFreight(order.getFreight());
        message.setTaxAmount(order.getTaxAmount());
        message.setTotalAmount(order.getTotalAmount());

        // 商品清单
        List<CustomsGoodsItem> goodsList = order.getItems().stream()
            .map(item -> CustomsGoodsItem.builder()
                .goodsName(item.getProductName())
                .hsCode(item.getHsCode())
                .quantity(item.getQuantity())
                .price(item.getPrice())
                .totalPrice(item.getTotalPrice())
                .unit(item.getUnit())
                .originCountry(item.getOriginCountry())
                .registrationNo(item.getRegistrationNo())
                .build())
            .collect(Collectors.toList());
        message.setGoodsList(goodsList);

        // 收货人信息
        message.setConsigneeName(order.getConsignee());
        message.setConsigneeIdCard(order.getIdCard());
        message.setConsigneePhone(order.getPhone());
        message.setConsigneeAddress(order.getAddress());

        // 企业信息
        message.setEbpCode(order.getCompanyCode());
        message.setEbpName(order.getCompanyName());

        // 数字签名（防篡改）
        String signature = signMessage(message);
        message.setSignature(signature);

        return message;
    }

    /**
     * 检查用户额度
     */
    private boolean checkUserQuota(Order order) {
        // 查询用户本年度已使用额度
        int year = LocalDateTime.now().getYear();
        BigDecimal usedQuota = orderRepository.sumTaxAmountByUserAndYear(
            order.getUserId(),
            year
        );

        // 本次订单税费
        BigDecimal currentTax = order.getTaxAmount();

        // 总额度26000元
        BigDecimal totalQuota = new BigDecimal("26000");

        // 判断是否超额
        return usedQuota.add(currentTax).compareTo(totalQuota) <= 0;
    }
}

/**
 * 海关推送失败处理
 */
@Service
public class CustomsRetryService {

    private static final int MAX_RETRY = 3;
    private static final int[] RETRY_DELAYS = {5, 30, 120}; // 秒

    /**
     * 失败重试
     */
    @Async
    public void retryDeclaration(String orderNo, String errorCode) {
        Order order = orderRepository.findByOrderNo(orderNo);

        // 判断错误是否可重试
        if (!isRetryableError(errorCode)) {
            // 不可重试，转人工处理
            createManualTask(order, errorCode);
            return;
        }

        // 获取已重试次数
        int retryCount = order.getCustomsRetryCount();

        if (retryCount >= MAX_RETRY) {
            // 超过最大重试次数，转人工处理
            createManualTask(order, "重试次数超限");
            return;
        }

        // 延迟重试
        int delaySeconds = RETRY_DELAYS[retryCount];
        try {
            Thread.sleep(delaySeconds * 1000);

            // 重新推送
            DeclarationResult result = declarationService.declareOrder(order);

            if (result.isSuccess()) {
                // 成功
                log.info("订单重试推送成功：{}", orderNo);
            } else {
                // 失败，记录并继续重试
                order.setCustomsRetryCount(retryCount + 1);
                orderRepository.save(order);

                retryDeclaration(orderNo, result.getErrorCode());
            }

        } catch (Exception e) {
            log.error("订单重试推送异常：{}", orderNo, e);
            order.setCustomsRetryCount(retryCount + 1);
            orderRepository.save(order);

            retryDeclaration(orderNo, "SYSTEM_ERROR");
        }
    }

    /**
     * 判断错误是否可重试
     */
    private boolean isRetryableError(String errorCode) {
        List<String> retryableErrors = Arrays.asList(
            "NETWORK_TIMEOUT",    // 网络超时
            "SYSTEM_BUSY",        // 系统繁忙
            "SERVICE_UNAVAILABLE" // 服务不可用
        );

        return retryableErrors.contains(errorCode);
    }

    /**
     * 创建人工处理任务
     */
    private void createManualTask(Order order, String reason) {
        ManualTask task = ManualTask.builder()
            .orderNo(order.getOrderNo())
            .taskType("CUSTOMS_DECLARATION_FAILED")
            .reason(reason)
            .status("PENDING")
            .createTime(LocalDateTime.now())
            .build();

        manualTaskRepository.save(task);

        // 发送告警
        alertService.sendAlert(
            "订单推送海关失败",
            "订单号：" + order.getOrderNo() + "\n原因：" + reason
        );
    }
}

/**
 * 支付单推送海关
 */
@Service
public class PaymentCustomsService {

    /**
     * 方案1：回调推送（主动推送）
     */
    @Async
    public void onPaymentSuccess(Payment payment) {
        try {
            // 1. 构建支付单报文
            CustomsPaymentMessage message = buildPaymentMessage(payment);

            // 2. 推送到海关
            CustomsResponse response = customsClient.submitPayment(message);

            // 3. 保存推送记录
            savePaymentDeclarationLog(payment, message, response);

            // 4. 更新状态
            if (response.isSuccess()) {
                payment.setCustomsStatus("SUBMITTED");
            } else {
                payment.setCustomsStatus("FAILED");
                // 触发重试
                retryService.retryPaymentDeclaration(payment.getPaymentNo());
            }
            paymentRepository.save(payment);

        } catch (Exception e) {
            log.error("支付单推送海关异常", e);
            // 触发重试
            retryService.retryPaymentDeclaration(payment.getPaymentNo());
        }
    }

    /**
     * 方案2：主动查询（兜底机制）
     */
    @Scheduled(cron = "0 */5 * * * ?")  // 每5分钟执行
    public void queryUnsubmittedPayments() {
        // 1. 查询已支付但未推送海关的支付单
        List<Payment> unsubmittedPayments = paymentRepository
            .findByStatusAndCustomsStatus("PAID", "NOT_SUBMITTED");

        for (Payment payment : unsubmittedPayments) {
            // 2. 检查支付时间
            long minutes = ChronoUnit.MINUTES.between(
                payment.getPayTime(),
                LocalDateTime.now()
            );

            // 3. 如果超过5分钟还未推送，主动推送
            if (minutes >= 5) {
                log.warn("支付单未及时推送，主动推送：{}",
                    payment.getPaymentNo());
                onPaymentSuccess(payment);
            }
        }
    }
}

/**
 * 支付状态查询服务
 */
@Service
public class PaymentQueryService {

    /**
     * 定时任务：查询未回调的支付单
     */
    @Scheduled(cron = "0 */1 * * * ?")  // 每1分钟执行
    public void queryPendingPayments() {
        // 1. 查询创建超过5分钟但未支付成功的订单
        LocalDateTime fiveMinutesAgo = LocalDateTime.now().minusMinutes(5);
        List<Order> pendingOrders = orderRepository
            .findByStatusAndCreateTimeBefore("PENDING_PAYMENT", fiveMinutesAgo);

        for (Order order : pendingOrders) {
            // 2. 主动查询支付状态
            PaymentQueryResult result = wechatPayService.queryOrder(
                order.getOrderNo()
            );

            if ("SUCCESS".equals(result.getTradeState())) {
                // 支付成功，但回调未到达
                log.warn("支付回调延迟，主动查询到支付成功：{}",
                    order.getOrderNo());

                // 3. 手动触发支付成功逻辑
                Payment payment = Payment.builder()
                    .orderNo(order.getOrderNo())
                    .paymentNo(result.getTransactionId())
                    .payAmount(result.getTotalFee())
                    .payTime(result.getTimeEnd())
                    .payType("WECHAT")
                    .status("PAID")
                    .build();

                paymentRepository.save(payment);

                // 4. 推送支付单到海关
                paymentCustomsService.onPaymentSuccess(payment);

                // 5. 更新订单状态
                order.setStatus("PAID");
                order.setPayTime(result.getTimeEnd());
                orderRepository.save(order);
            }
        }
    }
}

/**
 * 支付服务
 */
@Service
public class PaymentService {

    /**
     * 创建支付订单
     */
    public PaymentCreateResult createPayment(PaymentCreateRequest request) {
        // 1. 查询订单
        Order order = orderRepository.findByOrderNo(request.getOrderNo());
        if (order == null) {
            throw new BusinessException("订单不存在");
        }

        // 2. 校验订单状态
        if (!"PENDING_PAYMENT".equals(order.getStatus())) {
            throw new BusinessException("订单状态不正确");
        }

        // 3. 校验金额
        if (!request.getPayAmount().equals(order.getTotalAmount())) {
            throw new BusinessException("支付金额与订单金额不一致");
        }

        // 4. 创建支付记录
        Payment payment = Payment.builder()
            .paymentNo(generatePaymentNo())
            .orderNo(order.getOrderNo())
            .userId(order.getUserId())
            .payAmount(order.getTotalAmount())
            .payType(request.getPayType())
            .status("PENDING")
            .createTime(LocalDateTime.now())
            .build();
        paymentRepository.save(payment);

        // 5. 调用第三方支付
        PaymentCreateResponse response = null;
        switch (request.getPayType()) {
            case "WECHAT":
                response = wechatPayService.createOrder(payment);
                break;
            case "ALIPAY":
                response = alipayService.createOrder(payment);
                break;
            case "UNIONPAY":
                response = unionPayService.createOrder(payment);
                break;
            default:
                throw new BusinessException("不支持的支付方式");
        }

        // 6. 保存第三方支付单号
        payment.setThirdPayNo(response.getThirdPayNo());
        paymentRepository.save(payment);

        // 7. 返回支付参数（用于前端调起支付）
        return PaymentCreateResult.builder()
            .paymentNo(payment.getPaymentNo())
            .payParams(response.getPayParams())
            .build();
    }

    /**
     * 支付回调处理
     */
    @Transactional
    public void handlePaymentCallback(PaymentCallbackRequest callback) {
        // 1. 验证签名（防篡改）
        if (!verifySignature(callback)) {
            throw new BusinessException("签名验证失败");
        }

        // 2. 查询支付记录
        Payment payment = paymentRepository.findByThirdPayNo(
            callback.getThirdPayNo()
        );
        if (payment == null) {
            throw new BusinessException("支付记录不存在");
        }

        // 3. 检查是否已处理（防重复回调）
        if ("PAID".equals(payment.getStatus())) {
            log.warn("支付已处理，重复回调：{}", payment.getPaymentNo());
            return;
        }

        // 4. 更新支付状态
        payment.setStatus("PAID");
        payment.setPayTime(callback.getPayTime());
        payment.setPayerName(callback.getPayerName());
        payment.setPayerIdCard(callback.getPayerIdCard());
        paymentRepository.save(payment);

        // 5. 更新订单状态
        Order order = orderRepository.findByOrderNo(payment.getOrderNo());
        order.setStatus("PAID");
        order.setPayTime(callback.getPayTime());
        orderRepository.save(order);

        // 6. 推送支付单到海关（异步）
        CompletableFuture.runAsync(() -> {
            paymentCustomsService.onPaymentSuccess(payment);
        });

        // 7. 发送支付成功通知
        notificationService.sendPaymentSuccessNotification(order);

        // 8. 触发后续流程（如拣货）
        eventPublisher.publish(new OrderPaidEvent(order.getOrderNo()));
    }
}

/**
 * 支付对账服务
 */
@Service
public class PaymentReconciliationService {

    /**
     * 每日对账任务
     */
    @Scheduled(cron = "0 0 2 * * ?")  // 每天凌晨2点
    public void dailyReconciliation() {
        LocalDate yesterday = LocalDate.now().minusDays(1);

        // 1. 获取平台账单
        List<Payment> platformBill = paymentRepository.findByDate(yesterday);

        // 2. 获取微信支付账单
        List<WechatBillItem> wechatBill = wechatPayService.downloadBill(yesterday);

        // 3. 获取支付宝账单
        List<AliPayBillItem> alipayBill = alipayService.downloadBill(yesterday);

        // 4. 对账
        ReconciliationResult result = reconcile(
            platformBill,
            wechatBill,
            alipayBill
        );

        // 5. 生成对账报告
        generateReport(result, yesterday);

        // 6. 如果有差异，发送告警
        if (result.hasDifference()) {
            alertService.sendAlert(
                "支付对账发现差异",
                "日期：" + yesterday + "\n" +
                "差异笔数：" + result.getDifferenceCount() + "\n" +
                "差异金额：" + result.getDifferenceAmount()
            );
        }
    }

    /**
     * 对账逻辑
     */
    private ReconciliationResult reconcile(
            List<Payment> platformBill,
            List<WechatBillItem> wechatBill,
            List<AliPayBillItem> alipayBill) {

        ReconciliationResult result = new ReconciliationResult();

        // 将第三方账单转换为统一格式
        Map<String, BillItem> thirdPartyMap = new HashMap<>();

        wechatBill.forEach(item -> {
            thirdPartyMap.put(item.getTransactionId(), BillItem.builder()
                .thirdPayNo(item.getTransactionId())
                .amount(item.getTotalFee())
                .payTime(item.getPayTime())
                .source("WECHAT")
                .build());
        });

        alipayBill.forEach(item -> {
            thirdPartyMap.put(item.getTradeNo(), BillItem.builder()
                .thirdPayNo(item.getTradeNo())
                .amount(item.getAmount())
                .payTime(item.getPayTime())
                .source("ALIPAY")
                .build());
        });

        // 逐笔对账
        for (Payment payment : platformBill) {
            BillItem thirdPartyItem = thirdPartyMap.get(payment.getThirdPayNo());

            if (thirdPartyItem == null) {
                // 平台有，第三方没有 → 异常
                result.addDifference(DifferenceItem.builder()
                    .type("PLATFORM_ONLY")
                    .paymentNo(payment.getPaymentNo())
                    .amount(payment.getPayAmount())
                    .build());
                continue;
            }

            // 金额比对
            if (!payment.getPayAmount().equals(thirdPartyItem.getAmount())) {
                // 金额不一致 → 异常
                result.addDifference(DifferenceItem.builder()
                    .type("AMOUNT_MISMATCH")
                    .paymentNo(payment.getPaymentNo())
                    .platformAmount(payment.getPayAmount())
                    .thirdPartyAmount(thirdPartyItem.getAmount())
                    .build());
            }

            // 从map中移除（已匹配）
            thirdPartyMap.remove(payment.getThirdPayNo());
        }

        // 剩余的是第三方有，平台没有 → 异常
        thirdPartyMap.values().forEach(item -> {
            result.addDifference(DifferenceItem.builder()
                .type("THIRD_PARTY_ONLY")
                .thirdPayNo(item.getThirdPayNo())
                .amount(item.getAmount())
                .source(item.getSource())
                .build());
        });

        return result;
    }
}

/**
 * 物流追踪服务
 */
@Service
public class LogisticsTrackingService {

    /**
     * 统一查询接口
     */
    public LogisticsTrackingResponse track(String logisticsCompany, String trackingNo) {
        LogisticsProvider provider = getProvider(logisticsCompany);
        return provider.queryTracking(trackingNo);
    }

    /**
     * 获取物流提供商
     */
    private LogisticsProvider getProvider(String company) {
        switch (company) {
            case "SF":
                return new SFProvider();
            case "EMS":
                return new EMSProvider();
            case "DHL":
                return new DHLProvider();
            case "FEDEX":
                return new FedExProvider();
            default:
                throw new BusinessException("不支持的物流公司");
        }
    }

    /**
     * 顺丰物流适配器
     */
    public static class SFProvider implements LogisticsProvider {

        @Override
        public LogisticsTrackingResponse queryTracking(String trackingNo) {
            // 1. 调用顺丰API
            SFTrackingResponse sfResponse = sfClient.query(trackingNo);

            // 2. 转换为统一格式
            List<TrackingEvent> events = sfResponse.getRoutes().stream()
                .map(route -> TrackingEvent.builder()
                    .time(route.getAcceptTime())
                    .location(route.getAcceptStation())
                    .status(mapStatus(route.getOpcode()))
                    .description(route.getRemark())
                    .build())
                .collect(Collectors.toList());

            return LogisticsTrackingResponse.builder()
                .trackingNo(trackingNo)
                .company("SF")
                .currentStatus(sfResponse.getCurrentStatus())
                .events(events)
                .build();
        }

        private String mapStatus(String opcode) {
            Map<String, String> statusMapping = Map.of(
                "50", "PICKED_UP",           // 已揽收
                "10", "IN_TRANSIT",          // 运输中
                "20", "ARRIVED_AT_CITY",     // 到达目的城市
                "80", "OUT_FOR_DELIVERY",    // 派送中
                "200", "SIGNED"              // 已签收
            );
            return statusMapping.getOrDefault(opcode, "UNKNOWN");
        }
    }

    /**
     * DHL物流适配器
     */
    public static class DHLProvider implements LogisticsProvider {

        @Override
        public LogisticsTrackingResponse queryTracking(String trackingNo) {
            // 调用DHL API（格式完全不同）
            DHLTrackingResponse dhlResponse = dhlClient.track(trackingNo);

            // 转换为统一格式
            List<TrackingEvent> events = dhlResponse.getShipmentTrack().stream()
                .flatMap(track -> track.getEvents().stream())
                .map(event -> TrackingEvent.builder()
                    .time(event.getTimestamp())
                    .location(event.getServiceArea())
                    .status(mapDHLStatus(event.getStatusCode()))
                    .description(event.getDescription())
                    .build())
                .collect(Collectors.toList());

            return LogisticsTrackingResponse.builder()
                .trackingNo(trackingNo)
                .company("DHL")
                .currentStatus(dhlResponse.getCurrentStatus())
                .events(events)
                .build();
        }

        private String mapDHLStatus(String statusCode) {
            // DHL状态码映射
            Map<String, String> statusMapping = Map.of(
                "PU", "PICKED_UP",
                "IT", "IN_TRANSIT",
                "AR", "ARRIVED_AT_CUSTOMS",
                "CC", "CUSTOMS_CLEARED",
                "OD", "OUT_FOR_DELIVERY",
                "OK", "SIGNED"
            );
            return statusMapping.getOrDefault(statusCode, "UNKNOWN");
        }
    }

    /**
     * 定时同步物流状态
     */
    @Scheduled(cron = "0 */10 * * * ?")  // 每10分钟
    public void syncLogisticsStatus() {
        // 1. 查询运输中的订单
        List<Order> shippingOrders = orderRepository.findByStatus("SHIPPED");

        for (Order order : shippingOrders) {
            try {
                // 2. 查询最新物流状态
                LogisticsTrackingResponse tracking = track(
                    order.getLogisticsCompany(),
                    order.getLogisticsNo()
                );

                // 3. 保存物流轨迹
                for (TrackingEvent event : tracking.getEvents()) {
                    // 如果是新事件，保存
                    if (!logisticsEventRepository.existsByTrackingNoAndTime(
                            order.getLogisticsNo(), event.getTime())) {
                        LogisticsEvent logEvent = LogisticsEvent.builder()
                            .orderNo(order.getOrderNo())
                            .trackingNo(order.getLogisticsNo())
                            .eventTime(event.getTime())
                            .location(event.getLocation())
                            .status(event.getStatus())
                            .description(event.getDescription())
                            .build();
                        logisticsEventRepository.save(logEvent);

                        // 推送通知给用户
                        notificationService.sendLogisticsUpdate(order, event);
                    }
                }

                // 4. 如果已签收，更新订单状态
                if ("SIGNED".equals(tracking.getCurrentStatus())) {
                    order.setStatus("COMPLETED");
                    order.setCompletedTime(LocalDateTime.now());
                    orderRepository.save(order);

                    // 发送签收通知
                    notificationService.sendSignedNotification(order);
                }

            } catch (Exception e) {
                log.error("物流同步失败：{}", order.getOrderNo(), e);
            }
        }
    }
}