亚马逊卖家供应链数字化实战：从中国采购到美国销售的完整体系构建

/**
 * 跨境电商ERP系统架构
 */
@SpringBootApplication
public class CrossBorderErpApplication {

    /**
     * 核心模块
     */
    public static class ErpModules {

        // 1. 供应商管理模块
        @Autowired
        private SupplierManagementService supplierService;

        // 2. 采购管理模块
        @Autowired
        private PurchaseManagementService purchaseService;

        // 3. 库存管理模块
        @Autowired
        private InventoryManagementService inventoryService;

        // 4. 销售管理模块
        @Autowired
        private SalesManagementService salesService;

        // 5. 财务管理模块
        @Autowired
        private FinanceManagementService financeService;
    }
}

/**
 * 采购管理服务
 * 核心功能：采购订单管理、供应商协同、成本核算
 */
@Service
public class PurchaseManagementService {

    @Autowired
    private PurchaseOrderRepository purchaseOrderRepository;

    @Autowired
    private SupplierRepository supplierRepository;

    /**
     * 创建采购订单
     */
    @Transactional
    public PurchaseOrder createPurchaseOrder(PurchaseOrderRequest request) {
        // 1. 查询供应商信息
        Supplier supplier = supplierRepository.findById(request.getSupplierId())
            .orElseThrow(() -> new BusinessException("供应商不存在"));

        // 2. 计算采购总价
        BigDecimal totalAmount = request.getItems().stream()
            .map(item -> item.getPrice().multiply(new BigDecimal(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);

        // 3. 创建采购订单
        PurchaseOrder order = PurchaseOrder.builder()
            .orderNo(generateOrderNo("PO"))
            .supplierId(supplier.getId())
            .supplierName(supplier.getName())
            .totalAmount(totalAmount)
            .currency("CNY")
            .paymentTerm(supplier.getPaymentTerm())  // 付款条件（如：预付30%，尾款70%）
            .expectedDeliveryDate(request.getExpectedDeliveryDate())
            .status("PENDING")
            .build();

        // 4. 添加采购明细
        for (PurchaseOrderItemRequest itemReq : request.getItems()) {
            PurchaseOrderItem item = PurchaseOrderItem.builder()
                .purchaseOrderId(order.getId())
                .skuCode(itemReq.getSkuCode())
                .productName(itemReq.getProductName())
                .quantity(itemReq.getQuantity())
                .unitPrice(itemReq.getPrice())
                .totalPrice(itemReq.getPrice().multiply(new BigDecimal(itemReq.getQuantity())))
                .build();
            order.addItem(item);
        }

        // 5. 保存采购订单
        purchaseOrderRepository.save(order);

        // 6. 生成应付账款（业财一体化）
        generateAccountsPayable(order);

        // 7. 发送采购订单给供应商（EDI/邮件）
        sendPurchaseOrderToSupplier(order, supplier);

        return order;
    }

    /**
     * 生成应付账款（业财一体化的关键）
     */
    private void generateAccountsPayable(PurchaseOrder order) {
        // 1. 根据付款条件，生成应付账款
        BigDecimal totalAmount = order.getTotalAmount();
        String paymentTerm = order.getPaymentTerm();

        if ("PREPAY_30_BALANCE_70".equals(paymentTerm)) {
            // 预付30%
            AccountsPayable prepayment = AccountsPayable.builder()
                .orderNo(order.getOrderNo())
                .supplierId(order.getSupplierId())
                .amount(totalAmount.multiply(new BigDecimal("0.30")))
                .dueDate(LocalDate.now().plusDays(3))  // 3天内支付
                .status("UNPAID")
                .type("PREPAYMENT")
                .build();
            accountsPayableRepository.save(prepayment);

            // 尾款70%
            AccountsPayable balance = AccountsPayable.builder()
                .orderNo(order.getOrderNo())
                .supplierId(order.getSupplierId())
                .amount(totalAmount.multiply(new BigDecimal("0.70")))
                .dueDate(order.getExpectedDeliveryDate())  // 发货前支付
                .status("UNPAID")
                .type("BALANCE")
                .build();
            accountsPayableRepository.save(balance);
        }

        // 2. 自动生成财务凭证
        generateFinancialVoucher(order);
    }

    /**
     * 采购到货确认
     */
    @Transactional
    public void confirmPurchaseArrival(String orderNo, PurchaseArrivalRequest request) {
        PurchaseOrder order = purchaseOrderRepository.findByOrderNo(orderNo);

        // 1. 更新到货数量
        for (PurchaseArrivalItem item : request.getItems()) {
            PurchaseOrderItem orderItem = order.getItems().stream()
                .filter(i -> i.getSkuCode().equals(item.getSkuCode()))
                .findFirst()
                .orElseThrow(() -> new BusinessException("SKU不存在"));

            orderItem.setArrivedQuantity(item.getArrivedQuantity());
            orderItem.setQualifiedQuantity(item.getQualifiedQuantity());
            orderItem.setDefectiveQuantity(item.getDefectiveQuantity());
        }

        // 2. 更新订单状态
        order.setStatus("ARRIVED");
        order.setActualDeliveryDate(LocalDate.now());
        purchaseOrderRepository.save(order);

        // 3. 生成入库单
        generateInboundOrder(order);

        // 4. 更新库存（WMS系统）
        wmsService.addInventory(order);
    }

    /**
     * 智能补货建议
     * 基于销售预测，自动生成采购建议
     */
    public List<PurchaseRecommendation> generatePurchaseRecommendations() {
        List<PurchaseRecommendation> recommendations = new ArrayList<>();

        // 1. 查询所有在售SKU
        List<Product> products = productRepository.findByStatus("ACTIVE");

        for (Product product : products) {
            // 2. 查询当前库存（国内库存 + 海外库存）
            int domesticStock = inventoryService.getDomesticStock(product.getSkuCode());
            int overseasStock = inventoryService.getOverseasStock(product.getSkuCode());
            int totalStock = domesticStock + overseasStock;

            // 3. 查询在途库存（已采购但未到货）
            int inTransitStock = inventoryService.getInTransitStock(product.getSkuCode());

            // 4. 预测未来60天销量
            int predictedSales = salesForecastService.predict(product.getSkuCode(), 60);

            // 5. 计算安全库存（1.5倍的平均销量）
            int safetyStock = (int) (predictedSales * 1.5);

            // 6. 计算建议采购量
            int recommendedPurchaseQty = safetyStock - totalStock - inTransitStock;

            if (recommendedPurchaseQty > 0) {
                recommendations.add(PurchaseRecommendation.builder()
                    .skuCode(product.getSkuCode())
                    .currentStock(totalStock)
                    .inTransitStock(inTransitStock)
                    .predictedSales(predictedSales)
                    .safetyStock(safetyStock)
                    .recommendedQty(recommendedPurchaseQty)
                    .urgency(calculateUrgency(totalStock, predictedSales))
                    .build());
            }
        }

        return recommendations;
    }

    /**
     * 计算紧急程度
     */
    private String calculateUrgency(int currentStock, int predictedSales) {
        double daysOfStock = currentStock * 60.0 / predictedSales;

        if (daysOfStock < 15) {
            return "URGENT";  // 库存不足15天，紧急
        } else if (daysOfStock < 30) {
            return "HIGH";    // 库存不足30天，高优先级
        } else {
            return "NORMAL";  // 正常
        }
    }
}

/**
 * 仓储管理系统
 * 核心功能：入库管理、库位管理、出库管理、库存盘点
 */
@Service
public class WarehouseManagementService {

    /**
     * 采购入库
     */
    @Transactional
    public void purchaseInbound(PurchaseOrder order) {
        // 1. 创建入库单
        InboundOrder inbound = InboundOrder.builder()
            .inboundNo(generateInboundNo())
            .sourceType("PURCHASE")
            .sourceNo(order.getOrderNo())
            .warehouseCode("CN-SZ-01")  // 深圳中转仓
            .status("PENDING")
            .build();

        // 2. 添加入库明细
        for (PurchaseOrderItem item : order.getItems()) {
            InboundItem inboundItem = InboundItem.builder()
                .skuCode(item.getSkuCode())
                .expectedQty(item.getQuantity())
                .actualQty(0)  // 待验收
                .build();
            inbound.addItem(inboundItem);
        }

        inboundOrderRepository.save(inbound);

        // 3. 生成质检任务
        createQualityInspectionTask(inbound);
    }

    /**
     * 质检验收
     */
    @Transactional
    public void qualityInspection(String inboundNo, QualityInspectionResult result) {
        InboundOrder inbound = inboundOrderRepository.findByInboundNo(inboundNo);

        // 1. 更新验收结果
        for (QualityInspectionItem item : result.getItems()) {
            InboundItem inboundItem = inbound.getItems().stream()
                .filter(i -> i.getSkuCode().equals(item.getSkuCode()))
                .findFirst()
                .orElseThrow();

            inboundItem.setActualQty(item.getActualQty());
            inboundItem.setQualifiedQty(item.getQualifiedQty());
            inboundItem.setDefectiveQty(item.getDefectiveQty());
        }

        // 2. 质检合格的商品，分配库位
        for (InboundItem item : inbound.getItems()) {
            if (item.getQualifiedQty() > 0) {
                // 2.1 分配库位
                String locationCode = allocateLocation(
                    inbound.getWarehouseCode(),
                    item.getSkuCode(),
                    item.getQualifiedQty()
                );

                // 2.2 更新库存
                updateInventory(
                    inbound.getWarehouseCode(),
                    locationCode,
                    item.getSkuCode(),
                    item.getQualifiedQty(),
                    "ADD"
                );
            }

            // 2.3 不合格品，移入次品区
            if (item.getDefectiveQty() > 0) {
                moveToDefectiveArea(item.getSkuCode(), item.getDefectiveQty());
            }
        }

        // 3. 更新入库单状态
        inbound.setStatus("COMPLETED");
        inbound.setCompletedTime(LocalDateTime.now());
        inboundOrderRepository.save(inbound);
    }

    /**
     * FBA发货（从国内中转仓发往美国FBA）
     */
    @Transactional
    public void shipToFBA(FBAShipmentRequest request) {
        // 1. 创建FBA发货计划
        FBAShipmentPlan plan = FBAShipmentPlan.builder()
            .planNo(generateFBAPlanNo())
            .fbaWarehouseCode(request.getFbaWarehouseCode())
            .shipmentMethod("SEA")  // 海运
            .status("PREPARING")
            .build();

        // 2. 添加发货明细
        for (FBAShipmentItem item : request.getItems()) {
            plan.addItem(item);

            // 2.1 锁定库存
            lockInventory("CN-SZ-01", item.getSkuCode(), item.getQuantity());
        }

        fbaShipmentPlanRepository.save(plan);

        // 3. 生成出库单
        generateOutboundOrder(plan);

        // 4. 调用货代系统，预订舱位
        freightForwarderService.bookShipment(plan);
    }

    /**
     * 库存查询（实时库存）
     */
    public InventoryInfo getInventory(String skuCode) {
        // 1. 国内库存
        int domesticStock = inventoryRepository.sumByWarehouseTypeAndSkuCode("DOMESTIC", skuCode);

        // 2. 海外库存（FBA）
        int fbaStock = inventoryRepository.sumByWarehouseTypeAndSkuCode("FBA", skuCode);

        // 3. 在途库存（已发FBA但未到货）
        int inTransitToFBA = fbaShipmentRepository.sumInTransit(skuCode);

        // 4. 在途库存（已采购但未入库）
        int inTransitFromSupplier = purchaseOrderRepository.sumInTransit(skuCode);

        return InventoryInfo.builder()
            .skuCode(skuCode)
            .domesticStock(domesticStock)
            .fbaStock(fbaStock)
            .inTransitToFBA(inTransitToFBA)
            .inTransitFromSupplier(inTransitFromSupplier)
            .totalAvailable(domesticStock + fbaStock)
            .build();
    }
}

/**
 * 物流管理系统
 * 核心功能：物流订单管理、运费管理、物流追踪
 */
@Service
public class TransportManagementService {

    /**
     * 创建国际物流订单
     */
    @Transactional
    public LogisticsOrder createLogisticsOrder(FBAShipmentPlan plan) {
        // 1. 选择物流服务商（海运/空运）
        LogisticsProvider provider = selectLogisticsProvider(plan);

        // 2. 计算体积和重量
        BigDecimal totalVolume = calculateVolume(plan);
        BigDecimal totalWeight = calculateWeight(plan);

        // 3. 询价
        FreightQuote quote = provider.getQuote(
            "SHENZHEN",      // 起运港
            "LOS_ANGELES",   // 目的港
            totalVolume,
            totalWeight,
            "SEA"            // 运输方式
        );

        // 4. 创建物流订单
        LogisticsOrder order = LogisticsOrder.builder()
            .orderNo(generateLogisticsOrderNo())
            .fbaShipmentPlanNo(plan.getPlanNo())
            .providerId(provider.getId())
            .providerName(provider.getName())
            .shipmentMethod("SEA")
            .originPort("SHENZHEN")
            .destinationPort("LOS_ANGELES")
            .totalVolume(totalVolume)
            .totalWeight(totalWeight)
            .freight(quote.getFreight())               // 运费
            .customsFee(quote.getCustomsFee())         // 报关费
            .destinationFee(quote.getDestinationFee()) // 目的港费用
            .totalCost(quote.getTotalCost())
            .etd(LocalDate.now().plusDays(7))          // 预计起运时间
            .eta(LocalDate.now().plusDays(42))         // 预计到达时间
            .status("BOOKED")
            .build();

        logisticsOrderRepository.save(order);

        // 5. 生成应付账款（物流费用）
        generateLogisticsPayable(order);

        return order;
    }

    /**
     * 物流追踪
     */
    @Scheduled(cron = "0 */30 * * * ?")  // 每30分钟更新一次
    public void trackLogistics() {
        // 1. 查询运输中的物流订单
        List<LogisticsOrder> orders = logisticsOrderRepository.findByStatus("IN_TRANSIT");

        for (LogisticsOrder order : orders) {
            // 2. 调用物流商API查询最新状态
            LogisticsTrackingInfo tracking = logisticsProviderClient.track(
                order.getProviderName(),
                order.getTrackingNo()
            );

            // 3. 更新物流状态
            order.setCurrentStatus(tracking.getStatus());
            order.setCurrentLocation(tracking.getLocation());
            order.setUpdateTime(LocalDateTime.now());

            // 4. 关键节点通知
            if ("ARRIVED_AT_PORT".equals(tracking.getStatus())) {
                // 到达目的港，通知清关
                notificationService.sendArrivalNotification(order);
            }

            if ("CUSTOMS_CLEARED".equals(tracking.getStatus())) {
                // 清关完成，通知派送
                notificationService.sendClearanceNotification(order);
            }

            if ("DELIVERED_TO_FBA".equals(tracking.getStatus())) {
                // 送达FBA，更新库存
                order.setStatus("COMPLETED");
                order.setActualArrivalDate(LocalDate.now());

                // 更新FBA库存
                updateFBAInventory(order);
            }

            logisticsOrderRepository.save(order);
        }
    }

    /**
     * 运费核算
     * 家具是大件商品，需要精确核算体积重和实际重，取大值计费
     */
    private BigDecimal calculateFreight(BigDecimal volume, BigDecimal weight) {
        // 1. 计算体积重（1CBM = 167kg）
        BigDecimal volumeWeight = volume.multiply(new BigDecimal("167"));

        // 2. 取实际重量和体积重的较大值
        BigDecimal chargeableWeight = volumeWeight.max(weight);

        // 3. 根据计费重量计算运费（假设$50/100kg）
        BigDecimal freight = chargeableWeight
            .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP)
            .multiply(new BigDecimal("50"));

        return freight;
    }
}

/**
 * 财务管理服务（业财一体化）
 */
@Service
public class FinanceManagementService {

    /**
     * 场景1：采购订单生成应付账款
     */
    @EventListener
    public void onPurchaseOrderCreated(PurchaseOrderCreatedEvent event) {
        PurchaseOrder order = event.getPurchaseOrder();

        // 1. 生成财务凭证
        FinancialVoucher voucher = FinancialVoucher.builder()
            .voucherNo(generateVoucherNo())
            .voucherType("PURCHASE")
            .sourceType("PURCHASE_ORDER")
            .sourceNo(order.getOrderNo())
            .voucherDate(LocalDate.now())
            .build();

        // 2. 借：库存商品（预估）
        voucher.addDebitEntry(DebitEntry.builder()
            .accountCode("1405")  // 库存商品
            .accountName("库存商品-办公家具")
            .amount(order.getTotalAmount())
            .build());

        // 3. 贷：应付账款
        voucher.addCreditEntry(CreditEntry.builder()
            .accountCode("2202")  // 应付账款
            .accountName("应付账款-" + order.getSupplierName())
            .amount(order.getTotalAmount())
            .build());

        financialVoucherRepository.save(voucher);
    }

    /**
     * 场景2：商品入库，核算实际成本
     */
    @EventListener
    public void onInventoryInbound(InventoryInboundEvent event) {
        InboundOrder inbound = event.getInboundOrder();

        // 1. 查询采购订单，获取采购成本
        PurchaseOrder purchase = purchaseOrderRepository.findByOrderNo(inbound.getSourceNo());

        // 2. 核算实际入库成本
        for (InboundItem item : inbound.getItems()) {
            // 2.1 计算单位成本
            BigDecimal unitCost = purchase.getItems().stream()
                .filter(i -> i.getSkuCode().equals(item.getSkuCode()))
                .findFirst()
                .map(PurchaseOrderItem::getUnitPrice)
                .orElse(BigDecimal.ZERO);

            // 2.2 更新库存成本
            InventoryCost cost = InventoryCost.builder()
                .skuCode(item.getSkuCode())
                .warehouseCode(inbound.getWarehouseCode())
                .quantity(item.getQualifiedQty())
                .unitCost(unitCost)
                .totalCost(unitCost.multiply(new BigDecimal(item.getQualifiedQty())))
                .costMethod("WEIGHTED_AVERAGE")  // 加权平均法
                .build();
            inventoryCostRepository.save(cost);
        }
    }

    /**
     * 场景3：亚马逊销售，核算销售成本和收入
     */
    @EventListener
    public void onAmazonOrderShipped(AmazonOrderShippedEvent event) {
        AmazonOrder order = event.getOrder();

        // 1. 确认收入
        FinancialVoucher incomeVoucher = FinancialVoucher.builder()
            .voucherNo(generateVoucherNo())
            .voucherType("SALES_INCOME")
            .sourceType("AMAZON_ORDER")
            .sourceNo(order.getAmazonOrderId())
            .voucherDate(LocalDate.now())
            .build();

        // 借：应收账款-亚马逊
        incomeVoucher.addDebitEntry(DebitEntry.builder()
            .accountCode("1122")
            .accountName("应收账款-亚马逊")
            .amount(order.getTotalAmount())
            .build());

        // 贷：主营业务收入
        incomeVoucher.addCreditEntry(CreditEntry.builder()
            .accountCode("6001")
            .accountName("主营业务收入-家具销售")
            .amount(order.getTotalAmount())
            .build());

        financialVoucherRepository.save(incomeVoucher);

        // 2. 结转销售成本
        FinancialVoucher costVoucher = FinancialVoucher.builder()
            .voucherNo(generateVoucherNo())
            .voucherType("SALES_COST")
            .sourceType("AMAZON_ORDER")
            .sourceNo(order.getAmazonOrderId())
            .voucherDate(LocalDate.now())
            .build();

        // 计算销售成本
        BigDecimal salesCost = calculateSalesCost(order);

        // 借：主营业务成本
        costVoucher.addDebitEntry(DebitEntry.builder()
            .accountCode("6401")
            .accountName("主营业务成本-家具销售")
            .amount(salesCost)
            .build());

        // 贷：库存商品
        costVoucher.addCreditEntry(CreditEntry.builder()
            .accountCode("1405")
            .accountName("库存商品-办公家具")
            .amount(salesCost)
            .build());

        financialVoucherRepository.save(costVoucher);
    }

    /**
     * 计算销售成本（关键！）
     */
    private BigDecimal calculateSalesCost(AmazonOrder order) {
        BigDecimal totalCost = BigDecimal.ZERO;

        for (AmazonOrderItem item : order.getItems()) {
            // 1. 查询该SKU的库存成本（加权平均）
            BigDecimal unitCost = inventoryCostRepository.getWeightedAverageCost(
                item.getSkuCode(),
                "FBA-US-LAX1"  // FBA仓库代码
            );

            // 2. 计算成本
            BigDecimal itemCost = unitCost.multiply(new BigDecimal(item.getQuantity()));
            totalCost = totalCost.add(itemCost);
        }

        return totalCost;
    }

    /**
     * 场景4：亚马逊收款，核算平台费用
     */
    @EventListener
    public void onAmazonSettlement(AmazonSettlementEvent event) {
        AmazonSettlement settlement = event.getSettlement();

        // 1. 确认银行存款（实际收款）
        FinancialVoucher voucher = FinancialVoucher.builder()
            .voucherNo(generateVoucherNo())
            .voucherType("SETTLEMENT")
            .sourceType("AMAZON_SETTLEMENT")
            .sourceNo(settlement.getSettlementId())
            .voucherDate(LocalDate.now())
            .build();

        // 借：银行存款-美国账户
        voucher.addDebitEntry(DebitEntry.builder()
            .accountCode("1002")
            .accountName("银行存款-BOA美国账户")
            .amount(settlement.getTotalAmount())
            .currency("USD")
            .build());

        // 借：销售费用-亚马逊佣金
        voucher.addDebitEntry(DebitEntry.builder()
            .accountCode("6601")
            .accountName("销售费用-亚马逊佣金")
            .amount(settlement.getCommissionFee())
            .currency("USD")
            .build());

        // 借：销售费用-FBA费用
        voucher.addDebitEntry(DebitEntry.builder()
            .accountCode("6602")
            .accountName("销售费用-FBA配送费")
            .amount(settlement.getFbaFee())
            .currency("USD")
            .build());

        // 贷：应收账款-亚马逊
        voucher.addCreditEntry(CreditEntry.builder()
            .accountCode("1122")
            .accountName("应收账款-亚马逊")
            .amount(settlement.getTotalAmount()
                .add(settlement.getCommissionFee())
                .add(settlement.getFbaFee()))
            .currency("USD")
            .build());

        financialVoucherRepository.save(voucher);
    }
}

/**
 * 销售预测服务
 * 算法：时间序列预测（ARIMA模型）
 */
@Service
public class SalesForecastService {

    @Autowired
    private TimeSeriesAnalysisService timeSeriesService;

    /**
     * 预测未来N天的销量
     */
    public int predict(String skuCode, int days) {
        // 1. 查询历史销售数据（最近90天）
        List<DailySales> historicalData = salesRepository.findHistoricalSales(
            skuCode,
            LocalDate.now().minusDays(90),
            LocalDate.now()
        );

        // 2. 构建时间序列
        double[] timeSeries = historicalData.stream()
            .mapToDouble(DailySales::getQuantity)
            .toArray();

        // 3. ARIMA预测
        double[] forecast = timeSeriesService.forecast(timeSeries, days);

        // 4. 求和得到总销量预测
        int predictedSales = (int) Arrays.stream(forecast).sum();

        // 5. 考虑季节性因素（如黑五、圣诞节）
        double seasonalFactor = getSeasonalFactor(LocalDate.now(), days);
        predictedSales = (int) (predictedSales * seasonalFactor);

        return predictedSales;
    }

    /**
     * 季节性因素
     */
    private double getSeasonalFactor(LocalDate startDate, int days) {
        LocalDate endDate = startDate.plusDays(days);

        // 黑色星期五前后（11月第四个周五），销量翻倍
        if (isBlackFridayPeriod(startDate, endDate)) {
            return 2.0;
        }

        // 圣诞节前后（12月），销量增长50%
        if (isChristmasPeriod(startDate, endDate)) {
            return 1.5;
        }

        // 新年促销（1月），销量增长30%
        if (isNewYearPeriod(startDate, endDate)) {
            return 1.3;
        }

        return 1.0;
    }
}

/**
 * 多币种成本核算服务
 */
@Service
public class MultiCurrencyCostService {

    /**
     * 核算SKU的完整成本（多币种）
     */
    public ProductCostBreakdown calculateCost(String skuCode) {
        // 1. 采购成本（CNY）
        BigDecimal purchaseCostCNY = getPurchaseCost(skuCode);

        // 2. 国际物流成本（CNY）
        BigDecimal logisticsCostCNY = getLogisticsCost(skuCode);

        // 3. 关税成本（USD，到岸价×关税率）
        BigDecimal customsDutyUSD = getCustomsDuty(skuCode);

        // 4. FBA费用（USD）
        BigDecimal fbaFeeUSD = getFBAFee(skuCode);

        // 5. 亚马逊佣金（USD，售价×15%）
        BigDecimal commissionUSD = getAmazonCommission(skuCode);

        // 6. 汇率转换（统一为USD）
        BigDecimal exchangeRate = getExchangeRate("CNY", "USD");

        BigDecimal totalCostUSD = purchaseCostCNY.add(logisticsCostCNY)
            .multiply(exchangeRate)  // CNY转USD
            .add(customsDutyUSD)
            .add(fbaFeeUSD)
            .add(commissionUSD);

        return ProductCostBreakdown.builder()
            .skuCode(skuCode)
            .purchaseCostCNY(purchaseCostCNY)
            .purchaseCostUSD(purchaseCostCNY.multiply(exchangeRate))
            .logisticsCostCNY(logisticsCostCNY)
            .logisticsCostUSD(logisticsCostCNY.multiply(exchangeRate))
            .customsDutyUSD(customsDutyUSD)
            .fbaFeeUSD(fbaFeeUSD)
            .commissionUSD(commissionUSD)
            .totalCostUSD(totalCostUSD)
            .exchangeRate(exchangeRate)
            .build();
    }

    /**
     * 汇率锁定策略
     */
    public void lockExchangeRate(String purchaseOrderNo) {
        PurchaseOrder order = purchaseOrderRepository.findByOrderNo(purchaseOrderNo);

        // 1. 获取当前汇率
        BigDecimal currentRate = getExchangeRate("CNY", "USD");

        // 2. 锁定汇率（通过银行远期外汇合约）
        ExchangeRateLock lock = ExchangeRateLock.builder()
            .orderNo(purchaseOrderNo)
            .fromCurrency("CNY")
            .toCurrency("USD")
            .lockedRate(currentRate)
            .amount(order.getTotalAmount())
            .lockDate(LocalDate.now())
            .expiryDate(LocalDate.now().plusDays(90))  // 90天后到期
            .build();
        exchangeRateLockRepository.save(lock);

        // 3. 订单使用锁定汇率
        order.setLockedExchangeRate(currentRate);
        purchaseOrderRepository.save(order);
    }
}

/**
 * 现金流管理服务
 */
@Service
public class CashFlowManagementService {

    /**
     * 现金流预测（未来30天）
     */
    public CashFlowForecast forecastCashFlow(int days) {
        LocalDate startDate = LocalDate.now();
        LocalDate endDate = startDate.plusDays(days);

        // 1. 预测现金流入
        List<CashInflow> inflows = new ArrayList<>();

        // 1.1 亚马逊结算（每14天一次）
        List<AmazonSettlement> settlements = predictAmazonSettlements(startDate, endDate);
        for (AmazonSettlement settlement : settlements) {
            inflows.add(CashInflow.builder()
                .date(settlement.getSettlementDate())
                .type("AMAZON_SETTLEMENT")
                .amount(settlement.getTotalAmount())
                .currency("USD")
                .build());
        }

        // 2. 预测现金流出
        List<CashOutflow> outflows = new ArrayList<>();

        // 2.1 采购付款
        List<AccountsPayable> payables = accountsPayableRepository
            .findByDueDateBetween(startDate, endDate);
        for (AccountsPayable payable : payables) {
            outflows.add(CashOutflow.builder()
                .date(payable.getDueDate())
                .type("PURCHASE_PAYMENT")
                .amount(payable.getAmount())
                .currency("CNY")
                .build());
        }

        // 2.2 物流付款
        List<LogisticsOrder> logistics = logisticsOrderRepository
            .findByPaymentDueDateBetween(startDate, endDate);
        for (LogisticsOrder order : logistics) {
            outflows.add(CashOutflow.builder()
                .date(order.getPaymentDueDate())
                .type("LOGISTICS_PAYMENT")
                .amount(order.getTotalCost())
                .currency("CNY")
                .build());
        }

        // 3. 计算每日现金流
        Map<LocalDate, BigDecimal> dailyCashFlow = new HashMap<>();
        BigDecimal currentBalance = getCurrentBalance();

        for (LocalDate date = startDate; !date.isAfter(endDate); date = date.plusDays(1)) {
            BigDecimal dailyInflow = inflows.stream()
                .filter(i -> i.getDate().equals(date))
                .map(CashInflow::getAmountInCNY)
                .reduce(BigDecimal.ZERO, BigDecimal::add);

            BigDecimal dailyOutflow = outflows.stream()
                .filter(o -> o.getDate().equals(date))
                .map(CashOutflow::getAmount)
                .reduce(BigDecimal.ZERO, BigDecimal::add);

            BigDecimal netFlow = dailyInflow.subtract(dailyOutflow);
            currentBalance = currentBalance.add(netFlow);

            dailyCashFlow.put(date, currentBalance);

            // 4. 预警：如果现金余额低于安全线（50万），告警
            if (currentBalance.compareTo(new BigDecimal("500000")) < 0) {
                log.warn("现金流预警：{}日余额仅为{}，低于安全线", date, currentBalance);
                sendCashFlowAlert(date, currentBalance);
            }
        }

        return CashFlowForecast.builder()
            .startDate(startDate)
            .endDate(endDate)
            .inflows(inflows)
            .outflows(outflows)
            .dailyCashFlow(dailyCashFlow)
            .build();
    }
}

/**
 * 利润优化系统
 * 自动分析每个SKU的盈亏情况，给出优化建议
 */
@Service
public class ProfitOptimizationService {

    /**
     * 分析SKU盈亏
     */
    public ProfitAnalysis analyzeProfitability(String skuCode) {
        // 1. 获取成本结构
        ProductCostBreakdown cost = costService.calculateCost(skuCode);

        // 2. 获取售价
        BigDecimal sellingPrice = productRepository.findBySkuCode(skuCode).getPrice();

        // 3. 计算利润
        BigDecimal profit = sellingPrice.subtract(cost.getTotalCostUSD());
        BigDecimal profitMargin = profit.divide(sellingPrice, 4, RoundingMode.HALF_UP);

        // 4. 判断盈亏
        String status;
        if (profitMargin.compareTo(new BigDecimal("0.30")) > 0) {
            status = "EXCELLENT";  // 利润率>30%，优秀
        } else if (profitMargin.compareTo(new BigDecimal("0.15")) > 0) {
            status = "GOOD";       // 利润率15-30%，良好
        } else if (profitMargin.compareTo(BigDecimal.ZERO) > 0) {
            status = "WARNING";    // 利润率0-15%，预警
        } else {
            status = "LOSS";       // 亏损
        }

        // 5. 生成优化建议
        List<OptimizationSuggestion> suggestions = generateSuggestions(cost, sellingPrice);

        return ProfitAnalysis.builder()
            .skuCode(skuCode)
            .costBreakdown(cost)
            .sellingPrice(sellingPrice)
            .profit(profit)
            .profitMargin(profitMargin)
            .status(status)
            .suggestions(suggestions)
            .build();
    }

    /**
     * 生成优化建议
     */
    private List<OptimizationSuggestion> generateSuggestions(
        ProductCostBreakdown cost,
        BigDecimal sellingPrice
    ) {
        List<OptimizationSuggestion> suggestions = new ArrayList<>();

        // 建议1：采购成本占比过高
        BigDecimal purchaseRatio = cost.getPurchaseCostUSD()
            .divide(cost.getTotalCostUSD(), 4, RoundingMode.HALF_UP);

        if (purchaseRatio.compareTo(new BigDecimal("0.40")) > 0) {
            suggestions.add(OptimizationSuggestion.builder()
                .type("PURCHASE_COST")
                .severity("HIGH")
                .description("采购成本占比过高：" + purchaseRatio.multiply(new BigDecimal("100")) + "%")
                .suggestion("建议：1. 与供应商重新谈判价格；2. 寻找替代供应商；3. 增加采购量以获得折扣")
                .build());
        }

        // 建议2：物流成本占比过高
        BigDecimal logisticsRatio = cost.getLogisticsCostUSD()
            .divide(cost.getTotalCostUSD(), 4, RoundingMode.HALF_UP);

        if (logisticsRatio.compareTo(new BigDecimal("0.30")) > 0) {
            suggestions.add(OptimizationSuggestion.builder()
                .type("LOGISTICS_COST")
                .severity("MEDIUM")
                .description("物流成本占比过高：" + logisticsRatio.multiply(new BigDecimal("100")) + "%")
                .suggestion("建议：1. 采用慢船海运；2. 与其他卖家拼柜；3. 批量发货降低单件成本")
                .build());
        }

        // 建议3：广告成本过高
        BigDecimal adCostRatio = cost.getCommissionUSD()
            .divide(sellingPrice, 4, RoundingMode.HALF_UP);

        if (adCostRatio.compareTo(new BigDecimal("0.20")) > 0) {
            suggestions.add(OptimizationSuggestion.builder()
                .type("AD_COST")
                .severity("MEDIUM")
                .description("广告成本占比过高：" + adCostRatio.multiply(new BigDecimal("100")) + "%")
                .suggestion("建议：1. 优化关键词，提高自然排名；2. 调整广告竞价；3. 提升产品评分降低广告依赖")
                .build());
        }

        return suggestions;
    }
}