const LivestockType = require('../models/LivestockType');
const User = require('../models/User');
const responseFormat = require('../utils/response');
const { Op } = require('sequelize');

// 获取牲畜类型列表
const getLivestockTypes = async (req, res) => {
  try {
    const {
      name,
      is_active,
      page = 1,
      limit = 10
    } = req.query;
    
    const whereClause = {};
    
    // 名称筛选
    if (name) {
      whereClause.name = { [Op.like]: `%${name}%` };
    }
    
    // 状态筛选
    if (is_active !== undefined) {
      whereClause.is_active = is_active === 'true';
    }
    
    const offset = (page - 1) * limit;
    
    const { count, rows } = await LivestockType.findAndCountAll({
      where: whereClause,
      order: [['created_at', 'DESC']],
      offset,
      limit: parseInt(limit)
    });
    
    res.json(responseFormat.pagination(rows, {
      page: parseInt(page),
      limit: parseInt(limit),
      total: count
    }, '获取牲畜类型列表成功'));
  } catch (error) {
    console.error('获取牲畜类型列表错误:', error);
    res.status(500).json(responseFormat.error('获取牲畜类型列表失败'));
  }
};

// 获取所有启用的牲畜类型（用于下拉选择）
const getActiveLivestockTypes = async (req, res) => {
  try {
    const types = await LivestockType.findAll({
      where: { is_active: true },
      attributes: ['id', 'name', 'description', 'base_value', 'premium_rate'],
      order: [['name', 'ASC']]
    });
    
    res.json(responseFormat.success(types, '获取启用牲畜类型成功'));
  } catch (error) {
    console.error('获取启用牲畜类型错误:', error);
    res.status(500).json(responseFormat.error('获取启用牲畜类型失败'));
  }
};

// 创建牲畜类型
const createLivestockType = async (req, res) => {
  try {
    const typeData = req.body;
    
    // 检查名称是否已存在
    const existingType = await LivestockType.findOne({
      where: { name: typeData.name }
    });
    
    if (existingType) {
      return res.status(400).json(responseFormat.error('牲畜类型名称已存在'));
    }
    
    const type = await LivestockType.create({
      ...typeData,
      created_by: req.user?.id
    });
    
    res.status(201).json(responseFormat.created(type, '牲畜类型创建成功'));
  } catch (error) {
    console.error('创建牲畜类型错误:', error);
    if (error.name === 'SequelizeValidationError') {
      const messages = error.errors.map(err => err.message);
      return res.status(400).json(responseFormat.error(messages.join(', ')));
    }
    res.status(500).json(responseFormat.error('创建牲畜类型失败'));
  }
};

// 获取单个牲畜类型详情
const getLivestockTypeById = async (req, res) => {
  try {
    const { id } = req.params;
    
    const type = await LivestockType.findByPk(id);
    
    if (!type) {
      return res.status(404).json(responseFormat.error('牲畜类型不存在'));
    }
    
    res.json(responseFormat.success(type, '获取牲畜类型详情成功'));
  } catch (error) {
    console.error('获取牲畜类型详情错误:', error);
    res.status(500).json(responseFormat.error('获取牲畜类型详情失败'));
  }
};

// 更新牲畜类型
const updateLivestockType = async (req, res) => {
  try {
    const { id } = req.params;
    const updateData = req.body;
    
    const type = await LivestockType.findByPk(id);
    if (!type) {
      return res.status(404).json(responseFormat.error('牲畜类型不存在'));
    }
    
    // 如果更新名称，检查是否与其他记录重复
    if (updateData.name && updateData.name !== type.name) {
      const existingType = await LivestockType.findOne({
        where: { 
          name: updateData.name,
          id: { [Op.ne]: id }
        }
      });
      
      if (existingType) {
        return res.status(400).json(responseFormat.error('牲畜类型名称已存在'));
      }
    }
    
    updateData.updated_by = req.user?.id;
    
    await type.update(updateData);
    
    res.json(responseFormat.success(type, '牲畜类型更新成功'));
  } catch (error) {
    console.error('更新牲畜类型错误:', error);
    if (error.name === 'SequelizeValidationError') {
      const messages = error.errors.map(err => err.message);
      return res.status(400).json(responseFormat.error(messages.join(', ')));
    }
    res.status(500).json(responseFormat.error('更新牲畜类型失败'));
  }
};

// 删除牲畜类型（软删除 - 设置为不启用）
const deleteLivestockType = async (req, res) => {
  try {
    const { id } = req.params;
    
    const type = await LivestockType.findByPk(id);
    if (!type) {
      return res.status(404).json(responseFormat.error('牲畜类型不存在'));
    }
    
    // 检查是否有关联的保单
    const LivestockPolicy = require('../models/LivestockPolicy');
    const relatedPolicies = await LivestockPolicy.count({
      where: { livestock_type_id: id }
    });
    
    if (relatedPolicies > 0) {
      // 如果有关联保单，只能设置为不启用
      await type.update({
        is_active: false,
        updated_by: req.user?.id
      });
      return res.json(responseFormat.success(null, '牲畜类型已设置为不启用（存在关联保单）'));
    }
    
    // 如果没有关联保单，可以物理删除
    await type.destroy();
    
    res.json(responseFormat.success(null, '牲畜类型删除成功'));
  } catch (error) {
    console.error('删除牲畜类型错误:', error);
    res.status(500).json(responseFormat.error('删除牲畜类型失败'));
  }
};

// 批量更新牲畜类型状态
const batchUpdateLivestockTypeStatus = async (req, res) => {
  try {
    const { ids, is_active } = req.body;
    
    if (!Array.isArray(ids) || ids.length === 0) {
      return res.status(400).json(responseFormat.error('请提供有效的ID列表'));
    }
    
    await LivestockType.update(
      { 
        is_active,
        updated_by: req.user?.id
      },
      { 
        where: { id: { [Op.in]: ids } }
      }
    );
    
    res.json(responseFormat.success(null, '批量更新牲畜类型状态成功'));
  } catch (error) {
    console.error('批量更新牲畜类型状态错误:', error);
    res.status(500).json(responseFormat.error('批量更新牲畜类型状态失败'));
  }
};

module.exports = {
  getLivestockTypes,
  getActiveLivestockTypes,
  createLivestockType,
  getLivestockTypeById,
  updateLivestockType,
  deleteLivestockType,
  batchUpdateLivestockTypeStatus
};