JDWA Green-U 奖品兑换模块

@Data
@TableName("jdwa_prize")
public class JDWAPrize {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String prizeCode;
    private String prizeName;
    private String prizeType;
    private String prizeLevel;
    private Long categoryId;
    private Integer pointsPrice;
    private BigDecimal marketPrice;
    private BigDecimal cashPrice;
    private String thumbnail;
    private String images;
    private String description;
    private String specification;
    private Integer exchangeLimit;
    private LocalDateTime exchangeStart;
    private LocalDateTime exchangeEnd;
    private BigDecimal weight;
    private BigDecimal deliveryFee;
    private String supplier;
    private String supplierContact;
    private Integer status;
    private Integer isHot;
    private Integer isNew;
    private Integer isRecommend;
    private Integer sortOrder;
    private Integer viewCount;
    private Integer exchangeCount;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    
    @TableField(exist = false)
    private JDWAPrizeCategory category;
    
    @TableField(exist = false)
    private JDWAPrizeStock stock;
    
    @TableField(exist = false)
    private List<JDWAPrizeRule> rules;
}

@Data
@TableName("jdwa_prize_category")
public class JDWAPrizeCategory {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String categoryName;
    private Long parentId;
    private String icon;
    private String description;
    private Integer sortOrder;
    private Integer status;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    
    @TableField(exist = false)
    private List<JDWAPrizeCategory> children;
}

@Data
@TableName("jdwa_prize_stock")
public class JDWAPrizeStock {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long prizeId;
    private Integer totalStock;
    private Integer availableStock;
    private Integer lockedStock;
    private Integer warnStock;
    private String warehouse;
    private LocalDateTime lastRestockTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_exchange_order")
public class JDWAExchangeOrder {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String orderNo;
    private Long userId;
    private String orderType;
    private Integer totalPoints;
    private BigDecimal totalCash;
    private Integer totalAmount;
    private String status;
    private Integer paymentStatus;
    private LocalDateTime paymentTime;
    private String deliveryMethod;
    private BigDecimal deliveryFee;
    private Long addressId;
    private String consignee;
    private String consigneePhone;
    private String consigneeAddress;
    private String logisticsCompany;
    private String logisticsNo;
    private LocalDateTime deliveryTime;
    private LocalDateTime receiveTime;
    private LocalDateTime completionTime;
    private String cancelReason;
    private LocalDateTime cancelTime;
    private String remark;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    
    @TableField(exist = false)
    private List<JDWAExchangeOrderItem> items;
    
    @TableField(exist = false)
    private JDWALogisticsInfo logisticsInfo;
}

@Data
@TableName("jdwa_exchange_order_item")
public class JDWAExchangeOrderItem {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long orderId;
    private String orderNo;
    private Long userId;
    private Long prizeId;
    private String prizeCode;
    private String prizeName;
    private String prizeType;
    private String prizeImage;
    private Integer pointsPrice;
    private BigDecimal cashPrice;
    private Integer quantity;
    private Integer totalPoints;
    private BigDecimal totalCash;
    private String virtualCode;
    private String virtualInfo;
    private String status;
    private Integer isReviewed;
    private LocalDateTime expireTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_logistics_info")
public class JDWALogisticsInfo {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long orderId;
    private String orderNo;
    private String logisticsCompany;
    private String logisticsCode;
    private String logisticsNo;
    private String sender;
    private String senderPhone;
    private String senderAddress;
    private String consignee;
    private String consigneePhone;
    private String consigneeAddress;
    private BigDecimal packageWeight;
    private Integer packageQuantity;
    private String status;
    private String trackingInfo;
    private LocalDateTime deliveryTime;
    private LocalDateTime estimatedDelivery;
    private LocalDateTime actualDelivery;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_address")
public class JDWAAddress {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private String receiver;
    private String phone;
    private String province;
    private String city;
    private String district;
    private String detailAddress;
    private String postCode;
    private Integer isDefault;
    private Integer isDeleted;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_prize_rule")
public class JDWAPrizeRule {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String ruleCode;
    private String ruleName;
    private Long prizeId;
    private String ruleType;
    private String ruleCondition;
    private String ruleValue;
    private Integer priority;
    private LocalDateTime startTime;
    private LocalDateTime endTime;
    private Integer status;
    private String description;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

public class JDWAPrizeConstants {
    // 奖品类型
    public static final String PRIZE_TYPE_PHYSICAL = "PHYSICAL";  // 实物奖品
    public static final String PRIZE_TYPE_VIRTUAL = "VIRTUAL";    // 虚拟商品
    public static final String PRIZE_TYPE_COUPON = "COUPON";      // 优惠券
    public static final String PRIZE_TYPE_PRIVILEGE = "PRIVILEGE"; // 会员特权
    public static final String PRIZE_TYPE_DONATION = "DONATION";   // 公益捐赠
    
    // 奖品等级
    public static final String PRIZE_LEVEL_COMMON = "COMMON";       // 普通奖品
    public static final String PRIZE_LEVEL_PREMIUM = "PREMIUM";     // 精品奖品
    public static final String PRIZE_LEVEL_RARE = "RARE";           // 珍稀奖品
    public static final String PRIZE_LEVEL_EXCLUSIVE = "EXCLUSIVE"; // 专属奖品
    
    // 订单类型
    public static final String ORDER_TYPE_PHYSICAL = "PHYSICAL"; // 实物订单
    public static final String ORDER_TYPE_VIRTUAL = "VIRTUAL";   // 虚拟订单
    public static final String ORDER_TYPE_MIXED = "MIXED";       // 混合订单
    
    // 订单状态 - 实物
    public static final String ORDER_STATUS_PENDING = "PENDING";         // 待处理
    public static final String ORDER_STATUS_CONFIRMED = "CONFIRMED";     // 已确认
    public static final String ORDER_STATUS_PREPARING = "PREPARING";     // 备货中
    public static final String ORDER_STATUS_SHIPPED = "SHIPPED";         // 已发货
    public static final String ORDER_STATUS_RECEIVED = "RECEIVED";       // 已签收
    public static final String ORDER_STATUS_COMPLETED = "COMPLETED";     // 已完成
    public static final String ORDER_STATUS_CANCELLED = "CANCELLED";     // 已取消
    public static final String ORDER_STATUS_RETURNING = "RETURNING";     // 退换中
    public static final String ORDER_STATUS_RETURNED = "RETURNED";       // 已退换
    
    // 订单状态 - 虚拟
    public static final String VIRTUAL_STATUS_PENDING = "PENDING";       // 待处理
    public static final String VIRTUAL_STATUS_PROCESSING = "PROCESSING"; // 处理中
    public static final String VIRTUAL_STATUS_DELIVERED = "DELIVERED";   // 已发放
    public static final String VIRTUAL_STATUS_USED = "USED";             // 已使用
    public static final String VIRTUAL_STATUS_EXPIRED = "EXPIRED";       // 已过期
    public static final String VIRTUAL_STATUS_CANCELLED = "CANCELLED";   // 已取消
    
    // 配送方式
    public static final String DELIVERY_EXPRESS = "EXPRESS";           // 快递配送
    public static final String DELIVERY_SELF_DELIVERY = "SELF_DELIVERY"; // 自有配送
    public static final String DELIVERY_PICKUP = "PICKUP";             // 门店自提
    
    // 规则类型
    public static final String RULE_TYPE_DISCOUNT = "DISCOUNT";       // 积分优惠
    public static final String RULE_TYPE_LIMIT = "LIMIT";             // 兑换限制
    public static final String RULE_TYPE_QUALIFICATION = "QUALIFICATION"; // 资格限制
} 

@Slf4j
@RestController
@RequestMapping("/api/prizes")
public class JDWAPrizeController {

    @Autowired
    private JDWAPrizeService prizeService;
    
    /**
     * 获取奖品列表
     * @param categoryId 分类ID
     * @param prizeType 奖品类型
     * @param prizeLevel 奖品等级
     * @param keyword 关键词
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 奖品列表
     */
    @GetMapping("/list")
    public Result<PageResult<JDWAPrizeVO>> getPrizeList(
            @RequestParam(required = false) Long categoryId,
            @RequestParam(required = false) String prizeType,
            @RequestParam(required = false) String prizeLevel,
            @RequestParam(required = false) String keyword,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        log.info("Get prize list: categoryId={}, prizeType={}, prizeLevel={}, keyword={}", 
                categoryId, prizeType, prizeLevel, keyword);
        
        PageResult<JDWAPrizeVO> result = prizeService.getPrizeList(
                categoryId, prizeType, prizeLevel, keyword, pageNum, pageSize);
        
        return Result.success(result);
    }
    
    /**
     * 获取奖品详情
     * @param prizeCode 奖品编码
     * @return 奖品详情
     */
    @GetMapping("/detail/{prizeCode}")
    public Result<JDWAPrizeDetailVO> getPrizeDetail(@PathVariable String prizeCode) {
        log.info("Get prize detail: prizeCode={}", prizeCode);
        
        JDWAPrizeDetailVO detail = prizeService.getPrizeDetail(prizeCode);
        if (detail == null) {
            return Result.error(ErrorCode.PRIZE_NOT_FOUND, "奖品不存在");
        }
        
        return Result.success(detail);
    }
    
    /**
     * 获取奖品分类列表
     * @return 分类列表
     */
    @GetMapping("/categories")
    public Result<List<JDWAPrizeCategoryVO>> getCategories() {
        List<JDWAPrizeCategoryVO> categories = prizeService.getAllCategories();
        return Result.success(categories);
    }
    
    /**
     * 根据身份和条件推荐奖品
     * @param type 推荐类型：HOT/NEW/RECOMMEND/POINTS_MATCH
     * @param limit 限制数量
     * @return 推荐奖品列表
     */
    @GetMapping("/recommend")
    public Result<List<JDWAPrizeVO>> getRecommendPrizes(
            @RequestParam(defaultValue = "RECOMMEND") String type,
            @RequestParam(defaultValue = "4") Integer limit) {
        
        List<JDWAPrizeVO> prizes = prizeService.getRecommendPrizes(type, limit);
        return Result.success(prizes);
    }
    
    /**
     * 加入兑换购物车
     * @param request 加入购物车请求
     * @return 操作结果
     */
    @PostMapping("/cart/add")
    public Result<Void> addToCart(@RequestBody @Validated JDWACartAddRequest request) {
        log.info("Add to cart: {}", request);
        
        boolean success = prizeService.addToCart(request);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "加入购物车失败");
        }
        
        return Result.success();
    }
    
    /**
     * 获取购物车列表
     * @return 购物车列表
     */
    @GetMapping("/cart/list")
    public Result<List<JDWACartItemVO>> getCartList() {
        List<JDWACartItemVO> cartItems = prizeService.getCartItems();
        return Result.success(cartItems);
    }
    
    /**
     * 移除购物车商品
     * @param cartItemIds 购物车项ID列表
     * @return 操作结果
     */
    @PostMapping("/cart/remove")
    public Result<Void> removeFromCart(@RequestBody List<Long> cartItemIds) {
        log.info("Remove from cart: {}", cartItemIds);
        
        boolean success = prizeService.removeFromCart(cartItemIds);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "移除购物车商品失败");
        }
        
        return Result.success();
    }
    
    /**
     * 更新购物车数量
     * @param cartItemId 购物车项ID
     * @param quantity 数量
     * @return 操作结果
     */
    @PostMapping("/cart/update")
    public Result<Void> updateCartQuantity(
            @RequestParam Long cartItemId,
            @RequestParam Integer quantity) {
        
        log.info("Update cart quantity: cartItemId={}, quantity={}", cartItemId, quantity);
        
        boolean success = prizeService.updateCartQuantity(cartItemId, quantity);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "更新购物车数量失败");
        }
        
        return Result.success();
    }
    
    /**
     * 创建兑换订单
     * @param request 创建订单请求
     * @return 订单编号
     */
    @PostMapping("/order/create")
    public Result<String> createExchangeOrder(@RequestBody @Validated JDWAExchangeOrderCreateRequest request) {
        log.info("Create exchange order: {}", request);
        
        String orderNo = prizeService.createExchangeOrder(request);
        if (StringUtils.isEmpty(orderNo)) {
            return Result.error(ErrorCode.OPERATION_FAILED, "创建订单失败");
        }
        
        return Result.success(orderNo);
    }
    
    /**
     * 获取订单列表
     * @param status 订单状态
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 订单列表
     */
    @GetMapping("/order/list")
    public Result<PageResult<JDWAExchangeOrderVO>> getOrderList(
            @RequestParam(required = false) String status,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        PageResult<JDWAExchangeOrderVO> result = prizeService.getOrderList(status, pageNum, pageSize);
        return Result.success(result);
    }
    
    /**
     * 获取订单详情
     * @param orderNo 订单编号
     * @return 订单详情
     */
    @GetMapping("/order/detail/{orderNo}")
    public Result<JDWAExchangeOrderDetailVO> getOrderDetail(@PathVariable String orderNo) {
        JDWAExchangeOrderDetailVO detail = prizeService.getOrderDetail(orderNo);
        if (detail == null) {
            return Result.error(ErrorCode.ORDER_NOT_FOUND, "订单不存在");
        }
        
        return Result.success(detail);
    }
    
    /**
     * 取消订单
     * @param orderNo 订单编号
     * @param reason 取消原因
     * @return 操作结果
     */
    @PostMapping("/order/cancel")
    public Result<Void> cancelOrder(
            @RequestParam String orderNo,
            @RequestParam String reason) {
        
        log.info("Cancel order: orderNo={}, reason={}", orderNo, reason);
        
        boolean success = prizeService.cancelOrder(orderNo, reason);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "取消订单失败");
        }
        
        return Result.success();
    }
    
    /**
     * 确认收货
     * @param orderNo 订单编号
     * @return 操作结果
     */
    @PostMapping("/order/confirm")
    public Result<Void> confirmReceive(@RequestParam String orderNo) {
        log.info("Confirm receive: orderNo={}", orderNo);
        
        boolean success = prizeService.confirmReceive(orderNo);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "确认收货失败");
        }
        
        return Result.success();
    }
    
    /**
     * 获取订单物流信息
     * @param orderNo 订单编号
     * @return 物流信息
     */
    @GetMapping("/order/logistics/{orderNo}")
    public Result<JDWALogisticsInfoVO> getLogisticsInfo(@PathVariable String orderNo) {
        JDWALogisticsInfoVO logisticsInfo = prizeService.getLogisticsInfo(orderNo);
        if (logisticsInfo == null) {
            return Result.error(ErrorCode.LOGISTICS_NOT_FOUND, "物流信息不存在");
        }
        
        return Result.success(logisticsInfo);
    }
    
    /**
     * 激活虚拟奖品
     * @param orderItemId 订单项ID
     * @return 操作结果
     */
    @PostMapping("/virtual/activate")
    public Result<JDWAVirtualPrizeVO> activateVirtualPrize(@RequestParam Long orderItemId) {
        log.info("Activate virtual prize: orderItemId={}", orderItemId);
        
        JDWAVirtualPrizeVO result = prizeService.activateVirtualPrize(orderItemId);
        if (result == null) {
            return Result.error(ErrorCode.OPERATION_FAILED, "激活虚拟奖品失败");
        }
        
        return Result.success(result);
    }
    
    /**
     * 获取收货地址列表
     * @return 地址列表
     */
    @GetMapping("/address/list")
    public Result<List<JDWAAddressVO>> getAddressList() {
        List<JDWAAddressVO> addresses = prizeService.getUserAddresses();
        return Result.success(addresses);
    }
    
    /**
     * 添加新地址
     * @param address 地址信息
     * @return 操作结果
     */
    @PostMapping("/address/add")
    public Result<Long> addAddress(@RequestBody @Validated JDWAAddressVO address) {
        log.info("Add address: {}", address);
        
        Long addressId = prizeService.addAddress(address);
        if (addressId == null) {
            return Result.error(ErrorCode.OPERATION_FAILED, "添加地址失败");
        }
        
        return Result.success(addressId);
    }
    
    /**
     * 修改地址
     * @param address 地址信息
     * @return 操作结果
     */
    @PostMapping("/address/update")
    public Result<Void> updateAddress(@RequestBody @Validated JDWAAddressVO address) {
        log.info("Update address: {}", address);
        
        boolean success = prizeService.updateAddress(address);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "修改地址失败");
        }
        
        return Result.success();
    }
    
    /**
     * 删除地址
     * @param addressId 地址ID
     * @return 操作结果
     */
    @PostMapping("/address/delete")
    public Result<Void> deleteAddress(@RequestParam Long addressId) {
        log.info("Delete address: addressId={}", addressId);
        
        boolean success = prizeService.deleteAddress(addressId);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "删除地址失败");
        }
        
        return Result.success();
    }
    
    /**
     * 设置默认地址
     * @param addressId 地址ID
     * @return 操作结果
     */
    @PostMapping("/address/default")
    public Result<Void> setDefaultAddress(@RequestParam Long addressId) {
        log.info("Set default address: addressId={}", addressId);
        
        boolean success = prizeService.setDefaultAddress(addressId);
        if (!success) {
            return Result.error(ErrorCode.OPERATION_FAILED, "设置默认地址失败");
        }
        
        return Result.success();
    }
}

/**
 * 奖品兑换服务接口
 */
public interface JDWAPrizeService {

    /**
     * 获取奖品列表
     * @param categoryId 分类ID
     * @param prizeType 奖品类型
     * @param prizeLevel 奖品等级
     * @param keyword 关键词
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 奖品列表
     */
    PageResult<JDWAPrizeVO> getPrizeList(Long categoryId, String prizeType, 
                                       String prizeLevel, String keyword, 
                                       Integer pageNum, Integer pageSize);
    
    /**
     * 获取奖品详情
     * @param prizeCode 奖品编码
     * @return 奖品详情
     */
    JDWAPrizeDetailVO getPrizeDetail(String prizeCode);
    
    /**
     * 获取所有奖品分类
     * @return 分类列表
     */
    List<JDWAPrizeCategoryVO> getAllCategories();
    
    /**
     * 根据推荐类型获取推荐奖品
     * @param type 推荐类型
     * @param limit 限制数量
     * @return 推荐奖品列表
     */
    List<JDWAPrizeVO> getRecommendPrizes(String type, Integer limit);
    
    /**
     * 加入兑换购物车
     * @param request 加入购物车请求
     * @return 是否成功
     */
    boolean addToCart(JDWACartAddRequest request);
    
    /**
     * 获取购物车商品列表
     * @return 购物车商品列表
     */
    List<JDWACartItemVO> getCartItems();
    
    /**
     * 从购物车移除商品
     * @param cartItemIds 购物车项ID列表
     * @return 是否成功
     */
    boolean removeFromCart(List<Long> cartItemIds);
    
    /**
     * 更新购物车商品数量
     * @param cartItemId 购物车项ID
     * @param quantity 数量
     * @return 是否成功
     */
    boolean updateCartQuantity(Long cartItemId, Integer quantity);
    
    /**
     * 创建兑换订单
     * @param request 创建订单请求
     * @return 订单编号
     */
    String createExchangeOrder(JDWAExchangeOrderCreateRequest request);
    
    /**
     * 获取订单列表
     * @param status 订单状态
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 订单列表
     */
    PageResult<JDWAExchangeOrderVO> getOrderList(String status, Integer pageNum, Integer pageSize);
    
    /**
     * 获取订单详情
     * @param orderNo 订单编号
     * @return 订单详情
     */
    JDWAExchangeOrderDetailVO getOrderDetail(String orderNo);
    
    /**
     * 取消订单
     * @param orderNo 订单编号
     * @param reason 取消原因
     * @return 是否成功
     */
    boolean cancelOrder(String orderNo, String reason);
    
    /**
     * 确认收货
     * @param orderNo 订单编号
     * @return 是否成功
     */
    boolean confirmReceive(String orderNo);
    
    /**
     * 获取物流信息
     * @param orderNo 订单编号
     * @return 物流信息
     */
    JDWALogisticsInfoVO getLogisticsInfo(String orderNo);
    
    /**
     * 激活虚拟奖品
     * @param orderItemId 订单项ID
     * @return 虚拟奖品信息
     */
    JDWAVirtualPrizeVO activateVirtualPrize(Long orderItemId);
    
    /**
     * 获取用户收货地址列表
     * @return 地址列表
     */
    List<JDWAAddressVO> getUserAddresses();
    
    /**
     * 添加收货地址
     * @param address 地址信息
     * @return 地址ID
     */
    Long addAddress(JDWAAddressVO address);
    
    /**
     * 更新收货地址
     * @param address 地址信息
     * @return 是否成功
     */
    boolean updateAddress(JDWAAddressVO address);
    
    /**
     * 删除收货地址
     * @param addressId 地址ID
     * @return 是否成功
     */
    boolean deleteAddress(Long addressId);
    
    /**
     * 设置默认收货地址
     * @param addressId 地址ID
     * @return 是否成功
     */
    boolean setDefaultAddress(Long addressId);
    
    /**
     * 验证库存和兑换资格
     * @param prizeId 奖品ID
     * @param quantity 数量
     * @return 验证结果
     */
    JDWAExchangeVerifyResult verifyExchangeQualification(Long prizeId, Integer quantity);
    
    /**
     * 锁定奖品库存
     * @param prizeId 奖品ID
     * @param quantity 数量
     * @return 是否成功
     */
    boolean lockPrizeStock(Long prizeId, Integer quantity);
    
    /**
     * 释放奖品库存
     * @param prizeId 奖品ID
     * @param quantity 数量
     * @return 是否成功
     */
    boolean releasePrizeStock(Long prizeId, Integer quantity);
    
    /**
     * 扣减用户积分
     * @param userId 用户ID
     * @param points 积分数量
     * @param orderNo 订单号
     * @param description 描述
     * @return 是否成功
     */
    boolean deductUserPoints(Long userId, Integer points, String orderNo, String description);
}

@Slf4j
@Service
public class JDWAPrizeServiceImpl implements JDWAPrizeService {

    @Autowired
    private JDWAPrizeMapper prizeMapper;
    
    @Autowired
    private JDWAPrizeCategoryMapper categoryMapper;
    
    @Autowired
    private JDWAPrizeStockMapper stockMapper;
    
    @Autowired
    private JDWAPrizeRuleMapper ruleMapper;
    
    @Autowired
    private JDWACartItemMapper cartItemMapper;
    
    @Autowired
    private JDWAExchangeOrderMapper orderMapper;
    
    @Autowired
    private JDWAExchangeOrderItemMapper orderItemMapper;
    
    @Autowired
    private JDWALogisticsInfoMapper logisticsInfoMapper;
    
    @Autowired
    private JDWAAddressMapper addressMapper;
    
    @Autowired
    private JDWAUserPointsService userPointsService;
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    @Value("${jdwa.prize.stock.lock.timeout:300}")
    private Long stockLockTimeout;
    
    @Value("${jdwa.prize.order.expire.minutes:30}")
    private Integer orderExpireMinutes;
    
    @Override
    public PageResult<JDWAPrizeVO> getPrizeList(Long categoryId, String prizeType, 
                                             String prizeLevel, String keyword, 
                                             Integer pageNum, Integer pageSize) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 构建查询条件
        LambdaQueryWrapper<JDWAPrize> wrapper = Wrappers.<JDWAPrize>lambdaQuery()
                .eq(JDWAPrize::getStatus, 1) // 只查询上架商品
                .eq(categoryId != null, JDWAPrize::getCategoryId, categoryId)
                .eq(StringUtils.isNotEmpty(prizeType), JDWAPrize::getPrizeType, prizeType)
                .eq(StringUtils.isNotEmpty(prizeLevel), JDWAPrize::getPrizeLevel, prizeLevel)
                .and(StringUtils.isNotEmpty(keyword), w -> w
                    .like(JDWAPrize::getPrizeName, keyword)
                    .or()
                    .like(JDWAPrize::getDescription, keyword)
                )
                .le(JDWAPrize::getExchangeStart, LocalDateTime.now())
                .ge(JDWAPrize::getExchangeEnd, LocalDateTime.now())
                .orderByDesc(JDWAPrize::getIsHot)
                .orderByDesc(JDWAPrize::getIsRecommend)
                .orderByDesc(JDWAPrize::getSortOrder);
        
        // 分页查询
        Page<JDWAPrize> page = new Page<>(pageNum, pageSize);
        Page<JDWAPrize> prizePage = prizeMapper.selectPage(page, wrapper);
        
        // 获取奖品对应库存
        List<JDWAPrize> prizeList = prizePage.getRecords();
        if (CollectionUtils.isEmpty(prizeList)) {
            return PageResult.empty();
        }
        
        // 获取库存信息
        List<Long> prizeIds = prizeList.stream()
                .map(JDWAPrize::getId)
                .collect(Collectors.toList());
        
        List<JDWAPrizeStock> stockList = stockMapper.selectList(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .in(JDWAPrizeStock::getPrizeId, prizeIds));
        
        Map<Long, JDWAPrizeStock> stockMap = stockList.stream()
                .collect(Collectors.toMap(JDWAPrizeStock::getPrizeId, stock -> stock));
        
        // 转换为VO对象
        List<JDWAPrizeVO> voList = prizeList.stream().map(prize -> {
            JDWAPrizeVO vo = new JDWAPrizeVO();
            BeanUtils.copyProperties(prize, vo);
            
            // 设置库存信息
            JDWAPrizeStock stock = stockMap.get(prize.getId());
            if (stock != null) {
                vo.setAvailableStock(stock.getAvailableStock());
            } else {
                vo.setAvailableStock(0);
            }
            
            // 检查用户是否有足够积分
            JDWAUserPoints userPoints = userPointsService.getUserPoints(userId);
            if (userPoints != null) {
                vo.setHasEnoughPoints(userPoints.getAvailablePoints() >= prize.getPointsPrice());
            } else {
                vo.setHasEnoughPoints(false);
            }
            
            return vo;
        }).collect(Collectors.toList());
        
        return new PageResult<>(voList, prizePage.getTotal(), pageNum, pageSize);
    }
    
    @Override
    public JDWAPrizeDetailVO getPrizeDetail(String prizeCode) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询奖品信息
        JDWAPrize prize = prizeMapper.selectOne(
                Wrappers.<JDWAPrize>lambdaQuery()
                        .eq(JDWAPrize::getPrizeCode, prizeCode)
                        .eq(JDWAPrize::getStatus, 1));
        
        if (prize == null) {
            return null;
        }
        
        // 增加浏览次数
        prizeMapper.increaseViewCount(prize.getId());
        
        // 查询库存信息
        JDWAPrizeStock stock = stockMapper.selectOne(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .eq(JDWAPrizeStock::getPrizeId, prize.getId()));
        
        // 查询分类信息
        JDWAPrizeCategory category = categoryMapper.selectById(prize.getCategoryId());
        
        // 查询规则信息
        List<JDWAPrizeRule> rules = ruleMapper.selectList(
                Wrappers.<JDWAPrizeRule>lambdaQuery()
                        .eq(JDWAPrizeRule::getPrizeId, prize.getId())
                        .eq(JDWAPrizeRule::getStatus, 1)
                        .le(JDWAPrizeRule::getStartTime, LocalDateTime.now())
                        .ge(JDWAPrizeRule::getEndTime, LocalDateTime.now())
                        .orderByDesc(JDWAPrizeRule::getPriority));
        
        // 查询用户积分
        JDWAUserPoints userPoints = userPointsService.getUserPoints(userId);
        
        // 转换为VO对象
        JDWAPrizeDetailVO detailVO = new JDWAPrizeDetailVO();
        BeanUtils.copyProperties(prize, detailVO);
        
        // 设置库存信息
        if (stock != null) {
            detailVO.setAvailableStock(stock.getAvailableStock());
            detailVO.setTotalStock(stock.getTotalStock());
        } else {
            detailVO.setAvailableStock(0);
            detailVO.setTotalStock(0);
        }
        
        // 设置分类信息
        if (category != null) {
            detailVO.setCategoryName(category.getCategoryName());
        }
        
        // 设置规则信息
        if (!CollectionUtils.isEmpty(rules)) {
            List<JDWAPrizeRuleVO> ruleVOs = rules.stream().map(rule -> {
                JDWAPrizeRuleVO ruleVO = new JDWAPrizeRuleVO();
                BeanUtils.copyProperties(rule, ruleVO);
                return ruleVO;
            }).collect(Collectors.toList());
            detailVO.setRules(ruleVOs);
        }
        
        // 设置积分信息
        if (userPoints != null) {
            detailVO.setUserCurrentPoints(userPoints.getAvailablePoints());
            detailVO.setHasEnoughPoints(userPoints.getAvailablePoints() >= prize.getPointsPrice());
        } else {
            detailVO.setUserCurrentPoints(0);
            detailVO.setHasEnoughPoints(false);
        }
        
        // 设置兑换资格
        detailVO.setCanExchange(verifyExchangeQualification(prize.getId(), 1).isQualified());
        
        return detailVO;
    }
    
    @Override
    public List<JDWAPrizeCategoryVO> getAllCategories() {
        // 查询所有启用的分类
        List<JDWAPrizeCategory> categories = categoryMapper.selectList(
                Wrappers.<JDWAPrizeCategory>lambdaQuery()
                        .eq(JDWAPrizeCategory::getStatus, 1)
                        .orderByAsc(JDWAPrizeCategory::getSortOrder));
        
        if (CollectionUtils.isEmpty(categories)) {
            return Collections.emptyList();
        }
        
        // 转换为树形结构
        Map<Long, List<JDWAPrizeCategory>> childrenMap = categories.stream()
                .filter(category -> !category.getParentId().equals(0L))
                .collect(Collectors.groupingBy(JDWAPrizeCategory::getParentId));
        
        // 转换为VO对象
        return categories.stream()
                .filter(category -> category.getParentId().equals(0L))
                .map(category -> {
                    JDWAPrizeCategoryVO vo = new JDWAPrizeCategoryVO();
                    BeanUtils.copyProperties(category, vo);
                    
                    // 设置子分类
                    List<JDWAPrizeCategory> children = childrenMap.get(category.getId());
                    if (!CollectionUtils.isEmpty(children)) {
                        List<JDWAPrizeCategoryVO> childrenVOs = children.stream().map(child -> {
                            JDWAPrizeCategoryVO childVO = new JDWAPrizeCategoryVO();
                            BeanUtils.copyProperties(child, childVO);
                            return childVO;
                        }).collect(Collectors.toList());
                        vo.setChildren(childrenVOs);
                    }
                    
                    return vo;
                }).collect(Collectors.toList());
    }
    
    @Override
    public List<JDWAPrizeVO> getRecommendPrizes(String type, Integer limit) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 构建查询条件
        LambdaQueryWrapper<JDWAPrize> wrapper = Wrappers.<JDWAPrize>lambdaQuery()
                .eq(JDWAPrize::getStatus, 1) // 只查询上架商品
                .le(JDWAPrize::getExchangeStart, LocalDateTime.now())
                .ge(JDWAPrize::getExchangeEnd, LocalDateTime.now());
        
        // 根据推荐类型筛选
        switch (type) {
            case "HOT":
                wrapper.eq(JDWAPrize::getIsHot, 1)
                       .orderByDesc(JDWAPrize::getExchangeCount);
                break;
            case "NEW":
                wrapper.eq(JDWAPrize::getIsNew, 1)
                       .orderByDesc(JDWAPrize::getCreateTime);
                break;
            case "RECOMMEND":
                wrapper.eq(JDWAPrize::getIsRecommend, 1)
                       .orderByDesc(JDWAPrize::getSortOrder);
                break;
            case "POINTS_MATCH":
                // 获取用户积分
                JDWAUserPoints userPoints = userPointsService.getUserPoints(userId);
                if (userPoints != null) {
                    Integer availablePoints = userPoints.getAvailablePoints();
                    // 积分匹配：查询积分价格小于等于用户可用积分的奖品
                    wrapper.le(JDWAPrize::getPointsPrice, availablePoints)
                           .orderByDesc(JDWAPrize::getPointsPrice);
                }
                break;
            default:
                wrapper.orderByDesc(JDWAPrize::getSortOrder);
        }
        
        // 限制查询数量
        Page<JDWAPrize> page = new Page<>(1, limit);
        Page<JDWAPrize> prizePage = prizeMapper.selectPage(page, wrapper);
        
        List<JDWAPrize> prizeList = prizePage.getRecords();
        if (CollectionUtils.isEmpty(prizeList)) {
            return Collections.emptyList();
        }
        
        // 获取库存信息
        List<Long> prizeIds = prizeList.stream()
                .map(JDWAPrize::getId)
                .collect(Collectors.toList());
        
        List<JDWAPrizeStock> stockList = stockMapper.selectList(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .in(JDWAPrizeStock::getPrizeId, prizeIds));
        
        Map<Long, JDWAPrizeStock> stockMap = stockList.stream()
                .collect(Collectors.toMap(JDWAPrizeStock::getPrizeId, stock -> stock));
        
        // 转换为VO对象
        return prizeList.stream().map(prize -> {
            JDWAPrizeVO vo = new JDWAPrizeVO();
            BeanUtils.copyProperties(prize, vo);
            
            // 设置库存信息
            JDWAPrizeStock stock = stockMap.get(prize.getId());
            if (stock != null) {
                vo.setAvailableStock(stock.getAvailableStock());
            } else {
                vo.setAvailableStock(0);
            }
            
            return vo;
        }).collect(Collectors.toList());
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addToCart(JDWACartAddRequest request) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询奖品信息
        JDWAPrize prize = prizeMapper.selectById(request.getPrizeId());
        if (prize == null || prize.getStatus() != 1) {
            log.error("Prize not found or not active: prizeId={}", request.getPrizeId());
            return false;
        }
        
        // 验证库存
        JDWAPrizeStock stock = stockMapper.selectOne(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .eq(JDWAPrizeStock::getPrizeId, request.getPrizeId()));
        
        if (stock == null || stock.getAvailableStock() < request.getQuantity()) {
            log.error("Insufficient stock: prizeId={}, required={}, available={}",
                    request.getPrizeId(), request.getQuantity(), 
                    stock != null ? stock.getAvailableStock() : 0);
            return false;
        }
        
        // 验证兑换资格
        JDWAExchangeVerifyResult verifyResult = verifyExchangeQualification(
                request.getPrizeId(), request.getQuantity());
        
        if (!verifyResult.isQualified()) {
            log.error("Exchange qualification check failed: prizeId={}, reason={}",
                    request.getPrizeId(), verifyResult.getMessage());
            return false;
        }
        
        // 检查购物车中是否已存在该商品
        JDWACartItem existingItem = cartItemMapper.selectOne(
                Wrappers.<JDWACartItem>lambdaQuery()
                        .eq(JDWACartItem::getUserId, userId)
                        .eq(JDWACartItem::getPrizeId, request.getPrizeId()));
        
        if (existingItem != null) {
            // 更新数量
            existingItem.setQuantity(existingItem.getQuantity() + request.getQuantity());
            existingItem.setUpdateTime(LocalDateTime.now());
            cartItemMapper.updateById(existingItem);
        } else {
            // 创建新购物车项
            JDWACartItem cartItem = new JDWACartItem();
            cartItem.setUserId(userId);
            cartItem.setPrizeId(request.getPrizeId());
            cartItem.setPrizeCode(prize.getPrizeCode());
            cartItem.setPrizeName(prize.getPrizeName());
            cartItem.setPrizeType(prize.getPrizeType());
            cartItem.setPrizeImage(prize.getThumbnail());
            cartItem.setPointsPrice(prize.getPointsPrice());
            cartItem.setCashPrice(prize.getCashPrice());
            cartItem.setQuantity(request.getQuantity());
            cartItem.setSelectedStatus(1);
            cartItem.setCreateTime(LocalDateTime.now());
            cartItem.setUpdateTime(LocalDateTime.now());
            
            cartItemMapper.insert(cartItem);
        }
        
        return true;
    }
    
    @Override
    public List<JDWACartItemVO> getCartItems() {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询购物车项
        List<JDWACartItem> cartItems = cartItemMapper.selectList(
                Wrappers.<JDWACartItem>lambdaQuery()
                        .eq(JDWACartItem::getUserId, userId)
                        .orderByDesc(JDWACartItem::getCreateTime));
        
        if (CollectionUtils.isEmpty(cartItems)) {
            return Collections.emptyList();
        }
        
        // 获取奖品ID列表
        List<Long> prizeIds = cartItems.stream()
                .map(JDWACartItem::getPrizeId)
                .distinct()
                .collect(Collectors.toList());
        
        // 查询奖品库存
        List<JDWAPrizeStock> stockList = stockMapper.selectList(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .in(JDWAPrizeStock::getPrizeId, prizeIds));
        
        Map<Long, JDWAPrizeStock> stockMap = stockList.stream()
                .collect(Collectors.toMap(JDWAPrizeStock::getPrizeId, stock -> stock));
        
        // 查询奖品当前信息
        List<JDWAPrize> prizeList = prizeMapper.selectList(
                Wrappers.<JDWAPrize>lambdaQuery()
                        .in(JDWAPrize::getId, prizeIds));
        
        Map<Long, JDWAPrize> prizeMap = prizeList.stream()
                .collect(Collectors.toMap(JDWAPrize::getId, prize -> prize));
        
        // 转换为VO对象
        return cartItems.stream().map(item -> {
            JDWACartItemVO vo = new JDWACartItemVO();
            BeanUtils.copyProperties(item, vo);
            
            // 更新奖品最新信息
            JDWAPrize prize = prizeMap.get(item.getPrizeId());
            if (prize != null) {
                vo.setPointsPrice(prize.getPointsPrice());
                vo.setCashPrice(prize.getCashPrice());
                vo.setPrizeStatus(prize.getStatus());
                
                // 判断是否可兑换（商品状态、时间）
                boolean canExchange = prize.getStatus() == 1 
                        && LocalDateTime.now().isAfter(prize.getExchangeStart())
                        && LocalDateTime.now().isBefore(prize.getExchangeEnd());
                vo.setCanExchange(canExchange);
            } else {
                vo.setPrizeStatus(0);
                vo.setCanExchange(false);
            }
            
            // 设置库存信息
            JDWAPrizeStock stock = stockMap.get(item.getPrizeId());
            if (stock != null) {
                vo.setAvailableStock(stock.getAvailableStock());
                vo.setStockEnough(stock.getAvailableStock() >= item.getQuantity());
            } else {
                vo.setAvailableStock(0);
                vo.setStockEnough(false);
            }
            
            // 计算总积分和总金额
            vo.setTotalPoints(vo.getPointsPrice() * item.getQuantity());
            vo.setTotalCash(vo.getCashPrice() != null ? 
                    vo.getCashPrice().multiply(new BigDecimal(item.getQuantity())) : BigDecimal.ZERO);
            
            return vo;
        }).collect(Collectors.toList());
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean removeFromCart(List<Long> cartItemIds) {
        if (CollectionUtils.isEmpty(cartItemIds)) {
            return true;
        }
        
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 删除购物车项
        int result = cartItemMapper.delete(
                Wrappers.<JDWACartItem>lambdaQuery()
                        .eq(JDWACartItem::getUserId, userId)
                        .in(JDWACartItem::getId, cartItemIds));
        
        return result > 0;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateCartQuantity(Long cartItemId, Integer quantity) {
        if (quantity <= 0) {
            return false;
        }
        
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询购物车项
        JDWACartItem cartItem = cartItemMapper.selectOne(
                Wrappers.<JDWACartItem>lambdaQuery()
                        .eq(JDWACartItem::getId, cartItemId)
                        .eq(JDWACartItem::getUserId, userId));
        
        if (cartItem == null) {
            return false;
        }
        
        // 验证库存
        JDWAPrizeStock stock = stockMapper.selectOne(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .eq(JDWAPrizeStock::getPrizeId, cartItem.getPrizeId()));
        
        if (stock == null || stock.getAvailableStock() < quantity) {
            log.error("Insufficient stock: prizeId={}, required={}, available={}",
                    cartItem.getPrizeId(), quantity, 
                    stock != null ? stock.getAvailableStock() : 0);
            return false;
        }
        
        // 更新数量
        cartItem.setQuantity(quantity);
        cartItem.setUpdateTime(LocalDateTime.now());
        cartItemMapper.updateById(cartItem);
        
        return true;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String createExchangeOrder(JDWAExchangeOrderCreateRequest request) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 生成订单号
        String orderNo = generateOrderNo();
        
        // 处理订单商品
        List<JDWAExchangeOrderItemCreateDTO> items = request.getItems();
        if (CollectionUtils.isEmpty(items)) {
            log.error("Order items cannot be empty: userId={}", userId);
            return null;
        }
        
        // 检查库存和资格
        Map<Long, JDWAPrize> prizeMap = new HashMap<>();
        Map<Long, Integer> prizeQuantityMap = new HashMap<>();
        
        for (JDWAExchangeOrderItemCreateDTO item : items) {
            // 检查商品信息
            JDWAPrize prize = prizeMapper.selectById(item.getPrizeId());
            if (prize == null || prize.getStatus() != 1) {
                log.error("Prize not found or not active: prizeId={}", item.getPrizeId());
                return null;
            }
            
            prizeMap.put(prize.getId(), prize);
            
            // 累加同种商品数量
            prizeQuantityMap.merge(prize.getId(), item.getQuantity(), Integer::sum);
        }
        
        // 逐个检查库存和兑换资格
        for (Map.Entry<Long, Integer> entry : prizeQuantityMap.entrySet()) {
            Long prizeId = entry.getKey();
            Integer quantity = entry.getValue();
            
            // 检查库存
            JDWAPrizeStock stock = stockMapper.selectOne(
                    Wrappers.<JDWAPrizeStock>lambdaQuery()
                            .eq(JDWAPrizeStock::getPrizeId, prizeId));
            
            if (stock == null || stock.getAvailableStock() < quantity) {
                log.error("Insufficient stock: prizeId={}, required={}, available={}",
                        prizeId, quantity, stock != null ? stock.getAvailableStock() : 0);
                return null;
            }
            
            // 检查兑换资格
            JDWAExchangeVerifyResult verifyResult = verifyExchangeQualification(prizeId, quantity);
            if (!verifyResult.isQualified()) {
                log.error("Exchange qualification check failed: prizeId={}, reason={}",
                        prizeId, verifyResult.getMessage());
                return null;
            }
            
            // 锁定库存
            boolean locked = lockPrizeStock(prizeId, quantity);
            if (!locked) {
                log.error("Failed to lock stock: prizeId={}, quantity={}", prizeId, quantity);
                return null;
            }
        }
        
        try {
            // 创建订单
            JDWAExchangeOrder order = new JDWAExchangeOrder();
            order.setOrderNo(orderNo);
            order.setUserId(userId);
            
            // 确定订单类型
            boolean hasPhysical = false;
            boolean hasVirtual = false;
            
            // 计算总积分和总数量
            int totalPoints = 0;
            BigDecimal totalCash = BigDecimal.ZERO;
            int totalAmount = 0;
            
            // 创建订单项
            List<JDWAExchangeOrderItem> orderItems = new ArrayList<>();
            
            for (JDWAExchangeOrderItemCreateDTO itemDTO : items) {
                JDWAPrize prize = prizeMap.get(itemDTO.getPrizeId());
                
                // 判断商品类型
                if (JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(prize.getPrizeType())) {
                    hasPhysical = true;
                } else {
                    hasVirtual = true;
                }
                
                // 创建订单项
                JDWAExchangeOrderItem orderItem = new JDWAExchangeOrderItem();
                orderItem.setOrderId(null); // 稍后设置
                orderItem.setOrderNo(orderNo);
                orderItem.setUserId(userId);
                orderItem.setPrizeId(prize.getId());
                orderItem.setPrizeCode(prize.getPrizeCode());
                orderItem.setPrizeName(prize.getPrizeName());
                orderItem.setPrizeType(prize.getPrizeType());
                orderItem.setPrizeImage(prize.getThumbnail());
                orderItem.setPointsPrice(prize.getPointsPrice());
                orderItem.setCashPrice(prize.getCashPrice());
                orderItem.setQuantity(itemDTO.getQuantity());
                orderItem.setTotalPoints(prize.getPointsPrice() * itemDTO.getQuantity());
                
                if (prize.getCashPrice() != null) {
                    orderItem.setTotalCash(prize.getCashPrice()
                            .multiply(new BigDecimal(itemDTO.getQuantity())));
                } else {
                    orderItem.setTotalCash(BigDecimal.ZERO);
                }
                
                // 设置状态
                if (JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(prize.getPrizeType())) {
                    orderItem.setStatus(JDWAPrizeConstants.ORDER_STATUS_PENDING);
                } else {
                    orderItem.setStatus(JDWAPrizeConstants.VIRTUAL_STATUS_PENDING);
                }
                
                // 设置过期时间（虚拟奖品）
                if (!JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(prize.getPrizeType())) {
                    orderItem.setExpireTime(LocalDateTime.now().plusDays(90)); // 设置90天有效期
                }
                
                orderItem.setCreateTime(LocalDateTime.now());
                orderItem.setUpdateTime(LocalDateTime.now());
                
                orderItems.add(orderItem);
                
                // 累计总积分和总数量
                totalPoints += orderItem.getTotalPoints();
                totalCash = totalCash.add(orderItem.getTotalCash());
                totalAmount += itemDTO.getQuantity();
            }
            
            // 设置订单类型
            if (hasPhysical && hasVirtual) {
                order.setOrderType(JDWAPrizeConstants.ORDER_TYPE_MIXED);
            } else if (hasPhysical) {
                order.setOrderType(JDWAPrizeConstants.ORDER_TYPE_PHYSICAL);
            } else {
                order.setOrderType(JDWAPrizeConstants.ORDER_TYPE_VIRTUAL);
            }
            
            // 设置订单基本信息
            order.setTotalPoints(totalPoints);
            order.setTotalCash(totalCash);
            order.setTotalAmount(totalAmount);
            
            // 设置订单状态
            if (hasPhysical) {
                order.setStatus(JDWAPrizeConstants.ORDER_STATUS_PENDING);
                
                // 设置收货地址
                if (request.getAddressId() != null) {
                    JDWAAddress address = addressMapper.selectById(request.getAddressId());
                    if (address != null) {
                        order.setAddressId(address.getId());
                        order.setConsignee(address.getReceiver());
                        order.setConsigneePhone(address.getPhone());
                        order.setConsigneeAddress(address.getProvince() + address.getCity() + 
                                address.getDistrict() + address.getDetailAddress());
                    }
                }
                
                // 设置配送方式
                order.setDeliveryMethod(request.getDeliveryMethod());
                
                // 设置运费
                // TODO: 根据地址和配送方式计算运费
                order.setDeliveryFee(BigDecimal.ZERO);
            } else {
                order.setStatus(JDWAPrizeConstants.VIRTUAL_STATUS_PENDING);
            }
            
            // 设置支付状态
            order.setPaymentStatus(0); // 未支付
            
            // 设置备注
            order.setRemark(request.getRemark());
            
            order.setCreateTime(LocalDateTime.now());
            order.setUpdateTime(LocalDateTime.now());
            
            // 保存订单
            orderMapper.insert(order);
            
            // 设置订单项的订单ID并保存
            for (JDWAExchangeOrderItem orderItem : orderItems) {
                orderItem.setOrderId(order.getId());
                orderItemMapper.insert(orderItem);
            }
            
            // 扣减用户积分
            boolean deducted = deductUserPoints(userId, totalPoints, orderNo, "兑换奖品");
            if (!deducted) {
                log.error("Failed to deduct user points: userId={}, points={}", userId, totalPoints);
                throw new RuntimeException("Failed to deduct user points");
            }
            
            // 如果有现金部分，需要处理支付
            if (totalCash.compareTo(BigDecimal.ZERO) > 0) {
                // TODO: 处理现金支付
            } else {
                // 无需现金支付，直接更新支付状态
                order.setPaymentStatus(1);
                order.setPaymentTime(LocalDateTime.now());
                orderMapper.updateById(order);
            }
            
            // 处理虚拟奖品
            if (!hasPhysical) {
                // 虚拟奖品自动完成
                for (JDWAExchangeOrderItem orderItem : orderItems) {
                    if (!JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(orderItem.getPrizeType())) {
                        // 生成虚拟兑换码
                        String virtualCode = generateVirtualCode(orderItem.getPrizeId());
                        orderItem.setVirtualCode(virtualCode);
                        orderItem.setStatus(JDWAPrizeConstants.VIRTUAL_STATUS_DELIVERED);
                        orderItemMapper.updateById(orderItem);
                    }
                }
                
                // 更新订单状态
                order.setStatus(JDWAPrizeConstants.VIRTUAL_STATUS_DELIVERED);
                order.setCompletionTime(LocalDateTime.now());
                orderMapper.updateById(order);
            }
            
            // 从购物车移除已购商品
            if (!CollectionUtils.isEmpty(request.getCartItemIds())) {
                cartItemMapper.delete(
                        Wrappers.<JDWACartItem>lambdaQuery()
                                .eq(JDWACartItem::getUserId, userId)
                                .in(JDWACartItem::getId, request.getCartItemIds()));
            }
            
            // 设置订单过期时间
            redisTemplate.opsForValue().set(
                    String.format("order:expire:%s", orderNo),
                    orderNo,
                    orderExpireMinutes,
                    TimeUnit.MINUTES);
            
            return orderNo;
        } catch (Exception e) {
            log.error("Create order failed: userId={}, error={}", userId, e.getMessage(), e);
            
            // 释放锁定的库存
            for (Map.Entry<Long, Integer> entry : prizeQuantityMap.entrySet()) {
                releasePrizeStock(entry.getKey(), entry.getValue());
            }
            
            throw e;
        }
    }
    
    /**
     * 生成订单号
     */
    private String generateOrderNo() {
        return "JD" + DateTimeFormatter.ofPattern("yyyyMMddHHmmss").format(LocalDateTime.now())
                + RandomStringUtils.randomNumeric(6);
    }
    
    /**
     * 生成虚拟奖品兑换码
     */
    private String generateVirtualCode(Long prizeId) {
        return "VC" + prizeId + DateTimeFormatter.ofPattern("yyyyMMdd").format(LocalDateTime.now())
                + RandomStringUtils.randomAlphanumeric(8).toUpperCase();
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean lockPrizeStock(Long prizeId, Integer quantity) {
        // 先用Redis分布式锁防止并发问题
        String lockKey = String.format("prize:stock:lock:%d", prizeId);
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
        
        if (Boolean.FALSE.equals(locked)) {
            log.warn("Failed to acquire Redis lock for stock: prizeId={}", prizeId);
            return false;
        }
        
        try {
            // 查询当前库存
            JDWAPrizeStock stock = stockMapper.selectOne(
                    Wrappers.<JDWAPrizeStock>lambdaQuery()
                            .eq(JDWAPrizeStock::getPrizeId, prizeId));
            
            if (stock == null || stock.getAvailableStock() < quantity) {
                log.error("Insufficient stock when locking: prizeId={}, required={}, available={}",
                        prizeId, quantity, stock != null ? stock.getAvailableStock() : 0);
                return false;
            }
            
            // 更新库存
            int updated = stockMapper.lockStock(prizeId, quantity);
            return updated > 0;
        } finally {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean releasePrizeStock(Long prizeId, Integer quantity) {
        // 先用Redis分布式锁防止并发问题
        String lockKey = String.format("prize:stock:lock:%d", prizeId);
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
        
        if (Boolean.FALSE.equals(locked)) {
            log.warn("Failed to acquire Redis lock for releasing stock: prizeId={}", prizeId);
            return false;
        }
        
        try {
            // 查询当前库存
            JDWAPrizeStock stock = stockMapper.selectOne(
                    Wrappers.<JDWAPrizeStock>lambdaQuery()
                            .eq(JDWAPrizeStock::getPrizeId, prizeId));
            
            if (stock == null) {
                log.error("Stock not found when releasing: prizeId={}", prizeId);
                return false;
            }
            
            // 更新库存
            int updated = stockMapper.releaseStock(prizeId, quantity);
            return updated > 0;
        } finally {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    }
    
    @Override
    public JDWAExchangeVerifyResult verifyExchangeQualification(Long prizeId, Integer quantity) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询奖品信息
        JDWAPrize prize = prizeMapper.selectById(prizeId);
        if (prize == null || prize.getStatus() != 1) {
            return new JDWAExchangeVerifyResult(false, "奖品不存在或已下架");
        }
        
        // 检查兑换时间
        LocalDateTime now = LocalDateTime.now();
        if (prize.getExchangeStart() != null && now.isBefore(prize.getExchangeStart())) {
            return new JDWAExchangeVerifyResult(false, "兑换尚未开始");
        }
        
        if (prize.getExchangeEnd() != null && now.isAfter(prize.getExchangeEnd())) {
            return new JDWAExchangeVerifyResult(false, "兑换已结束");
        }
        
        // 检查库存
        JDWAPrizeStock stock = stockMapper.selectOne(
                Wrappers.<JDWAPrizeStock>lambdaQuery()
                        .eq(JDWAPrizeStock::getPrizeId, prizeId));
        
        if (stock == null || stock.getAvailableStock() < quantity) {
            return new JDWAExchangeVerifyResult(false, "库存不足");
        }
        
        // 检查用户积分
        JDWAUserPoints userPoints = userPointsService.getUserPoints(userId);
        if (userPoints == null || userPoints.getAvailablePoints() < prize.getPointsPrice() * quantity) {
            return new JDWAExchangeVerifyResult(false, "积分不足");
        }
        
        // 检查每人兑换限制
        if (prize.getExchangeLimit() != null && prize.getExchangeLimit() > 0) {
            // 查询用户已兑换数量
            Integer exchangedCount = orderItemMapper.selectUserExchangedCount(userId, prizeId);
            if (exchangedCount != null && exchangedCount + quantity > prize.getExchangeLimit()) {
                return new JDWAExchangeVerifyResult(false, 
                        String.format("超出每人限兑%d个的限制", prize.getExchangeLimit()));
            }
        }
        
        // 检查兑换规则
        List<JDWAPrizeRule> rules = ruleMapper.selectList(
                Wrappers.<JDWAPrizeRule>lambdaQuery()
                        .eq(JDWAPrizeRule::getPrizeId, prizeId)
                        .eq(JDWAPrizeRule::getStatus, 1)
                        .le(JDWAPrizeRule::getStartTime, now)
                        .ge(JDWAPrizeRule::getEndTime, now)
                        .orderByDesc(JDWAPrizeRule::getPriority));
        
        if (!CollectionUtils.isEmpty(rules)) {
            // 检查资格限制类规则
            for (JDWAPrizeRule rule : rules) {
                if (JDWAPrizeConstants.RULE_TYPE_QUALIFICATION.equals(rule.getRuleType())) {
                    // 解析规则条件
                    try {
                        QualificationRule qualificationRule = 
                                JsonUtils.parseObject(rule.getRuleCondition(), QualificationRule.class);
                        
                        if (qualificationRule != null) {
                            // 根据规则类型进行检查
                            switch (qualificationRule.getQualificationType()) {
                                case "USER_LEVEL":
                                    // 检查用户等级
                                    JDWAUser user = userService.getUserById(userId);
                                    if (user == null || user.getUserLevel() < qualificationRule.getMinLevel()) {
                                        return new JDWAExchangeVerifyResult(false, 
                                                String.format("需要达到%d级才能兑换", qualificationRule.getMinLevel()));
                                    }
                                    break;
                                case "ACTIVITY_COUNT":
                                    // 检查活动参与次数
                                    Integer activityCount = 
                                            activityService.getUserActivityCount(userId, qualificationRule.getActivityType());
                                    if (activityCount < qualificationRule.getMinCount()) {
                                        return new JDWAExchangeVerifyResult(false, 
                                                String.format("需要参与%d次%s活动才能兑换", 
                                                        qualificationRule.getMinCount(), 
                                                        qualificationRule.getActivityTypeName()));
                                    }
                                    break;
                                case "ACHIEVEMENT":
                                    // 检查成就解锁
                                    boolean hasAchievement = 
                                            achievementService.hasAchievement(userId, qualificationRule.getAchievementCode());
                                    if (!hasAchievement) {
                                        return new JDWAExchangeVerifyResult(false, 
                                                String.format("需要解锁%s成就才能兑换", qualificationRule.getAchievementName()));
                                    }
                                    break;
                                default:
                                    log.warn("Unknown qualification type: {}", qualificationRule.getQualificationType());
                            }
                        }
                    } catch (Exception e) {
                        log.error("Failed to parse qualification rule: ruleId={}, error={}",
                                rule.getId(), e.getMessage(), e);
                    }
                }
            }
        }
        
        return new JDWAExchangeVerifyResult(true, "验证通过");
    }
    
    @Override
    public PageResult<JDWAExchangeOrderVO> getOrderList(String status, Integer pageNum, Integer pageSize) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 构建查询条件
        LambdaQueryWrapper<JDWAExchangeOrder> wrapper = Wrappers.<JDWAExchangeOrder>lambdaQuery()
                .eq(JDWAExchangeOrder::getUserId, userId)
                .eq(StringUtils.isNotEmpty(status), JDWAExchangeOrder::getStatus, status)
                .orderByDesc(JDWAExchangeOrder::getCreateTime);
        
        // 分页查询
        Page<JDWAExchangeOrder> page = new Page<>(pageNum, pageSize);
        Page<JDWAExchangeOrder> orderPage = orderMapper.selectPage(page, wrapper);
        
        List<JDWAExchangeOrder> orderList = orderPage.getRecords();
        if (CollectionUtils.isEmpty(orderList)) {
            return PageResult.empty();
        }
        
        // 获取订单ID列表
        List<Long> orderIds = orderList.stream()
                .map(JDWAExchangeOrder::getId)
                .collect(Collectors.toList());
        
        // 查询订单项
        List<JDWAExchangeOrderItem> itemList = orderItemMapper.selectList(
                Wrappers.<JDWAExchangeOrderItem>lambdaQuery()
                        .in(JDWAExchangeOrderItem::getOrderId, orderIds));
        
        // 按订单ID分组
        Map<Long, List<JDWAExchangeOrderItem>> itemMap = itemList.stream()
                .collect(Collectors.groupingBy(JDWAExchangeOrderItem::getOrderId));
        
        // 转换为VO对象
        List<JDWAExchangeOrderVO> voList = orderList.stream().map(order -> {
            JDWAExchangeOrderVO vo = new JDWAExchangeOrderVO();
            BeanUtils.copyProperties(order, vo);
            
            // 设置订单项信息
            List<JDWAExchangeOrderItem> items = itemMap.get(order.getId());
            if (!CollectionUtils.isEmpty(items)) {
                List<JDWAExchangeOrderItemVO> itemVOs = items.stream().map(item -> {
                    JDWAExchangeOrderItemVO itemVO = new JDWAExchangeOrderItemVO();
                    BeanUtils.copyProperties(item, itemVO);
                    return itemVO;
                }).collect(Collectors.toList());
                vo.setItems(itemVOs);
                
                // 设置首个商品图片作为订单展示图
                vo.setFirstPrizeImage(items.get(0).getPrizeImage());
            }
            
            return vo;
        }).collect(Collectors.toList());
        
        return new PageResult<>(voList, orderPage.getTotal(), pageNum, pageSize);
    }
    
    @Override
    public JDWAExchangeOrderDetailVO getOrderDetail(String orderNo) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询订单信息
        JDWAExchangeOrder order = orderMapper.selectOne(
                Wrappers.<JDWAExchangeOrder>lambdaQuery()
                        .eq(JDWAExchangeOrder::getOrderNo, orderNo)
                        .eq(JDWAExchangeOrder::getUserId, userId));
        
        if (order == null) {
            return null;
        }
        
        // 查询订单项
        List<JDWAExchangeOrderItem> items = orderItemMapper.selectList(
                Wrappers.<JDWAExchangeOrderItem>lambdaQuery()
                        .eq(JDWAExchangeOrderItem::getOrderId, order.getId()));
        
        // 查询物流信息
        JDWALogisticsInfo logistics = null;
        if (JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(order.getOrderType())
                || JDWAPrizeConstants.PRIZE_TYPE_MIXED.equals(order.getOrderType())) {
            logistics = logisticsInfoMapper.selectOne(
                    Wrappers.<JDWALogisticsInfo>lambdaQuery()
                            .eq(JDWALogisticsInfo::getOrderId, order.getId()));
        }
        
        // 转换为VO对象
        JDWAExchangeOrderDetailVO detailVO = new JDWAExchangeOrderDetailVO();
        BeanUtils.copyProperties(order, detailVO);
        
        // 设置订单项信息
        if (!CollectionUtils.isEmpty(items)) {
            List<JDWAExchangeOrderItemVO> itemVOs = items.stream().map(item -> {
                JDWAExchangeOrderItemVO itemVO = new JDWAExchangeOrderItemVO();
                BeanUtils.copyProperties(item, itemVO);
                return itemVO;
            }).collect(Collectors.toList());
            detailVO.setItems(itemVOs);
        }
        
        // 设置物流信息
        if (logistics != null) {
            JDWALogisticsInfoVO logisticsVO = new JDWALogisticsInfoVO();
            BeanUtils.copyProperties(logistics, logisticsVO);
            detailVO.setLogistics(logisticsVO);
        }
        
        return detailVO;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean cancelOrder(String orderNo, String reason) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询订单信息
        JDWAExchangeOrder order = orderMapper.selectOne(
                Wrappers.<JDWAExchangeOrder>lambdaQuery()
                        .eq(JDWAExchangeOrder::getOrderNo, orderNo)
                        .eq(JDWAExchangeOrder::getUserId, userId));
        
        if (order == null) {
            log.error("Order not found for cancellation: orderNo={}", orderNo);
            return false;
        }
        
        // 检查订单状态
        if (JDWAPrizeConstants.ORDER_TYPE_PHYSICAL.equals(order.getOrderType())
                || JDWAPrizeConstants.ORDER_TYPE_MIXED.equals(order.getOrderType())) {
            // 实物订单只有待处理和已确认状态可以取消
            if (!JDWAPrizeConstants.ORDER_STATUS_PENDING.equals(order.getStatus())
                    && !JDWAPrizeConstants.ORDER_STATUS_CONFIRMED.equals(order.getStatus())) {
                log.error("Cannot cancel order with status: orderNo={}, status={}", 
                        orderNo, order.getStatus());
                return false;
            }
        } else {
            // 虚拟订单只有待处理和处理中状态可以取消
            if (!JDWAPrizeConstants.VIRTUAL_STATUS_PENDING.equals(order.getStatus())
                    && !JDWAPrizeConstants.VIRTUAL_STATUS_PROCESSING.equals(order.getStatus())) {
                log.error("Cannot cancel virtual order with status: orderNo={}, status={}", 
                        orderNo, order.getStatus());
                return false;
            }
        }
        
        // 查询订单项
        List<JDWAExchangeOrderItem> items = orderItemMapper.selectList(
                Wrappers.<JDWAExchangeOrderItem>lambdaQuery()
                        .eq(JDWAExchangeOrderItem::getOrderId, order.getId()));
        
        if (CollectionUtils.isEmpty(items)) {
            log.error("No order items found: orderNo={}", orderNo);
            return false;
        }
        
        // 更新订单状态
        order.setStatus(JDWAPrizeConstants.ORDER_STATUS_CANCELLED);
        order.setCancelReason(reason);
        order.setCancelTime(LocalDateTime.now());
        order.setUpdateTime(LocalDateTime.now());
        
        orderMapper.updateById(order);
        
        // 更新订单项状态
        for (JDWAExchangeOrderItem item : items) {
            if (JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(item.getPrizeType())) {
                item.setStatus(JDWAPrizeConstants.ORDER_STATUS_CANCELLED);
            } else {
                item.setStatus(JDWAPrizeConstants.VIRTUAL_STATUS_CANCELLED);
            }
            
            item.setUpdateTime(LocalDateTime.now());
            orderItemMapper.updateById(item);
            
            // 释放库存
            releasePrizeStock(item.getPrizeId(), item.getQuantity());
        }
        
        // 退还积分
        if (order.getTotalPoints() > 0) {
            userPointsService.refundPoints(
                    userId, order.getTotalPoints(), order.getOrderNo(), "取消订单退还积分");
        }
        
        return true;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean confirmReceive(String orderNo) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询订单信息
        JDWAExchangeOrder order = orderMapper.selectOne(
                Wrappers.<JDWAExchangeOrder>lambdaQuery()
                        .eq(JDWAExchangeOrder::getOrderNo, orderNo)
                        .eq(JDWAExchangeOrder::getUserId, userId));
        
        if (order == null) {
            log.error("Order not found for confirmation: orderNo={}", orderNo);
            return false;
        }
        
        // 检查订单状态，只有已发货状态可以确认收货
        if (!JDWAPrizeConstants.ORDER_STATUS_SHIPPED.equals(order.getStatus())) {
            log.error("Cannot confirm receipt for order with status: orderNo={}, status={}", 
                    orderNo, order.getStatus());
            return false;
        }
        
        // 更新订单状态
        order.setStatus(JDWAPrizeConstants.ORDER_STATUS_RECEIVED);
        order.setReceiveTime(LocalDateTime.now());
        order.setUpdateTime(LocalDateTime.now());
        
        // 设置完成时间
        order.setCompletionTime(LocalDateTime.now());
        order.setStatus(JDWAPrizeConstants.ORDER_STATUS_COMPLETED);
        
        orderMapper.updateById(order);
        
        // 更新订单项状态
        List<JDWAExchangeOrderItem> items = orderItemMapper.selectList(
                Wrappers.<JDWAExchangeOrderItem>lambdaQuery()
                        .eq(JDWAExchangeOrderItem::getOrderId, order.getId()));
        
        if (!CollectionUtils.isEmpty(items)) {
            for (JDWAExchangeOrderItem item : items) {
                if (JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(item.getPrizeType())) {
                    item.setStatus(JDWAPrizeConstants.ORDER_STATUS_COMPLETED);
                }
                
                item.setUpdateTime(LocalDateTime.now());
                orderItemMapper.updateById(item);
            }
        }
        
        // 更新物流信息
        JDWALogisticsInfo logistics = logisticsInfoMapper.selectOne(
                Wrappers.<JDWALogisticsInfo>lambdaQuery()
                        .eq(JDWALogisticsInfo::getOrderId, order.getId()));
        
        if (logistics != null) {
            logistics.setStatus("DELIVERED");
            logistics.setActualDelivery(LocalDateTime.now());
            logistics.setUpdateTime(LocalDateTime.now());
            logisticsInfoMapper.updateById(logistics);
        }
        
        return true;
    }
    
    @Override
    public JDWALogisticsInfoVO getLogisticsInfo(String orderNo) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询订单信息
        JDWAExchangeOrder order = orderMapper.selectOne(
                Wrappers.<JDWAExchangeOrder>lambdaQuery()
                        .eq(JDWAExchangeOrder::getOrderNo, orderNo)
                        .eq(JDWAExchangeOrder::getUserId, userId));
        
        if (order == null) {
            log.error("Order not found for logistics query: orderNo={}", orderNo);
            return null;
        }
        
        // 检查订单类型，只有实物或混合订单才有物流信息
        if (!JDWAPrizeConstants.ORDER_TYPE_PHYSICAL.equals(order.getOrderType())
                && !JDWAPrizeConstants.ORDER_TYPE_MIXED.equals(order.getOrderType())) {
            log.error("Not a physical order: orderNo={}, type={}", orderNo, order.getOrderType());
            return null;
        }
        
        // 查询物流信息
        JDWALogisticsInfo logistics = logisticsInfoMapper.selectOne(
                Wrappers.<JDWALogisticsInfo>lambdaQuery()
                        .eq(JDWALogisticsInfo::getOrderId, order.getId()));
        
        if (logistics == null) {
            return null;
        }
        
        // 转换为VO对象
        JDWALogisticsInfoVO logisticsVO = new JDWALogisticsInfoVO();
        BeanUtils.copyProperties(logistics, logisticsVO);
        
        // 补充订单信息
        logisticsVO.setOrderNo(order.getOrderNo());
        logisticsVO.setOrderStatus(order.getStatus());
        
        // 解析跟踪信息
        if (StringUtils.isNotEmpty(logistics.getTrackingInfo())) {
            try {
                List<JDWALogisticsTrackingVO> trackingList = 
                        JsonUtils.parseArray(logistics.getTrackingInfo(), JDWALogisticsTrackingVO.class);
                logisticsVO.setTrackingList(trackingList);
            } catch (Exception e) {
                log.error("Failed to parse tracking info: logisticsId={}, error={}", 
                        logistics.getId(), e.getMessage(), e);
            }
        }
        
        return logisticsVO;
    }
    
    @Override
    public JDWAVirtualPrizeVO activateVirtualPrize(Long orderItemId) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询订单项
        JDWAExchangeOrderItem orderItem = orderItemMapper.selectOne(
                Wrappers.<JDWAExchangeOrderItem>lambdaQuery()
                        .eq(JDWAExchangeOrderItem::getId, orderItemId)
                        .eq(JDWAExchangeOrderItem::getUserId, userId));
        
        if (orderItem == null) {
            log.error("Order item not found for activation: orderItemId={}", orderItemId);
            return null;
        }
        
        // 检查订单项类型和状态
        if (JDWAPrizeConstants.PRIZE_TYPE_PHYSICAL.equals(orderItem.getPrizeType())) {
            log.error("Cannot activate physical prize: orderItemId={}", orderItemId);
            return null;
        }
        
        if (!JDWAPrizeConstants.VIRTUAL_STATUS_DELIVERED.equals(orderItem.getStatus())) {
            log.error("Cannot activate prize with status: orderItemId={}, status={}", 
                    orderItemId, orderItem.getStatus());
            return null;
        }
        
        // 检查是否已过期
        if (orderItem.getExpireTime() != null && LocalDateTime.now().isAfter(orderItem.getExpireTime())) {
            log.error("Virtual prize has expired: orderItemId={}, expireTime={}", 
                    orderItemId, orderItem.getExpireTime());
            return null;
        }
        
        // 更新状态为已使用
        orderItem.setStatus(JDWAPrizeConstants.VIRTUAL_STATUS_USED);
        orderItem.setUpdateTime(LocalDateTime.now());
        orderItemMapper.updateById(orderItem);
        
        // 构建虚拟奖品信息
        JDWAVirtualPrizeVO vo = new JDWAVirtualPrizeVO();
        vo.setOrderItemId(orderItem.getId());
        vo.setOrderNo(orderItem.getOrderNo());
        vo.setPrizeId(orderItem.getPrizeId());
        vo.setPrizeCode(orderItem.getPrizeCode());
        vo.setPrizeName(orderItem.getPrizeName());
        vo.setPrizeType(orderItem.getPrizeType());
        vo.setVirtualCode(orderItem.getVirtualCode());
        
        // 解析虚拟商品信息
        if (StringUtils.isNotEmpty(orderItem.getVirtualInfo())) {
            try {
                Map<String, Object> virtualInfo = 
                        JsonUtils.parseObject(orderItem.getVirtualInfo(), new TypeReference<Map<String, Object>>() {});
                vo.setVirtualInfo(virtualInfo);
            } catch (Exception e) {
                log.error("Failed to parse virtual info: orderItemId={}, error={}", 
                        orderItemId, e.getMessage(), e);
            }
        }
        
        vo.setExpireTime(orderItem.getExpireTime());
        vo.setStatus(orderItem.getStatus());
        
        return vo;
    }
    
    @Override
    public List<JDWAAddressVO> getUserAddresses() {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询用户地址
        List<JDWAAddress> addresses = addressMapper.selectList(
                Wrappers.<JDWAAddress>lambdaQuery()
                        .eq(JDWAAddress::getUserId, userId)
                        .eq(JDWAAddress::getIsDeleted, 0)
                        .orderByDesc(JDWAAddress::getIsDefault)
                        .orderByDesc(JDWAAddress::getUpdateTime));
        
        if (CollectionUtils.isEmpty(addresses)) {
            return Collections.emptyList();
        }
        
        // 转换为VO对象
        return addresses.stream().map(address -> {
            JDWAAddressVO vo = new JDWAAddressVO();
            BeanUtils.copyProperties(address, vo);
            return vo;
        }).collect(Collectors.toList());
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long addAddress(JDWAAddressVO addressVO) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 检查用户地址数量
        Integer addressCount = addressMapper.selectCount(
                Wrappers.<JDWAAddress>lambdaQuery()
                        .eq(JDWAAddress::getUserId, userId)
                        .eq(JDWAAddress::getIsDeleted, 0));
        
        if (addressCount >= 20) {
            log.error("Too many addresses: userId={}, count={}", userId, addressCount);
            return null;
        }
        
        // 创建地址
        JDWAAddress address = new JDWAAddress();
        BeanUtils.copyProperties(addressVO, address);
        address.setUserId(userId);
        
        // 如果是第一个地址，设为默认
        if (addressCount == 0) {
            address.setIsDefault(1);
        } else if (addressVO.getIsDefault() != null && addressVO.getIsDefault() == 1) {
            // 如果设为默认，先取消其他默认地址
            addressMapper.update(null, 
                    Wrappers.<JDWAAddress>lambdaUpdate()
                            .eq(JDWAAddress::getUserId, userId)
                            .eq(JDWAAddress::getIsDefault, 1)
                            .set(JDWAAddress::getIsDefault, 0));
        }
        
        address.setCreateTime(LocalDateTime.now());
        address.setUpdateTime(LocalDateTime.now());
        
        addressMapper.insert(address);
        
        return address.getId();
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateAddress(JDWAAddressVO addressVO) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询地址是否存在
        JDWAAddress existingAddress = addressMapper.selectOne(
                Wrappers.<JDWAAddress>lambdaQuery()
                        .eq(JDWAAddress::getId, addressVO.getId())
                        .eq(JDWAAddress::getUserId, userId)
                        .eq(JDWAAddress::getIsDeleted, 0));
        
        if (existingAddress == null) {
            log.error("Address not found for update: addressId={}", addressVO.getId());
            return false;
        }
        
        // 更新地址
        JDWAAddress address = new JDWAAddress();
        BeanUtils.copyProperties(addressVO, address);
        address.setUserId(userId);
        address.setUpdateTime(LocalDateTime.now());
        
        // 如果设为默认，先取消其他默认地址
        if (addressVO.getIsDefault() != null && addressVO.getIsDefault() == 1 
                && existingAddress.getIsDefault() != 1) {
            addressMapper.update(null, 
                    Wrappers.<JDWAAddress>lambdaUpdate()
                            .eq(JDWAAddress::getUserId, userId)
                            .eq(JDWAAddress::getIsDefault, 1)
                            .set(JDWAAddress::getIsDefault, 0));
        }
        
        addressMapper.updateById(address);
        
        return true;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteAddress(Long addressId) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询地址是否存在
        JDWAAddress existingAddress = addressMapper.selectOne(
                Wrappers.<JDWAAddress>lambdaQuery()
                        .eq(JDWAAddress::getId, addressId)
                        .eq(JDWAAddress::getUserId, userId)
                        .eq(JDWAAddress::getIsDeleted, 0));
        
        if (existingAddress == null) {
            log.error("Address not found for deletion: addressId={}", addressId);
            return false;
        }
        
        // 逻辑删除地址
        existingAddress.setIsDeleted(1);
        existingAddress.setUpdateTime(LocalDateTime.now());
        
        addressMapper.updateById(existingAddress);
        
        // 如果删除的是默认地址，设置最新的地址为默认
        if (existingAddress.getIsDefault() == 1) {
            JDWAAddress newestAddress = addressMapper.selectOne(
                    Wrappers.<JDWAAddress>lambdaQuery()
                            .eq(JDWAAddress::getUserId, userId)
                            .eq(JDWAAddress::getIsDeleted, 0)
                            .orderByDesc(JDWAAddress::getUpdateTime)
                            .last("LIMIT 1"));
            
            if (newestAddress != null) {
                newestAddress.setIsDefault(1);
                newestAddress.setUpdateTime(LocalDateTime.now());
                addressMapper.updateById(newestAddress);
            }
        }
        
        return true;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean setDefaultAddress(Long addressId) {
        // 获取当前登录用户
        Long userId = JDWASecurityUtil.getCurrentUserId();
        
        // 查询地址是否存在
        JDWAAddress existingAddress = addressMapper.selectOne(
                Wrappers.<JDWAAddress>lambdaQuery()
                        .eq(JDWAAddress::getId, addressId)
                        .eq(JDWAAddress::getUserId, userId)
                        .eq(JDWAAddress::getIsDeleted, 0));
        
        if (existingAddress == null) {
            log.error("Address not found for setting default: addressId={}", addressId);
            return false;
        }
        
        // 如果已经是默认地址，不需要操作
        if (existingAddress.getIsDefault() == 1) {
            return true;
        }
        
        // 取消其他默认地址
        addressMapper.update(null, 
                Wrappers.<JDWAAddress>lambdaUpdate()
                        .eq(JDWAAddress::getUserId, userId)
                        .eq(JDWAAddress::getIsDefault, 1)
                        .set(JDWAAddress::getIsDefault, 0));
        
        // 设置为默认地址
        existingAddress.setIsDefault(1);
        existingAddress.setUpdateTime(LocalDateTime.now());
        
        addressMapper.updateById(existingAddress);
        
        return true;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deductUserPoints(Long userId, Integer points, String orderNo, String description) {
        // 调用积分服务扣减用户积分
        return userPointsService.deductPoints(userId, points, "EXCHANGE", orderNo, description);
    }
}