#!/usr/bin/env python3
# coding: utf-8

"""
Script d'automatisation pour la gestion du système timelapse
Ce script vérifie le statut du serveur et configure le système en conséquence.
"""

import os
import sys
import time
import logging
import subprocess
from timelapse.config import config
from timelapse.api_client import api_client
from timelapse.sensors import micro_controller


def main():
    """
    Fonction principale d'automatisation
    """
    logging.info("==================== AUTOMATISATION TIMELAPSE ====================")
    
    try:
        # Récupérer le statut de la caméra depuis l'API
        camera_status = api_client.get_camera_status()
        
        # Vérifier si la configuration actuelle est déjà active et non terminée
        is_active_config = config.get("config_active", False)
        images_remaining = config.get("nb_images_restantes", 0)
        
        if camera_status is None:
            logging.warning("Impossible d'obtenir le statut de la caméra depuis l'API")
            if is_active_config and images_remaining > 0:
                logging.info("Utilisation de la configuration locale existante")
                return
            logging.info("Aucune configuration active et impossibilité de récupérer le statut")
            return
        
        # Vérifier l'état de maintenance en priorité
        if camera_status.get("maintenance", False):
            logging.info("Caméra en mode maintenance")
            
            # Vérifier si un projet est déjà en cours (config active avec images restantes)
            if is_active_config and images_remaining > 0:
                logging.info(f"Un projet est en cours avec {images_remaining} images restantes - capture maintenue en mode maintenance")
                
                # Importer le gestionnaire de capture
                from timelapse.capture import timelapse_manager
                
                # Prendre une image et l'envoyer
                logging.info("Prise d'image en mode maintenance pour projet en cours")
                online_status = api_client.check_connection()
                timelapse_manager.single_capture(online=online_status)
                
                # Décrémenter le compteur d'images restantes
                config.decrement_remaining_images()
                
                # Si c'était la dernière image, désactiver la configuration
                if config.get("nb_images_restantes", 0) <= 0:
                    logging.info("Dernière image capturée, désactivation de la configuration")
                    config.update_config({"config_active": False})
            else:
                logging.info("Aucun projet en cours, mode maintenance sans action")
            
            # Mettre à jour la configuration pour refléter le mode maintenance
            config.update_config({"maintenance": True})
            return
        
        # Vérifier si un arrêt de la procédure est demandé
        if camera_status.get("stop_flag", False):
            logging.info("Arrêt de la procédure en cours...")
            
            # Réinitialiser les configurations actives
            config.update_config({
                "config_active": False,
                "nb_images_restantes": 0,
                "stop_current_config": True
            })
            
            # Confirmer l'arrêt au serveur
            confirmed = api_client.confirm_stop()
            if confirmed:
                logging.info("Arrêt confirmé au serveur")
            else:
                logging.warning("Échec de la confirmation d'arrêt au serveur")
                
            # Configuration d'un redémarrage régulier pour vérifier les nouvelles configurations
            config.set("restart_interval", 120)  # 2 minutes
            
            return
        
        # Vérifier si le système est en IDLE et si une configuration est déjà active
        is_idle = camera_status.get("idle", True)
        
        if is_idle:
            logging.info("Système en mode IDLE")
            if is_active_config:
                # Si le nombre d'images est atteint, désactiver la configuration
                if images_remaining <= 0:
                    logging.info("Configuration terminée: nombre d'images atteint")
                    config.update_config({"config_active": False})
                else:
                    logging.info(f"Configuration active: il reste {images_remaining} images à capturer")
            else:
                logging.info("Aucune configuration active, attente en mode IDLE")
                # Configuration d'un redémarrage régulier pour vérifier les nouvelles configurations
                config.set("restart_interval", 120)  # 2 minutes
            return
        
        # Si on arrive ici, il y a une nouvelle configuration à appliquer
        logging.info("Nouvelle configuration active détectée")
        
        # Mettre à jour la configuration locale
        config_update = {
            "config_active": True,
            "maintenance": False,
            "timelapse": camera_status.get("interval", 3),
            "conf_nb_images": camera_status.get("nb_images", 1),
            "nb_images_restantes": camera_status.get("nb_images", 1),
            "stop_current_config": False,
            "idle": is_idle
        }
        
        config.update_config(config_update)
        
        # Envoyer l'intervalle au microcontrôleur
        interval = camera_status.get("interval", 3)
        logging.info(f"Envoi de l'intervalle au microcontrôleur: {interval}s")
        micro_controller.send_interval(interval)
        
        # Éteindre le système après configuration (mais ne pas arrêter en prod)
        # logging.info("Configuration terminée, arrêt du système")
        # subprocess.run(["sudo", "shutdown", "now"])
        
    except Exception as e:
        logging.error(f"Erreur dans le script d'automatisation: {e}")


if __name__ == "__main__":
    main()