Mini-Program/pages/evaluate1/index.js

Page({
  data: {
    productName: '',
    specifications: [],
    loading: false,
    error: ''
  },
  onLoad(options) {
    let productName = '';
    // 首先检查URL参数
    if (options.productName) {
      productName = options.productName;
    } else {
      // 然后检查本地存储（用于wx.switchTab导航）
      productName = wx.getStorageSync('selectedProductName') || '';
      // 清除本地存储中的商品名称，避免影响下次进入
      if (productName) {
        wx.removeStorageSync('selectedProductName');
      }
    }
    
    if (productName) {
      this.setData({ productName: productName });
      this.loadSpecifications(productName);
    } else {
      // 如果没有商品名称参数，跳转到商品列表页面
      wx.redirectTo({
        url: '/pages/evaluate1/product-list'
      });
    }
  },
  
  loadSpecifications(productName) {
    this.setData({ loading: true, specifications: [] });
    
    // 直接从本地存储获取商品数据，避免重复请求
    const localGoods = wx.getStorageSync('goods') || [];
    console.log('从本地存储获取的商品数量:', localGoods.length);
    
    if (localGoods.length > 0) {
      this.processSpecifications(productName, localGoods);
    } else {
      // 如果本地没有数据，再请求服务器
      const api = require('../../utils/api');
      api.getProducts(1, 1000).then(result => {
        // 从返回对象中提取products数组
        const products = result.products || [];
        this.processSpecifications(productName, products);
      }).catch(err => {
        console.error('获取规格失败:', err);
        this.setData({
          error: '获取规格失败，请稍后重试',
          loading: false
        });
      });
    }
  },
  
  // 解析规格，提取类型（净重/毛重）和数值范围
  parseSpecification(spec) {
    const weightMatch = spec.match(/(净重|毛重)(\d+)-(\d+)/);
    if (weightMatch) {
      const type = weightMatch[1]; // 净重或毛重
      const min = parseFloat(weightMatch[2]);
      const max = parseFloat(weightMatch[3]);
      const avg = (min + max) / 2;
      return {
        type: type,
        min: min,
        max: max,
        avg: avg
      };
    }
    return null;
  },
  
  processSpecifications(productName, products) {
    console.log('处理的商品数据数量:', products.length);
    console.log('当前处理的商品名称:', productName);
    
    // 检查products是否为空
    if (!products || products.length === 0) {
      console.error('商品数据为空');
      this.setData({
        error: '商品数据为空',
        loading: false
      });
      return;
    }
    
    // 过滤出当前商品名称的所有商品
    const filteredProducts = products.filter(product => {
      const match = product.productName === productName;
      console.log('商品:', product.productName, '规格:', product.specification, '价格:', product.price, '匹配:', match);
      return match;
    });
    
    console.log('过滤后的商品数量:', filteredProducts.length);
    console.log('过滤后的商品详情:', filteredProducts);
    
    // 检查filteredProducts是否为空
    if (filteredProducts.length === 0) {
      console.error('未找到商品名称为"' + productName + '"的商品');
      this.setData({
        error: '未找到对应商品名称的商品',
        loading: false
      });
      return;
    }
    
    // 提取规格和价格，处理可能的空值和空格
    const specPriceMap = {};
    filteredProducts.forEach((product, productIndex) => {
      const specStr = (product.specification || product.spec || '').trim();
      const price = product.price || '';
      
      console.log(`处理第${productIndex + 1}个商品: 规格字符串='${specStr}', 价格字符串='${price}'`);
      
      // 价格为空的不参与计算
      if (!price || price.trim() === '') {
        console.log(`商品价格为空，跳过处理`);
        return;
      }
      
      if (specStr.length > 0) {
        // 处理逗号分隔的多个规格，确保每个规格都被正确分割
        // 首先按逗号分割
        let specs = specStr.split(',').map(spec => spec.trim()).filter(spec => spec.length > 0);
        
        // 进一步处理规格，确保每个规格都是独立的
        const processedSpecs = [];
        specs.forEach(spec => {
          // 检查规格是否包含多个规格（例如："净重29-30，净重31-32"）
          if (spec.includes('，')) {
            // 按中文逗号分割
            const subSpecs = spec.split('，').map(s => s.trim()).filter(s => s.length > 0);
            processedSpecs.push(...subSpecs);
          } else {
            processedSpecs.push(spec);
          }
        });
        
        specs = processedSpecs;
        
        // 处理逗号分隔的多个价格
        const prices = (price || '').split(',').map(p => p.trim()).filter(p => p && p.trim() !== '');
        
        console.log(`规格数组:`, specs);
        console.log(`价格数组:`, prices);
        
        // 价格为空的不参与计算
        if (prices.length === 0) {
          console.log(`价格数组为空，跳过处理`);
          return;
        }
        
        // 将规格和价格配对
        specs.forEach((spec, index) => {
          if (spec.length > 0) {
            // 确保价格索引不超出范围
            const priceIndex = index % prices.length;
            const matchedPrice = prices[priceIndex] || '';
            console.log(`规格'${spec}' 配对价格: '${matchedPrice}'`);
            
            // 只有当价格不为空时才添加该规格
            if (matchedPrice && matchedPrice.trim() !== '') {
              // 收集相同规格的所有价格，以便计算平均值
              if (!specPriceMap[spec]) {
                specPriceMap[spec] = [];
              }
              specPriceMap[spec].push(matchedPrice);
            } else {
              console.log(`规格'${spec}' 价格为空，不添加`);
            }
          }
        });
      }
    });
    
    // 转换为规格对象数组
    const specifications = Object.keys(specPriceMap).map(spec => {
      const prices = specPriceMap[spec];
      console.log(`规格'${spec}' 的所有原始价格:`, prices);
      
      // 解析规格
      const specInfo = this.parseSpecification(spec);
      
      // 处理每个价格
      const processedPrices = prices.map(price => {
        if (!price || price.trim() === '' || isNaN(parseFloat(price))) {
          return 0;
        }
        
        const priceValue = parseFloat(price);
        console.log(`处理价格: ${priceValue}`);
        
        // 价格<10的需要按照公式计算
        if (priceValue < 10 && specInfo) {
          console.log(`价格 ${priceValue} < 10，按照公式计算`);
          if (specInfo.type === '净重') {
            // 净重：规格平均值 × 价格
            return specInfo.avg * priceValue;
          } else if (specInfo.type === '毛重') {
            // 毛重：(规格平均值 - 5) × 价格
            return (specInfo.avg - 5) * priceValue;
          }
        }
        // 价格>=10的直接使用
        return priceValue;
      }).filter(price => price > 0); // 过滤掉0值
      
      console.log(`规格'${spec}' 处理后的价格:`, processedPrices);
      
      // 计算处理后价格的平均值
      let finalPrice = 0;
      let finalPriceText = '';
      
      if (processedPrices.length > 0) {
        const sum = processedPrices.reduce((acc, price) => acc + price, 0);
        finalPrice = sum / processedPrices.length;
        finalPriceText = finalPrice.toFixed(2);
        console.log(`规格'${spec}' 处理后价格的平均值: ${finalPriceText} (基于 ${processedPrices.length} 个价格)`);
      } else {
        console.log(`规格'${spec}' 没有有效价格`);
      }
      
      const specObj = {
        name: spec,
        price: finalPriceText,
        priceText: finalPriceText,
        finalPrice: finalPrice,
        finalPriceText: finalPriceText
      };
      
      console.log('创建的规格对象:', specObj);
      
      return specObj;
    });
    
    console.log('提取的规格和价格:', specifications);
    
    // 对规格进行排序
    specifications.sort((a, b) => {
      // 解析两个规格
      const specA = this.parseSpecification(a.name);
      const specB = this.parseSpecification(b.name);
      
      // 如果有一个规格解析失败，保持原顺序
      if (!specA || !specB) {
        return 0;
      }
      
      // 1. 按类型排序：净重在前，毛重在后
      if (specA.type !== specB.type) {
        return specA.type === '净重' ? -1 : 1;
      }
      
      // 2. 按规格最小值排序：从小到大
      return specA.min - specB.min;
    });
    
    console.log('排序后的规格:', specifications);
    
    this.setData({
      specifications: specifications,
      error: '', // 清除之前的错误
      loading: false
    });
  },
  
  // 跳转到规格详情页面
  goToSpecDetail(e) {
    const specItem = e.currentTarget.dataset.spec;
    console.log('点击的规格项:', specItem);
    console.log('传递的价格:', specItem.finalPriceText);
    wx.navigateTo({
      url: `/pages/evaluate1/spec-detail?productName=${encodeURIComponent(this.data.productName)}&specification=${encodeURIComponent(specItem.name)}&price=${encodeURIComponent(specItem.finalPriceText)}`
    });
  },
  
  // 返回上一页
  goBack() {
    wx.navigateBack();
  },
  
  // 返回商品列表页面
  goBackToProductList() {
    wx.redirectTo({
      url: '/pages/evaluate1/product-list'
    });
  }
});