const express = require('express');
const router = express.Router();
const db = require('../db');
const serverError = require('../utils/serverError');
const { start } = require('repl');

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

var defaultCaptureInterval = 5; // minutes
var defaultMaintenance = 0;
var defaultActive = 0; // 0 = pas de capture, 1 = capture en cours

async 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, active)
            VALUES ($1, $2, $3, $4)
         `;
         const insertValues = [1, defaultCaptureInterval, defaultMaintenance, defaultActive];

         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.');
      }
   });
}

async function getCamera() {
   // retourner l'état de la caméra
   const query = 'SELECT * FROM public.camera WHERE id = $1';
   const values = [1];

   try {
      const result = await db.query(query, values);
      if (result.rows.length === 0) {
         console.log('Aucune entrée caméra trouvée.');
         return null;
      } else {
         const camera = result.rows[0];
         console.log('État de la caméra récupéré avec succès:', camera);
         return {
            captureInterval: camera.interval,
            captureProjectID: camera.active,
            captureStatus: camera.active,
            maintenance: camera.maintenance
         };
      }
   } catch (err) {
      console.error('Erreur lors de la récupération de l\'état de la caméra:', err);
      throw err;
   }
}

async function printCameraStatus() {
   let camera = await 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('Statut de la capture:', camera.active === 1 ? 'En cours' : 'Arrêté');
   console.log('-----------------------------------');
}

async function isCameraOccupied() {
   try {
      const query = 'SELECT id FROM public.projects WHERE status = $1 LIMIT 1';
      const values = [1];

      return new Promise((resolve, reject) => {
         db.query(query, values, (err, result) => {
            if (err) {
               console.error('Erreur lors de la vérification de l\'occupation de la caméra:', err);
               reject(err);
            } else {
               const isOccupied = result.rows.length > 0 ? result.rows[0].id : null;
               resolve(isOccupied);
            }
         });
      });

   } catch (err) {
      console.error('Erreur inattendue lors de la vérification de l\'occupation de la caméra:', err);
   }
}

async function getCurrentProject() {
   try {
   const query = 'SELECT * FROM public.projects WHERE status = $1 LIMIT 1';
   const values = [1];

   return new Promise((resolve, reject) => {
      db.query(query, values, (err, result) => {
         if (err) {
            console.error('Erreur lors de la récupération du projet en cours:', err);
            reject(err);
         } else if (result.rows.length === 0) {
            console.log('Aucun projet en cours trouvé.');
            resolve(null);
         } else {
            const currentProject = result.rows[0];
            console.log('Projet en cours récupéré avec succès:', currentProject);
            resolve(currentProject);
         }
      });
   });
   } catch (err) {
      console.error('Erreur inattendue lors de la récupération du projet en cours:', err);
   }
}

async function resetProjectStatus() {
   const query = 'UPDATE public.projects SET status = $1 WHERE status = $2';
   const values = [2, 1];

   db.query(query, values, (err) => {
      if (err) {
         console.error('Erreur lors de la réinitialisation du statut des projets:', err);
      } else {
         console.log('Statut des projets réinitialisé avec succès.');
      }
   });
}

async function activateCamera() {
   const query = 'UPDATE public.camera SET active = $1 WHERE id = $2';
   const values = [1, 1];

   db.query(query, values, (err) => {
      if (err) {
         console.error('Erreur lors de l\'activation de la caméra:', err);
      } else {
         console.log('Caméra activée avec succès.');
      }
   });
}

async function deactivateCamera() {
   const query = 'UPDATE public.camera SET active = $1 WHERE id = $2';
   const values = [0, 1];

   db.query(query, values, (err) => {
      if (err) {
         console.error('Erreur lors de la désactivation de la caméra:', err);
      } else {
         console.log('Caméra désactivée avec succès.');
      }
   });
}

async function changeProjectStatus(projectId, status) {
   try {
      const query = 'UPDATE public.projects SET status = $1 WHERE id = $2';
      const values = [status, projectId];

      await db.query(query, values);
      console.log(`Statut du projet ID ${projectId} modifié avec succès à ${status}.`);
   } catch (err) {
      console.error('Une erreur inattendue s\'est produite lors de la modification du statut du projet:', err);
   }
}

async function startup() {
   await initCamera();
   await printCameraStatus();
}

startup()
   .catch(err => {
      console.error('Erreur lors de l\'initialisation de la caméra:', err);
   });

/**
 * @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 = await 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);
   }
});

async function setCameraSettings(interval, maintenance) {
   try {
      const query = `
         UPDATE public.camera
         SET interval = $1, maintenance = $2
         WHERE id = $3
      `;
      const values = [interval, maintenance, 1];

      db.query(query, values, (err) => {
         if (err) {
            console.error('Erreur lors de la mise à jour des paramètres de la caméra:', err);
         } else {
            console.log('Paramètres de la caméra mis à jour avec succès.');
            //captureInterval = interval;
            //maintenance = maintenance;
         }
      });
   } catch (err) {
      console.error('Une erreur inattendue s\'est produite lors de la mise à jour des paramètres de la caméra:', err);
   }
}

async function startProcedure(projectId, interval, maintenance) {
   if (isNaN(projectId) || isNaN(interval) || isNaN(maintenance)) {
      return { error: 'Invalid parameters' };
   }
   const cameraOccupied = await isCameraOccupied();
   if (cameraOccupied) {
      return { error: 'Camera is occupied by another project' };
   } else {
      await activateCamera();
      await setCameraSettings(interval, maintenance);
      await changeProjectStatus(projectId, 1); // changer le statut du projet en cours à 1 (en cours)
      console.log('Procédure de capture démarrée avec succès.');
      return { message: 'Capture procedure started successfully' };
   }
}

async function stopProcedure() {
   var project = await getCurrentProject();
   console.log(project);
   if (project) {
      await resetProjectStatus(); // réinitialiser le statut du projet en cours
      await deactivateCamera(); // désactiver la caméra
      await changeProjectStatus(project.id, 2); // changer le statut du projet en cours à 2 (terminé)
      console.log('Procédure de capture arrêtée avec succès.');
      return { message: 'Capture procedure stopped successfully' };
   } else {
      return { error: 'No project is currently being captured' };
   }
}

/**
 * @swagger
 * /procedure/start/:
 *   post:
 *     summary: Start the capture procedure
 *     tags:
 *       - Procedure
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               projectId:
 *                 type: integer
 *                 description: ID of the project to start capturing
 *               interval:
 *                 type: integer
 *                 description: Capture interval in minutes
 *               maintenance:
 *                 type: integer
 *                 description: Maintenance status (0 = none, 1 = ongoing)
 *     responses:
 *       200:
 *         description: Successfully started the capture procedure
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *               properties:
 *                 message:
 *                   type: string
 *                   description: Success message
 *                 error:
 *                   type: string
 *                   description: Error message, if any
 *       500:
 *         description: Internal server error
 * /procedure/stop/:
 *   post:
 *     summary: Stop the capture procedure
 *     tags:
 *       - Procedure
 *     responses:
 *       200:
 *         description: Successfully stopped the capture procedure
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *               properties:
 *                 message:
 *                   type: string
 *                   description: Success message
 *                 error:
 *                   type: string
 *                   description: Error message, if any
 *       500:
 *         description: Internal server error
 */
router.post('/procedure/start/', async (req, res) => {
   const { projectId, interval, maintenance } = req.body;
    try {
         const result = await startProcedure(projectId, interval, maintenance);
         res.status(200).json(result);
    } catch (err) {
         serverError.sendError('Erreur lors du démarrage de la procédure de capture:', res, err, 500);
    }
});

router.post('/procedure/stop/', async (req, res) => {
   try {
      const result = await 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;