timelapse-backend/routes/capture_system.js

const express = require('express');
const router = express.Router();
const sharp = require('sharp');
const fs = require('fs');
const dbTester = require('../test/tester');
const db = require('../db');
const serverError = require('../utils/serverError');
const database_manager = require('../src/database/database_manager');
const storage_manager = require('../src/data/storage_manager');

const defaultSettings = {
   id: 1,
   interval: null,
   nb_images: null,
   maintenance: false,
   stop_flag: false,
   idle: true
};

async function camera_initialization() {
   // si capture.get_camera est vide ou undefined, on l'initialise
   let current_camera = await database_manager.capture.get_camera();
   if (!current_camera || current_camera === undefined) {
      console.log("Initializing camera...");
      current_camera = await database_manager.capture.init_camera(
         defaultSettings.id,
         defaultSettings.interval,
         defaultSettings.nb_images,
         defaultSettings.maintenance,
         defaultSettings.stop_flag,
         defaultSettings.idle
      );
      console.log("Camera initialized:", current_camera);
   }
   else {
      console.log("Camera already initialized:", current_camera);
   }
}

camera_initialization()

async function get_camera_settings() {
   const settings = await database_manager.capture.get_camera();
   if (!settings) {
      // balancer une erreur si la caméra n'est pas initialisée
      throw new Error("Camera settings not found in the database.");
   }
   return settings;
}

router.get('/camera/status', async (req, res) => {
   try {
      const settings = await get_camera_settings();
      res.json(settings);
   } catch (error) {
      serverError.sendError('Error getting camera status:', res, error, 500);
   }
});

async function stop_procedure() { // côté serveur
   let new_settings = {
      stop_flag: true,
   }
   await database_manager.capture.edit_camera(new_settings);
   console.log("Stopping camera... en attente de confirmation de la caméra...");
}

async function confirm_stop_procedure() { // côté caméra
   let new_settings = {
      interval: null,
      nb_images: null,
      stop_flag: false,
      idle: true,
   }
   await database_manager.capture.edit_camera(new_settings);
   console.log("Camera stopped.");
}

async function start_procedure(interval, nb_images) {
   let new_settings = {
      interval: interval,
      nb_images: nb_images,
      stop_flag: false,
      idle: false,
   }
   console.log("Starting Procedure with settings:", new_settings);
   await database_manager.capture.edit_camera(new_settings);
   console.log("Camera started.");
}

async function activate_maintenance() {
   let new_settings = {
      maintenance: true,
   }
   await database_manager.capture.edit_camera(new_settings);
   console.log("Camera in maintenance mode.");
}

async function deactivate_maintenance() {
   let new_settings = {
      maintenance: false,
   }
   await database_manager.capture.edit_camera(new_settings);
   console.log("Camera out of maintenance mode.");
}

router.post('/procedure/start', async (req, res) => {
   const { interval, nb_images } = req.body;
   if (!interval || !nb_images) {
      return res.status(400).json({ error: 'Interval and number of images are required' });
   }
   try {
      await start_procedure(interval, nb_images);
      res.json({ message: 'Camera started successfully', settings: { interval, nb_images } });
   } catch (error) {
      serverError.sendError('Error starting camera procedure:', res, error, 500);
   }
});

router.post('/procedure/stop', async (req, res) => {
   try {
      await stop_procedure();
      res.json({ message: 'Camera stop procedure initiated successfully' });
   } catch (error) {
      serverError.sendError('Error stopping camera procedure:', res, error, 500);
   }
});

router.post('/camera/stop', async (req, res) => {
   try {
      await confirm_stop_procedure();
      res.json({ message: 'Camera stopped successfully' });
   } catch (error) {
      serverError.sendError('Error stopping camera:', res, error, 500);
   }
});


router.post('/camera/maintenance', async (req, res) => {
   try {
      await activate_maintenance();
      res.json({ message: 'Camera in maintenance mode' });
   } catch (error) {
      serverError.sendError('Error activating maintenance mode:', res, error, 500);
   }
}
);

router.post('/camera/maintenance/deactivate', async (req, res) => {
   try {
      await deactivate_maintenance();
      res.json({ message: 'Camera out of maintenance mode' });
   } catch (error) {
      serverError.sendError('Error deactivating maintenance mode:', res, error, 500);
   }
});