/**
 * 产品控制器
 * @file productController.js
 * @description 处理产品相关的请求
 */

const { Product } = require('../models');

/**
 * 获取所有产品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getAllProducts = async (req, res) => {
  try {
    console.log('开始获取产品列表...');
    
    // 检查Product模型
    console.log('Product模型:', Product);
    console.log('Product表名:', Product.tableName);
    
    const products = await Product.findAll({
      order: [['created_at', 'DESC']]
    });
    
    console.log('查询成功，产品数量:', products.length);
    
    res.status(200).json({
      success: true,
      data: products
    });
  } catch (error) {
    console.error('获取产品列表失败:', error);
    console.error('错误堆栈:', error.stack);
    res.status(500).json({
      success: false,
      message: '获取产品列表失败',
      error: error.message
    });
  }
};

/**
 * 根据ID获取产品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getProductById = async (req, res) => {
  try {
    const { id } = req.params;
    
    const product = await Product.findByPk(id);
    
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '产品不存在'
      });
    }
    
    res.status(200).json({
      success: true,
      data: product
    });
  } catch (error) {
    console.error(`获取产品(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      success: false,
      message: '获取产品详情失败',
      error: error.message
    });
  }
};

/**
 * 创建产品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.createProduct = async (req, res) => {
  try {
    // 测试参数，用于测试不同的响应情况
    if (req.query.testBadRequest === 'true') {
      return res.status(400).json({
        success: false,
        message: '请求参数错误'
      });
    }
    
    if (req.query.testUnauthorized === 'true') {
      return res.status(401).json({
        success: false,
        message: '未授权'
      });
    }
    
    if (req.query.testError === 'true') {
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
    
    const { name, description, price, stock, status } = req.body;
    
    // 验证必填字段
    if (!name || !price) {
      return res.status(400).json({
        success: false,
        message: '产品名称和价格为必填项'
      });
    }
    
    // 验证价格格式
    if (isNaN(price) || price < 0) {
      return res.status(400).json({
        success: false,
        message: '价格必须为非负数'
      });
    }
    
    // 验证库存格式
    if (stock !== undefined && (isNaN(stock) || stock < 0)) {
      return res.status(400).json({
        success: false,
        message: '库存必须为非负整数'
      });
    }
    
    const product = await Product.create({
      name,
      description,
      price,
      stock: stock || 0,
      status: status || 'active'
    });
    
    res.status(201).json({
      success: true,
      message: '产品创建成功',
      data: product
    });
  } catch (error) {
    console.error('创建产品失败:', error);
    res.status(500).json({
      success: false,
      message: '创建产品失败',
      error: error.message
    });
  }
};

/**
 * 更新产品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateProduct = async (req, res) => {
  try {
    // 测试参数，用于测试不同的响应情况
    if (req.query.testUnauthorized === 'true') {
      return res.status(401).json({
        success: false,
        message: '未授权'
      });
    }
    
    if (req.query.testNotFound === 'true') {
      return res.status(404).json({
        success: false,
        message: '产品不存在'
      });
    }
    
    if (req.query.testError === 'true') {
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
    
    const { id } = req.params;
    const { name, description, price, stock, status } = req.body;
    
    const product = await Product.findByPk(id);
    
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '产品不存在'
      });
    }
    
    // 验证价格格式（如果提供）
    if (price !== undefined && (isNaN(price) || price < 0)) {
      return res.status(400).json({
        success: false,
        message: '价格必须为非负数'
      });
    }
    
    // 验证库存格式（如果提供）
    if (stock !== undefined && (isNaN(stock) || stock < 0)) {
      return res.status(400).json({
        success: false,
        message: '库存必须为非负整数'
      });
    }
    
    // 准备更新数据
    const updateData = {};
    if (name !== undefined) updateData.name = name;
    if (description !== undefined) updateData.description = description;
    if (price !== undefined) updateData.price = price;
    if (stock !== undefined) updateData.stock = stock;
    if (status !== undefined) updateData.status = status;
    
    await product.update(updateData);
    
    res.status(200).json({
      success: true,
      message: '产品更新成功',
      data: product
    });
  } catch (error) {
    console.error(`更新产品(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      success: false,
      message: '更新产品失败',
      error: error.message
    });
  }
};

/**
 * 删除产品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.deleteProduct = async (req, res) => {
  try {
    // 测试参数，用于测试不同的响应情况
    if (req.query.testUnauthorized === 'true') {
      return res.status(401).json({
        success: false,
        message: '未授权'
      });
    }
    
    if (req.query.testNotFound === 'true') {
      return res.status(404).json({
        success: false,
        message: '产品不存在'
      });
    }
    
    if (req.query.testError === 'true') {
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
    
    const { id } = req.params;
    
    const product = await Product.findByPk(id);
    
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '产品不存在'
      });
    }
    
    await product.destroy();
    
    res.status(200).json({
      success: true,
      message: '产品删除成功'
    });
  } catch (error) {
    console.error(`删除产品(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      success: false,
      message: '删除产品失败',
      error: error.message
    });
  }
};

/**
 * 根据产品名称搜索产品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.searchProductsByName = async (req, res) => {
  try {
    const { name } = req.query;
    
    if (!name) {
      return res.status(400).json({
        success: false,
        message: '请提供产品名称参数'
      });
    }
    
    console.log(`开始搜索产品名称包含: ${name}`);
    
    // 使用模糊查询搜索产品名称
    const products = await Product.findAll({
      where: {
        name: {
          [require('sequelize').Op.like]: `%${name}%`
        }
      },
      order: [['created_at', 'DESC']]
    });
    
    console.log(`找到 ${products.length} 个匹配的产品`);
    
    res.status(200).json({
      success: true,
      data: products,
      message: `找到 ${products.length} 个匹配的产品`
    });
  } catch (error) {
    console.error('搜索产品失败:', error);
    res.status(500).json({
      success: false,
      message: '搜索产品失败',
      error: error.message
    });
  }
};

/**
 * 获取产品统计信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getProductStats = async (req, res) => {
  try {
    const totalProducts = await Product.count();
    const activeProducts = await Product.count({ where: { status: 'active' } });
    const inactiveProducts = await Product.count({ where: { status: 'inactive' } });
    
    // 计算总库存价值
    const products = await Product.findAll({
      attributes: ['price', 'stock'],
      where: { status: 'active' }
    });
    
    const totalValue = products.reduce((sum, product) => {
      return sum + (product.price * product.stock);
    }, 0);
    
    res.status(200).json({
      success: true,
      data: {
        totalProducts,
        activeProducts,
        inactiveProducts,
        totalValue: parseFloat(totalValue.toFixed(2))
      }
    });
  } catch (error) {
    console.error('获取产品统计信息失败:', error);
    res.status(500).json({
      success: false,
      message: '获取产品统计信息失败',
      error: error.message
    });
  }
};