/**
 * 员工控制器
 * @file employeeController.js
 * @description 处理员工相关的请求
 */
const { Employee, Department, Position } = require('../models');
const { validationResult } = require('express-validator');
const { Op } = require('sequelize');

/**
 * 获取员工列表
 * @param {Object} req 请求对象
 * @param {Object} res 响应对象
 */
exports.getEmployees = async (req, res) => {
  try {
    const {
      page = 1,
      limit = 10,
      search = '',
      department = '',
      position = '',
      status = '',
      sortBy = 'created_at',
      sortOrder = 'DESC'
    } = req.query;

    const offset = (page - 1) * limit;
    const whereClause = {};

    // 搜索条件
    if (search) {
      whereClause[Op.or] = [
        { name: { [Op.like]: `%${search}%` } },
        { employee_id: { [Op.like]: `%${search}%` } },
        { phone: { [Op.like]: `%${search}%` } },
        { email: { [Op.like]: `%${search}%` } }
      ];
    }

    // 部门筛选
    if (department) {
      whereClause.department_id = department;
    }

    // 职位筛选
    if (position) {
      whereClause.position_id = position;
    }

    // 状态筛选
    if (status) {
      whereClause.status = status;
    }

    const { count, rows: employees } = await Employee.findAndCountAll({
      where: whereClause,
      include: [
        {
          model: Department,
          as: 'department',
          attributes: ['id', 'name']
        },
        {
          model: Position,
          as: 'position',
          attributes: ['id', 'name', 'level']
        }
      ],
      order: [[sortBy, sortOrder.toUpperCase()]],
      limit: parseInt(limit),
      offset: parseInt(offset)
    });

    res.json({
      success: true,
      message: '获取员工列表成功',
      data: {
        employees,
        pagination: {
          current: parseInt(page),
          pageSize: parseInt(limit),
          total: count,
          pages: Math.ceil(count / limit)
        }
      }
    });

  } catch (error) {
    console.error('获取员工列表错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: error.message
    });
  }
};

/**
 * 创建员工
 * @param {Object} req 请求对象
 * @param {Object} res 响应对象
 */
exports.createEmployee = async (req, res) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入数据验证失败',
        errors: errors.array()
      });
    }

    const {
      name,
      employee_id,
      department_id,
      position_id,
      phone,
      email,
      hire_date,
      salary,
      status = 'active'
    } = req.body;

    // 检查员工编号是否已存在
    const existingEmployee = await Employee.findOne({
      where: { employee_id }
    });

    if (existingEmployee) {
      return res.status(400).json({
        success: false,
        message: '员工编号已存在'
      });
    }

    const employee = await Employee.create({
      name,
      employee_id,
      department_id,
      position_id,
      phone,
      email,
      hire_date,
      salary: salary * 100, // 转换为分
      status
    });

    res.status(201).json({
      success: true,
      message: '创建员工成功',
      data: employee
    });

  } catch (error) {
    console.error('创建员工错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: error.message
    });
  }
};

/**
 * 获取员工详情
 * @param {Object} req 请求对象
 * @param {Object} res 响应对象
 */
exports.getEmployeeById = async (req, res) => {
  try {
    const { id } = req.params;

    const employee = await Employee.findByPk(id, {
      include: [
        {
          model: Department,
          as: 'department',
          attributes: ['id', 'name', 'description']
        },
        {
          model: Position,
          as: 'position',
          attributes: ['id', 'name', 'level', 'description']
        }
      ]
    });

    if (!employee) {
      return res.status(404).json({
        success: false,
        message: '员工不存在'
      });
    }

    res.json({
      success: true,
      message: '获取员工详情成功',
      data: employee
    });

  } catch (error) {
    console.error('获取员工详情错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: error.message
    });
  }
};

/**
 * 更新员工
 * @param {Object} req 请求对象
 * @param {Object} res 响应对象
 */
exports.updateEmployee = async (req, res) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入数据验证失败',
        errors: errors.array()
      });
    }

    const { id } = req.params;
    const updateData = req.body;

    // 如果更新薪资，转换为分
    if (updateData.salary) {
      updateData.salary = updateData.salary * 100;
    }

    const employee = await Employee.findByPk(id);

    if (!employee) {
      return res.status(404).json({
        success: false,
        message: '员工不存在'
      });
    }

    await employee.update(updateData);

    res.json({
      success: true,
      message: '更新员工成功',
      data: employee
    });

  } catch (error) {
    console.error('更新员工错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: error.message
    });
  }
};

/**
 * 删除员工
 * @param {Object} req 请求对象
 * @param {Object} res 响应对象
 */
exports.deleteEmployee = async (req, res) => {
  try {
    const { id } = req.params;

    const employee = await Employee.findByPk(id);

    if (!employee) {
      return res.status(404).json({
        success: false,
        message: '员工不存在'
      });
    }

    await employee.destroy();

    res.json({
      success: true,
      message: '删除员工成功'
    });

  } catch (error) {
    console.error('删除员工错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: error.message
    });
  }
};

/**
 * 获取员工统计
 * @param {Object} req 请求对象
 * @param {Object} res 响应对象
 */
exports.getEmployeeStats = async (req, res) => {
  try {
    const totalEmployees = await Employee.count();
    const activeEmployees = await Employee.count({ where: { status: 'active' } });
    const inactiveEmployees = await Employee.count({ where: { status: 'inactive' } });

    const departmentStats = await Employee.findAll({
      attributes: [
        'department_id',
        [Employee.sequelize.fn('COUNT', Employee.sequelize.col('id')), 'count']
      ],
      include: [{
        model: Department,
        as: 'department',
        attributes: ['name']
      }],
      group: ['department_id', 'department.id'],
      raw: false
    });

    const positionStats = await Employee.findAll({
      attributes: [
        'position_id',
        [Employee.sequelize.fn('COUNT', Employee.sequelize.col('id')), 'count']
      ],
      include: [{
        model: Position,
        as: 'position',
        attributes: ['name', 'level']
      }],
      group: ['position_id', 'position.id'],
      raw: false
    });

    res.json({
      success: true,
      message: '获取员工统计成功',
      data: {
        total: totalEmployees,
        active: activeEmployees,
        inactive: inactiveEmployees,
        departmentStats: departmentStats.map(item => ({
          department: item.department.name,
          count: parseInt(item.dataValues.count)
        })),
        positionStats: positionStats.map(item => ({
          position: item.position.name,
          level: item.position.level,
          count: parseInt(item.dataValues.count)
        }))
      }
    });

  } catch (error) {
    console.error('获取员工统计错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: error.message
    });
  }
};