const { CattlePen, Farm, IotCattle } = require('../models');
const { Op } = require('sequelize');

/**
 * 栏舍设置控制器
 */
class CattlePenController {
  /**
   * 获取栏舍列表
   */
  async getPens(req, res) {
    try {
      const { page = 1, pageSize = 10, search, status, type } = req.query;
      const offset = (page - 1) * pageSize;

      // 构建查询条件
      const where = {};
      if (search) {
        where[Op.or] = [
          { name: { [Op.like]: `%${search}%` } },
          { code: { [Op.like]: `%${search}%` } }
        ];
      }
      if (status) {
        where.status = status;
      }
      if (type) {
        where.type = type;
      }

      const { count, rows } = await CattlePen.findAndCountAll({
        where,
        include: [
          {
            model: Farm,
            as: 'farm',
            attributes: ['id', 'name']
          }
        ],
        limit: parseInt(pageSize),
        offset: parseInt(offset),
        order: [['created_at', 'DESC']]
      });

      res.json({
        success: true,
        data: {
          list: rows,
          total: count,
          page: parseInt(page),
          pageSize: parseInt(pageSize)
        },
        message: '获取栏舍列表成功'
      });
    } catch (error) {
      console.error('获取栏舍列表失败:', error);
      res.status(500).json({
        success: false,
        message: '获取栏舍列表失败',
        error: error.message
      });
    }
  }

  /**
   * 获取单个栏舍详情
   */
  async getPenById(req, res) {
    try {
      const { id } = req.params;

      const pen = await CattlePen.findByPk(id, {
        include: [
          {
            model: Farm,
            as: 'farm',
            attributes: ['id', 'name']
          }
        ]
      });

      if (!pen) {
        return res.status(404).json({
          success: false,
          message: '栏舍不存在'
        });
      }

      res.json({
        success: true,
        data: pen,
        message: '获取栏舍详情成功'
      });
    } catch (error) {
      console.error('获取栏舍详情失败:', error);
      res.status(500).json({
        success: false,
        message: '获取栏舍详情失败',
        error: error.message
      });
    }
  }

  /**
   * 创建栏舍
   */
  async createPen(req, res) {
    try {
      console.log('🆕 [后端-栏舍设置] 开始创建操作');
      console.log('📋 [后端-栏舍设置] 请求数据:', req.body);

      const penData = req.body;

      // 验证必填字段
      if (!penData.name || !penData.code || !penData.type || !penData.capacity || !penData.area) {
        console.log('❌ [后端-栏舍设置] 必填字段验证失败:', {
          name: !!penData.name,
          code: !!penData.code,
          type: !!penData.type,
          capacity: !!penData.capacity,
          area: !!penData.area
        });
        return res.status(400).json({
          success: false,
          message: '请填写所有必填字段（栏舍名称、编号、类型、容量、面积）'
        });
      }

      // 检查编号是否已存在
      const existingPen = await CattlePen.findOne({
        where: { code: penData.code }
      });

      if (existingPen) {
        console.log('❌ [后端-栏舍设置] 栏舍编号已存在:', penData.code);
        return res.status(400).json({
          success: false,
          message: '栏舍编号已存在'
        });
      }

      // 准备创建数据
      const createData = {
        name: penData.name,
        code: penData.code,
        type: penData.type,
        capacity: parseInt(penData.capacity),
        currentCount: penData.currentCount ? parseInt(penData.currentCount) : 0,
        area: parseFloat(penData.area),
        location: penData.location || '',
        status: penData.status || '启用',
        remark: penData.remark || '',
        farmId: penData.farmId || 1
      };

      console.log('📝 [后端-栏舍设置] 准备创建的数据:', createData);

      const pen = await CattlePen.create(createData);

      console.log('✅ [后端-栏舍设置] 栏舍创建成功:', pen.id);

      res.status(201).json({
        success: true,
        data: pen,
        message: '创建栏舍成功'
      });
    } catch (error) {
      console.error('❌ [后端-栏舍设置] 创建失败:', error);
      res.status(500).json({
        success: false,
        message: '创建栏舍失败',
        error: error.message
      });
    }
  }

  /**
   * 更新栏舍
   */
  async updatePen(req, res) {
    try {
      const { id } = req.params;
      const updateData = req.body;

      const pen = await CattlePen.findByPk(id);
      if (!pen) {
        return res.status(404).json({
          success: false,
          message: '栏舍不存在'
        });
      }

      // 如果更新编号，检查是否与其他栏舍冲突
      if (updateData.code && updateData.code !== pen.code) {
        const existingPen = await CattlePen.findOne({
          where: { 
            code: updateData.code,
            id: { [Op.ne]: id }
          }
        });

        if (existingPen) {
          return res.status(400).json({
            success: false,
            message: '栏舍编号已存在'
          });
        }
      }

      await pen.update(updateData);

      res.json({
        success: true,
        data: pen,
        message: '更新栏舍成功'
      });
    } catch (error) {
      console.error('更新栏舍失败:', error);
      res.status(500).json({
        success: false,
        message: '更新栏舍失败',
        error: error.message
      });
    }
  }

  /**
   * 删除栏舍
   */
  async deletePen(req, res) {
    try {
      console.log('🗑️ [后端-栏舍设置] 开始删除操作');
      console.log('📋 [后端-栏舍设置] 请求参数:', req.params);

      const { id } = req.params;

      const pen = await CattlePen.findByPk(id);
      if (!pen) {
        console.log('❌ [后端-栏舍设置] 栏舍不存在，ID:', id);
        return res.status(404).json({
          success: false,
          message: '栏舍不存在'
        });
      }

      console.log('✅ [后端-栏舍设置] 找到栏舍:', {
        id: pen.id,
        name: pen.name,
        code: pen.code
      });

      // 注意：由于IotCattle表中没有penId字段，暂时跳过牛只检查
      // 在实际应用中，应该根据业务需求决定是否需要检查关联数据

      await pen.destroy();
      console.log('✅ [后端-栏舍设置] 栏舍删除成功');

      res.json({
        success: true,
        message: '删除栏舍成功'
      });
    } catch (error) {
      console.error('❌ [后端-栏舍设置] 删除失败:', error);
      res.status(500).json({
        success: false,
        message: '删除栏舍失败',
        error: error.message
      });
    }
  }

  /**
   * 批量删除栏舍
   */
  async batchDeletePens(req, res) {
    try {
      const { ids } = req.body;

      if (!ids || !Array.isArray(ids) || ids.length === 0) {
        return res.status(400).json({
          success: false,
          message: '请选择要删除的栏舍'
        });
      }

      // 检查是否有栏舍包含牛只
      const animalCount = await IotCattle.count({
        where: { penId: { [Op.in]: ids } }
      });

      if (animalCount > 0) {
        return res.status(400).json({
          success: false,
          message: '选中的栏舍中还有牛只，无法删除'
        });
      }

      await CattlePen.destroy({
        where: { id: { [Op.in]: ids } }
      });

      res.json({
        success: true,
        message: `成功删除 ${ids.length} 个栏舍`
      });
    } catch (error) {
      console.error('批量删除栏舍失败:', error);
      res.status(500).json({
        success: false,
        message: '批量删除栏舍失败',
        error: error.message
      });
    }
  }

  /**
   * 获取栏舍中的牛只
   */
  async getPenIotCattles(req, res) {
    try {
      const { id } = req.params;
      const { page = 1, pageSize = 10 } = req.query;
      const offset = (page - 1) * pageSize;

      const pen = await CattlePen.findByPk(id);
      if (!pen) {
        return res.status(404).json({
          success: false,
          message: '栏舍不存在'
        });
      }

      const { count, rows } = await IotCattle.findAndCountAll({
        where: { penId: id },
        limit: parseInt(pageSize),
        offset: parseInt(offset),
        order: [['created_at', 'DESC']]
      });

      res.json({
        success: true,
        data: {
          list: rows,
          total: count,
          page: parseInt(page),
          pageSize: parseInt(pageSize)
        },
        message: '获取栏舍牛只成功'
      });
    } catch (error) {
      console.error('获取栏舍牛只失败:', error);
      res.status(500).json({
        success: false,
        message: '获取栏舍牛只失败',
        error: error.message
      });
    }
  }

  /**
   * 获取栏舍中的牛只
   */
  async getPenAnimals(req, res) {
    try {
      const { id } = req.params;
      const { page = 1, pageSize = 10 } = req.query;
      const offset = (page - 1) * pageSize;

      // 检查栏舍是否存在
      const pen = await CattlePen.findByPk(id);
      if (!pen) {
        return res.status(404).json({
          success: false,
          message: '栏舍不存在'
        });
      }

      // 获取栏舍中的牛只
      const { count, rows } = await IotCattle.findAndCountAll({
        where: { penId: id },
        attributes: ['id', 'earNumber', 'sex', 'strain', 'orgId'],
        include: [
          {
            model: Farm,
            as: 'farm',
            attributes: ['id', 'name']
          }
        ],
        limit: parseInt(pageSize),
        offset: offset,
        order: [['earNumber', 'ASC']]
      });

      res.json({
        success: true,
        data: {
          list: rows,
          total: count,
          page: parseInt(page),
          pageSize: parseInt(pageSize)
        },
        message: '获取栏舍牛只成功'
      });
    } catch (error) {
      console.error('获取栏舍牛只失败:', error);
      res.status(500).json({
        success: false,
        message: '获取栏舍牛只失败',
        error: error.message
      });
    }
  }
}

module.exports = new CattlePenController();