const JWT = require('jsonwebtoken');
const fs = require('fs');

// ici, on récupère nos clefs publique/privée, qui nous serviront
// pour la signature de nos JWT. On ne s'embête pas à faire de
// l'asynchrone car ces deux instructions seront, ici, uniquement
// exécutées au démarrage du serveur.
const RSA_PRIVATE_KEY = fs.readFileSync('./keys/jwtRS256.key');
const RSA_PUBLIC_KEY = fs.readFileSync('./keys/jwtRS256.key.pub');


// crée et renvoie un nouveau token JWT
function createJWT(userId) {
  // ci-dessous, on met en place le JWT : on signe un token JWT.
  // Ici, le payload est l'identifiant de l'utilisateur (mais on pourrait
  // envisager de stocker plus d'informations) plus un champ refreshTime dont
  // verra l'intérêt dans la fonction sendSessionCookie.
  // Quand on décodera le JWT, on aura accès à l'ID de l'utilisateur.
  // Dans les options du token, le champ expiresIn indique pendant combien
  // de temps le token sera valide (pas besoin de se relogguer tant que le
  // token n'a pas expiré).
  const jwtToken = JWT.sign(
    {
      userId: userId,
      refreshTime: Math.floor(Date.now() / 1000) + 2700 // validité: 45mn
    },
    RSA_PRIVATE_KEY,
    {
      algorithm: 'RS256',
      expiresIn: '1h' // champ exp: validité 1h
    });

  return jwtToken;
}
// ici, on n'exporte pas la fonction, elle reste interne


// Décode un cookie de session transmis dans une requête (on suppose qu'il
// contient le JWT) et renvoie les informations contenues dans ce cookie,
// ici le userId. Si le cookie n'existe pas ou bien si le token a expiré,
// la fonction renvoie juste un objet avec un userId égal à -1.
function decodeSessionCookie(req) {
  // on suppose que le cookie de session contenant le JWT s'appelle SESSIONID.
  // S'il n'existe pas, on renvoie une session vide avec juste un userId à -1
  if (typeof req.cookies.SESSIONID === 'undefined') {
    return {userId: -1};
  }

  // ici, le cookie existe. On récupère ses données
  const sessionid = req.cookies.SESSIONID;
  try {
    const token = JWT.verify(
      sessionid,        // le token
      RSA_PUBLIC_KEY,   // la clef de déchiffrement
      {algorithms: ['RS256']});

    return token;  // contient le payload du token
  } catch (err) {  // exception TokenExpiredError si JWT expiré
    return {userId: -1};
  }
}
module.exports.decodeSessionCookie = decodeSessionCookie;


// sendSessionCookie envoie le cookie de session JWT au navigateur.
// Le paramètre payload correspond à ce qui a été retourné par la fonction
// decodeSessionCookie. Autrement dit, si celui-ci contient une propriété
// idUser et une propriété refreshTime, cela correspond au contenu d'un
// JWT transmis par le navigateur. S'il n'est pas trop vieux (encore loin de
// sa date d'invalidité), on le renvoie tel quel. Dans les autres cas, on
// renvoie un cookie avec un nouveau JWT.
function sendSessionCookie(req, res, payload) {
  // On regarde si le payload provient bien d'un JWT transmis par le navigateur.
  // Si c'est le cas, il a une date de validité (cf. expiresIn). On pourrait
  // renvoyer le JWT du navigateur tant qu'on n'a pas atteint cette limite. Mais
  // si l'on est à 1s de cette date et qu'on renvoie le JWT du navigateur, la
  // prochaine fois que l'utilisateur tentera d'accéder au backend, le JWT aura
  // expiré et cela obligera l'utilisateur à se relogguer. Pour pallier cela,
  // refreshTime correspond à 15mn avant l'expiration du JWT. Si on a dépassé
  // refreshTime, on reconstruit un nouveau JWT. Notez que cela a un coût (de
  // chiffrement) et, donc, on veut éviter de créer un nouveau JWT à chaque
  // requête.
  let jwtToken = '';
  if ((typeof payload.userId !== 'undefined') &&
    (typeof payload.refreshTime !== 'undefined') &&
    (Math.floor(Date.now() / 1000) <= payload.refreshTime)) {
    // ici, on peut renvoyer le JWT que le navigateur avait transmis : il reste
    // à l'utilisateur au moins 15 minutes pour effectuer sa prochaine requête
    jwtToken = req.cookies.SESSIONID;
  } else {
    // on crée un nouveau JWT
    jwtToken = createJWT(payload.userId);
  }

  // on renvoie le cookie au client
  // on met le secure à false afin de pouvoir utiliser http plutôt que https
  // pour nos tests
  res.cookie('SESSIONID', jwtToken, {
    httpOnly: true,
    secure: false,
    sameSite: 'Lax'
  });
}
module.exports.sendSessionCookie = sendSessionCookie;

const {sendError, sendMessage} = require ("./message");
const sessionJWT = require('./sessionJWT')
const Courses = require("./database/sql_courses");

async function getCourses(req, res) {
   // On récupère la variable de session et, dans celle-ci, on va récupérer
   // l'ID du user. C'est équivalent en PHP à :
   // session_start();
   // $userId = $_SESSION['userId'];
   const session = sessionJWT.decodeSessionCookie(req);
   const userId = session.userId;
   if (userId === -1)
     return sendError (res, 'not authenticated');
   sessionJWT.sendSessionCookie (req, res, session);

   // ici, on récupère la liste des cours et on la renvoie via un
   // return sendMessage(res, ....)
   ..............
}
module.exports = getCourses;

......
sessionJWT.sendSessionCookie(req, res, { userId: userId});
return sendMessage(res, 'message');