const User = require('../models/User');
const Role = require('../models/Role');

/**
 * 固定Token认证中间件
 * 支持JWT token和固定token两种认证方式
 */
const fixedTokenAuth = async (req, res, next) => {
  try {
    const authHeader = req.headers.authorization;
    
    if (!authHeader) {
      return res.status(401).json({
        status: 'error',
        message: '未提供认证token'
      });
    }

    // 检查是否为Bearer token格式
    if (authHeader.startsWith('Bearer ')) {
      const token = authHeader.substring(7);
      
      // 首先尝试固定token验证
      const user = await User.findOne({
        where: { 
          fixed_token: token,
          status: 'active'
        },
        include: [{
          model: Role,
          as: 'role',
          attributes: ['id', 'name', 'permissions']
        }]
      });

      if (user) {
        // 固定token验证成功
        req.user = {
          id: user.id,
          username: user.username,
          role_id: user.role_id,
          role: user.role,
          permissions: user.role ? user.role.permissions : []
        };
        return next();
      }
      
      // 如果固定token验证失败，尝试JWT验证
      const jwt = require('jsonwebtoken');
      try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        
        if (decoded.type !== 'access') {
          return res.status(401).json({
            status: 'error',
            message: 'Token类型错误'
          });
        }

        // 验证用户是否存在且状态正常
        const jwtUser = await User.findOne({
          where: { 
            id: decoded.userId,
            status: 'active'
          },
          include: [{
            model: Role,
            as: 'role',
            attributes: ['id', 'name', 'permissions']
          }]
        });

        if (!jwtUser) {
          return res.status(401).json({
            status: 'error',
            message: '用户不存在或已被禁用'
          });
        }

        req.user = {
          id: jwtUser.id,
          username: jwtUser.username,
          role_id: jwtUser.role_id,
          role: jwtUser.role,
          permissions: decoded.permissions || (jwtUser.role ? jwtUser.role.permissions : [])
        };
        
        return next();
      } catch (jwtError) {
        if (jwtError.name === 'TokenExpiredError') {
          return res.status(401).json({
            status: 'error',
            code: 'TOKEN_EXPIRED',
            message: 'Token已过期'
          });
        } else if (jwtError.name === 'JsonWebTokenError') {
          return res.status(401).json({
            status: 'error',
            message: 'Token无效'
          });
        }
        throw jwtError;
      }
    } else {
      return res.status(401).json({
        status: 'error',
        message: 'Token格式错误，请使用Bearer格式'
      });
    }
  } catch (error) {
    console.error('Token验证错误:', error);
    return res.status(500).json({
      status: 'error',
      message: '服务器内部错误'
    });
  }
};

module.exports = fixedTokenAuth;