// src/controllers/cameraController.js
const Camera = require('../models/Camera');
const Project = require('../models/Project');
const { sendError, asyncHandler } = require('../utils/errorHandler');
const config = require('../config');

/**
 * Contrôleur pour les opérations liées à la caméra
 */
class CameraController {
  /**
   * Récupère le statut actuel de la caméra
   */
  static getCameraStatus = asyncHandler(async (req, res) => {
    try {
      const settings = await Camera.getCamera();
      
      if (!settings) {
        // Initialise la caméra si elle n'existe pas
        const cameraSettings = await Camera.initializeCamera();
        return res.json(cameraSettings);
      }
      
      res.json(settings);
    } catch (error) {
      sendError('Erreur lors de la récupération du statut de la caméra', res, error, 500);
    }
  });

  /**
   * Démarre une procédure de capture
   */
  static startProcedure = asyncHandler(async (req, res) => {
    const { project_id, interval, nb_images } = req.body;
    
    if (!interval || !nb_images) {
      return sendError('L\'intervalle et le nombre d\'images sont requis', res, null, 400);
    }
    
    try {
      // Vérifie qu'aucune procédure n'est déjà en cours
      const existingProject = await Project.findCurrentRenderingProject();
      
      if (existingProject) {
        return sendError('Un projet est déjà en cours de capture. Veuillez l\'arrêter avant d\'en démarrer un nouveau.', res, null, 400);
      }
      
      // Met à jour les paramètres de la caméra
      const newSettings = {
        interval: interval,
        nb_images: nb_images,
        stop_flag: false,
        active: 1 // active = 1 (idle = 0)
      };
      
      await Camera.updateCamera(1, newSettings);
      
      // Met à jour le statut du projet
      await Project.updateProject(project_id, { status: config.status.inProgress });
      
      console.log(`[CAMERA] Procédure démarrée pour le projet : ${project_id}`);
      
      res.json({ 
        message: 'Procédure de capture démarrée avec succès', 
        settings: { interval, nb_images } 
      });
    } catch (error) {
      sendError('Erreur lors du démarrage de la procédure de capture', res, error, 500);
    }
  });

  /**
   * Initie l'arrêt de la procédure de capture
   */
  static stopProcedure = asyncHandler(async (req, res) => {
    try {
      // Marque le drapeau d'arrêt
      await Camera.updateCamera(1, { stop_flag: true });
      
      console.log('[CAMERA] Arrêt de la caméra demandé, en attente de confirmation...');
      
      res.json({ message: 'Procédure d\'arrêt de la caméra initiée avec succès' });
    } catch (error) {
      sendError('Erreur lors de l\'arrêt de la procédure de capture', res, error, 500);
    }
  });

  /**
   * Confirme l'arrêt de la caméra (appelé par la caméra)
   */
  static confirmStopProcedure = asyncHandler(async (req, res) => {
    try {
      // Réinitialise les paramètres de la caméra
      const newSettings = {
        interval: null,
        nb_images: null,
        stop_flag: false,
        active: 0 // idle = true
      };
      
      await Camera.updateCamera(1, newSettings);
      
      // Réinitialise le statut du projet en cours
      const currentProject = await Project.findCurrentRenderingProject();
      
      if (currentProject) {
        await Project.updateProject(currentProject.id, { status: config.status.waiting });
        console.log(`[CAMERA] Projet : ${currentProject.id} arrêté.`);
      } else {
        console.log('[CAMERA] Aucun projet à arrêter.');
      }
      
      console.log('[CAMERA] Caméra arrêtée.');
      
      res.json({ message: 'Caméra arrêtée avec succès' });
    } catch (error) {
      sendError('Erreur lors de la confirmation de l\'arrêt de la caméra', res, error, 500);
    }
  });

  /**
   * Active le mode maintenance
   */
  static activateMaintenance = asyncHandler(async (req, res) => {
    try {
      await Camera.updateCamera(1, { maintenance: 1 });
      
      console.log('[CAMERA] Mode maintenance activé.');
      
      res.json({ message: 'Caméra en mode maintenance' });
    } catch (error) {
      sendError('Erreur lors de l\'activation du mode maintenance', res, error, 500);
    }
  });

  /**
   * Désactive le mode maintenance
   */
  static deactivateMaintenance = asyncHandler(async (req, res) => {
    try {
      await Camera.updateCamera(1, { maintenance: 0 });
      
      console.log('[CAMERA] Mode maintenance désactivé.');
      
      res.json({ message: 'Caméra sortie du mode maintenance' });
    } catch (error) {
      sendError('Erreur lors de la désactivation du mode maintenance', res, error, 500);
    }
  });
}

module.exports = CameraController;