const jwt = require('jsonwebtoken');
require('dotenv').config();

const JWT_SECRET = process.env.JWT_SECRET || 'default_secret_change_in_production';

// Middleware pour vérifier le token JWT
const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

  if (!token) {
    return res.status(401).json({
      success: false,
      message: 'Token d\'authentification requis'
    });
  }

  jwt.verify(token, JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({
        success: false,
        message: 'Token invalide ou expiré'
      });
    }

    req.user = user;
    next();
  });
};

// Middleware pour vérifier les rôles
const authorizeRoles = (...roles) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({
        success: false,
        message: 'Utilisateur non authentifié'
      });
    }

    if (!roles.includes(req.user.role)) {
      return res.status(403).json({
        success: false,
        message: 'Permissions insuffisantes'
      });
    }

    next();
  };
};

// Générer un token JWT
const generateToken = (user) => {
  return jwt.sign(
    {
      id: user.id,
      username: user.username,
      role: user.role
    },
    JWT_SECRET,
    { expiresIn: process.env.JWT_EXPIRES_IN || '24h' }
  );
};

// Middleware pour logger les requêtes
const logRequest = (req, res, next) => {
  const timestamp = new Date().toISOString();
  const method = req.method;
  const path = req.path;
  const userId = req.user ? req.user.id : 'anonymous';
  
  console.log(`[${timestamp}] ${method} ${path} - User: ${userId}`);
  
  // Enregistrer dans un fichier de logs (optionnel)
  next();
};

// Middleware pour limiter les requêtes par utilisateur
const rateLimitByUser = new Map();
const RATE_LIMIT_WINDOW = 15 * 60 * 1000; // 15 minutes
const RATE_LIMIT_MAX = 100; // 100 requêtes par fenêtre

const userRateLimiter = (req, res, next) => {
  const userId = req.user ? req.user.id : req.ip;
  const now = Date.now();
  
  if (!rateLimitByUser.has(userId)) {
    rateLimitByUser.set(userId, { count: 1, startTime: now });
    return next();
  }
  
  const userLimit = rateLimitByUser.get(userId);
  
  if (now - userLimit.startTime > RATE_LIMIT_WINDOW) {
    rateLimitByUser.set(userId, { count: 1, startTime: now });
    return next();
  }
  
  if (userLimit.count >= RATE_LIMIT_MAX) {
    return res.status(429).json({
      success: false,
      message: 'Trop de requêtes, veuillez attendre'
    });
  }
  
  userLimit.count++;
  next();
};

module.exports = {
  authenticateToken,
  authorizeRoles,
  generateToken,
  logRequest,
  userRateLimiter
};