// src/models/users.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const users = sequelizeClient.define('users', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    // 基本信息
    email: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: { isEmail: true }
    },
    
    phone: {
      type: DataTypes.STRING,
      unique: true,
      validate: {
        is: /^1[3-9]\d{9}$/
      }
    },
    
    password: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    nickname: DataTypes.STRING,
    avatar: DataTypes.STRING,
    gender: {
      type: DataTypes.ENUM('male', 'female', 'unknown'),
      defaultValue: 'unknown'
    },
    
    birthDate: {
      type: DataTypes.DATEONLY,
      field: 'birth_date'
    },
    
    // 用户等级和积分
    level: {
      type: DataTypes.INTEGER,
      defaultValue: 1
    },
    
    points: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },
    
    totalSpent: {
      type: DataTypes.DECIMAL(10, 2),
      defaultValue: 0,
      field: 'total_spent'
    },
    
    // 状态
    status: {
      type: DataTypes.ENUM('active', 'inactive', 'banned'),
      defaultValue: 'active'
    },
    
    emailVerified: {
      type: DataTypes.BOOLEAN,
      defaultValue: false,
      field: 'email_verified'
    },
    
    phoneVerified: {
      type: DataTypes.BOOLEAN,
      defaultValue: false,
      field: 'phone_verified'
    },
    
    // 偏好设置
    preferences: {
      type: DataTypes.JSON,
      defaultValue: {
        notifications: {
          order: true,
          promotion: true,
          system: true
        },
        privacy: {
          showProfile: true,
          showPurchaseHistory: false
        }
      }
    },
    
    lastLoginAt: {
      type: DataTypes.DATE,
      field: 'last_login_at'
    }
  }, {
    tableName: 'users',
    timestamps: true,
    underscored: true,
    
    indexes: [
      { fields: ['email'] },
      { fields: ['phone'] },
      { fields: ['status'] },
      { fields: ['level'] }
    ]
  });

  users.associate = function(models) {
    // 用户地址
    users.hasMany(models.userAddresses, {
      foreignKey: 'userId',
      as: 'addresses'
    });
    
    // 用户订单
    users.hasMany(models.orders, {
      foreignKey: 'userId',
      as: 'orders'
    });
    
    // 购物车
    users.hasMany(models.cartItems, {
      foreignKey: 'userId',
      as: 'cartItems'
    });
    
    // 商品收藏
    users.belongsToMany(models.products, {
      through: 'user_favorites',
      foreignKey: 'userId',
      otherKey: 'productId',
      as: 'favorites'
    });
  };

  return users;
};

// src/models/user-addresses.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const userAddresses = sequelizeClient.define('userAddresses', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    userId: {
      type: DataTypes.UUID,
      allowNull: false,
      field: 'user_id'
    },
    
    name: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    phone: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    province: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    city: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    district: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    address: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    postalCode: {
      type: DataTypes.STRING,
      field: 'postal_code'
    },
    
    isDefault: {
      type: DataTypes.BOOLEAN,
      defaultValue: false,
      field: 'is_default'
    }
  }, {
    tableName: 'user_addresses',
    timestamps: true,
    underscored: true,
    
    indexes: [
      { fields: ['user_id'] },
      { fields: ['is_default'] }
    ]
  });

  userAddresses.associate = function(models) {
    userAddresses.belongsTo(models.users, {
      foreignKey: 'userId',
      as: 'user'
    });
  };

  return userAddresses;
};

// src/models/categories.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const categories = sequelizeClient.define('categories', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    name: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    slug: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true
    },
    
    description: DataTypes.TEXT,
    image: DataTypes.STRING,
    icon: DataTypes.STRING,
    
    // 层级结构
    parentId: {
      type: DataTypes.UUID,
      field: 'parent_id'
    },
    
    level: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },
    
    path: DataTypes.STRING,
    
    // 排序和状态
    sortOrder: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'sort_order'
    },
    
    isActive: {
      type: DataTypes.BOOLEAN,
      defaultValue: true,
      field: 'is_active'
    },
    
    // 统计
    productsCount: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'products_count'
    }
  }, {
    tableName: 'categories',
    timestamps: true,
    underscored: true
  });

  categories.associate = function(models) {
    // 分类商品
    categories.hasMany(models.products, {
      foreignKey: 'categoryId',
      as: 'products'
    });
    
    // 自关联
    categories.hasMany(categories, {
      foreignKey: 'parentId',
      as: 'children'
    });
    
    categories.belongsTo(categories, {
      foreignKey: 'parentId',
      as: 'parent'
    });
  };

  return categories;
};

// src/models/products.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const products = sequelizeClient.define('products', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    // 基本信息
    name: {
      type: DataTypes.STRING,
      allowNull: false
    },
    
    slug: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true
    },
    
    description: DataTypes.TEXT,
    shortDescription: {
      type: DataTypes.TEXT,
      field: 'short_description'
    },
    
    // 分类
    categoryId: {
      type: DataTypes.UUID,
      allowNull: false,
      field: 'category_id'
    },
    
    // 品牌
    brand: DataTypes.STRING,
    model: DataTypes.STRING,
    
    // 价格
    price: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false
    },
    
    originalPrice: {
      type: DataTypes.DECIMAL(10, 2),
      field: 'original_price'
    },
    
    costPrice: {
      type: DataTypes.DECIMAL(10, 2),
      field: 'cost_price'
    },
    
    // 库存
    stock: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },
    
    minStock: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'min_stock'
    },
    
    maxStock: {
      type: DataTypes.INTEGER,
      field: 'max_stock'
    },
    
    // 规格属性
    attributes: {
      type: DataTypes.JSON,
      defaultValue: {}
    },
    
    // 媒体
    images: {
      type: DataTypes.JSON,
      defaultValue: []
    },
    
    videos: {
      type: DataTypes.JSON,
      defaultValue: []
    },
    
    // 重量和尺寸
    weight: DataTypes.DECIMAL(8, 2),
    length: DataTypes.DECIMAL(8, 2),
    width: DataTypes.DECIMAL(8, 2),
    height: DataTypes.DECIMAL(8, 2),
    
    // 状态
    status: {
      type: DataTypes.ENUM('active', 'inactive', 'out_of_stock'),
      defaultValue: 'active'
    },
    
    isFeatured: {
      type: DataTypes.BOOLEAN,
      defaultValue: false,
      field: 'is_featured'
    },
    
    isDigital: {
      type: DataTypes.BOOLEAN,
      defaultValue: false,
      field: 'is_digital'
    },
    
    // SEO
    metaTitle: {
      type: DataTypes.STRING,
      field: 'meta_title'
    },
    
    metaDescription: {
      type: DataTypes.TEXT,
      field: 'meta_description'
    },
    
    metaKeywords: {
      type: DataTypes.JSON,
      field: 'meta_keywords',
      defaultValue: []
    },
    
    // 统计
    viewCount: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'view_count'
    },
    
    salesCount: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'sales_count'
    },
    
    favoriteCount: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'favorite_count'
    },
    
    rating: {
      type: DataTypes.DECIMAL(3, 2),
      defaultValue: 0
    },
    
    reviewCount: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'review_count'
    }
  }, {
    tableName: 'products',
    timestamps: true,
    underscored: true,
    
    indexes: [
      { fields: ['category_id'] },
      { fields: ['slug'] },
      { fields: ['status'] },
      { fields: ['is_featured'] },
      { fields: ['price'] },
      { fields: ['stock'] },
      { fields: ['brand'] }
    ]
  });

  products.associate = function(models) {
    // 商品分类
    products.belongsTo(models.categories, {
      foreignKey: 'categoryId',
      as: 'category'
    });
    
    // 商品变体
    products.hasMany(models.productVariants, {
      foreignKey: 'productId',
      as: 'variants'
    });
    
    // 商品评价
    products.hasMany(models.productReviews, {
      foreignKey: 'productId',
      as: 'reviews'
    });
    
    // 购物车项目
    products.hasMany(models.cartItems, {
      foreignKey: 'productId',
      as: 'cartItems'
    });
    
    // 订单项目
    products.hasMany(models.orderItems, {
      foreignKey: 'productId',
      as: 'orderItems'
    });
  };

  return products;
};

// src/models/product-variants.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const productVariants = sequelizeClient.define('productVariants', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    productId: {
      type: DataTypes.UUID,
      allowNull: false,
      field: 'product_id'
    },
    
    sku: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true
    },
    
    name: DataTypes.STRING,
    
    // 变体属性（如：颜色、尺寸等）
    attributes: {
      type: DataTypes.JSON,
      allowNull: false
    },
    
    // 价格（可以覆盖主商品价格）
    price: DataTypes.DECIMAL(10, 2),
    originalPrice: {
      type: DataTypes.DECIMAL(10, 2),
      field: 'original_price'
    },
    
    // 库存
    stock: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },
    
    // 媒体
    images: {
      type: DataTypes.JSON,
      defaultValue: []
    },
    
    // 重量和尺寸（可以覆盖主商品）
    weight: DataTypes.DECIMAL(8, 2),
    length: DataTypes.DECIMAL(8, 2),
    width: DataTypes.DECIMAL(8, 2),
    height: DataTypes.DECIMAL(8, 2),
    
    // 状态
    isActive: {
      type: DataTypes.BOOLEAN,
      defaultValue: true,
      field: 'is_active'
    },
    
    sortOrder: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'sort_order'
    }
  }, {
    tableName: 'product_variants',
    timestamps: true,
    underscored: true,
    
    indexes: [
      { fields: ['product_id'] },
      { fields: ['sku'] },
      { fields: ['is_active'] }
    ]
  });

  productVariants.associate = function(models) {
    productVariants.belongsTo(models.products, {
      foreignKey: 'productId',
      as: 'product'
    });
  };

  return productVariants;
};

// src/models/orders.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const orders = sequelizeClient.define('orders', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    // 订单号
    orderNumber: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      field: 'order_number'
    },
    
    // 用户信息
    userId: {
      type: DataTypes.UUID,
      allowNull: false,
      field: 'user_id'
    },
    
    // 收货信息
    shippingAddress: {
      type: DataTypes.JSON,
      allowNull: false,
      field: 'shipping_address'
    },
    
    billingAddress: {
      type: DataTypes.JSON,
      field: 'billing_address'
    },
    
    // 金额信息
    subtotal: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false
    },
    
    shippingFee: {
      type: DataTypes.DECIMAL(10, 2),
      defaultValue: 0,
      field: 'shipping_fee'
    },
    
    taxAmount: {
      type: DataTypes.DECIMAL(10, 2),
      defaultValue: 0,
      field: 'tax_amount'
    },
    
    discountAmount: {
      type: DataTypes.DECIMAL(10, 2),
      defaultValue: 0,
      field: 'discount_amount'
    },
    
    totalAmount: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false,
      field: 'total_amount'
    },
    
    // 优惠券
    couponId: {
      type: DataTypes.UUID,
      field: 'coupon_id'
    },
    
    couponDiscount: {
      type: DataTypes.DECIMAL(10, 2),
      defaultValue: 0,
      field: 'coupon_discount'
    },
    
    // 积分
    pointsUsed: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'points_used'
    },
    
    pointsEarned: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'points_earned'
    },
    
    // 状态
    status: {
      type: DataTypes.ENUM(
        'pending',      // 待付款
        'paid',         // 已付款
        'processing',   // 处理中
        'shipped',      // 已发货
        'delivered',    // 已送达
        'completed',    // 已完成
        'cancelled',    // 已取消
        'refunded'      // 已退款
      ),
      defaultValue: 'pending'
    },
    
    paymentStatus: {
      type: DataTypes.ENUM('pending', 'paid', 'failed', 'refunded'),
      defaultValue: 'pending',
      field: 'payment_status'
    },
    
    shippingStatus: {
      type: DataTypes.ENUM('pending', 'processing', 'shipped', 'delivered'),
      defaultValue: 'pending',
      field: 'shipping_status'
    },
    
    // 时间信息
    paidAt: {
      type: DataTypes.DATE,
      field: 'paid_at'
    },
    
    shippedAt: {
      type: DataTypes.DATE,
      field: 'shipped_at'
    },
    
    deliveredAt: {
      type: DataTypes.DATE,
      field: 'delivered_at'
    },
    
    // 备注
    notes: DataTypes.TEXT,
    adminNotes: {
      type: DataTypes.TEXT,
      field: 'admin_notes'
    },
    
    // 物流信息
    shippingMethod: {
      type: DataTypes.STRING,
      field: 'shipping_method'
    },
    
    trackingNumber: {
      type: DataTypes.STRING,
      field: 'tracking_number'
    },
    
    // 发票信息
    invoiceRequired: {
      type: DataTypes.BOOLEAN,
      defaultValue: false,
      field: 'invoice_required'
    },
    
    invoiceInfo: {
      type: DataTypes.JSON,
      field: 'invoice_info'
    }
  }, {
    tableName: 'orders',
    timestamps: true,
    underscored: true,
    
    indexes: [
      { fields: ['user_id'] },
      { fields: ['order_number'] },
      { fields: ['status'] },
      { fields: ['payment_status'] },
      { fields: ['created_at'] }
    ]
  });

  orders.associate = function(models) {
    // 订单用户
    orders.belongsTo(models.users, {
      foreignKey: 'userId',
      as: 'user'
    });
    
    // 订单项目
    orders.hasMany(models.orderItems, {
      foreignKey: 'orderId',
      as: 'items'
    });
    
    // 支付记录
    orders.hasMany(models.payments, {
      foreignKey: 'orderId',
      as: 'payments'
    });
    
    // 退款记录
    orders.hasMany(models.refunds, {
      foreignKey: 'orderId',
      as: 'refunds'
    });
    
    // 优惠券
    orders.belongsTo(models.coupons, {
      foreignKey: 'couponId',
      as: 'coupon'
    });
  };

  // 实例方法
  orders.prototype.canCancel = function() {
    return ['pending', 'paid'].includes(this.status);
  };

  orders.prototype.canRefund = function() {
    return ['paid', 'processing', 'shipped', 'delivered'].includes(this.status);
  };

  orders.prototype.getTotalWeight = async function() {
    const items = await this.getItems({
      include: ['product', 'variant']
    });
    
    return items.reduce((total, item) => {
      const weight = item.variant?.weight || item.product.weight || 0;
      return total + (weight * item.quantity);
    }, 0);
  };

  // 类方法
  orders.generateOrderNumber = function() {
    const now = new Date();
    const year = now.getFullYear().toString().slice(-2);
    const month = (now.getMonth() + 1).toString().padStart(2, '0');
    const day = now.getDate().toString().padStart(2, '0');
    const random = Math.random().toString(36).substr(2, 6).toUpperCase();
    
    return `\${year}\${month}\${day}\${random}`;
  };

  return orders;
};

// src/models/order-items.model.js
module.exports = function (app) {
  const sequelizeClient = app.get('sequelizeClient');
  const { DataTypes } = require('sequelize');
  
  const orderItems = sequelizeClient.define('orderItems', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true
    },
    
    orderId: {
      type: DataTypes.UUID,
      allowNull: false,
      field: 'order_id'
    },
    
    productId: {
      type: DataTypes.UUID,
      allowNull: false,
      field: 'product_id'
    },
    
    variantId: {
      type: DataTypes.UUID,
      field: 'variant_id'
    },
    
    // 商品信息快照
    productName: {
      type: DataTypes.STRING,
      allowNull: false,
      field: 'product_name'
    },
    
    productImage: {
      type: DataTypes.STRING,
      field: 'product_image'
    },
    
    variantAttributes: {
      type: DataTypes.JSON,
      field: 'variant_attributes'
    },
    
    // 价格和数量
    price: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false
    },
    
    quantity: {
      type: DataTypes.INTEGER,
      allowNull: false
    },
    
    total: {
      type: DataTypes.DECIMAL(10, 2),
      allowNull: false
    },
    
    // 退款状态
    refundStatus: {
      type: DataTypes.ENUM('none', 'partial', 'full'),
      defaultValue: 'none',
      field: 'refund_status'
    },
    
    refundedQuantity: {
      type: DataTypes.INTEGER,
      defaultValue: 0,
      field: 'refunded_quantity'
    },
    
    refundedAmount: {
      type: DataTypes.DECIMAL(10, 2),
      defaultValue: 0,
      field: 'refunded_amount'
    }
  }, {
    tableName: 'order_items',
    timestamps: true,
    underscored: true,
    
    indexes: [
      { fields: ['order_id'] },
      { fields: ['product_id'] },
      { fields: ['variant_id'] }
    ]
  });

  orderItems.associate = function(models) {
    orderItems.belongsTo(models.orders, {
      foreignKey: 'orderId',
      as: 'order'
    });
    
    orderItems.belongsTo(models.products, {
      foreignKey: 'productId',
      as: 'product'
    });
    
    orderItems.belongsTo(models.productVariants, {
      foreignKey: 'variantId',
      as: 'variant'
    });
  };

  return orderItems;
};

// src/services/cart/cart.class.js
const { Service } = require('feathers-sequelize');

class CartService extends Service {
  constructor(options, app) {
    super(options, app);
    this.app = app;
  }

  // 添加商品到购物车
  async addToCart(data, params) {
    const { user } = params;
    const { productId, variantId, quantity = 1 } = data;

    return this.Model.sequelize.transaction(async (t) => {
      // 检查商品和变体
      const product = await this.app.service('products').get(productId, {
        query: { $populate: ['variants'] },
        transaction: t
      });

      if (product.status !== 'active') {
        throw new Error('商品已下架');
      }

      let variant = null;
      let availableStock = product.stock;
      let price = product.price;

      if (variantId) {
        variant = product.variants.find(v => v.id === variantId);
        if (!variant || !variant.isActive) {
          throw new Error('商品规格不存在或已下架');
        }
        availableStock = variant.stock;
        price = variant.price || product.price;
      }

      if (availableStock < quantity) {
        throw new Error('库存不足');
      }

      // 检查购物车中是否已有相同商品
      const existingItem = await this.Model.findOne({
        where: {
          userId: user.id,
          productId,
          variantId: variantId || null
        },
        transaction: t
      });

      if (existingItem) {
        // 更新数量
        const newQuantity = existingItem.quantity + quantity;
        if (newQuantity > availableStock) {
          throw new Error('库存不足');
        }

        return existingItem.update({
          quantity: newQuantity,
          total: price * newQuantity
        }, { transaction: t });
      } else {
        // 创建新的购物车项目
        return this.Model.create({
          userId: user.id,
          productId,
          variantId,
          quantity,
          price,
          total: price * quantity
        }, { transaction: t });
      }
    });
  }

  // 更新购物车项目
  async updateCartItem(id, data, params) {
    const { user } = params;
    const { quantity } = data;

    return this.Model.sequelize.transaction(async (t) => {
      const cartItem = await this.Model.findOne({
        where: { id, userId: user.id },
        include: ['product', 'variant'],
        transaction: t
      });

      if (!cartItem) {
        throw new Error('购物车项目不存在');
      }

      // 检查库存
      const availableStock = cartItem.variant?.stock || cartItem.product.stock;
      if (quantity > availableStock) {
        throw new Error('库存不足');
      }

      const price = cartItem.variant?.price || cartItem.product.price;
      
      return cartItem.update({
        quantity,
        total: price * quantity
      }, { transaction: t });
    });
  }

  // 获取用户购物车
  async getUserCart(params) {
    const { user } = params;

    const cartItems = await this.Model.findAll({
      where: { userId: user.id },
      include: [
        {
          model: this.app.service('products').Model,
          as: 'product',
          attributes: ['id', 'name', 'images', 'status', 'stock']
        },
        {
          model: this.app.service('productVariants').Model,
          as: 'variant',
          attributes: ['id', 'name', 'attributes', 'images', 'stock', 'price'],
          required: false
        }
      ],
      order: [['createdAt', 'DESC']]
    });

    // 计算总计
    const subtotal = cartItems.reduce((sum, item) => sum + parseFloat(item.total), 0);
    const totalItems = cartItems.reduce((sum, item) => sum + item.quantity, 0);

    return {
      items: cartItems,
      summary: {
        totalItems,
        subtotal,
        estimatedTotal: subtotal  // 这里可以加上运费等
      }
    };
  }

  // 清空购物车
  async clearCart(params) {
    const { user } = params;

    await this.Model.destroy({
      where: { userId: user.id }
    });

    return { message: '购物车已清空' };
  }

  // 批量删除购物车项目
  async removeItems(data, params) {
    const { user } = params;
    const { itemIds } = data;

    await this.Model.destroy({
      where: {
        id: { [Op.in]: itemIds },
        userId: user.id
      }
    });

    return { message: '已删除选中商品' };
  }

  // 检查购物车有效性
  async validateCart(params) {
    const { user } = params;

    const cartItems = await this.Model.findAll({
      where: { userId: user.id },
      include: ['product', 'variant']
    });

    const invalidItems = [];
    const validItems = [];

    for (const item of cartItems) {
      const product = item.product;
      const variant = item.variant;

      // 检查商品状态
      if (product.status !== 'active') {
        invalidItems.push({
          item,
          reason: '商品已下架'
        });
        continue;
      }

      // 检查变体状态
      if (variant && !variant.isActive) {
        invalidItems.push({
          item,
          reason: '商品规格已下架'
        });
        continue;
      }

      // 检查库存
      const availableStock = variant?.stock || product.stock;
      if (item.quantity > availableStock) {
        invalidItems.push({
          item,
          reason: `库存不足，当前库存：\${availableStock}`
        });
        continue;
      }

      // 检查价格变化
      const currentPrice = variant?.price || product.price;
      if (parseFloat(item.price) !== parseFloat(currentPrice)) {
        // 更新价格
        await item.update({
          price: currentPrice,
          total: currentPrice * item.quantity
        });
      }

      validItems.push(item);
    }

    return {
      validItems,
      invalidItems,
      isValid: invalidItems.length === 0
    };
  }
}

module.exports = CartService;