const { User, Role } = require('../models');
const { Op } = require('sequelize');
const responseFormat = require('../utils/response');
const crypto = require('crypto');
const ExcelExport = require('../utils/excelExport');

// 获取用户列表
const getUsers = async (req, res) => {
  try {
    const { page = 1, limit = 10, search, role_id, status } = req.query;
    const offset = (page - 1) * limit;
    
    const whereClause = {};
    if (search) {
      whereClause[Op.or] = [
        { username: { [Op.like]: `%${search}%` } },
        { real_name: { [Op.like]: `%${search}%` } },
        { email: { [Op.like]: `%${search}%` } },
        { phone: { [Op.like]: `%${search}%` } }
      ];
    }
    if (role_id) whereClause.role_id = role_id;
    if (status) whereClause.status = status;
    
    const { count, rows: users } = await User.findAndCountAll({
      where: whereClause,
      include: [{
        model: Role,
        as: 'role',
        attributes: ['id', 'name']
      }],
      attributes: { exclude: ['password'] },
      limit: parseInt(limit),
      offset: parseInt(offset),
      order: [['created_at', 'DESC']]
    });
    
    res.json(responseFormat.success({
      users,
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total: count,
        pages: Math.ceil(count / limit)
      }
    }, '获取用户列表成功'));
  } catch (error) {
    console.error('获取用户列表错误:', error);
    res.status(500).json(responseFormat.error('获取用户列表失败'));
  }
};

// 获取单个用户信息
const getUser = async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id, {
      include: [{
        model: Role,
        as: 'role',
        attributes: ['id', 'name', 'permissions']
      }],
      attributes: { exclude: ['password'] }
    });
    
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    res.json(responseFormat.success(user, '获取用户信息成功'));
  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.status(500).json(responseFormat.error('获取用户信息失败'));
  }
};

// 创建用户
const createUser = async (req, res) => {
  try {
    const { username, password, real_name, email, phone, role_id, status = 'active' } = req.body;
    
    // 检查用户名是否已存在
    const existingUser = await User.findOne({ where: { username } });
    if (existingUser) {
      return res.status(400).json(responseFormat.error('用户名已存在'));
    }
    
    // 检查邮箱是否已存在
    const existingEmail = await User.findOne({ where: { email } });
    if (existingEmail) {
      return res.status(400).json(responseFormat.error('邮箱已存在'));
    }
    
    // 检查手机号是否已存在
    const existingPhone = await User.findOne({ where: { phone } });
    if (existingPhone) {
      return res.status(400).json(responseFormat.error('手机号已存在'));
    }
    
    // 检查角色是否存在
    const role = await Role.findByPk(role_id);
    if (!role) {
      return res.status(400).json(responseFormat.error('角色不存在'));
    }
    
    // 创建用户
    const user = await User.create({
      username,
      password,
      real_name,
      email,
      phone,
      role_id,
      status
    });
    
    res.status(201).json(responseFormat.created(user, '用户创建成功'));
  } catch (error) {
    console.error('创建用户错误:', error);
    res.status(500).json(responseFormat.error('创建用户失败'));
  }
};

// 更新用户信息
const updateUser = async (req, res) => {
  try {
    const { id } = req.params;
    const { real_name, email, phone, role_id } = req.body;
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 检查邮箱是否已被其他用户使用
    if (email && email !== user.email) {
      const existingEmail = await User.findOne({ where: { email } });
      if (existingEmail) {
        return res.status(400).json(responseFormat.error('邮箱已被其他用户使用'));
      }
    }
    
    // 检查手机号是否已被其他用户使用
    if (phone && phone !== user.phone) {
      const existingPhone = await User.findOne({ where: { phone } });
      if (existingPhone) {
        return res.status(400).json(responseFormat.error('手机号已被其他用户使用'));
      }
    }
    
    // 检查角色是否存在
    if (role_id) {
      const role = await Role.findByPk(role_id);
      if (!role) {
        return res.status(400).json(responseFormat.error('角色不存在'));
      }
    }
    
    // 更新用户信息
    await user.update({
      real_name: real_name || user.real_name,
      email: email || user.email,
      phone: phone || user.phone,
      role_id: role_id || user.role_id
    });
    
    res.json(responseFormat.success(user, '用户信息更新成功'));
  } catch (error) {
    console.error('更新用户信息错误:', error);
    res.status(500).json(responseFormat.error('更新用户信息失败'));
  }
};

// 删除用户
const deleteUser = async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 不能删除自己
    if (user.id === req.user.id) {
      return res.status(400).json(responseFormat.error('不能删除自己的账户'));
    }
    
    await user.destroy();
    
    res.json(responseFormat.success(null, '用户删除成功'));
  } catch (error) {
    console.error('删除用户错误:', error);
    res.status(500).json(responseFormat.error('删除用户失败'));
  }
};

// 更新用户状态
const updateUserStatus = async (req, res) => {
  try {
    const { id } = req.params;
    const { status } = req.body;
    
    if (!['active', 'inactive', 'suspended'].includes(status)) {
      return res.status(400).json(responseFormat.error('状态值无效'));
    }
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 不能禁用自己
    if (user.id === req.user.id && status !== 'active') {
      return res.status(400).json(responseFormat.error('不能禁用自己的账户'));
    }
    
    await user.update({ status });
    
    res.json(responseFormat.success(user, '用户状态更新成功'));
  } catch (error) {
    console.error('更新用户状态错误:', error);
    res.status(500).json(responseFormat.error('更新用户状态失败'));
  }
};

// 获取个人资料
const getProfile = async (req, res) => {
  try {
    const userId = req.user.id;
    
    const user = await User.findByPk(userId, {
      include: [{
        model: Role,
        as: 'role'
      }]
    });
    
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 手动排除密码字段
    const userProfile = {
      id: user.id,
      username: user.username,
      real_name: user.real_name,
      email: user.email,
      phone: user.phone,
      role_id: user.role_id,
      status: user.status,
      last_login: user.last_login,
      avatar: user.avatar,
      created_at: user.created_at,
      updated_at: user.updated_at,
      role: user.role
    };
    
    res.json(responseFormat.success(userProfile, '获取个人资料成功'));
  } catch (error) {
    console.error('获取个人资料错误:', error);
    res.status(500).json(responseFormat.error('获取个人资料失败'));
  }
};

// 更新个人资料
const updateProfile = async (req, res) => {
  try {
    const userId = req.user.id;
    const { real_name, email, phone } = req.body;
    
    const user = await User.findByPk(userId);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 检查邮箱是否已被其他用户使用
    if (email && email !== user.email) {
      const existingEmail = await User.findOne({ 
        where: { email, id: { [Op.ne]: userId } } 
      });
      if (existingEmail) {
        return res.status(400).json(responseFormat.error('邮箱已被其他用户使用'));
      }
    }
    
    // 检查手机号是否已被其他用户使用
    if (phone && phone !== user.phone) {
      const existingPhone = await User.findOne({ 
        where: { phone, id: { [Op.ne]: userId } } 
      });
      if (existingPhone) {
        return res.status(400).json(responseFormat.error('手机号已被其他用户使用'));
      }
    }
    
    // 更新个人资料
    await user.update({
      real_name: real_name || user.real_name,
      email: email || user.email,
      phone: phone || user.phone
    });
    
    // 返回更新后的用户信息（不包含密码）
    const updatedUser = await User.findByPk(userId, {
      include: [{
        model: Role,
        as: 'role',
        attributes: ['id', 'name']
      }],
      attributes: { exclude: ['password'] }
    });
    
    res.json(responseFormat.success(updatedUser, '个人资料更新成功'));
  } catch (error) {
    console.error('更新个人资料错误:', error);
    res.status(500).json(responseFormat.error('更新个人资料失败'));
  }
};

// 修改密码
const changePassword = async (req, res) => {
  try {
    const userId = req.user.id;
    const { currentPassword, newPassword } = req.body;
    
    if (!currentPassword || !newPassword) {
      return res.status(400).json(responseFormat.error('当前密码和新密码不能为空'));
    }
    
    if (newPassword.length < 6) {
      return res.status(400).json(responseFormat.error('新密码长度至少6位'));
    }
    
    const user = await User.findByPk(userId);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 验证当前密码
    const isValidPassword = await user.validatePassword(currentPassword);
    if (!isValidPassword) {
      return res.status(400).json(responseFormat.error('当前密码错误'));
    }
    
    // 更新密码
    await user.update({ password: newPassword });
    
    res.json(responseFormat.success(null, '密码修改成功'));
  } catch (error) {
    console.error('修改密码错误:', error);
    res.status(500).json(responseFormat.error('修改密码失败'));
  }
};

// 上传头像
const uploadAvatar = async (req, res) => {
  try {
    const userId = req.user.id;
    
    if (!req.file) {
      return res.status(400).json(responseFormat.error('请选择头像文件'));
    }
    
    const user = await User.findByPk(userId);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 构建头像URL（这里假设文件已经通过multer中间件处理）
    const avatarUrl = `/uploads/avatars/${req.file.filename}`;
    
    // 更新用户头像
    await user.update({ avatar: avatarUrl });
    
    res.json(responseFormat.success({ avatar: avatarUrl }, '头像上传成功'));
  } catch (error) {
    console.error('上传头像错误:', error);
    res.status(500).json(responseFormat.error('头像上传失败'));
  }
};

// 生成固定token
const generateFixedToken = async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 生成32位随机token
    const fixedToken = crypto.randomBytes(32).toString('hex');
    
    // 更新用户的固定token
    await user.update({ fixed_token: fixedToken });
    
    res.json(responseFormat.success({ 
      fixed_token: fixedToken,
      user_id: user.id,
      username: user.username
    }, '固定Token生成成功'));
  } catch (error) {
    console.error('生成固定Token错误:', error);
    if (error.name === 'SequelizeUniqueConstraintError') {
      return res.status(400).json(responseFormat.error('Token生成失败，请重试'));
    }
    res.status(500).json(responseFormat.error('生成固定Token失败'));
  }
};

// 重新生成固定token
const regenerateFixedToken = async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 生成新的32位随机token
    const newFixedToken = crypto.randomBytes(32).toString('hex');
    
    // 更新用户的固定token
    await user.update({ fixed_token: newFixedToken });
    
    res.json(responseFormat.success({ 
      fixed_token: newFixedToken,
      user_id: user.id,
      username: user.username
    }, '固定Token重新生成成功'));
  } catch (error) {
    console.error('重新生成固定Token错误:', error);
    if (error.name === 'SequelizeUniqueConstraintError') {
      return res.status(400).json(responseFormat.error('Token生成失败，请重试'));
    }
    res.status(500).json(responseFormat.error('重新生成固定Token失败'));
  }
};

// 删除固定token
const deleteFixedToken = async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id);
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    // 清除用户的固定token
    await user.update({ fixed_token: null });
    
    res.json(responseFormat.success(null, '固定Token删除成功'));
  } catch (error) {
    console.error('删除固定Token错误:', error);
    res.status(500).json(responseFormat.error('删除固定Token失败'));
  }
};

// 获取用户的固定token信息
const getFixedTokenInfo = async (req, res) => {
  try {
    const { id } = req.params;
    
    const user = await User.findByPk(id, {
      attributes: ['id', 'username', 'fixed_token']
    });
    
    if (!user) {
      return res.status(404).json(responseFormat.error('用户不存在'));
    }
    
    res.json(responseFormat.success({
      userId: user.id,
      username: user.username,
      hasToken: !!user.fixed_token,
      tokenPreview: user.fixed_token ? `${user.fixed_token.substring(0, 8)}...` : null,
      createdAt: user.fixed_token ? new Date().toISOString() : null
    }, '获取固定Token信息成功'));
  } catch (error) {
    console.error('获取固定Token信息错误:', error);
    res.status(500).json(responseFormat.error('获取固定Token信息失败'));
  }
};

// 导出用户列表到Excel
const exportToExcel = async (req, res) => {
  try {
    const { search, status } = req.query;
    
    const whereClause = {};
    if (search) {
      whereClause[Op.or] = [
        { username: { [Op.like]: `%${search}%` } },
        { real_name: { [Op.like]: `%${search}%` } },
        { email: { [Op.like]: `%${search}%` } },
        { phone: { [Op.like]: `%${search}%` } }
      ];
    }
    if (status) whereClause.status = status;
    
    // 查询所有符合条件的数据
    const users = await User.findAll({
      where: whereClause,
      include: [{
        model: Role,
        as: 'role',
        attributes: ['name']
      }],
      order: [['created_at', 'DESC']],
      raw: true,
      nest: true
    });

    // 状态映射
    const statusMap = {
      active: '活跃',
      inactive: '禁用',
      suspended: '暂停'
    };

    // 准备导出数据
    const exportData = users.map(user => ({
      id: user.id || '',
      username: user.username || '',
      real_name: user.real_name || '',
      email: user.email || '',
      phone: user.phone || '',
      role_name: user.role?.name || '',
      status: ExcelExport.formatStatus(user.status, statusMap),
      created_at: ExcelExport.formatDate(user.created_at),
      updated_at: ExcelExport.formatDate(user.updated_at)
    }));

    // 定义列
    const columns = [
      { header: 'ID', key: 'id', width: 10 },
      { header: '用户名', key: 'username', width: 15 },
      { header: '真实姓名', key: 'real_name', width: 15 },
      { header: '邮箱', key: 'email', width: 25 },
      { header: '手机号', key: 'phone', width: 15 },
      { header: '角色', key: 'role_name', width: 12 },
      { header: '状态', key: 'status', width: 10 },
      { header: '创建时间', key: 'created_at', width: 20 },
      { header: '更新时间', key: 'updated_at', width: 20 }
    ];

    // 生成Excel
    const buffer = await ExcelExport.exportToExcel(exportData, columns, '用户列表');

    // 设置响应头
    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
    res.setHeader('Content-Disposition', `attachment; filename=users_${Date.now()}.xlsx`);
    
    // 发送文件
    res.send(buffer);

  } catch (error) {
    console.error('导出用户列表失败:', error);
    res.status(500).json(responseFormat.error('导出失败'));
  }
};

module.exports = {
  getUsers,
  getUser,
  createUser,
  updateUser,
  deleteUser,
  updateUserStatus,
  getProfile,
  updateProfile,
  changePassword,
  uploadAvatar,
  generateFixedToken,
  regenerateFixedToken,
  deleteFixedToken,
  getFixedTokenInfo,
  exportToExcel
};