// 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;

    console.log('project_id:', project_id);
    
    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,
        idle: false // idle = 1 (idle = 0)
      };
      
      await Camera.updateCamera(1, newSettings);
      
      // Met à jour le statut du projet
      await Project.updateProject(project_id, { status: config.projectStatus.capturing });
      
      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 {
      // Trouve le projet actuellement en cours de capture
      const currentProject = await Project.findCurrentRenderingProject();
      
      if (!currentProject) {
        return sendError('Aucun projet en cours de capture trouvé', res, null, 404);
      }
      
      // Met à jour le statut du projet en cours d'arrêt
      await Project.updateProjectStatus(currentProject.id, config.projectStatus.stopping);
      
      // Marque le drapeau d'arrêt
      await Camera.updateCamera(1, { stop_flag: true });
      
      console.log(`[CAMERA] Arrêt de la caméra demandé pour le projet ${currentProject.id}, en attente de confirmation...`);
      
      res.json({ 
        message: 'Procédure d\'arrêt de la caméra initiée avec succès',
        project_id: currentProject.id
      });
    } 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,
        idle: true // idle = true
      };
      
      await Camera.updateCamera(1, newSettings);
      
      // Recherche le projet en cours d'arrêt
      const stoppingProject = await Project.findStoppingProject();
      
      if (stoppingProject) {
        // Mettre à jour le statut du projet en cours d'arrêt vers idle
        await Project.updateProjectStatus(stoppingProject.id, config.projectStatus.idle);
        console.log(`[CAMERA] Projet : ${stoppingProject.id} arrêté avec succès.`);
        
        res.json({ 
          message: 'Caméra arrêtée avec succès',
          project_id: stoppingProject.id,
          status: config.projectStatus.idle
        });
      } else {
        // Vérifier s'il y a un projet en cours de capture qui n'aurait pas été marqué comme stopping
        const currentProject = await Project.findCurrentRenderingProject();
        
        if (currentProject) {
          await Project.updateProjectStatus(currentProject.id, config.projectStatus.idle);
          console.log(`[CAMERA] Projet : ${currentProject.id} arrêté (était en capture).`);
          
          res.json({ 
            message: 'Caméra arrêtée avec succès (projet était en capture)',
            project_id: currentProject.id,
            status: config.projectStatus.idle
          });
        } else {
          console.log('[CAMERA] Aucun projet en cours d\'arrêt ou de capture trouvé.');
          res.json({ message: 'Caméra arrêtée avec succès mais aucun projet à mettre à jour' });
        }
      }
      
      console.log('[CAMERA] Caméra arrêtée.');
    } 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;