timelapse-backend/routes/cameraRoutes.js

const express = require('express');
const router = express.Router();
const path = require('path');
const fs = require('fs');
const dbTester = require('../test/tester');
const db = require('../db');
const serverError = require('../utils/serverError');

//const minInterval = 3; // Minutes
//const maxInterval = 60; // Minutes

var defaultCaptureInterval = 5; // minutes
var defaultMaintenance = 0;

var captureInterval = defaultCaptureInterval; // intervalle de capture en minutes
var maintenance = defaultMaintenance; // 0 = pas de maintenance, 1 = maintenance

function initCamera() {
   const query = 'SELECT * FROM public.camera WHERE id = $1';
   const values = [1];

   db.query(query, values, (err, result) => {
      if (err) {
         console.error('Erreur lors de la vérification de l\'entrée caméra:', err);
         return;
      }

      if (result.rows.length === 0) {
         const insertQuery = `
            INSERT INTO public.camera (id, interval, maintenance)
            VALUES ($1, $2, $3)
         `;
         const insertValues = [1, defaultCaptureInterval, defaultMaintenance];

         db.query(insertQuery, insertValues, (err) => {
            if (err) {
               console.error('Erreur lors de l\'initialisation de la caméra:', err);
            } else {
               console.log('Caméra initialisée avec les valeurs par défaut.');
            }
         });
      } else {
         console.log('L\'entrée caméra avec l\'ID 1 existe déjà. Aucune initialisation nécessaire.');
      }
   });
}

function getCamera() {
   // retourner l'état de la caméra
   const query = 'SELECT * FROM public.camera WHERE id = $1';
   const values = [1];
   db.query(query, values, (err, result) => {
      if (err) {
         console.error('Erreur lors de la récupération de l\'entrée caméra:', err);
         return;
      }

      if (result.rows.length === 0) {
         console.log('Aucune entrée caméra trouvée.');
         return;
      }

      const camera = result.rows[0];
      captureInterval = camera.interval;
      maintenance = camera.maintenance;

      console.log('Caméra récupérée avec succès:', camera);
   });
   return {
      captureInterval: captureInterval,
      maintenance: maintenance
   };
}

function printCameraStatus() {
   let camera = getCamera();
   console.log('Statut de la caméra:');
   console.log('Intervalle de capture:', camera.captureInterval, 'minutes');
   console.log('Maintenance:', camera.maintenance === 1 ? 'En cours' : 'Aucune');
   console.log('-----------------------------------');
}

function isCameraOccupied() {
   return getCamera().captureStatus === 1;
}

initCamera();
printCameraStatus();

/**
 * @swagger
 * /camera/status:
 *   get:
 *     summary: Get the current status of the camera
 *     tags:
 *       - Camera
 *     responses:
 *       200:
 *         description: Successfully retrieved the camera status
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *               properties:
 *                 captureInterval:
 *                   type: integer
 *                   description: Capture interval in minutes
 *                 captureProjectID:
 *                   type: integer
 *                   description: ID of the project currently being captured
 *                 captureStatus:
 *                   type: integer
 *                   description: Capture status (0 = stopped, 1 = ongoing)
 *                 maintenance:
 *                   type: integer
 *                   description: Maintenance status (0 = none, 1 = ongoing)
 *       500:
 *         description: Internal server error
 */
router.get('/camera/status', async (req, res) => {
   try {
      const cameraStatus = getCamera();
      res.status(200).json(cameraStatus);
   } catch (err) {
      serverError.sendError('Erreur lors de la récupération de l\'état de la caméra:', res, err, 500);
   }
}
);

router.post('/procedure/start/', async (req, res) => {
   const { projectId, interval } = req.body;
    try {
         const result = startProcedure(projectId, interval);
         res.status(200).json(result);
    } catch (err) {
         serverError.sendError('Erreur lors du démarrage de la procédure de capture:', res, err, 500);
    }
});

function startProcedure(projectId, interval) {
   if (isCameraOccupied()) {
      return { message: 'Caméra Occupée : Le projet ID ' + captureProjectID + ' est déjà en cours de capture.' };
   }
   console.log('Démarrage de la procédure de capture');
   exists = db.query('SELECT * FROM public.projects WHERE id = $1', [projectId]);
   if (!exists) {
      return { message: 'Le projet ID ' + projectId + ' n\'existe pas.' };
   }
   if (interval < minInterval) {
      return { message: 'L\'intervalle de capture doit être supérieur ou égal à ' + minInterval + ' minutes.' };
   }
   // if (interval > maxInterval) {
   //    return { message: 'L\'intervalle de capture doit être inférieur ou égal à ' + maxInterval + ' minutes.' };
   // }

   // Application des valeurs
   captureProjectID = projectId;
   captureInterval = interval;

   //via la DB changer le status du projet
   const query = 'UPDATE public.projects SET status = $2 WHERE id = $1 RETURNING *';
   const values = [projectId, 1];
   db.query(query, values, (err, res) => {
      if (err) {
         console.error('Erreur lors de la mise à jour du statut (activation) du projet:', err);
         return { message: 'Erreur lors de la mise à jour du statut (activation) du projet.' };
      }
   });

   console.log('Procédure de capture démarrée avec succès, projet ID: ' + projectId + ', interval: ' + interval + ' minutes.');
   return { message: 'Procédure de capture démarrée avec succès, projet ID: ' + projectId + ', interval: ' + interval + ' minutes.' };
}

function stopProcedure() {
   oldProjectID = captureProjectID;
   oldInterval = captureInterval;
   console.log('Ancien Projet : ' + oldProjectID + ', Ancien Intervalle : ' + oldInterval);

   // Application du reset
   captureProjectID = -1;
   captureInterval = 0;
   console.log('Nouveau Projet : ' + captureProjectID + ', Nouvel Intervalle : ' + captureInterval);

   console.log('Arrêt de la procédure de capture');

   //via la DB changer le status du projet
   const query = 'UPDATE public.projects SET status = $2 WHERE id = $1 RETURNING *';
   const values = [oldProjectID, 0];
   db.query(query, values, (err, res) => {
      if (err) {
         console.error('Erreur lors de la mise à jour du statut (désactivation) du projet:', err);
         return { message: 'Erreur lors de la mise à jour du statut (désactivation) du projet.' };
      }
   });

   return { message: 'Procédure de capture arrêtée avec succès, projet ID: ' + oldProjectID + ', interval: ' + oldInterval + ' minutes.' };
}


router.post('/procedure/stop/', async (req, res) => {
   try {
      const result = stopProcedure();
      res.status(200).json(result);
   } catch (err) {
      serverError.sendError('Erreur lors de l\'arrêt de la procédure de capture:', res, err, 500);
   }
});

module.exports = router;