import pool from "../config/db.js";
import jwt from "jsonwebtoken";
import bcrypt from 'bcryptjs';

// Création d'un utilisateur
export const register = async (req, res) => {
    let conn;
    try {
        conn = await pool.getConnection();
        const { email, firstname, lastname, password_hash } = req.body;
        if (!email || !firstname || !lastname || !password_hash) {
            return res.status(400).json({
                message: 'Tout les champs sont requis !',
                status: false
            });
        }
        const existingUsers = await conn.query(
            'SELECT * FROM users WHERE email = ?',
            [email]
        );
        if (existingUsers.length > 0) {
          return res.status(409).json({
            message: 'L\'utilisateur existe déjà !',
            status: false
          });
        }
        // Hash du mot de passe
        const hashedPassword = await bcrypt.hash(password_hash, 10);
        const result = await conn.query(
            'INSERT INTO users (email, firstname, lastname, password_hash) VALUES (?, ?, ?, ?)',
            [email, firstname, lastname, hashedPassword]
        );
        res.status(201).json({
            message: 'L\'utilisateur à bien été enregistré !',
            status: true
        });
    } catch (err) {
        console.error('Erreur interne :', err);
        return res.status(500).json({
            message: 'Erreur interne du serveur.',
            status: false
        });
    } finally {
        if (conn) await conn.release();
    }
};

// Connexion
export const login = async (req, res) => {
    let conn;
    try {
        conn = await pool.getConnection();
        const { email, password } = req.body;
        // Chercher l'utilisateur
        const users = await conn.query(
            'SELECT * FROM users WHERE email = ?',
            [email]
        );
        if (users.length === 0) {
            return res.status(401).json({
                message: 'Identifiant incorrect',
                status: false
            });
        }
        const user = users[0];
        // Verify password
        const isPasswordValid = await bcrypt.compare(password, user.password_hash);
        if (!isPasswordValid) {
            return res.status(401).json({
                message: 'Identifiant incorrect',
                status: false
            });
        }
        // Generate JWT token
        const token = jwt.sign(
            {
                id: user.id,
            },
            process.env.JWT_SECRET || 'fallback_secret',
            { expiresIn: '12h' }
        );
        await conn.query(
            'UPDATE users SET updated_at = CURRENT_TIMESTAMP WHERE id = ?',
            [user.id]
        );

        res.cookie('jwt', token, {
            httpOnly: true,
            secure: true,
            sameSite: 'Strict',
            maxAge: 12 * 60 * 60 * 1000
        });
        res.json({
            message: 'Connexion réussie',
            status: true
        });
    } catch (err) {
        console.error('Erreur interne :', err);
        return res.status(500).json({
            message: 'Erreur interne du serveur.',
            status: false
        });
    } finally {
        if (conn) await conn.release();
    }
};

// Déconnecter l'utilisateur
export const logout = (req, res) => {
    res.clearCookie('jwt', {
        httpOnly: true,
        secure: true,
        sameSite: 'Strict',
    });
    res.status(200).json({
        message: 'Successfully logged out',
        status: true
    });
};

// Vérification de la connexion sur la page pour guard angular
export const checkAuth = (req, res) => {
    const token = req.cookies.jwt;
    if (!token) {
        return res.status(401).json({
            message: 'Non identifié',
            status: false
        });
    }
    try {
        req.user = jwt.verify(token, process.env.JWT_SECRET);
        res.status(200).json({
            message: 'identifié',
            status: true
        });
    } catch (err) {
        console.error('Erreur interne :', err);
        return res.status(500).json({
            message: 'Erreur interne du serveur.',
            status: false
        });
    }
};

export const getprofile = async (req, res) => {
  const token = req.cookies.jwt;
  let conn;
  try {
    conn = await pool.getConnection();

    req.user = jwt.verify(token, process.env.JWT_SECRET);

    // Requête pour récupérer les informations de l'utilisateur sauf le mot de passe
    const query = `
            SELECT id, email, firstname, lastname, updated_at, created_at
            FROM users
            WHERE id = ?`;
    const results = await conn.query(query, [req.user.id]);

    // Vérifie si l'utilisateur existe
    if (results.length === 0) {
      return res.status(404).json({
        message: 'Utilisateur non trouvé.',
        status: false
      });
    }

    return res.status(200).json({
      results
    });
  } catch (error) {
    console.error('Erreur lors de la récupération de l\'utilisateur :', error);
    return res.status(500).json({
      message: 'Erreur lors de la récupération de l\'utilisateur.',
      status: false
    });
  } finally {
    if (conn) {
      await conn.release();
    }
  }
};