// PricingEngine 价格计算引擎
type PricingEngine struct {
    basePriceCalculator BasePriceCalculator
    promotionMatcher    PromotionMatcher
    feeCalculator       FeeCalculator
    voucherApplier      VoucherApplier
    snapshotGenerator   SnapshotGenerator
    priceCache          cache.Cache
    degradeConfig       *DegradeConfig // 降级配置
}

// PriceRequest 价格计算请求
type PriceRequest struct {
    UserID       int64                  `json:"user_id"`
    ItemID       int64                  `json:"item_id"`
    SKUID        int64                  `json:"sku_id"`
    Quantity     int                    `json:"quantity"`
    CategoryID   int64                  `json:"category_id"`
    Region       string                 `json:"region"`       // 国家/地区: TH, VN, ID...
    Currency     string                 `json:"currency"`     // 币种: THB, VND, IDR...
    VoucherCodes []string               `json:"voucher_codes"`
    Context      map[string]interface{} `json:"context"`      // 额外上下文（日期、场次等）
    Scene        string                 `json:"scene"`        // 场景: list, detail, cart, checkout
}

// PriceResponse 价格计算响应
type PriceResponse struct {
    // 基础价格
    BasePrice     decimal.Decimal `json:"base_price"`
    OriginalPrice decimal.Decimal `json:"original_price"`
    Subtotal      decimal.Decimal `json:"subtotal"`

    // 营销折扣
    PromotionDiscount decimal.Decimal   `json:"promotion_discount"`
    PromotionDetails  []PromotionDetail `json:"promotion_details"`

    // 费用
    TotalFee   decimal.Decimal `json:"total_fee"`
    FeeDetails []FeeDetail     `json:"fee_details"`

    // 优惠券
    VoucherDiscount decimal.Decimal   `json:"voucher_discount"`
    VoucherDetails  []VoucherDetail   `json:"voucher_details"`

    // 最终价格
    FinalPrice   decimal.Decimal `json:"final_price"`
    Currency     string          `json:"currency"`
    PriceFormula string          `json:"price_formula"`

    // 快照
    SnapshotCode string `json:"snapshot_code"`

    // 降级标记
    Degraded     bool   `json:"degraded"`      // 是否降级
    DegradeLevel string `json:"degrade_level"` // 降级级别: none, promotion, voucher, fee
}

// PromotionDetail 促销明细
type PromotionDetail struct {
    ActivityID   int64           `json:"activity_id"`
    ActivityName string          `json:"activity_name"`
    ActivityType string          `json:"activity_type"`
    Discount     decimal.Decimal `json:"discount"`
}

// FeeDetail 费用明细
type FeeDetail struct {
    FeeType     string          `json:"fee_type"`
    FeeName     string          `json:"fee_name"`
    Amount      decimal.Decimal `json:"amount"`
    CanDiscount bool            `json:"can_discount"` // 是否可被优惠券抵扣
    DisplayType string          `json:"display_type"` // separate / included
}

// VoucherDetail 优惠券明细
type VoucherDetail struct {
    VoucherID   int64           `json:"voucher_id"`
    VoucherCode string          `json:"voucher_code"`
    VoucherName string          `json:"voucher_name"`
    Discount    decimal.Decimal `json:"discount"`
}

// Calculate 计算价格（核心入口）
func (e *PricingEngine) Calculate(ctx context.Context, req *PriceRequest) (*PriceResponse, error) {
    resp := &PriceResponse{Currency: req.Currency}

    // Step 1: 计算基础价格
    basePrice, err := e.basePriceCalculator.Calculate(ctx, req)
    if err != nil {
        return nil, errors.Wrap(err, "calculate base price failed")
    }
    resp.BasePrice = basePrice.Price
    resp.OriginalPrice = basePrice.OriginalPrice
    resp.Subtotal = basePrice.Price.Mul(decimal.NewFromInt(int64(req.Quantity)))

    // Step 2: 匹配并应用营销活动（支持降级）
    promotions, err := e.matchPromotionsWithDegrade(ctx, req, basePrice.Price)
    if err != nil {
        // 促销服务故障时降级，不影响核心流程
        log.Warnf("promotion match degraded: %v", err)
        resp.Degraded = true
        resp.DegradeLevel = "promotion"
    }

    totalDiscount := decimal.Zero
    for _, promo := range promotions {
        discount := e.calculatePromotionDiscount(promo, resp.Subtotal)
        totalDiscount = totalDiscount.Add(discount)
        resp.PromotionDetails = append(resp.PromotionDetails, PromotionDetail{
            ActivityID:   promo.ActivityID,
            ActivityName: promo.ActivityName,
            ActivityType: promo.ActivityType,
            Discount:     discount,
        })
    }
    resp.PromotionDiscount = totalDiscount

    // Step 3: 计算费用（支持降级）
    fees, err := e.calculateFeesWithDegrade(ctx, req, basePrice.Price)
    if err != nil {
        log.Warnf("fee calculation degraded: %v", err)
        resp.Degraded = true
        resp.DegradeLevel = "fee"
    }

    totalFee := decimal.Zero
    for _, fee := range fees {
        totalFee = totalFee.Add(fee.Amount)
        resp.FeeDetails = append(resp.FeeDetails, FeeDetail{
            FeeType:     fee.FeeType,
            FeeName:     fee.FeeName,
            Amount:      fee.Amount,
            CanDiscount: fee.CanDiscount,
            DisplayType: fee.DisplayType,
        })
    }
    resp.TotalFee = totalFee

    // Step 4: 应用优惠券（支持降级）
    if len(req.VoucherCodes) > 0 {
        voucherResult, err := e.applyVouchersWithDegrade(ctx, req, resp)
        if err != nil {
            log.Warnf("voucher apply degraded: %v", err)
            resp.Degraded = true
            resp.DegradeLevel = "voucher"
        } else {
            resp.VoucherDiscount = voucherResult.TotalDiscount
            resp.VoucherDetails = voucherResult.Details
        }
    }

    // Step 5: 计算最终价格
    resp.FinalPrice = resp.Subtotal.
        Sub(resp.PromotionDiscount).
        Add(resp.TotalFee).
        Sub(resp.VoucherDiscount)

    // 确保价格不为负
    if resp.FinalPrice.LessThan(decimal.Zero) {
        resp.FinalPrice = decimal.Zero
    }

    // Step 6: 币种精度对齐（不同币种小数位不同）
    resp.FinalPrice = e.roundByCurrency(resp.FinalPrice, req.Currency)

    // Step 7: 生成价格公式（人类可读）
    resp.PriceFormula = e.buildPriceFormula(resp)

    // Step 8: 生成价格快照（异步写入，不阻塞主流程）
    go func() {
        snapshot, err := e.snapshotGenerator.Generate(context.Background(), req, resp)
        if err != nil {
            log.Errorf("generate snapshot failed: %v", err)
        } else {
            resp.SnapshotCode = snapshot.SnapshotCode
        }
    }()

    return resp, nil
}

// roundByCurrency 按币种精度四舍五入
func (e *PricingEngine) roundByCurrency(amount decimal.Decimal, currency string) decimal.Decimal {
    switch currency {
    case "VND", "IDR":
        // 越南盾、印尼盾无小数位，向上取整到最小货币单位
        return amount.Ceil()
    case "THB", "MYR", "SGD", "PHP":
        // 2位小数，Banker's Rounding（银行家舍入）
        return amount.Round(2)
    default:
        return amount.Round(2)
    }
}

// 多商品分摊时的精度处理（确保分摊总和 = 原始金额）
func spreadDiscount(totalDiscount decimal.Decimal, items []OrderItem) []decimal.Decimal {
    total := decimal.Zero
    for _, item := range items {
        total = total.Add(item.Subtotal)
    }

    results := make([]decimal.Decimal, len(items))
    allocated := decimal.Zero

    for i, item := range items {
        if i == len(items)-1 {
            // 最后一个商品承担所有剩余（消除分摊误差）
            results[i] = totalDiscount.Sub(allocated)
        } else {
            // 按比例分摊
            ratio := item.Subtotal.Div(total)
            results[i] = totalDiscount.Mul(ratio).Round(2)
            allocated = allocated.Add(results[i])
        }
    }
    return results
}

// PromotionMatcher 营销活动匹配器
type PromotionMatcher struct {
    promotionRepo repository.PromotionRepository
    userService   UserService   // 查询用户类型（新用户/VIP等）
    quotaService  QuotaService  // 配额管理（Redis 原子操作）
    cache         cache.Cache
}

// Match 匹配营销活动
func (m *PromotionMatcher) Match(ctx context.Context, req *PromotionMatchRequest) ([]*MatchedPromotion, error) {
    // 1. 获取所有生效的营销活动（优先从缓存）
    activities, err := m.loadActivePromotions(ctx, req.CategoryID)
    if err != nil {
        return nil, err
    }

    // 2. 按优先级排序（数字越大越优先）
    sort.Slice(activities, func(i, j int) bool {
        return activities[i].Priority > activities[j].Priority
    })

    var matched []*MatchedPromotion
    hasExclusive := false

    for _, activity := range activities {
        // 3. 检查生效条件
        if !m.checkConditions(ctx, activity, req) {
            continue
        }

        // 4. 互斥规则判断
        if activity.Exclusivity == 1 && len(matched) > 0 {
            continue // 当前活动互斥，且已有其他活动命中
        }
        if hasExclusive {
            continue // 已有互斥活动命中，跳过后续所有活动
        }

        // 5. 检查优惠券兼容性
        if req.HasVoucher && activity.VoucherCompatible == 0 {
            continue
        }

        // 6. 配额检查（Redis 原子操作）
        if activity.TotalQuota != nil {
            ok, err := m.quotaService.TryConsume(ctx, activity.ID, req.UserID)
            if err != nil || !ok {
                continue
            }
        }

        matched = append(matched, &MatchedPromotion{
            ActivityID:       activity.ID,
            ActivityName:     activity.ActivityName,
            ActivityType:     activity.ActivityType,
            DiscountType:     activity.DiscountType,
            DiscountValue:    activity.DiscountValue,
            MaxDiscountAmount: activity.MaxDiscountAmount,
        })

        // 7. 互斥活动命中后，停止遍历
        if activity.Exclusivity == 1 {
            hasExclusive = true
            break
        }
    }

    return matched, nil
}

// checkConditions 检查活动生效条件
func (m *PromotionMatcher) checkConditions(ctx context.Context, activity *model.PromotionActivity, req *PromotionMatchRequest) bool {
    now := time.Now()

    // 时间检查
    if now.Before(activity.StartTime) || now.After(activity.EndTime) {
        return false
    }

    // 类目检查
    if len(activity.CategoryIDs) > 0 && !contains(activity.CategoryIDs, req.CategoryID) {
        return false
    }

    // 商品/SKU 检查
    if len(activity.ItemIDs) > 0 && !contains(activity.ItemIDs, req.ItemID) {
        return false
    }
    if len(activity.SKUIDs) > 0 && !contains(activity.SKUIDs, req.SKUID) {
        return false
    }

    // 用户类型检查（调用 User Service）
    if activity.UserType != "all" {
        userType, _ := m.userService.GetUserType(ctx, req.UserID)
        if userType != activity.UserType {
            return false
        }
    }

    // 最低金额检查
    if activity.MinPurchaseAmount != nil {
        subtotal := req.BasePrice.Mul(decimal.NewFromInt(int64(req.Quantity)))
        if subtotal.LessThan(*activity.MinPurchaseAmount) {
            return false
        }
    }

    // 最低数量检查
    if activity.MinPurchaseQuantity != nil && req.Quantity < *activity.MinPurchaseQuantity {
        return false
    }

    return true
}

// FeeCalculator 费用计算器
type FeeCalculator struct {
    feeRepo repository.FeeRepository
    cache   cache.Cache
}

// Calculate 计算费用
func (c *FeeCalculator) Calculate(ctx context.Context, req *FeeCalcRequest) ([]*CalculatedFee, error) {
    // 1. 获取适用的费用配置（按 category → item → sku → entity 多维度匹配）
    feeConfigs, err := c.loadApplicableFees(ctx, req)
    if err != nil {
        return nil, err
    }

    // 2. 按优先级排序
    sort.Slice(feeConfigs, func(i, j int) bool {
        return feeConfigs[i].Priority > feeConfigs[j].Priority
    })

    var result []*CalculatedFee

    // 3. 逐项计算，同类型费用仅取最高优先级
    feeTypeSeen := make(map[string]bool)
    for _, config := range feeConfigs {
        if feeTypeSeen[config.FeeType] {
            continue // 同类型费用只取优先级最高的一条
        }
        feeTypeSeen[config.FeeType] = true

        amount, err := c.calculateFeeAmount(config, req)
        if err != nil {
            log.Errorf("calculate fee %s failed: %v", config.FeeCode, err)
            continue
        }

        result = append(result, &CalculatedFee{
            FeeType:     config.FeeType,
            FeeName:     config.FeeName,
            Amount:      amount,
            CanDiscount: config.CanBeDiscounted == 1,
            DisplayType: config.DisplayType,
        })
    }

    return result, nil
}

// calculateFeeAmount 计算费用金额
func (c *FeeCalculator) calculateFeeAmount(config *model.FeeConfig, req *FeeCalcRequest) (decimal.Decimal, error) {
    baseAmount := req.BasePrice.Mul(decimal.NewFromInt(int64(req.Quantity)))

    var amount decimal.Decimal

    switch config.CalculationType {
    case "fixed":
        val := config.CalculationConfig["amount"].(float64)
        amount = decimal.NewFromFloat(val).Mul(decimal.NewFromInt(int64(req.Quantity)))

    case "percentage":
        pct := config.CalculationConfig["percentage"].(float64)
        amount = baseAmount.Mul(decimal.NewFromFloat(pct / 100))

    case "tiered":
        tiers := config.CalculationConfig["tiers"].([]interface{})
        for _, tier := range tiers {
            t := tier.(map[string]interface{})
            threshold := decimal.NewFromFloat(t["threshold"].(float64))
            if baseAmount.GreaterThanOrEqual(threshold) {
                amount = decimal.NewFromFloat(t["fee"].(float64))
                break
            }
        }

    default:
        return decimal.Zero, fmt.Errorf("unsupported calculation type: %s", config.CalculationType)
    }

    // 应用最小/最大限制
    if config.MinFee != nil && amount.LessThan(*config.MinFee) {
        amount = *config.MinFee
    }
    if config.MaxFee != nil && amount.GreaterThan(*config.MaxFee) {
        amount = *config.MaxFee
    }

    return amount, nil
}

// buildPriceFormula 构建人类可读的价格公式
func (e *PricingEngine) buildPriceFormula(resp *PriceResponse) string {
    formula := fmt.Sprintf("%.2f", resp.Subtotal)

    if resp.PromotionDiscount.GreaterThan(decimal.Zero) {
        formula += fmt.Sprintf(" - %.2f (促销)", resp.PromotionDiscount)
        for _, p := range resp.PromotionDetails {
            formula += fmt.Sprintf(" [%s: -%.2f]", p.ActivityName, p.Discount)
        }
    }

    if resp.TotalFee.GreaterThan(decimal.Zero) {
        formula += fmt.Sprintf(" + %.2f (费用)", resp.TotalFee)
        for _, f := range resp.FeeDetails {
            formula += fmt.Sprintf(" [%s: +%.2f]", f.FeeName, f.Amount)
        }
    }

    if resp.VoucherDiscount.GreaterThan(decimal.Zero) {
        formula += fmt.Sprintf(" - %.2f (优惠券)", resp.VoucherDiscount)
    }

    formula += fmt.Sprintf(" = %.2f %s", resp.FinalPrice, resp.Currency)
    return formula
}

// 加入购物车 → 生成价格快照
func (s *CartService) AddToCart(ctx context.Context, req *AddToCartRequest) error {
    // 1. 实时计算价格
    priceResp, err := s.pricingEngine.Calculate(ctx, &PriceRequest{
        UserID: req.UserID, SKUID: req.SKUID, Quantity: req.Quantity,
        Scene: "cart",
    })
    if err != nil {
        return err
    }

    // 2. 生成价格快照（有效期30分钟）
    snapshot := &model.PriceSnapshot{
        SnapshotCode: generateSnapshotCode(),
        UserID:       req.UserID,
        SKUID:        req.SKUID,
        FinalPrice:   priceResp.FinalPrice,
        ExpiredAt:    time.Now().Add(30 * time.Minute),
    }
    if err := s.snapshotRepo.Create(ctx, snapshot); err != nil {
        return err
    }

    // 3. 购物车关联快照
    return s.cartRepo.Add(ctx, &model.CartItem{
        UserID: req.UserID, SKUID: req.SKUID,
        SnapshotCode: snapshot.SnapshotCode,
    })
}

// 下单 → 验证快照价格
func (s *OrderService) CreateOrder(ctx context.Context, req *CreateOrderRequest) (*model.Order, error) {
    // 1. 获取快照
    snapshot, err := s.snapshotRepo.GetByCode(ctx, req.SnapshotCode)
    if err != nil {
        return nil, err
    }

    // 2. 检查快照是否过期
    if snapshot.ExpiredAt.Before(time.Now()) {
        // 重新计算价格
        newPrice, _ := s.pricingEngine.Calculate(ctx, &PriceRequest{
            UserID: req.UserID, SKUID: req.SKUID, Scene: "checkout",
        })
        // 价格变动 → 要求用户重新确认
        if !newPrice.FinalPrice.Equal(snapshot.FinalPrice) {
            return nil, &PriceChangedError{
                OldPrice: snapshot.FinalPrice,
                NewPrice: newPrice.FinalPrice,
            }
        }
    }

    // 3. 使用快照价格创建订单
    order := &model.Order{
        FinalPrice:   snapshot.FinalPrice,
        SnapshotCode: snapshot.SnapshotCode,
    }
    return order, s.orderRepo.Create(ctx, order)
}

// calculateDiscountableAmount 计算优惠券可抵扣金额
func (a *VoucherApplier) calculateDiscountableAmount(req *VoucherApplyRequest) decimal.Decimal {
    // 基础金额 = 小计 - 促销折扣
    discountableAmount := req.Subtotal.Sub(req.PromotionDiscount)

    // 加上可被抵扣的费用
    for _, fee := range req.FeeDetails {
        if fee.CanDiscount {
            discountableAmount = discountableAmount.Add(fee.Amount)
        }
    }

    return discountableAmount
}

// 优惠券核销：Redis + MySQL 双写
func (a *VoucherApplier) consumeVoucher(ctx context.Context, userID int64, voucherCode string, orderID int64) error {
    lockKey := fmt.Sprintf("voucher:lock:%d:%s", userID, voucherCode)

    // 1. Redis 分布式锁（防止并发核销）
    acquired, err := a.redis.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
    if err != nil || !acquired {
        return errors.New("voucher is being used by another request")
    }
    defer a.redis.Del(ctx, lockKey)

    // 2. 检查优惠券状态
    userVoucher, err := a.userVoucherRepo.GetByUserAndCode(ctx, userID, voucherCode)
    if err != nil {
        return err
    }
    if userVoucher.Status != StatusUnused {
        return errors.New("voucher already used or expired")
    }

    // 3. 更新状态（乐观锁）
    affected, err := a.userVoucherRepo.UpdateStatus(ctx, userVoucher.ID, StatusUnused, StatusUsed, orderID)
    if err != nil {
        return err
    }
    if affected == 0 {
        return errors.New("voucher status changed, retry")
    }

    // 4. 更新优惠券使用数量
    a.voucherRepo.IncrUsedQuantity(ctx, userVoucher.VoucherID)

    return nil
}

// 订单取消/退款 → 回退优惠券和配额
func (s *RefundService) rollbackPriceComponents(ctx context.Context, order *model.Order) error {
    snapshot, err := s.snapshotRepo.GetByOrderID(ctx, order.ID)
    if err != nil {
        return err
    }

    // 1. 回退优惠券
    for _, v := range snapshot.VoucherDetails {
        if err := s.voucherApplier.RollbackVoucher(ctx, order.UserID, v.VoucherCode); err != nil {
            log.Errorf("rollback voucher %s failed: %v", v.VoucherCode, err)
            // 不中断，继续回退其他组件
        }
    }

    // 2. 回退营销活动配额
    for _, p := range snapshot.PromotionDetails {
        if err := s.quotaService.Rollback(ctx, p.ActivityID, order.UserID); err != nil {
            log.Errorf("rollback promotion %d quota failed: %v", p.ActivityID, err)
        }
    }

    // 3. 发送退款事件（Kafka）
    s.eventPublisher.Publish(ctx, &PriceRefundEvent{
        OrderID:    order.ID,
        SnapshotCode: snapshot.SnapshotCode,
        RefundAmount: snapshot.FinalPrice,
    })

    return nil
}

// DegradeConfig 降级配置
type DegradeConfig struct {
    PromotionTimeout   time.Duration `json:"promotion_timeout"`   // 促销匹配超时: 50ms
    FeeTimeout         time.Duration `json:"fee_timeout"`         // 费用计算超时: 30ms
    VoucherTimeout     time.Duration `json:"voucher_timeout"`     // 优惠券应用超时: 50ms
    PromotionDegrade   bool          `json:"promotion_degrade"`   // 促销服务强制降级开关
    VoucherDegrade     bool          `json:"voucher_degrade"`     // 优惠券服务强制降级开关
}

// matchPromotionsWithDegrade 带降级的促销匹配
func (e *PricingEngine) matchPromotionsWithDegrade(ctx context.Context, req *PriceRequest, basePrice decimal.Decimal) ([]*MatchedPromotion, error) {
    // 强制降级开关
    if e.degradeConfig.PromotionDegrade {
        return nil, nil
    }

    // 超时控制
    ctx, cancel := context.WithTimeout(ctx, e.degradeConfig.PromotionTimeout)
    defer cancel()

    promotions, err := e.promotionMatcher.Match(ctx, &PromotionMatchRequest{
        UserID: req.UserID, ItemID: req.ItemID, SKUID: req.SKUID,
        CategoryID: req.CategoryID, Quantity: req.Quantity, BasePrice: basePrice,
    })
    if err != nil {
        // 促销匹配失败 → 降级，不影响核心流程
        metrics.PromotionDegradeCounter.Inc()
        return nil, err
    }

    return promotions, nil
}

// 价格变更时主动失效缓存（通过 Kafka 消息驱动）
func (h *PriceCacheInvalidHandler) HandlePriceChange(ctx context.Context, event *PriceChangeEvent) error {
    keys := []string{
        fmt.Sprintf("price:base:%d", event.SKUID),
        fmt.Sprintf("price:calc:%d:*", event.SKUID), // 模式匹配删除
    }

    for _, key := range keys {
        if strings.Contains(key, "*") {
            // Scan + Delete 模式匹配
            h.redis.ScanAndDelete(ctx, key)
        } else {
            h.redis.Del(ctx, key)
        }
    }

    // 同时清除本地缓存
    h.localCache.Delete(fmt.Sprintf("price:base:%d", event.SKUID))

    return nil
}

// 幂等处理：避免重复消费导致配额多次扣减
func (h *PromotionChangeHandler) Handle(ctx context.Context, msg *kafka.Message) error {
    eventID := string(msg.Key)

    // Redis 幂等键（24小时过期）
    idempotentKey := fmt.Sprintf("pricing:event:idempotent:%s", eventID)
    set, err := h.redis.SetNX(ctx, idempotentKey, "1", 24*time.Hour).Result()
    if err != nil || !set {
        log.Infof("duplicate event %s, skip", eventID)
        return nil // 重复消息，跳过
    }

    // 处理消息
    event := &PriceChangeEvent{}
    if err := proto.Unmarshal(msg.Value, event); err != nil {
        return err
    }

    // 失效缓存
    return h.cacheInvalidator.Invalidate(ctx, event)
}

func (e *PricingEngine) parallelCalculate(ctx context.Context, req *PriceRequest) (
    *BasePriceResult, []*MatchedPromotion, []*CalculatedFee, error) {

    var (
        basePrice  *BasePriceResult
        promotions []*MatchedPromotion
        fees       []*CalculatedFee
        baseErr, promoErr, feeErr error
        wg sync.WaitGroup
    )

    wg.Add(3)

    go func() {
        defer wg.Done()
        basePrice, baseErr = e.basePriceCalculator.Calculate(ctx, req)
    }()

    go func() {
        defer wg.Done()
        promotions, promoErr = e.promotionMatcher.Match(ctx, &PromotionMatchRequest{...})
    }()

    go func() {
        defer wg.Done()
        fees, feeErr = e.feeCalculator.Calculate(ctx, &FeeCalcRequest{...})
    }()

    wg.Wait()

    // 基础价格是必须的，其他可降级
    if baseErr != nil {
        return nil, nil, nil, baseErr
    }

    return basePrice, promotions, fees, nil
}

// BatchCalculate 批量价格计算（列表页场景）
func (e *PricingEngine) BatchCalculate(ctx context.Context, reqs []*PriceRequest) ([]*PriceResponse, error) {
    // 1. 批量获取 SKU 基础价格（一次 DB 查询）
    skuIDs := extractSKUIDs(reqs)
    basePrices, err := e.basePriceCalculator.BatchGet(ctx, skuIDs)
    if err != nil {
        return nil, err
    }

    // 2. 批量获取品类活动（按 category 分组，减少缓存查询）
    categoryIDs := extractCategoryIDs(reqs)
    promotionsByCategory, err := e.promotionMatcher.BatchLoadActive(ctx, categoryIDs)
    if err != nil {
        log.Warnf("batch load promotions failed, degrade: %v", err)
    }

    // 3. 并行计算每个商品的价格
    results := make([]*PriceResponse, len(reqs))
    var wg sync.WaitGroup

    // 控制并发数
    sem := make(chan struct{}, 20)

    for i, req := range reqs {
        wg.Add(1)
        sem <- struct{}{}
        go func(idx int, r *PriceRequest) {
            defer wg.Done()
            defer func() { <-sem }()
            results[idx], _ = e.calculateSingle(ctx, r, basePrices, promotionsByCategory)
        }(i, req)
    }

    wg.Wait()
    return results, nil
}

// ReconstructPriceCalculation 根据订单还原价格计算（客服工具）
func (s *AuditService) ReconstructPriceCalculation(ctx context.Context, orderID int64) (*PriceAuditResult, error) {
    // 1. 获取价格快照
    snapshot, err := s.snapshotRepo.GetByOrderID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    // 2. 解析计算明细
    promotionDetails := parseJSON[[]PromotionDetail](snapshot.PromotionDetails)
    feeDetails := parseJSON[[]FeeDetail](snapshot.FeeDetails)
    voucherDetails := parseJSON[[]VoucherDetail](snapshot.VoucherDetails)

    // 3. 验证计算正确性
    calculatedFinalPrice := snapshot.Subtotal.
        Sub(snapshot.PromotionDiscount).
        Add(snapshot.TotalFee).
        Sub(snapshot.VoucherDiscount)

    isValid := calculatedFinalPrice.Equal(snapshot.FinalPrice)
    if !isValid {
        log.Errorf("price snapshot %s inconsistency: calculated=%s, recorded=%s",
            snapshot.SnapshotCode, calculatedFinalPrice, snapshot.FinalPrice)
    }

    // 4. 返回审计结果
    return &PriceAuditResult{
        SnapshotCode:     snapshot.SnapshotCode,
        BasePrice:        snapshot.BasePrice,
        Subtotal:         snapshot.Subtotal,
        PromotionDetails: promotionDetails,
        FeeDetails:       feeDetails,
        VoucherDetails:   voucherDetails,
        FinalPrice:       snapshot.FinalPrice,
        PriceFormula:     snapshot.PriceFormula,
        CalculationTime:  snapshot.CreatedAt,
        IsValid:          isValid,
    }, nil
}