// routes/api.js
const express = require('express');
const router = express.Router();
const projectController = require('../controllers/projectController');
const projectModel = require('../models/projectModel');
const db = require('../db'); // Assurez-vous d'importer le fichier db.js
const path = require('path');
const fs = require('fs');
const ffmpeg = require('../ffmpeg'); // Assurez-vous d'importer le fichier ffmpeg.js

/**
 * @swagger
 * /projects:
 *   get:
 *     description: Use to request all projects
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/projects', projectController.getAllProjects);

/**
 * @swagger
 * /projects/{id}/create-video:
 *   get:
 *     description: Create a video from images of a specific project by project id
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the project to create video for.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: Video created successfully
 *       404:
 *         description: No images found for this project
 *       500:
 *         description: Internal server error
 */
router.get('/projects/:id/create-video', async (req, res) => {
  const projectId = req.params.id;
  const imageDir = path.join(__dirname, `../storage/${projectId}`);
  const outputVideo = path.join(__dirname, `../storage/${projectId}/output_video.mp4`);
  const frameRate = 24;
  const tempFile = path.join(__dirname, `../storage/${projectId}/temp_file.txt`);

  try {
    const images = fs.readdirSync(imageDir).filter(file => file.endsWith('.jpg'));
    if (images.length === 0) {
      return res.status(404).json({ error: 'No images found for this project' });
    }

    const tempFileContent = images.map(img => `file '${path.join(imageDir, img)}'`).join('\n');
    fs.writeFileSync(tempFile, tempFileContent);

    const ffmpegCommand = `ffmpeg -r ${frameRate} -f concat -safe 0 -i ${tempFile} -vsync vfr -pix_fmt yuv420p ${outputVideo}`;
    require('child_process').execSync(ffmpegCommand);

    fs.unlinkSync(tempFile);
    res.status(200).json({ message: 'Video created successfully', videoPath: outputVideo });
  } catch (error) {
    console.error('Error creating video:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

/**
 * @swagger
 * /projects/{id}:
 *   get:
 *     description: Use to request a specific project by id
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the project to retrieve.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/projects/:id', async (req, res) => {
  try {
    const project = await projectModel.getProjectById(db, req.params.id);
    if (!project) {
      return res.status(404).json({ error: 'Projet non trouvé' });
    }
    res.json(project);
  } catch (error) {
    console.error('Erreur lors de la récupération du projet:', error);
    res.status(500).json({ error: 'Erreur serveur' });
  }
});

/**
 * @swagger
 * /projects/{id}/videos:
 *   get:
 *     description: Use to request all videos for a specific project by project id
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the project to retrieve videos for.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/projects/:id/videos', (req, res) => {
  const projectId = req.params.id;
  const query = 'SELECT * FROM public.videos WHERE project_id = $1';
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  db.query(query, [projectId], (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération des vidéos pour le projet:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.json(results.rows);
  });
});

/**
 * @swagger
 * /projects/{id}/measurements:
 *   get:
 *     description: Use to request all measurements for a specific project by project id
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the project to retrieve measurements for.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/projects/:id/measurements', (req, res) => {
  const projectId = req.params.id;
  const query = 'SELECT * FROM public.measurements WHERE project_id = $1';
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  db.query(query, [projectId], (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération des mesures pour le projet:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.json(results.rows);
  });
});

/**
 * @swagger
 * /projects:
 *   post:
 *     description: Use to add a new project
 *     responses:
 *       201:
 *         description: Project added successfully
 *       500:
 *         description: Internal server error
 */
router.post('/projects', projectController.createProject);

/**
 * @swagger
 * /projects/{id}:
 *   delete:
 *     description: Use to delete a project by ID
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the project to delete.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: Project deleted successfully
 *       404:
 *         description: No project found with this ID
 *       500:
 *         description: Internal server error
 */
router.delete('/projects/:id', projectController.deleteProject);

/**
 * @swagger
 * /measurements:
 *   get:
 *     description: Use to request all measurements
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/measurements', (req, res) => {
  const query = 'SELECT * FROM public.measurements';
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  db.query(query, (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération des mesures:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.json(results.rows);
  });
});

/**
 * @swagger
 * /measurements/{id}:
 *   get:
 *     description: Use to request a specific measurement by id
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the measurement to retrieve.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/measurements/:id', (req, res) => {
  const measurementId = req.params.id;
  const query = 'SELECT * FROM public.measurements WHERE id = $1';
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  db.query(query, [measurementId], (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération de la mesure:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.json(results.rows);
  });
});

/**
 * @swagger
 * /measurements:
 *   post:
 *     description: Use to add a new measurement
 *     responses:
 *       201:
 *         description: Measurement added successfully
 *       500:
 *         description: Internal server error
 */
router.post('/measurements', (req, res) => {
  const query = 'INSERT INTO public.measurements (project_id, timestamp, image_path, temperature, humidity, completed) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id';
  db.query(query, [req.body.project_id, req.body.timestamp, req.body.image_path, req.body.temperature, req.body.humidity, req.body.completed], (err, results) => {
    if (err) {
      console.error('Erreur lors de l\'ajout de la mesure:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.status(201).json({ message: 'Mesure ajoutée avec succès', id: results.rows[0].id });
  });
});

/**
 * @swagger
 * /measurements/{id}:
 *   delete:
 *     description: Use to delete a measurement by ID
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the measurement to delete.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: Measurement deleted successfully
 *       404:
 *         description: No measurement found with this ID
 *       500:
 *         description: Internal server error
 */
router.delete('/measurements/:id', (req, res) => {
  const measurementId = req.params.id;
  const query = 'DELETE FROM public.measurements WHERE id = $1 RETURNING id';
  db.query(query, [measurementId], (err, results) => {
    if (err) {
      console.error('Erreur lors de la suppression de la mesure:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    if (results.rowCount === 0) {
      return res.status(404).json({ error: 'Aucune mesure trouvée avec cet ID.' });
    }
    res.status(200).json({ message: 'Mesure supprimée avec succès', id: measurementId });
  });
});

/**
 * @swagger
 * /videos:
 *   get:
 *     description: Use to request all videos
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/videos', (req, res) => {
  const query = 'SELECT * FROM public.videos';
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  db.query(query, (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération des vidéos:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.json(results.rows);
  });
});

/**
 * @swagger
 * /videos/{id}:
 *   get:
 *     description: Use to request a specific video by id
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the video to retrieve.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: A successful response
 *       500:
 *         description: Internal server error
 */
router.get('/videos/:id', (req, res) => {
  const videoId = req.params.id;
  const query = 'SELECT * FROM public.videos WHERE id = $1';
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  db.query(query, [videoId], (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération de la vidéo:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    res.json(results.rows);
  });
});

/**
 * @swagger
 * /videos:
 *   post:
 *     description: Use to create a new video
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               project_id:
 *                 type: integer
 *               measurement_ids:
 *                 type: string
 *               video_path:
 *                 type: string
 *               duration:
 *                 type: number
 *               resolution:
 *                 type: string
 *               name:
 *                 type: string
 *     responses:
 *       201:
 *         description: Video created successfully
 *       500:
 *         description: Internal server error
 */
router.post('/videos', (req, res) => {
  const query = 'INSERT INTO public.videos (project_id, measurement_ids, video_path, start_timestamp, end_timestamp, image_count, resolution, duration, fps, status, name) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id';

  const list_ids = req.body.measurement_ids.split(',');
  const image_count = list_ids.length;
  const video_path = '/videos/' + req.body.name + '.mp4';

  const query_first = 'SELECT timestamp FROM public.measurements WHERE id = $1';
  const query_last = 'SELECT timestamp FROM public.measurements WHERE id = $1';
  db.query(query_first, [list_ids[0]], (err, results) => {
    if (err) {
      console.error('Erreur lors de la récupération du timestamp de la première image:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    const start_timestamp = results.rows[0].timestamp;

    db.query(query_last, [list_ids[image_count - 1]], (err, results) => {
      if (err) {
        console.error('Erreur lors de la récupération du timestamp de la dernière image:', err);
        return res.status(500).json({ error: 'Erreur serveur' });
      }
      const end_timestamp = results.rows[0].timestamp;
      const fps = image_count / req.body.duration;

      db.query(query, [req.body.project_id, req.body.measurement_ids, video_path, start_timestamp, end_timestamp, image_count, req.body.resolution, req.body.duration, fps, 0, req.body.name], (err, results) => {
        if (err) {
          console.error('Erreur lors de l\'ajout de la vidéo:', err);
          return res.status(500).json({ error: 'Erreur serveur' });
        }
        res.status(201).json({ message: 'Vidéo ajoutée avec succès', id: results.rows[0].id });
      });
    });
  });
});

/**
 * @swagger
 * /videos/{id}:
 *   delete:
 *     description: Use to delete a video by ID
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: Numeric ID of the video to delete.
 *         schema:
 *           type: integer
 *     responses:
 *       200:
 *         description: Video deleted successfully
 *       404:
 *         description: No video found with this ID
 *       500:
 *         description: Internal server error
 */
router.delete('/videos/:id', (req, res) => {
  const videoId = req.params.id;
  const query = 'DELETE FROM public.videos WHERE id = $1 RETURNING id';
  db.query(query, [videoId], (err, results) => {
    if (err) {
      console.error('Erreur lors de la suppression de la vidéo:', err);
      return res.status(500).json({ error: 'Erreur serveur' });
    }
    if (results.rowCount === 0) {
      return res.status(404).json({ error: 'Aucune vidéo trouvée avec cet ID.' });
    }
    res.status(200).json({ message: 'Vidéo supprimée avec succès', id: videoId });
  });
});

// Test Image
/**
 * @swagger
 * /smile:
 *   get:
 *     description: Use to request the smile image
 *     responses:
 *       200:
 *         description: A successful response
 *       404:
 *         description: Image not found
 */
router.get('/smile', (req, res) => {
  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  const imagePath = path.join(__dirname, '../storage/smile.jpg');
  fs.access(imagePath, fs.constants.F_OK, (err) => {
    if (err) {
      console.error('Image not found:', err);
      return res.status(404).json({ error: 'Image not found' });
    }
    res.sendFile(imagePath);
  });
});

module.exports = router;