const express = require('express');
const router = express.Router();
const bcrypt = require('bcrypt');
const { query } = require('../config/database');
const { generateToken } = require('../middleware/auth');

// Inscription
router.post('/register', async (req, res) => {
  try {
    const { username, password, email, role = 'employe' } = req.body;

    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: 'Nom d\'utilisateur et mot de passe requis'
      });
    }

    // Vérifier si l'utilisateur existe déjà
    const existingUser = await query('ggr', 'SELECT * FROM utilisateurs WHERE username = ?', [username]);
    if (existingUser.length > 0) {
      return res.status(400).json({
        success: false,
        message: 'Nom d\'utilisateur déjà pris'
      });
    }

    // Hash du mot de passe
    const saltRounds = 10;
    const hashedPassword = await bcrypt.hash(password, saltRounds);

    // Créer l'utilisateur
    const result = await query('ggr', `
      INSERT INTO utilisateurs (username, password, email, role, created_at)
      VALUES (?, ?, ?, ?, NOW())
    `, [username, hashedPassword, email, role]);

    res.status(201).json({
      success: true,
      message: 'Utilisateur créé avec succès',
      data: {
        id: result.insertId,
        username,
        email,
        role
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

// Connexion
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;

    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: 'Nom d\'utilisateur et mot de passe requis'
      });
    }

    // Chercher l'utilisateur
    const users = await query('ggr', 'SELECT * FROM utilisateurs WHERE username = ?', [username]);
    if (users.length === 0) {
      return res.status(401).json({
        success: false,
        message: 'Nom d\'utilisateur ou mot de passe incorrect'
      });
    }

    const user = users[0];

    // Vérifier le mot de passe
    const validPassword = await bcrypt.compare(password, user.password);
    if (!validPassword) {
      return res.status(401).json({
        success: false,
        message: 'Nom d\'utilisateur ou mot de passe incorrect'
      });
    }

    // Générer le token JWT
    const token = generateToken({
      id: user.id,
      username: user.username,
      role: user.role
    });

    res.json({
      success: true,
      message: 'Connexion réussie',
      data: {
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          role: user.role
        },
        token
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

// Profil utilisateur
router.get('/profile', async (req, res) => {
  try {
    const userId = req.user.id;

    const user = await query('ggr', 'SELECT id, username, email, role, created_at FROM utilisateurs WHERE id = ?', [userId]);
    if (user.length === 0) {
      return res.status(404).json({
        success: false,
        message: 'Utilisateur non trouvé'
      });
    }

    res.json({
      success: true,
      data: user[0]
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

// Mise à jour du profil
router.put('/profile', async (req, res) => {
  try {
    const userId = req.user.id;
    const { email, currentPassword, newPassword } = req.body;

    // Vérifier l'utilisateur
    const users = await query('ggr', 'SELECT * FROM utilisateurs WHERE id = ?', [userId]);
    if (users.length === 0) {
      return res.status(404).json({
        success: false,
        message: 'Utilisateur non trouvé'
      });
    }

    const user = users[0];

    // Si nouveau mot de passe, vérifier l'ancien
    if (newPassword) {
      const validPassword = await bcrypt.compare(currentPassword, user.password);
      if (!validPassword) {
        return res.status(401).json({
          success: false,
          message: 'Mot de passe actuel incorrect'
        });
      }

      // Hash du nouveau mot de passe
      const saltRounds = 10;
      const hashedPassword = await bcrypt.hash(newPassword, saltRounds);

      // Mettre à jour le mot de passe
      await query('ggr', 'UPDATE utilisateurs SET password = ? WHERE id = ?', [hashedPassword, userId]);
    }

    // Mettre à jour l'email si fourni
    if (email) {
      await query('ggr', 'UPDATE utilisateurs SET email = ? WHERE id = ?', [email, userId]);
    }

    // Retourner les informations mises à jour
    const updatedUser = await query('ggr', 'SELECT id, username, email, role, created_at FROM utilisateurs WHERE id = ?', [userId]);

    res.json({
      success: true,
      message: 'Profil mis à jour avec succès',
      data: updatedUser[0]
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

// Déconnexion (effacer le token côté client)
router.post('/logout', (req, res) => {
  res.json({
    success: true,
    message: 'Déconnexion réussie'
  });
});

// Obtenir tous les utilisateurs (admin seulement)
router.get('/users', async (req, res) => {
  try {
    // Vérifier si l'utilisateur est admin
    if (req.user.role !== 'admin') {
      return res.status(403).json({
        success: false,
        message: 'Permissions insuffisantes'
      });
    }

    const users = await query('ggr', 'SELECT id, username, email, role, created_at FROM utilisateurs ORDER BY created_at DESC');
    
    res.json({
      success: true,
      data: users
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

// Supprimer un utilisateur (admin seulement)
router.delete('/users/:id', async (req, res) => {
  try {
    const userId = req.params.id;
    const currentUserId = req.user.id;

    // Vérifier si l'utilisateur est admin
    if (req.user.role !== 'admin') {
      return res.status(403).json({
        success: false,
        message: 'Permissions insuffisantes'
      });
    }

    // Ne pas permettre la suppression de son propre compte
    if (userId == currentUserId) {
      return res.status(400).json({
        success: false,
        message: 'Impossible de supprimer votre propre compte'
      });
    }

    // Supprimer l'utilisateur
    await query('ggr', 'DELETE FROM utilisateurs WHERE id = ?', [userId]);

    res.json({
      success: true,
      message: 'Utilisateur supprimé avec succès'
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

module.exports = router;