timelapse-backend/routes/videoRoutes.js

const express = require('express');
const router = express.Router();
const db = require('../db');
const fs = require('fs');
const rangeParser = require('range-parser');
const path = require('path');
const serverError = require('../utils/serverError');
const videoManager = require('../src/video/videoManager');
const measureManager = require('../src/measure/measureManager');
const dbTester = require('../test/tester');

router.get('/videos', (req, res) => {
   const query = 'SELECT * FROM public.videos';
   db.query(query, (err, results) => {
      if (err) {
         serverError.sendError('Erreur lors de la récupération des vidéos:', res, err);
      }
      res.json(results.rows);
   });
});

router.get('/videos/:id', (req, res) => {
   const videoId = req.params.id;
   if (!videoId || isNaN(videoId)) {
      return res.status(400).json({ error: 'Invalid video ID' });
   }
   const query = 'SELECT * FROM public.videos WHERE id = $1';
   db.query(query, [videoId], (err, results) => {
      if (err) {
         serverError.sendError('Erreur lors de la récupération de la vidéo:', res, err);
      }
      res.json(results.rows);
   });
});

router.post('/videos', async (req, res) => {
   const { project_id, measurement_ids, name, resolution, duration } = req.body;
   console.log('Creating video:', req.body);
   if (!project_id || !measurement_ids || !name || !resolution || !duration) {
      return res.status(400).json({ error: 'Tous les champs sont requis.' });
   }

   console.log('Creating video with measurements:', measurement_ids);

   try {
      const videoId = await videoManager.createVideoProject(project_id, measurement_ids, name, resolution, duration);
      res.json({ message: 'Vidéo créée avec succès', videoId });
   } catch (err) {
      console.error('Erreur lors de la création de la vidéo:', err);
      res.status(500).json({ error: 'Erreur lors de la création de la vidéo' });
   }
});


router.delete('/videos/:id', (req, res) => {
   const videoId = req.params.id;
   if (!videoId || isNaN(videoId)) {
      return res.status(400).json({ error: 'Invalid video ID' });
   }
   videoManager.deleteVideoProject(videoId).then(() => {
      res.json({ message: 'Vidéo supprimée avec succès' });
   }).catch(err => {
      console.error('Erreur lors de la suppression de la vidéo:', err);
   });
});

router.get('/videos/file/:video_id', (req, res) => {
   const videoId = req.params.video_id;
   const query = 'SELECT video_file, status FROM public.videos WHERE id = $1';

   db.query(query, [videoId], (err, results) => {
      if (err) {
         console.error('Error getting video:', err);
         return serveFallbackVideo(res);
      }
      if (results.rows.length === 0) {
         console.error('Video not found');
         return serveFallbackVideo(res);
      }

      const video = results.rows[0];
      if (video.status === 0) {
         return res.status(400).json({ error: 'Video not yet produced' });
      }

      const videoPath = video.video_file;

      // Check if the video file exists
      fs.access(videoPath, fs.constants.F_OK, (err) => {
         if (err) {
            console.error('Video file not found:', err);
            return serveFallbackVideo(res);
         }

         const stat = fs.statSync(videoPath);
         const fileSize = stat.size;
         const range = req.headers.range;

         if (range) {
            const parts = rangeParser(fileSize, range);
            const start = parts[0].start;
            const end = parts[0].end;
            const chunksize = (end - start) + 1;
            const file = fs.createReadStream(videoPath, { start, end });
            const head = {
               'Content-Range': `bytes ${start}-${end}/${fileSize}`,
               'Accept-Ranges': 'bytes',
               'Content-Length': chunksize,
               'Content-Type': 'video/mp4',
            };
            res.writeHead(206, head);
            file.pipe(res);
         } else {
            const head = {
               'Content-Length': fileSize,
               'Content-Type': 'video/mp4',
            };
            res.writeHead(200, head);
            fs.createReadStream(videoPath).pipe(res);
         }
      });
   });
});

function serveFallbackVideo(res) {
   const videoPath = dbTester.getCatVideo();
   fs.access(videoPath, fs.constants.F_OK, (err) => {
      if (err) {
         console.error('Fallback video not found:', err);
         return res.status(500).json({ error: 'Fallback video not found' });
      }
      res.download(videoPath);
   });
}


router.post('/videos/render/:video_id', async (req, res) => {
   const videoId = req.params.video_id;
   const query = 'SELECT measurement_ids, project_id, duration FROM public.videos WHERE id = $1';

   db.query(query, [videoId], async (err, results) => {
      if (err) {
         return serverError.sendError('Error getting video:', res, err);
      }
      if (results.rows.length === 0) {
         return res.status(404).json({ error: 'Video not found' });
      }

      console.log('Video found:', results.rows[0]);
      const duration = results.rows[0].duration;

      console.log('Rendering video:', videoId);

      const measurementIds = results.rows[0].measurement_ids;
      const project_id = results.rows[0].project_id;
      console.log('Measurement IDs:', measurementIds);
      console.log('Project ID:', project_id);

      try {
         const pathList = await measureManager.getPathList(measurementIds, project_id);
         console.log('Path list:', pathList);
         res.json({ message: 'Render process started' });

         const videoFile = await videoManager.createVideoWithList(project_id, pathList, duration, videoId);
         console.log('Video file:', videoFile);

         await videoManager.updateVideoFile(videoId, videoFile);

         console.log('Video rendering complete');
      } catch (err) {
         console.error('Error during video rendering:', err);
         res.status(500).json({ error: 'Error during video rendering' });
      }
   });
});

router.get('/videos/reset/:video_id', (req, res) => {
   const videoId = req.params.video_id;
   const query = 'SELECT video_file FROM public.videos WHERE id = $1';

   db.query(query, [videoId], (err, results) => {
      if (err) {
         return serverError.sendError('Error getting video:', res, err);
      }
      if (results.rows.length === 0) {
         return res.status(404).json({ error: 'Video not found' });
      }

      const videoFile = results.rows[0].video_file;
      fs.unlink(videoFile, (err) => {
         if (err) {
            console.error('Error deleting video file:', err);
            return res.status(500).json({ error: 'Error deleting video file' });
         }

         const updateQuery = 'UPDATE public.videos SET status = 0, video_file = NULL WHERE id = $1';
         db.query(updateQuery, [videoId], (err) => {
            if (err) {
               return serverError.sendError('Error resetting video status:', res, err);
            }
            res.json({ message: 'Video reset successfully' });
         });
      });
   });
});


router.get('/cat', (_, res) => {
   const videoPath = dbTester.getCatVideo();
   fs.access(videoPath, fs.constants.F_OK, (err) => {
      if (err) {
         console.error('Video not found:', err);
         return res.status(404).json({ error: 'Video not found' });
      }
      res.download(videoPath);
   });
});

module.exports = router;