PricingRequest {
    Scene:      "PDP",
    Items:      [{ItemID: 123, ModelID: 456, Quantity: 1}],
    UserID:     789,
    Region:     "ID",
    IsNewUser:  true,
    Platform:   "App",
}

PricingRequest {
    Scene:      "AddToCart",
    Items:      [
        {ItemID: 123, Quantity: 1},  // 当前加购商品
    ],
    CartItems:  [
        {ItemID: 456, Quantity: 2},  // 购物车已有商品
    ],
    UserID:     789,
}

PricingRequest {
    Scene:      "Cart",
    Items:      [
        {ItemID: 123, ModelID: 456, Quantity: 2},
        {ItemID: 789, ModelID: 101, Quantity: 1},
        {ItemID: 234, ModelID: 567, Quantity: 3},
    ],
    UserID:     12345,
    Region:     "SG",
}

// SupplierPriceRequest 供应商价格查询请求
type SupplierPriceRequest struct {
    CategoryID      int64       `json:"category_id"`      // 品类ID
    SupplierID      int64       `json:"supplier_id"`      // 供应商ID
    Items           []ItemInfo  `json:"items"`            // 商品信息
    
    // 品类特定参数
    CheckInDate     string      `json:"check_in_date"`    // Hotel: 入住日期
    CheckOutDate    string      `json:"check_out_date"`   // Hotel: 退房日期
    RoomCount       int32       `json:"room_count"`       // Hotel: 房间数
    
    FlightDate      string      `json:"flight_date"`      // Flight: 航班日期
    Passengers      int32       `json:"passengers"`       // Flight: 乘客数
    
    TourDate        string      `json:"tour_date"`        // Tour: 出游日期
    TravelerCount   int32       `json:"traveler_count"`   // Tour: 游客数
}

// SupplierPriceResponse 供应商价格响应
type SupplierPriceResponse struct {
    Items           []SupplierItemPrice `json:"items"`
    Available       bool                `json:"available"`     // 是否可订
    BookingToken    string              `json:"booking_token"` // 预订令牌（5-15分钟有效）
    ExpireAt        int64               `json:"expire_at"`     // 令牌过期时间
    SupplierOrderID string              `json:"supplier_order_id"` // 供应商订单号
}

// SupplierItemPrice 供应商商品价格
type SupplierItemPrice struct {
    ItemID          int64   `json:"item_id"`
    SupplierPrice   int64   `json:"supplier_price"`   // 供应商报价
    SupplierCost    int64   `json:"supplier_cost"`    // 供应商成本
    Available       bool    `json:"available"`        // 是否可订
    Stock           int32   `json:"stock"`            // 剩余库存
    
    // 供应商特定信息
    SupplierSKU     string  `json:"supplier_sku"`
    SupplierRemark  string  `json:"supplier_remark"`  // 供应商备注（如取消政策）
}

func GetCartPrice(req *GetCartPriceRequest) (*CartPriceResponse, error) {
    var (
        selfOperatedItems []ItemInfo // 自营商品
        supplierItems     []ItemInfo // 供应商商品
    )
    
    // 1. 区分自营和供应商品类
    for _, item := range req.Items {
        if isSupplierCategory(item.CategoryID) {
            supplierItems = append(supplierItems, item)
        } else {
            selfOperatedItems = append(selfOperatedItems, item)
        }
    }
    
    var (
        wg              sync.WaitGroup
        selfPrice       *PricingResponse
        supplierPrices  map[int64]*SupplierItemPrice
        errs            []error
    )
    
    // 2. 并发查询价格
    if len(selfOperatedItems) > 0 {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 自营品类：使用本地计算
            selfPrice, _ = pricingEngine.Calculate(&PricingRequest{
                Scene: "Cart",
                Items: selfOperatedItems,
            })
        }()
    }
    
    if len(supplierItems) > 0 {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 供应商品类：查询供应商价格
            supplierPrices, _ = supplierPriceService.BatchQuery(ctx, supplierItems)
        }()
    }
    
    wg.Wait()
    
    // 3. 合并价格结果
    return mergeCartPrice(selfPrice, supplierPrices), nil
}

PricingRequest {
    Scene:      "CreateOrder",
    Items:      [...],          // 商品列表
    UserID:     12345,
    Region:     "SG",
    
    // 地址相关
    ShippingAddress: {...},     // 收货地址
    ShippingMethod:  "standard", // 配送方式
    
    // 增值服务（可选）
    Services: [
        {ServiceID: 1, Type: "screen_insurance", Price: 50, Selected: true},
    ],
    
    // 供应商品类特有参数
    SupplierBookings: [
        {
            ItemID:       101,
            SupplierID:   1001,
            BookingToken: "TKN-AGODA-20260227-001",  // 供应商预订令牌
            SupplierPrice: 1200,                      // 供应商报价
            CheckInDate:  "2026-03-01",
            CheckOutDate: "2026-03-05",
        },
    ],
    
    // 订单上下文
    OrderID:     "ORD202602270001",
    CartSnapshot: {...},        // 购物车价格快照（可选）
}

func CreateOrder(req *CreateOrderRequest) (*Order, error) {
    // 步骤0: 区分自营和供应商品类
    selfOperatedItems, supplierItems := classifyItems(req.Items)
    
    // 步骤1: 供应商品类价格查询（如果有）
    var supplierBookings map[int64]*SupplierBooking
    if len(supplierItems) > 0 {
        // 1.1 并发查询供应商价格并预订
        supplierBookings, err := queryAndBookSupplierItems(ctx, supplierItems)
        if err != nil {
            return nil, fmt.Errorf("supplier booking failed: %w", err)
        }
        
        // 1.2 验证所有供应商商品可用
        for itemID, booking := range supplierBookings {
            if !booking.Available {
                return nil, fmt.Errorf("item %d not available from supplier", itemID)
            }
        }
    }
    
    // 步骤2: 计算订单价格
    // Layer 1: 基础价格（自营品类用本地价格，供应商品类用供应商报价）
    // Layer 2: 营销活动（限时抢购、新人价等）
    // Layer 4: 附加费用（增值服务费、运费、平台服务费等）
    // 跳过 Layer 3: 优惠券和积分抵扣（留到Checkout）
    // 跳过支付手续费（留到Checkout根据支付渠道计算）
    pricingReq := &PricingRequest{
        Scene:            "CreateOrder",
        Items:            req.Items,
        UserID:           req.UserID,
        Services:         req.Services,
        SupplierBookings: supplierBookings, // 传入供应商预订信息
        // 不传 VoucherCode 和 CoinAmount
    }
    
    priceResult := pricingEngine.Calculate(pricingReq)
    
    // 步骤3: 预扣库存
    // 自营品类：锁定本地库存
    if len(selfOperatedItems) > 0 {
        if err := inventoryService.Reserve(req.OrderID, selfOperatedItems, 30*time.Minute); err != nil {
            // 回滚供应商预订
            rollbackSupplierBookings(supplierBookings)
            return nil, fmt.Errorf("reserve inventory failed: %w", err)
        }
    }
    
    // 供应商品类：BookingToken已在步骤1获取，此处记录即可
    
    // 步骤4: 创建订单
    order := &Order{
        OrderID:          req.OrderID,
        UserID:           req.UserID,
        Items:            req.Items,
        OrderPrice:       priceResult.FinalPrice,  // 订单价格（含基础+营销+附加费）
        SupplierBookings: supplierBookings,        // 供应商预订信息
        Status:           "pending_payment",
        CreatedAt:        time.Now(),
        ExpireAt:         time.Now().Add(30 * time.Minute),
    }
    
    // 步骤5: 保存订单快照（包含供应商预订信息）
    snapshot := saveOrderSnapshot(order.OrderID, priceResult, supplierBookings)
    
    // 步骤6: 保存订单
    if err := orderRepo.Create(order); err != nil {
        inventoryService.Release(req.OrderID)
        rollbackSupplierBookings(supplierBookings)
        return nil, err
    }
    
    return order, nil
}

// queryAndBookSupplierItems 查询供应商价格并预订
func queryAndBookSupplierItems(ctx context.Context, items []ItemInfo) (map[int64]*SupplierBooking, error) {
    var (
        wg       sync.WaitGroup
        mu       sync.Mutex
        bookings = make(map[int64]*SupplierBooking)
        errs     []error
    )
    
    for _, item := range items {
        wg.Add(1)
        go func(itm ItemInfo) {
            defer wg.Done()
            
            // 查询供应商价格和预订
            booking, err := supplierPriceService.QueryAndBook(ctx, &SupplierPriceRequest{
                ItemID:       itm.ItemID,
                SupplierID:   itm.SupplierID,
                CheckInDate:  itm.CheckInDate,
                CheckOutDate: itm.CheckOutDate,
                Quantity:     itm.Quantity,
            })
            
            mu.Lock()
            if err != nil {
                errs = append(errs, err)
            } else {
                bookings[itm.ItemID] = booking
            }
            mu.Unlock()
        }(item)
    }
    
    wg.Wait()
    
    if len(errs) > 0 {
        return nil, errs[0]
    }
    
    return bookings, nil
}

PricingRequest {
    Scene:      "Checkout",
    OrderID:    "ORD202602270001",  // 已创建的订单ID
    UserID:     12345,
    
    // 订单快照
    OrderSnapshot: {...},           // CreateOrder 生成的订单快照
    
    // 用户在收银台选择
    VoucherCode: "SAVE100",         // 优惠券
    UseCoin:     true,              // 使用积分
    CoinAmount:  500,               // 积分数量
    ChannelID:   1,                 // 支付渠道 (电子钱包)
}

func GetCheckoutPrice(req *CheckoutPriceRequest) (*CheckoutPriceResponse, error) {
    // 1. 获取订单快照（验证订单有效性）
    orderSnapshot := getOrderSnapshot(req.OrderID)
    if orderSnapshot == nil {
        return nil, fmt.Errorf("order not found or expired")
    }
    
    // 2. 验证订单状态
    order := orderRepo.GetByID(req.OrderID)
    if order.Status != "pending_payment" {
        return nil, fmt.Errorf("order status invalid: %s", order.Status)
    }
    
    // 3. 完整计算价格（Layer 1-5，包含券/积分/手续费）
    pricingReq := &PricingRequest{
        Scene:        "Checkout",
        OrderID:      req.OrderID,
        Items:        order.Items,
        UserID:       req.UserID,
        VoucherCode:  req.VoucherCode,
        UseCoin:      req.UseCoin,
        CoinAmount:   req.CoinAmount,
        ChannelID:    req.ChannelID,
        BasePrice:    orderSnapshot.OrderPrice, // 使用订单价格（基础+营销+附加费）
    }
    
    priceResult := pricingEngine.Calculate(pricingReq)
    
    // 4. 预核销优惠券（软锁定）
    if req.VoucherCode != "" {
        if err := voucherService.SoftReserve(req.OrderID, req.VoucherCode); err != nil {
            return nil, fmt.Errorf("voucher reserve failed: %w", err)
        }
    }
    
    // 5. 预扣积分（软锁定）
    if req.UseCoin {
        if err := coinService.SoftReserve(req.OrderID, req.UserID, req.CoinAmount); err != nil {
            return nil, fmt.Errorf("coin reserve failed: %w", err)
        }
    }
    
    // 6. 生成支付快照（15分钟有效）
    paymentSnapshot := createPaymentSnapshot(&PaymentSnapshot{
        SnapshotID:   generateSnapshotID(),
        OrderID:      req.OrderID,
        UserID:       req.UserID,
        VoucherCode:  req.VoucherCode,
        CoinAmount:   req.CoinAmount,
        ChannelID:    req.ChannelID,
        PriceResult:  priceResult,
        CreatedAt:    time.Now(),
        ExpireAt:     time.Now().Add(15 * time.Minute),
    })
    
    // 7. 构建响应
    return &CheckoutPriceResponse{
        OrderID:          req.OrderID,
        SnapshotID:       paymentSnapshot.SnapshotID,
        TotalAmount:      priceResult.TotalAmount,
        PromotionDiscount: priceResult.PromotionDiscount,
        VoucherDiscount:  priceResult.VoucherDiscount,
        CoinDeduction:    priceResult.CoinDeduction,
        HandlingFee:      priceResult.HandlingFee,
        AdditionalCharge: priceResult.AdditionalCharge,
        FinalPrice:       priceResult.FinalPrice,
        Breakdown:        priceResult.Breakdown,
        SnapshotExpireAt: paymentSnapshot.ExpireAt.Unix(),
    }, nil
}

PricingRequest {
    Scene:           "Payment",
    OrderID:         "ORD202602270001",
    PaymentSnapshotID: "PAY-20260227-001",  // Checkout生成的支付快照
    PaymentAmount:   19051,                 // 用户支付金额
}

func ProcessPayment(req *PaymentRequest) (*PaymentResponse, error) {
    // 1. 获取支付快照
    paymentSnapshot := getPaymentSnapshot(req.PaymentSnapshotID)
    if paymentSnapshot == nil {
        return nil, fmt.Errorf("payment snapshot not found or expired")
    }
    
    // 2. 验证订单ID
    if paymentSnapshot.OrderID != req.OrderID {
        return nil, fmt.Errorf("order mismatch")
    }
    
    // 3. 验证支付金额
    if req.PaymentAmount != paymentSnapshot.PriceResult.FinalPrice {
        return nil, fmt.Errorf("payment amount mismatch: expected %d, got %d",
            paymentSnapshot.PriceResult.FinalPrice, req.PaymentAmount)
    }
    
    // 4. 验证订单状态
    order := orderRepo.GetByID(req.OrderID)
    if order.Status != "pending_payment" {
        return nil, fmt.Errorf("order status invalid: %s", order.Status)
    }
    
    // 5. 正式锁定资源（库存已在CreateOrder锁定）
    // 正式核销优惠券
    if paymentSnapshot.VoucherCode != "" {
        if err := voucherService.Reserve(req.OrderID, paymentSnapshot.VoucherCode); err != nil {
            return nil, fmt.Errorf("voucher reserve failed: %w", err)
        }
    }
    
    // 正式扣减积分
    if paymentSnapshot.CoinAmount > 0 {
        if err := coinService.Reserve(req.OrderID, paymentSnapshot.UserID, paymentSnapshot.CoinAmount); err != nil {
            voucherService.Release(req.OrderID)
            return nil, fmt.Errorf("coin reserve failed: %w", err)
        }
    }
    
    // 6. 更新订单状态为 paying（支付中）
    order.Status = "paying"
    order.PaymentSnapshotID = req.PaymentSnapshotID
    orderRepo.Update(order)
    
    // 7. 返回支付信息（用于调起第三方支付）
    return &PaymentResponse{
        OrderID:       req.OrderID,
        PaymentAmount: paymentSnapshot.PriceResult.FinalPrice,
        ChannelID:     paymentSnapshot.ChannelID,
        PaymentURL:    generatePaymentURL(req.OrderID, paymentSnapshot),
    }, nil
}

func HandlePaymentCallback(req *PaymentCallbackRequest) error {
    // 1. 验证回调签名
    if !validatePaymentSignature(req) {
        return fmt.Errorf("invalid signature")
    }
    
    // 2. 获取订单
    order := orderRepo.GetByID(req.OrderID)
    if order == nil {
        return fmt.Errorf("order not found")
    }
    
    // 3. 验证订单状态（防止重复回调）
    if order.Status == "paid" {
        return nil // 已处理，直接返回成功
    }
    
    if order.Status != "paying" {
        return fmt.Errorf("invalid order status: %s", order.Status)
    }
    
    // 4. 获取支付快照（验证支付金额）
    paymentSnapshot := getPaymentSnapshot(order.PaymentSnapshotID)
    if paymentSnapshot == nil {
        return fmt.Errorf("payment snapshot not found")
    }
    
    if req.PaymentAmount != paymentSnapshot.PriceResult.FinalPrice {
        return fmt.Errorf("payment amount mismatch")
    }
    
    // 5. 扣减库存（从预扣变为实扣）
    if err := inventoryService.Confirm(order.OrderID); err != nil {
        return fmt.Errorf("confirm inventory failed: %w", err)
    }
    
    // 6. 确认优惠券核销（从预扣变为实扣）
    if paymentSnapshot.VoucherCode != "" {
        if err := voucherService.Confirm(order.OrderID); err != nil {
            return fmt.Errorf("confirm voucher failed: %w", err)
        }
    }
    
    // 7. 确认积分扣减（从预扣变为实扣）
    if paymentSnapshot.CoinAmount > 0 {
        if err := coinService.Confirm(order.OrderID); err != nil {
            return fmt.Errorf("confirm coin failed: %w", err)
        }
    }
    
    // 8. 标记支付快照已使用
    markSnapshotUsed(order.PaymentSnapshotID)
    
    // 9. 更新订单状态
    order.Status = "paid"
    order.PaymentID = req.PaymentID
    order.PaymentTime = time.Now()
    order.ActualAmount = req.PaymentAmount
    orderRepo.Update(order)
    
    // 10. 发送订单完成事件
    publishOrderPaidEvent(order)
    
    return nil
}

PricingRequest {
    Scene:      "FlashSale",
    Items:      [{ItemID: 123, Quantity: 1}],
    PromotionID: 456,  // 活动ID
    UserID:     789,
}

PricingRequest {
    Scene:      "BatchQuery",
    Items:      [
        {ItemID: 123, Quantity: 1},
        {ItemID: 456, Quantity: 1},
        {ItemID: 789, Quantity: 1},
        // ... 最多100个
    ],
    UserID:     12345,
}

package api

// PricingAPI 价格计算API接口
type PricingAPI interface {
    // GetItemPrice PDP页面商品价格（场景1）
    GetItemPrice(ctx context.Context, req *GetItemPriceRequest) (*ItemPriceResponse, error)
    
    // GetCartPrice 购物车价格计算（场景2-3）
    GetCartPrice(ctx context.Context, req *GetCartPriceRequest) (*CartPriceResponse, error)
    
    // CalculateOrderPrice 订单创建价格计算（场景4 - 先创建订单）
    CalculateOrderPrice(ctx context.Context, req *OrderPriceRequest) (*OrderPriceResponse, error)
    
    // GetCheckoutPrice 收银台价格计算（场景5 - 后进入收银台）
    GetCheckoutPrice(ctx context.Context, req *CheckoutPriceRequest) (*CheckoutPriceResponse, error)
    
    // GetPaymentPrice 支付价格验证（场景6）
    GetPaymentPrice(ctx context.Context, req *PaymentPriceRequest) (*PaymentPriceResponse, error)
    
    // BatchGetPrice 批量查询价格（场景7）
    BatchGetPrice(ctx context.Context, req *BatchPriceRequest) (*BatchPriceResponse, error)
    
    // PreviewVoucherPrice 优惠券预览
    PreviewVoucherPrice(ctx context.Context, req *VoucherPreviewRequest) ([]*VoucherPriceOption, error)
}

// GetItemPriceRequest PDP商品价格请求
type GetItemPriceRequest struct {
    ItemID      int64  `json:"item_id" binding:"required"`
    ModelID     int64  `json:"model_id"`
    UserID      int64  `json:"user_id"`
    Region      string `json:"region" binding:"required"`
    Platform    string `json:"platform"`
}

// ItemPriceResponse PDP价格响应（轻量级）
type ItemPriceResponse struct {
    ItemID           int64   `json:"item_id"`
    
    // 基础价格
    MarketPrice      int64   `json:"market_price"`      // 市场价
    DiscountPrice    int64   `json:"discount_price"`    // 折扣价
    
    // 活动价格（可选）
    FlashSalePrice   *int64  `json:"flash_sale_price"`  // 限时抢购价
    NewUserPrice     *int64  `json:"new_user_price"`    // 新人价
    
    // 营销标签
    PromotionTags    []string `json:"promotion_tags"`   // ["flash_sale", "new_user"]
    
    // 优惠预估
    EstimatedPrice   int64   `json:"estimated_price"`   // 预估到手价（使用最优优惠券）
    AvailableVouchers int32  `json:"available_vouchers"` // 可用优惠券数量
    
    // 元数据
    CacheHit         bool    `json:"-"`                 // 是否缓存命中
    CalculatedAt     int64   `json:"calculated_at"`     // 计算时间戳
}

// CheckoutPriceRequest 订单确认页价格请求
type CheckoutPriceRequest struct {
    Items           []CartItem `json:"items" binding:"required"`
    UserID          int64      `json:"user_id" binding:"required"`
    Region          string     `json:"region" binding:"required"`
    
    // 用户选择
    VoucherCode     string     `json:"voucher_code"`
    UseCoin         bool       `json:"use_coin"`
    CoinAmount      int64      `json:"coin_amount"`
    ChannelID       int64      `json:"channel_id"`
    
    // 增值服务
    Services        []ServiceSelection `json:"services"`
    
    // 配送信息
    ShippingAddress *Address   `json:"shipping_address"`
}

// CheckoutPriceResponse 订单确认页价格响应（完整）
type CheckoutPriceResponse struct {
    // 价格快照ID
    SnapshotID       string  `json:"snapshot_id"`       // 快照ID（15分钟有效）
    
    // 商品价格明细
    Items            []ItemPricing `json:"items"`
    
    // 价格汇总
    TotalAmount      int64   `json:"total_amount"`      // 商品总额
    PromotionDiscount int64  `json:"promotion_discount"` // 活动优惠
    VoucherDiscount  int64   `json:"voucher_discount"`  // 优惠券抵扣
    CoinDeduction    int64   `json:"coin_deduction"`    // 积分抵扣
    HandlingFee      int64   `json:"handling_fee"`      // 手续费
    AdditionalCharge int64   `json:"additional_charge"` // 附加费用
    FinalPrice       int64   `json:"final_price"`       // 最终价格
    
    // 价格拆解
    Breakdown        PriceBreakdown `json:"breakdown"` // 计算明细
    
    // 锁定信息
    LockedUntil      int64   `json:"locked_until"`      // 价格锁定到期时间
    SnapshotVersion  string  `json:"snapshot_version"`  // 快照版本号
    
    CalculatedAt     int64   `json:"calculated_at"`
}

// OrderPriceRequest 订单创建价格请求
type OrderPriceRequest struct {
    OrderID          string  `json:"order_id" binding:"required"`
    SnapshotID       string  `json:"snapshot_id"`       // Checkout的快照ID
    
    Items            []CartItem `json:"items" binding:"required"`
    UserID           int64   `json:"user_id" binding:"required"`
    VoucherCode      string  `json:"voucher_code"`
    UseCoin          bool    `json:"use_coin"`
    CoinAmount       int64   `json:"coin_amount"`
    ChannelID        int64   `json:"channel_id"`
    Services         []ServiceSelection `json:"services"`
}

// OrderPriceResponse 订单价格响应
type OrderPriceResponse struct {
    OrderID          string  `json:"order_id"`
    
    // 价格验证结果
    PriceValid       bool    `json:"price_valid"`       // 价格是否一致
    PriceChanged     bool    `json:"price_changed"`     // 价格是否变化
    OldPrice         int64   `json:"old_price"`         // 快照价格
    NewPrice         int64   `json:"new_price"`         // 重新计算价格
    PriceDiff        int64   `json:"price_diff"`        // 价格差异
    
    // 如果价格一致，返回完整价格信息
    FinalPrice       int64   `json:"final_price"`
    Breakdown        PriceBreakdown `json:"breakdown"`
    
    // 新快照ID（用于支付）
    PaymentSnapshotID string `json:"payment_snapshot_id"` // 支付快照ID
    SnapshotExpireAt  int64  `json:"snapshot_expire_at"`  // 快照过期时间
    
    CalculatedAt      int64  `json:"calculated_at"`
}

package handler

// PDPHandler PDP场景处理器（高性能）
type PDPHandler struct {
    engine        PricingEngine
    cache         CacheManager
    itemService   ItemService
    promoService  PromotionService
}

func (h *PDPHandler) Handle(ctx context.Context, req *GetItemPriceRequest) (*ItemPriceResponse, error) {
    // 1. 构建缓存Key
    cacheKey := h.buildCacheKey(req)
    
    // 2. 查询缓存（PDP场景缓存命中率要求 > 90%）
    if cached := h.cache.Get(cacheKey); cached != nil {
        return cached.(*ItemPriceResponse), nil
    }
    
    // 3. 计算价格（仅执行 Layer 1-2，不计算抵扣和费用）
    pricingReq := &PricingRequest{
        Scene:      ScenePDP,
        Items:      []ItemInfo{{ItemID: req.ItemID, ModelID: req.ModelID, Quantity: 1}},
        UserID:     req.UserID,
        Region:     req.Region,
        Platform:   req.Platform,
        
        // PDP场景不需要计算抵扣和费用
        SkipLayers: []string{"deduction", "charge"},
    }
    
    result := h.engine.Calculate(ctx, pricingReq)
    
    // 4. 构建响应（轻量级）
    resp := &ItemPriceResponse{
        ItemID:         req.ItemID,
        MarketPrice:    result.Items[0].MarketPrice,
        DiscountPrice:  result.Items[0].DiscountPrice,
        FlashSalePrice: result.Items[0].FlashSalePrice,
        NewUserPrice:   result.Items[0].NewUserPrice,
        PromotionTags:  result.PromotionTags,
        CalculatedAt:   time.Now().Unix(),
    }
    
    // 5. 预估可用优惠券（异步，不阻塞）
    go h.estimateVouchers(ctx, req, resp)
    
    // 6. 写入缓存（5分钟）
    h.cache.Set(cacheKey, resp, 5*time.Minute)
    
    return resp, nil
}

// CheckoutHandler Checkout场景处理器（完整计算+快照）
type CheckoutHandler struct {
    engine          PricingEngine
    snapshotManager *SnapshotManager
    inventoryService InventoryService
}

func (h *CheckoutHandler) Handle(ctx context.Context, req *CheckoutPriceRequest) (*CheckoutPriceResponse, error) {
    // 1. 预检库存（避免无库存商品计算价格）
    if err := h.inventoryService.CheckAvailability(ctx, req.Items); err != nil {
        return nil, fmt.Errorf("inventory check failed: %w", err)
    }
    
    // 2. 完整计算价格（执行所有 Layer）
    pricingReq := &PricingRequest{
        Scene:       SceneCheckout,
        Items:       req.Items,
        UserID:      req.UserID,
        Region:      req.Region,
        VoucherCode: req.VoucherCode,
        UseCoin:     req.UseCoin,
        CoinAmount:  req.CoinAmount,
        ChannelID:   req.ChannelID,
        Services:    req.Services,
        
        // Checkout场景执行完整计算
        SkipLayers: []string{},
    }
    
    result := h.engine.Calculate(ctx, pricingReq)
    
    // 3. 生成价格快照（15分钟有效）
    snapshot := h.snapshotManager.CreateSnapshot(&PriceSnapshot{
        SnapshotID:   generateSnapshotID(),
        Scene:        SceneCheckout,
        UserID:       req.UserID,
        Items:        req.Items,
        PriceResult:  result,
        CreatedAt:    time.Now(),
        ExpireAt:     time.Now().Add(15 * time.Minute),
    })
    
    // 4. 构建响应
    resp := &CheckoutPriceResponse{
        SnapshotID:       snapshot.SnapshotID,
        Items:            result.Items,
        TotalAmount:      result.TotalAmount,
        PromotionDiscount: result.PromotionDiscount,
        VoucherDiscount:  result.VoucherDiscount,
        CoinDeduction:    result.CoinDeduction,
        HandlingFee:      result.HandlingFee,
        AdditionalCharge: result.AdditionalCharge,
        FinalPrice:       result.FinalPrice,
        Breakdown:        result.Breakdown,
        LockedUntil:      snapshot.ExpireAt.Unix(),
        SnapshotVersion:  snapshot.Version,
        CalculatedAt:     time.Now().Unix(),
    }
    
    return resp, nil
}

// OrderHandler 订单创建场景处理器（价格验证+锁定）
type OrderHandler struct {
    engine          PricingEngine
    snapshotManager *SnapshotManager
    inventoryService InventoryService
    voucherService  VoucherService
    coinService     CoinService
}

func (h *OrderHandler) Handle(ctx context.Context, req *OrderPriceRequest) (*OrderPriceResponse, error) {
    // 1. 获取 Checkout 快照
    checkoutSnapshot := h.snapshotManager.GetSnapshot(req.SnapshotID)
    if checkoutSnapshot == nil {
        return nil, fmt.Errorf("checkout snapshot expired or not found")
    }
    
    // 2. 重新计算价格（二次验证）
    pricingReq := &PricingRequest{
        Scene:       SceneCreateOrder,
        Items:       req.Items,
        UserID:      req.UserID,
        VoucherCode: req.VoucherCode,
        UseCoin:     req.UseCoin,
        CoinAmount:  req.CoinAmount,
        ChannelID:   req.ChannelID,
        Services:    req.Services,
    }
    
    newResult := h.engine.Calculate(ctx, pricingReq)
    
    // 3. 价格比对
    priceChanged := false
    priceDiff := int64(0)
    oldPrice := checkoutSnapshot.PriceResult.FinalPrice
    newPrice := newResult.FinalPrice
    
    if oldPrice != newPrice {
        priceChanged = true
        priceDiff = newPrice - oldPrice
        
        // 价格变化超过5元，拒绝创建订单
        if abs(priceDiff) > 500 {
            return &OrderPriceResponse{
                PriceValid:   false,
                PriceChanged: true,
                OldPrice:     oldPrice,
                NewPrice:     newPrice,
                PriceDiff:    priceDiff,
            }, nil
        }
    }
    
    // 4. 库存锁定
    if err := h.inventoryService.Reserve(ctx, req.OrderID, req.Items, 30*time.Minute); err != nil {
        return nil, fmt.Errorf("reserve inventory failed: %w", err)
    }
    
    // 5. 优惠券预核销
    if req.VoucherCode != "" {
        if err := h.voucherService.Reserve(ctx, req.OrderID, req.VoucherCode); err != nil {
            h.inventoryService.Release(ctx, req.OrderID)
            return nil, fmt.Errorf("reserve voucher failed: %w", err)
        }
    }
    
    // 6. 积分预扣
    if req.UseCoin {
        if err := h.coinService.Reserve(ctx, req.OrderID, req.UserID, req.CoinAmount); err != nil {
            h.voucherService.Release(ctx, req.OrderID)
            h.inventoryService.Release(ctx, req.OrderID)
            return nil, fmt.Errorf("reserve coin failed: %w", err)
        }
    }
    
    // 7. 生成支付快照（30分钟有效）
    paymentSnapshot := h.snapshotManager.CreateSnapshot(&PriceSnapshot{
        SnapshotID:   generateSnapshotID(),
        Scene:        ScenePayment,
        OrderID:      req.OrderID,
        UserID:       req.UserID,
        Items:        req.Items,
        PriceResult:  newResult,
        CreatedAt:    time.Now(),
        ExpireAt:     time.Now().Add(30 * time.Minute),
        Version:      "v1",
    })
    
    // 8. 构建响应
    resp := &OrderPriceResponse{
        OrderID:            req.OrderID,
        PriceValid:         true,
        PriceChanged:       priceChanged,
        OldPrice:           oldPrice,
        NewPrice:           newPrice,
        PriceDiff:          priceDiff,
        FinalPrice:         newResult.FinalPrice,
        Breakdown:          newResult.Breakdown,
        PaymentSnapshotID:  paymentSnapshot.SnapshotID,
        SnapshotExpireAt:   paymentSnapshot.ExpireAt.Unix(),
        CalculatedAt:       time.Now().Unix(),
    }
    
    return resp, nil
}