深度解密：京东国际/天猫国际背后的跨境电商关务体系全貌

// 订单推送到海关的核心逻辑
@Service
public class CustomsOrderPushService {

    /**
     * 订单创建后立即推送到海关
     * 时效要求：订单创建后10秒内必须推送
     */
    @Async
    @Transactional
    public void pushOrderToCustoms(Order order) {
        // 1. 订单金额校验（必须包含优惠券、运费、税费）
        BigDecimal totalAmount = calculateTotalAmount(order);

        // 2. 身份信息校验（收货人必须是下单人本人）
        validateIdentity(order);

        // 3. 商品备案编号校验（每个SKU必须在海关备案）
        validateGoodsRegistration(order);

        // 4. 构建海关报文（50+字段）
        CustomsOrderMessage message = buildCustomsMessage(order);

        // 5. 推送到海关（重试3次）
        CustomsResponse response = customsClient.submitOrder(message);

        // 6. 保存推送记录
        saveCustomsLog(order, message, response);

        // 7. 更新订单状态
        if (response.isSuccess()) {
            order.setCustomsStatus("SUBMITTED");
        } else {
            order.setCustomsStatus("FAILED");
            // 失败告警
            alertService.sendAlert("订单推送海关失败", order.getOrderNo());
        }
    }

    /**
     * 金额计算（关键！）
     * 公式：商品总价 + 运费 + 税费 - 优惠金额 = 实付金额
     */
    private BigDecimal calculateTotalAmount(Order order) {
        BigDecimal goodsAmount = order.getItems().stream()
            .map(item -> item.getPrice().multiply(new BigDecimal(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);

        BigDecimal freight = order.getFreight();
        BigDecimal tax = calculateTax(goodsAmount, freight); // 综合税率9.1%
        BigDecimal discount = order.getDiscountAmount();

        return goodsAmount.add(freight).add(tax).subtract(discount);
    }
}

-- 订单表（核心字段）
CREATE TABLE `orders` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `order_no` VARCHAR(32) UNIQUE COMMENT '订单号',
  `user_id` BIGINT COMMENT '用户ID',
  `consignee` VARCHAR(50) COMMENT '收货人姓名',
  `id_card` VARCHAR(18) COMMENT '收货人身份证',
  `phone` VARCHAR(11) COMMENT '手机号',
  `goods_amount` DECIMAL(10,2) COMMENT '商品总价',
  `freight` DECIMAL(10,2) COMMENT '运费',
  `tax_amount` DECIMAL(10,2) COMMENT '税费',
  `discount_amount` DECIMAL(10,2) COMMENT '优惠金额',
  `total_amount` DECIMAL(10,2) COMMENT '实付金额',
  `customs_status` VARCHAR(20) COMMENT '海关状态：PENDING/SUBMITTED/PASSED/FAILED',
  `customs_error_code` VARCHAR(10) COMMENT '海关错误码',
  `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
  INDEX `idx_customs_status` (`customs_status`, `create_time`)
) ENGINE=InnoDB COMMENT='订单表';

/**
 * 支付实名认证
 * 要求：支付人必须是订单收货人本人
 */
@Service
public class PaymentAuthService {

    public void verifyPayerIdentity(Payment payment, Order order) {
        // 1. 从支付渠道获取支付人实名信息
        PayerInfo payerInfo = getPayerInfoFromChannel(payment);

        // 2. 校验支付人姓名与订单收货人姓名一致
        if (!payerInfo.getName().equals(order.getConsignee())) {
            throw new BusinessException("支付人与收货人不一致，不允许支付");
        }

        // 3. 校验支付人身份证与订单身份证一致
        if (!payerInfo.getIdCard().equals(order.getIdCard())) {
            throw new BusinessException("支付人身份证与收货人不一致");
        }

        // 4. 微信支付/支付宝已完成实名认证，无需再次验证
        // 但银行卡支付需要调用银联接口二次确认
        if (payment.getPayType().equals("BANK_CARD")) {
            boolean verified = unionPayService.verifyIdentity(
                payerInfo.getIdCard(),
                payerInfo.getName()
            );
            if (!verified) {
                throw new BusinessException("银行卡实名认证失败");
            }
        }
    }

    /**
     * 从微信/支付宝获取支付人实名信息
     */
    private PayerInfo getPayerInfoFromChannel(Payment payment) {
        if (payment.getPayType().equals("WECHAT")) {
            // 调用微信实名信息接口
            return wechatPayService.getPayerInfo(payment.getTransactionId());
        } else if (payment.getPayType().equals("ALIPAY")) {
            // 调用支付宝实名信息接口
            return alipayService.getPayerInfo(payment.getTradeNo());
        }
        throw new BusinessException("不支持的支付方式");
    }
}

/**
 * 支付成功后立即推送到海关
 * 时效要求：支付成功后30秒内必须推送
 */
@Service
public class CustomsPaymentPushService {

    @Async
    public void pushPaymentToCustoms(Payment payment) {
        // 1. 查询订单信息
        Order order = orderService.getByOrderNo(payment.getOrderNo());

        // 2. 构建支付单报文
        CustomsPaymentMessage message = CustomsPaymentMessage.builder()
            .paymentNo(payment.getPaymentNo())           // 支付单号
            .orderNo(order.getOrderNo())                 // 订单号
            .payAmount(payment.getAmount())              // 支付金额
            .payType(payment.getPayType())               // 支付方式
            .payTime(payment.getPayTime())               // 支付时间
            .payerName(payment.getPayerName())           // 支付人姓名
            .payerIdCard(payment.getPayerIdCard())       // 支付人身份证
            .ebpCode(order.getEbpCode())                 // 电商平台备案编号
            .build();

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

        // 4. 保存推送记录
        saveCustomsLog(payment, message, response);

        // 5. 更新状态
        if (response.isSuccess()) {
            payment.setCustomsStatus("SUBMITTED");
            // 通知订单系统：支付单已推送
            eventPublisher.publish(new PaymentSubmittedEvent(payment));
        }
    }
}

/**
 * 物流单推送到海关的时机
 * 1. 保税仓模式：包裹打包完成后推送
 * 2. 直邮模式：包裹出境时推送
 */
@Service
public class CustomsLogisticsPushService {

    /**
     * 保税仓模式：包裹打包后推送
     */
    @EventListener
    public void onPackagePackaged(PackagePackagedEvent event) {
        // 1. 生成物流单号
        String logisticsNo = generateLogisticsNo();

        // 2. 查询订单信息
        Order order = orderService.getByOrderNo(event.getOrderNo());

        // 3. 构建物流报文
        CustomsLogisticsMessage message = CustomsLogisticsMessage.builder()
            .logisticsNo(logisticsNo)                    // 物流单号
            .orderNo(order.getOrderNo())                 // 订单号
            .logisticsCompany("SF")                      // 物流公司代码
            .receiverName(order.getConsignee())          // 收货人姓名
            .receiverIdCard(order.getIdCard())           // 收货人身份证
            .receiverPhone(order.getPhone())             // 收货人电话
            .receiverAddress(order.getAddress())         // 收货地址
            .packageWeight(event.getWeight())            // 包裹重量
            .packageCount(1)                             // 包裹件数
            .build();

        // 4. 推送到海关
        CustomsResponse response = customsClient.submitLogistics(message);

        // 5. 推送成功后才能出库
        if (response.isSuccess()) {
            warehouseService.allowOutbound(event.getPackageNo());
        } else {
            // 推送失败，阻止出库
            warehouseService.blockOutbound(event.getPackageNo());
            alertService.sendAlert("物流单推送失败", event.getPackageNo());
        }
    }
}

/**
 * 物流轨迹同步
 * 定时任务：每5分钟同步一次
 */
@Component
public class LogisticsTrackingSyncJob {

    @Scheduled(cron = "0 */5 * * * ?")
    public void syncLogisticsTracking() {
        // 1. 查询运输中的订单
        List<Order> shippingOrders = orderService.findByStatus("SHIPPED");

        for (Order order : shippingOrders) {
            // 2. 调用顺丰/菜鸟接口查询最新物流信息
            LogisticsTrackingResponse tracking = logisticsClient.queryTracking(
                order.getLogisticsNo()
            );

            // 3. 保存物流轨迹
            saveLogisticsTracking(order, tracking);

            // 4. 判断是否签收
            if (tracking.getStatus().equals("SIGNED")) {
                // 更新订单状态为已完成
                order.setStatus("COMPLETED");
                order.setCompletedTime(tracking.getSignTime());
                orderRepository.save(order);

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

/**
 * 保税仓库存模型
 * 关键：实物库存 = 可用库存 + 锁定库存 + 不良品库存
 */
@Entity
@Table(name = "warehouse_inventory")
public class WarehouseInventory {

    @Id
    private Long id;

    private String skuCode;           // SKU编码
    private String warehouseCode;     // 仓库编码
    private Integer totalQty;         // 总库存（实物库存）
    private Integer availableQty;     // 可用库存（可销售）
    private Integer lockedQty;        // 锁定库存（已下单未出库）
    private Integer defectiveQty;     // 不良品库存

    /**
     * 订单下单时：锁定库存
     */
    public void lockInventory(int qty) {
        if (availableQty < qty) {
            throw new BusinessException("库存不足");
        }
        this.availableQty -= qty;
        this.lockedQty += qty;
    }

    /**
     * 订单取消时：释放库存
     */
    public void releaseInventory(int qty) {
        this.lockedQty -= qty;
        this.availableQty += qty;
    }

    /**
     * 订单出库时：扣减库存
     */
    public void deductInventory(int qty) {
        this.lockedQty -= qty;
        this.totalQty -= qty;
    }
}

/**
 * 拣货打包流程
 * 1. 拣货 → 2. 复核 → 3. 打包 → 4. 称重 → 5. 贴单 → 6. 出库
 */
@Service
public class WarehouseOutboundService {

    /**
     * 拣货
     */
    public void pickGoods(String orderNo) {
        // 1. 查询订单商品
        List<OrderItem> items = orderItemService.findByOrderNo(orderNo);

        // 2. 生成拣货任务
        PickingTask task = PickingTask.builder()
            .orderNo(orderNo)
            .items(items)
            .assignedTo("picker-001")  // 分配给拣货员
            .status("PENDING")
            .build();
        pickingTaskRepository.save(task);

        // 3. 拣货员PDA扫描货位，拣货
        // 4. 拣货完成，扫描商品条码确认
    }

    /**
     * 打包
     */
    @Transactional
    public void packGoods(String orderNo) {
        // 1. 选择合适的包装箱
        PackageBox box = selectPackageBox(orderNo);

        // 2. 装箱
        Package pkg = Package.builder()
            .orderNo(orderNo)
            .boxType(box.getType())
            .build();

        // 3. 称重
        BigDecimal weight = weighingService.weigh(pkg);
        pkg.setWeight(weight);

        // 4. 生成面单
        String waybillNo = logisticsService.generateWaybill(pkg);
        pkg.setWaybillNo(waybillNo);

        // 5. 保存包裹信息
        packageRepository.save(pkg);

        // 6. 触发物流单推送事件
        eventPublisher.publish(new PackagePackagedEvent(orderNo, weight));
    }

    /**
     * 出库（通过海关卡口）
     */
    public void outbound(String packageNo) {
        // 1. 查询包裹信息
        Package pkg = packageRepository.findByPackageNo(packageNo);

        // 2. 检查海关放行状态
        Order order = orderService.getByOrderNo(pkg.getOrderNo());
        if (!order.getCustomsStatus().equals("PASSED")) {
            throw new BusinessException("海关未放行，不允许出库");
        }

        // 3. 卡口扫描（保税仓出口）
        gateService.scanOutbound(packageNo);

        // 4. 交给物流公司
        logisticsService.handover(pkg.getWaybillNo());

        // 5. 更新订单状态为已发货
        order.setStatus("SHIPPED");
        order.setShippedTime(LocalDateTime.now());
        orderRepository.save(order);
    }
}

/**
 * 三单对碰协调器
 * 核心逻辑：等待三单齐全后才能放行
 */
@Service
public class ThreeOrdersMatchingService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 订单推送后，记录状态
     */
    public void onOrderSubmitted(String orderNo) {
        String key = "customs:matching:" + orderNo;
        redisTemplate.opsForHash().put(key, "order", "SUBMITTED");
        redisTemplate.expire(key, 24, TimeUnit.HOURS);

        // 检查是否三单齐全
        checkAndTriggerMatching(orderNo);
    }

    /**
     * 支付单推送后，记录状态
     */
    public void onPaymentSubmitted(String orderNo) {
        String key = "customs:matching:" + orderNo;
        redisTemplate.opsForHash().put(key, "payment", "SUBMITTED");

        // 检查是否三单齐全
        checkAndTriggerMatching(orderNo);
    }

    /**
     * 物流单推送后，记录状态
     */
    public void onLogisticsSubmitted(String orderNo) {
        String key = "customs:matching:" + orderNo;
        redisTemplate.opsForHash().put(key, "logistics", "SUBMITTED");

        // 检查是否三单齐全
        checkAndTriggerMatching(orderNo);
    }

    /**
     * 检查三单是否齐全，齐全则触发海关对碰
     */
    private void checkAndTriggerMatching(String orderNo) {
        String key = "customs:matching:" + orderNo;
        Map<Object, Object> status = redisTemplate.opsForHash().entries(key);

        boolean orderReady = "SUBMITTED".equals(status.get("order"));
        boolean paymentReady = "SUBMITTED".equals(status.get("payment"));
        boolean logisticsReady = "SUBMITTED".equals(status.get("logistics"));

        if (orderReady && paymentReady && logisticsReady) {
            log.info("三单齐全，触发海关对碰：{}", orderNo);

            // 通知海关进行三单对碰
            customsClient.triggerMatching(orderNo);

            // 标记为对碰中
            redisTemplate.opsForHash().put(key, "status", "MATCHING");
        }
    }

    /**
     * 海关对碰结果回调
     */
    public void onMatchingResult(String orderNo, String result, String errorCode) {
        Order order = orderService.getByOrderNo(orderNo);

        if ("PASSED".equals(result)) {
            // 对碰成功，放行
            order.setCustomsStatus("PASSED");
            order.setCustomsPassTime(LocalDateTime.now());

            // 通知仓库可以出库
            eventPublisher.publish(new CustomsPassedEvent(orderNo));

        } else {
            // 对碰失败，记录错误码
            order.setCustomsStatus("FAILED");
            order.setCustomsErrorCode(errorCode);

            // 根据错误码进行自动修复或人工处理
            handleCustomsError(order, errorCode);
        }

        orderRepository.save(order);
    }
}

/**
 * 跨境电商综合税计算
 * 税率公式：(商品价格 + 运费) × 70% × (关税率 + 增值税率 + 消费税率)
 * 简化税率：9.1%（大部分商品）
 */
@Service
public class TaxCalculationService {

    /**
     * 计算订单税费
     */
    public BigDecimal calculateTax(Order order) {
        // 1. 计算完税价格（商品价格 + 运费）
        BigDecimal dutiableValue = order.getGoodsAmount().add(order.getFreight());

        // 2. 获取商品税率
        BigDecimal taxRate = getTaxRate(order.getItems());

        // 3. 计算税费
        // 公式：完税价格 × 70% × 综合税率
        BigDecimal tax = dutiableValue
            .multiply(new BigDecimal("0.70"))  // 70%优惠
            .multiply(taxRate)
            .setScale(2, RoundingMode.HALF_UP);

        // 4. 免税额判断（单笔订单<=5000元，年度累计<=26000元）
        if (dutiableValue.compareTo(new BigDecimal("5000")) <= 0
            && checkAnnualLimit(order.getUserId(), tax)) {
            return tax;
        } else {
            throw new BusinessException("超过免税额度，需按一般贸易缴税");
        }
    }

    /**
     * 获取商品综合税率
     */
    private BigDecimal getTaxRate(List<OrderItem> items) {
        // 不同品类税率不同
        // 母婴用品：0%
        // 食品：9.1%
        // 化妆品：26.37%（含消费税）
        // 电子产品：13%

        // 示例：根据商品类目查询税率
        String category = items.get(0).getCategoryCode();
        TaxRateConfig config = taxRateRepository.findByCategory(category);
        return config.getTaxRate();
    }

    /**
     * 检查年度累计额度
     */
    private boolean checkAnnualLimit(Long userId, BigDecimal tax) {
        // 查询该用户本年度已使用额度
        BigDecimal usedAmount = orderRepository.sumTaxAmountByUserAndYear(
            userId,
            LocalDateTime.now().getYear()
        );

        // 判断是否超过年度26000元限额
        return usedAmount.add(tax).compareTo(new BigDecimal("26000")) <= 0;
    }
}

/**
 * 商品海关备案
 * 每个SKU上架前，必须在海关完成备案
 */
@Service
public class ProductCustomsRegistrationService {

    /**
     * 商品备案到海关
     */
    @Transactional
    public void registerProduct(Product product) {
        // 1. 准备备案材料
        RegistrationMaterial material = RegistrationMaterial.builder()
            .productName(product.getName())               // 商品名称
            .brand(product.getBrand())                    // 品牌
            .specification(product.getSpecification())    // 规格
            .originCountry(product.getOriginCountry())    // 原产国
            .hsCode(product.getHsCode())                  // HS编码（海关编码）
            .ciqCode(product.getCiqCode())                // CIQ编码（检验检疫编码）
            .barcode(product.getBarcode())                // 条形码
            .build();

        // 2. 上传商品图片、说明书、检验报告
        uploadDocuments(product);

        // 3. 提交到海关备案系统
        CustomsRegistrationResponse response = customsClient.registerProduct(material);

        // 4. 保存备案编号
        if (response.isSuccess()) {
            product.setCustomsCode(response.getCustomsCode());  // 海关备案编号
            product.setRegistrationStatus("APPROVED");
            productRepository.save(product);
        } else {
            throw new BusinessException("商品备案失败：" + response.getErrorMessage());
        }
    }

    /**
     * 查询商品备案状态
     */
    public void syncRegistrationStatus(String customsCode) {
        // 定时任务：每天同步一次备案状态
        // 因为海关可能会撤销备案（如商品下架、资质过期）
        CustomsRegistrationStatus status = customsClient.queryRegistrationStatus(customsCode);

        Product product = productRepository.findByCustomsCode(customsCode);
        product.setRegistrationStatus(status.getStatus());
        productRepository.save(product);

        // 如果备案被撤销，自动下架商品
        if ("REVOKED".equals(status.getStatus())) {
            product.setOnlineStatus("OFFLINE");
            alertService.sendAlert("商品备案被撤销，已自动下架", product.getSkuCode());
        }
    }
}

-- 商品表（核心字段）
CREATE TABLE `products` (
  `id` BIGINT PRIMARY KEY AUTO_INCREMENT,
  `sku_code` VARCHAR(32) UNIQUE COMMENT 'SKU编码',
  `product_name` VARCHAR(200) COMMENT '商品名称',
  `brand` VARCHAR(100) COMMENT '品牌',
  `origin_country` VARCHAR(50) COMMENT '原产国',
  `hs_code` VARCHAR(10) COMMENT 'HS编码（海关编码）',
  `ciq_code` VARCHAR(10) COMMENT 'CIQ编码（检验检疫编码）',
  `customs_code` VARCHAR(50) UNIQUE COMMENT '海关备案编号',
  `registration_status` VARCHAR(20) COMMENT '备案状态：PENDING/APPROVED/REVOKED',
  `tax_rate` DECIMAL(5,4) COMMENT '税率',
  `price` DECIMAL(10,2) COMMENT '售价',
  `online_status` VARCHAR(20) COMMENT '上架状态：ONLINE/OFFLINE',
  `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
  INDEX `idx_customs_code` (`customs_code`)
) ENGINE=InnoDB COMMENT='商品表';

/**
 * 海关三单对碰规则
 */
public class ThreeOrdersMatchingRule {

    /**
     * 规则1：金额一致性
     * 订单金额 = 支付金额（允许±1元误差）
     */
    public boolean checkAmountConsistency(Order order, Payment payment) {
        BigDecimal orderAmount = order.getTotalAmount();
        BigDecimal paymentAmount = payment.getAmount();
        BigDecimal diff = orderAmount.subtract(paymentAmount).abs();

        return diff.compareTo(BigDecimal.ONE) <= 0;
    }

    /**
     * 规则2：身份一致性
     * 订单收货人 = 支付人 = 运单收货人
     */
    public boolean checkIdentityConsistency(Order order, Payment payment, Logistics logistics) {
        String orderName = order.getConsignee();
        String paymentName = payment.getPayerName();
        String logisticsName = logistics.getReceiverName();

        return orderName.equals(paymentName) && orderName.equals(logisticsName);
    }

    /**
     * 规则3：时间窗口
     * 三单必须在24小时内推送完成
     */
    public boolean checkTimeWindow(Order order, Payment payment, Logistics logistics) {
        LocalDateTime orderTime = order.getCustomsSubmitTime();
        LocalDateTime paymentTime = payment.getCustomsSubmitTime();
        LocalDateTime logisticsTime = logistics.getCustomsSubmitTime();

        LocalDateTime earliest = Collections.min(Arrays.asList(orderTime, paymentTime, logisticsTime));
        LocalDateTime latest = Collections.max(Arrays.asList(orderTime, paymentTime, logisticsTime));

        Duration duration = Duration.between(earliest, latest);
        return duration.toHours() <= 24;
    }

    /**
     * 综合判断
     */
    public MatchingResult match(Order order, Payment payment, Logistics logistics) {
        if (!checkAmountConsistency(order, payment)) {
            return MatchingResult.failed("T001", "订单金额与支付金额不一致");
        }

        if (!checkIdentityConsistency(order, payment, logistics)) {
            return MatchingResult.failed("T002", "收货人身份不一致");
        }

        if (!checkTimeWindow(order, payment, logistics)) {
            return MatchingResult.failed("T003", "三单推送超时");
        }

        return MatchingResult.passed();
    }
}

/**
 * 保税仓卡口管理
 * 作用：确保只有海关放行的包裹才能出库
 */
@Service
public class WarehouseGateService {

    /**
     * 卡口出库扫描
     */
    public void scanOutbound(String packageNo) {
        // 1. 查询包裹对应的订单
        Package pkg = packageRepository.findByPackageNo(packageNo);
        Order order = orderService.getByOrderNo(pkg.getOrderNo());

        // 2. 检查海关放行状态
        if (!order.getCustomsStatus().equals("PASSED")) {
            // 海关未放行，拦截出库
            log.error("卡口拦截：海关未放行，不允许出库。订单号：{}", order.getOrderNo());
            throw new BusinessException("海关未放行，不允许出库");
        }

        // 3. 检查是否有海关查验指令
        if (order.isInspectionRequired()) {
            // 需要开箱查验
            log.warn("海关查验指令，包裹需开箱检查。订单号：{}", order.getOrderNo());
            createInspectionTask(order);
            throw new BusinessException("海关查验中，暂不可出库");
        }

        // 4. 记录卡口出库日志
        GateLog gateLog = GateLog.builder()
            .packageNo(packageNo)
            .orderNo(order.getOrderNo())
            .gateType("OUTBOUND")
            .scanTime(LocalDateTime.now())
            .operator("gate-scanner-001")
            .build();
        gateLogRepository.save(gateLog);

        // 5. 允许出库
        log.info("卡口放行：包裹出库成功。订单号：{}", order.getOrderNo());
    }

    /**
     * 创建海关查验任务
     */
    private void createInspectionTask(Order order) {
        InspectionTask task = InspectionTask.builder()
            .orderNo(order.getOrderNo())
            .inspectionType("RANDOM")  // 随机抽检
            .status("PENDING")
            .build();
        inspectionTaskRepository.save(task);

        // 通知仓库人员
        notificationService.sendInspectionNotification(task);
    }
}

/**
 * 京东国际：一站式系统
 * 订单、仓储、物流全部自营，系统深度集成
 */
@Service
public class JDIntegratedService {

    /**
     * 订单创建后，立即触发全链路流程
     */
    @Transactional
    public void createOrder(Order order) {
        // 1. 创建订单
        orderRepository.save(order);

        // 2. 推送到海关
        customsService.submitOrder(order);

        // 3. 锁定京东自建保税仓库存
        warehouseService.lockInventory(order);

        // 4. 生成拣货任务（京东仓储系统）
        pickingService.createTask(order);

        // 5. 预分配京东物流运力
        logisticsService.allocateCapacity(order);

        // 整个流程无需对接第三方，系统调用延迟低
    }
}

/**
 * 京东物流：211限时达、次日达
 */
@Service
public class JDLogisticsService {

    /**
     * 智能路由：根据用户地址，选择最近的保税仓
     */
    public String selectWarehouse(String city) {
        // 京东在全国有10+个保税仓
        // 杭州、上海、广州、天津、郑州、重庆...

        Map<String, String> cityWarehouseMapping = Map.of(
            "上海", "SHA-BONDED-01",
            "杭州", "HGH-BONDED-01",
            "广州", "CAN-BONDED-01",
            "北京", "PEK-BONDED-01"
        );

        return cityWarehouseMapping.getOrDefault(city, "SHA-BONDED-01");
    }

    /**
     * 时效承诺
     */
    public LocalDateTime estimateDeliveryTime(Order order) {
        String city = order.getCity();

        // 一线城市：次日达
        if (Arrays.asList("北京", "上海", "广州", "深圳").contains(city)) {
            return LocalDateTime.now().plusDays(1);
        }

        // 二线城市：2日达
        return LocalDateTime.now().plusDays(2);
    }
}

/**
 * 天猫国际：开放API，支持第三方商家接入
 */
@RestController
@RequestMapping("/api/tmall/open")
public class TmallOpenApiController {

    /**
     * 商家推送订单到天猫
     */
    @PostMapping("/order/push")
    public ApiResponse pushOrder(@RequestBody OrderPushRequest request) {
        // 1. 验证商家签名
        if (!verifySignature(request)) {
            return ApiResponse.error("签名验证失败");
        }

        // 2. 接收订单
        Order order = convertToOrder(request);
        orderService.createOrder(order);

        // 3. 推送到海关
        customsService.submitOrder(order);

        return ApiResponse.success();
    }

    /**
     * 商家查询订单状态
     */
    @GetMapping("/order/query")
    public ApiResponse queryOrder(@RequestParam String orderNo) {
        Order order = orderService.getByOrderNo(orderNo);
        return ApiResponse.success(order);
    }
}

/**
 * 菜鸟网络：跨境物流解决方案
 */
@Service
public class CainiaoLogisticsService {

    /**
     * 菜鸟智能路由
     * 支持海外仓直邮、保税仓备货等多种模式
     */
    public LogisticsRoute selectRoute(Order order) {
        // 1. 判断商品存储位置
        String warehouseType = order.getWarehouseType();

        if ("OVERSEAS".equals(warehouseType)) {
            // 海外仓直邮：日本仓 → 中国海关 → 用户
            return LogisticsRoute.builder()
                .startWarehouse("JP-TOKYO-01")
                .customsPort("PVG-CUSTOMS")  // 上海浦东海关
                .endCity(order.getCity())
                .estimatedDays(7)
                .build();
        } else {
            // 保税仓：国内保税仓 → 用户
            return LogisticsRoute.builder()
                .startWarehouse("HGH-BONDED-01")
                .endCity(order.getCity())
                .estimatedDays(2)
                .build();
        }
    }
}

/**
 * 技术成本计算器
 */
public class TechCostCalculator {

    /**
     * 计算单笔订单的技术成本
     * 假设：月订单量100万单
     */
    public BigDecimal calculatePerOrderCost() {
        // 1. 服务器成本：阿里云ECS + RDS + Redis
        BigDecimal serverCost = new BigDecimal("50000");  // 月均5万

        // 2. 带宽成本：CDN + 对外接口
        BigDecimal bandwidthCost = new BigDecimal("20000");  // 月均2万

        // 3. 海关接口调用费用
        BigDecimal apiCost = new BigDecimal("30000");  // 每次调用0.03元，月均3万

        // 4. 短信/推送通知成本
        BigDecimal notificationCost = new BigDecimal("15000");  // 月均1.5万

        // 5. 人力成本（研发团队20人，月均工资2万）
        BigDecimal laborCost = new BigDecimal("400000");  // 月均40万

        // 总成本
        BigDecimal totalCost = serverCost.add(bandwidthCost)
                                         .add(apiCost)
                                         .add(notificationCost)
                                         .add(laborCost);

        // 月订单量
        BigDecimal monthlyOrders = new BigDecimal("1000000");

        // 单笔订单技术成本
        return totalCost.divide(monthlyOrders, 2, RoundingMode.HALF_UP);
        // 结果：0.52元/单
    }
}

/**
 * 金额计算引擎
 * 核心原则：所有金额计算必须在订单创建时确定，不允许后续修改
 */
@Service
public class OrderAmountCalculator {

    /**
     * 计算订单总金额
     */
    public OrderAmount calculate(OrderCreateRequest request) {
        // 1. 商品金额
        BigDecimal goodsAmount = request.getItems().stream()
            .map(item -> item.getPrice().multiply(new BigDecimal(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);

        // 2. 运费（满99免运费）
        BigDecimal freight = goodsAmount.compareTo(new BigDecimal("99")) >= 0
            ? BigDecimal.ZERO
            : new BigDecimal("10");

        // 3. 税费（商品金额 + 运费）× 9.1%
        BigDecimal dutiableValue = goodsAmount.add(freight);
        BigDecimal tax = dutiableValue
            .multiply(new BigDecimal("0.70"))
            .multiply(new BigDecimal("0.091"))
            .setScale(2, RoundingMode.HALF_UP);

        // 4. 优惠金额
        BigDecimal discount = calculateDiscount(request);

        // 5. 实付金额 = 商品 + 运费 + 税费 - 优惠
        BigDecimal totalAmount = goodsAmount
            .add(freight)
            .add(tax)
            .subtract(discount)
            .setScale(2, RoundingMode.HALF_UP);

        return OrderAmount.builder()
            .goodsAmount(goodsAmount)
            .freight(freight)
            .taxAmount(tax)
            .discountAmount(discount)
            .totalAmount(totalAmount)
            .build();
    }

    /**
     * 优惠券计算（关键！）
     */
    private BigDecimal calculateDiscount(OrderCreateRequest request) {
        if (request.getCouponCode() == null) {
            return BigDecimal.ZERO;
        }

        Coupon coupon = couponService.getCoupon(request.getCouponCode());

        // 1. 满减券：满200减30
        if (coupon.getType().equals("FULL_REDUCTION")) {
            BigDecimal goodsAmount = request.getGoodsAmount();
            if (goodsAmount.compareTo(coupon.getThreshold()) >= 0) {
                return coupon.getAmount();
            }
        }

        // 2. 折扣券：9折
        if (coupon.getType().equals("DISCOUNT")) {
            BigDecimal goodsAmount = request.getGoodsAmount();
            BigDecimal discountRate = coupon.getDiscountRate();  // 0.9
            return goodsAmount.multiply(BigDecimal.ONE.subtract(discountRate))
                              .setScale(2, RoundingMode.HALF_UP);
        }

        return BigDecimal.ZERO;
    }

    /**
     * 验证金额一致性（在支付前再次校验）
     */
    public void validateAmount(Order order, Payment payment) {
        if (!order.getTotalAmount().equals(payment.getAmount())) {
            log.error("金额不一致！订单：{}，支付：{}",
                order.getTotalAmount(), payment.getAmount());
            throw new BusinessException("订单金额与支付金额不一致");
        }
    }
}

/**
 * 实名认证服务
 */
@Service
public class RealNameAuthService {

    /**
     * 方案1：微信支付/支付宝自带实名认证
     * 用户在微信/支付宝已完成实名认证（绑定身份证）
     * 平台直接获取支付人实名信息
     */
    public PayerInfo getWechatPayerInfo(String transactionId) {
        // 调用微信支付API
        WechatPayResponse response = wechatPayClient.queryTransaction(transactionId);

        return PayerInfo.builder()
            .name(response.getPayerName())      // 脱敏：张*
            .idCard(response.getPayerIdCard())  // 脱敏：3301**********1234
            .build();
    }

    /**
     * 方案2：银行卡支付需要二次认证
     * 调用银联接口，进行四要素验证（姓名、身份证、银行卡号、手机号）
     */
    public boolean verifyBankCard(BankCardInfo info) {
        UnionPayRequest request = UnionPayRequest.builder()
            .name(info.getName())
            .idCard(info.getIdCard())
            .cardNo(info.getCardNo())
            .phone(info.getPhone())
            .build();

        UnionPayResponse response = unionPayClient.verify(request);

        return response.isSuccess();
    }

    /**
     * 方案3：人脸识别（高价值订单）
     * 单笔订单超过5000元，需要人脸识别
     */
    public boolean verifyFaceId(Long userId, String faceImage) {
        // 1. 获取用户身份证照片（注册时上传）
        String idCardPhoto = userService.getIdCardPhoto(userId);

        // 2. 调用人脸识别API（阿里云、腾讯云）
        FaceCompareResponse response = faceRecognitionClient.compare(
            idCardPhoto,
            faceImage
        );

        // 3. 相似度>90%通过
        return response.getSimilarity() > 90;
    }
}

/**
 * 海关接口超时处理
 * 核心策略：异步推送 + 状态轮询 + 失败重试
 */
@Service
public class CustomsAsyncPushService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 异步推送到消息队列
     */
    public void asyncSubmitOrder(Order order) {
        // 1. 发送到MQ
        rocketMQTemplate.asyncSend("customs-order-topic", order, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("订单推送MQ成功：{}", order.getOrderNo());
            }

            @Override
            public void onException(Throwable e) {
                log.error("订单推送MQ失败：{}", order.getOrderNo(), e);
            }
        });
    }

    /**
     * 消费者：从MQ消费订单，推送到海关
     */
    @RocketMQMessageListener(
        topic = "customs-order-topic",
        consumerGroup = "customs-order-consumer"
    )
    public class CustomsOrderConsumer implements RocketMQListener<Order> {

        @Override
        public void onMessage(Order order) {
            try {
                // 调用海关接口（设置超时时间30秒）
                CustomsResponse response = customsClient.submitOrder(order);

                if (response.isSuccess()) {
                    order.setCustomsStatus("SUBMITTED");
                } else {
                    // 推送失败，重试
                    throw new RuntimeException("海关接口返回失败");
                }

            } catch (Exception e) {
                log.error("海关接口调用失败，准备重试", e);
                // 抛出异常，触发RocketMQ重试机制（最多重试3次）
                throw e;
            }
        }
    }

    /**
     * 定时任务：回查海关状态
     * 每5分钟执行一次，查询未回执的订单
     */
    @Scheduled(cron = "0 */5 * * * ?")
    public void queryCustomsStatus() {
        // 1. 查询24小时内未回执的订单
        List<Order> pendingOrders = orderRepository.findByCustomsStatusAndCreateTimeAfter(
            "SUBMITTED",
            LocalDateTime.now().minusHours(24)
        );

        for (Order order : pendingOrders) {
            try {
                // 2. 调用海关查询接口
                CustomsStatusResponse status = customsClient.queryStatus(order.getOrderNo());

                // 3. 更新订单状态
                order.setCustomsStatus(status.getStatus());
                orderRepository.save(order);

            } catch (Exception e) {
                log.error("查询海关状态失败：{}", order.getOrderNo(), e);
            }
        }
    }
}

/**
 * 区块链溯源
 * 每个商品从生产到销售的全链路记录上链
 */
@Service
public class BlockchainTraceabilityService {

    /**
     * 商品上链
     */
    public void recordProductToBlockchain(Product product) {
        // 1. 构建区块链数据
        BlockchainData data = BlockchainData.builder()
            .productId(product.getId())
            .productName(product.getName())
            .brand(product.getBrand())
            .originCountry(product.getOriginCountry())
            .manufacturer(product.getManufacturer())
            .productionDate(product.getProductionDate())
            .batchNo(product.getBatchNo())
            .timestamp(System.currentTimeMillis())
            .build();

        // 2. 上链
        String txHash = blockchainClient.submitTransaction(data);

        // 3. 保存交易哈希
        product.setBlockchainTxHash(txHash);
        productRepository.save(product);
    }

    /**
     * 用户扫码查询商品全链路信息
     */
    public TraceabilityInfo queryTraceability(String productId) {
        Product product = productRepository.findById(productId);

        // 从区块链查询数据（不可篡改）
        BlockchainData data = blockchainClient.queryTransaction(
            product.getBlockchainTxHash()
        );

        return TraceabilityInfo.builder()
            .productInfo(data)
            .manufacturer(data.getManufacturer())
            .productionDate(data.getProductionDate())
            .logisticsPath(data.getLogisticsPath())  // 物流路径
            .customsClearance(data.getCustomsClearance())  // 海关清关记录
            .build();
    }
}

/**
 * AI客服：基于大模型的智能问答
 */
@Service
public class AICustomerService {

    /**
     * 用户提问："我的包裹为什么还没发货？"
     */
    public String answerQuestion(String userId, String question) {
        // 1. 查询用户最近订单
        Order order = orderService.getLatestOrder(userId);

        // 2. 分析订单状态
        if (order.getCustomsStatus().equals("FAILED")) {
            // 海关失败，自动分析错误原因
            String errorCode = order.getCustomsErrorCode();
            String errorMsg = getErrorMessage(errorCode);

            return String.format(
                "您的订单因海关问题暂时无法发货。原因：%s。" +
                "我们的客服人员正在处理，预计24小时内解决。",
                errorMsg
            );
        }

        if (order.getCustomsStatus().equals("SUBMITTED")) {
            // 海关审核中
            return "您的订单正在海关审核中，预计2小时内完成审核，请耐心等待。";
        }

        return "系统未识别到您的问题，请联系人工客服。";
    }
}