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

// 用户注册
const register = async (req, res) => {
  try {
    const { username, password, real_name, email, phone, role_id } = 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
    });
    
    res.status(201).json(responseFormat.created(user, '用户注册成功'));
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json(responseFormat.error('用户注册失败'));
  }
};

// 用户登录
const login = async (req, res) => {
  try {
    const { username, password } = req.body;
    
    if (!username || !password) {
      return res.status(400).json(responseFormat.error('用户名和密码不能为空'));
    }
    
    // 查找用户（支持用户名、邮箱、手机号登录）
    const user = await User.findOne({
      where: {
        [Op.or]: [
          { username },
          { email: username },
          { phone: username }
        ]
      },
      include: [{
        model: Role,
        as: 'role',
        attributes: ['id', 'name', 'permissions']
      }]
    });
    
    if (!user) {
      return res.status(401).json(responseFormat.error('用户不存在'));
    }
    
    if (user.status !== 'active') {
      return res.status(401).json(responseFormat.error('账户已被禁用'));
    }
    
    // 验证密码
    const isValidPassword = await user.validatePassword(password);
    if (!isValidPassword) {
      return res.status(401).json(responseFormat.error('密码错误'));
    }
    
    // 更新最后登录时间
    await user.update({ last_login: new Date() });
    
    // 生成访问令牌（短期有效）
    const accessToken = jwt.sign(
      {
        id: user.id,
        username: user.username,
        role_id: user.role_id,
        permissions: user.role?.permissions || [],
        type: 'access'
      },
      process.env.JWT_SECRET,
      { expiresIn: '15m' } // 15分钟
    );
    
    // 生成刷新令牌（长期有效）
    const refreshToken = jwt.sign(
      {
        id: user.id,
        username: user.username,
        type: 'refresh'
      },
      process.env.JWT_SECRET,
      { expiresIn: '7d' } // 7天
    );
    
    const userJson = user.toJSON();
    console.log('用户JSON数据:', userJson);
    
    // 确保用户数据是纯JSON对象，包含角色信息
    const userData = {
      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,
      createdAt: user.createdAt,
      updatedAt: user.updatedAt,
      role: user.role ? {
        id: user.role.id,
        name: user.role.name,
        permissions: user.role.permissions
      } : null
    };
    
    const responseData = {
      user: userData,
      accessToken,
      refreshToken,
      accessTokenExpiresIn: 15 * 60, // 15分钟（秒）
      refreshTokenExpiresIn: 7 * 24 * 60 * 60 // 7天（秒）
    };
    
    console.log('响应数据:', responseData);
    
    res.json(responseFormat.success(responseData, '登录成功'));
  } catch (error) {
    console.error('登录错误详情:', {
      message: error.message,
      stack: error.stack,
      name: error.name
    });
    res.status(500).json(responseFormat.error('登录失败: ' + error.message));
  }
};

// 获取当前用户信息
const getCurrentUser = async (req, res) => {
  try {
    const user = await User.findByPk(req.user.id, {
      include: [{
        model: Role,
        as: 'role',
        attributes: ['id', 'name', 'permissions']
      }]
    });
    
    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 changePassword = async (req, res) => {
  try {
    const { currentPassword, newPassword } = req.body;
    const userId = req.user.id;
    
    if (!currentPassword || !newPassword) {
      return res.status(400).json(responseFormat.error('当前密码和新密码不能为空'));
    }
    
    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(401).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 refreshToken = async (req, res) => {
  try {
    const { refreshToken: refresh_token } = req.body;
    
    if (!refresh_token) {
      return res.status(400).json(responseFormat.error('刷新令牌不能为空'));
    }
    
    // 验证刷新令牌
    let decoded;
    try {
      decoded = jwt.verify(refresh_token, process.env.JWT_SECRET);
    } catch (error) {
      return res.status(401).json(responseFormat.error('刷新令牌无效或已过期'));
    }
    
    // 检查令牌类型
    if (decoded.type !== 'refresh') {
      return res.status(401).json(responseFormat.error('无效的令牌类型'));
    }
    
    const user = await User.findByPk(decoded.id, {
      include: [{
        model: Role,
        as: 'role',
        attributes: ['id', 'name', 'permissions']
      }]
    });
    
    if (!user || user.status !== 'active') {
      return res.status(401).json(responseFormat.error('用户不存在或已被禁用'));
    }
    
    // 生成新的访问令牌
    const newAccessToken = jwt.sign(
      {
        id: user.id,
        username: user.username,
        role_id: user.role_id,
        permissions: user.role?.permissions || [],
        type: 'access'
      },
      process.env.JWT_SECRET,
      { expiresIn: '15m' } // 15分钟
    );
    
    // 可选：生成新的刷新令牌（滚动刷新）
    const newRefreshToken = jwt.sign(
      {
        id: user.id,
        username: user.username,
        type: 'refresh'
      },
      process.env.JWT_SECRET,
      { expiresIn: '7d' } // 7天
    );
    
    res.json(responseFormat.success({
      accessToken: newAccessToken,
      refreshToken: newRefreshToken,
      accessTokenExpiresIn: 15 * 60, // 15分钟（秒）
      refreshTokenExpiresIn: 7 * 24 * 60 * 60, // 7天（秒）
      user: user.toJSON()
    }, '令牌刷新成功'));
  } catch (error) {
    console.error('刷新令牌错误:', error);
    res.status(401).json(responseFormat.error('刷新令牌失败'));
  }
};

// 用户登出
const logout = async (req, res) => {
  try {
    // 这里可以添加令牌黑名单逻辑
    res.json(responseFormat.success(null, '登出成功'));
  } catch (error) {
    console.error('登出错误:', error);
    res.status(500).json(responseFormat.error('登出失败'));
  }
};

module.exports = {
  register,
  login,
  getCurrentUser,
  changePassword,
  refreshToken,
  logout
};