"""
Scheduler APScheduler pour les scans réseau périodiques
"""
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.interval import IntervalTrigger
from datetime import datetime, timedelta
from typing import Optional, Callable
import asyncio


class ScanScheduler:
    """Gestionnaire de tâches planifiées pour les scans"""

    def __init__(self):
        """Initialise le scheduler"""
        self.scheduler = AsyncIOScheduler()
        self.is_running = False

    def start(self):
        """Démarre le scheduler"""
        if not self.is_running:
            self.scheduler.start()
            self.is_running = True
            print(f"[{datetime.now()}] Scheduler démarré")

    def stop(self):
        """Arrête le scheduler"""
        if self.is_running:
            self.scheduler.shutdown()
            self.is_running = False
            print(f"[{datetime.now()}] Scheduler arrêté")

    def add_ping_scan_job(self, scan_function: Callable, interval_seconds: int = 60):
        """
        Ajoute une tâche de scan ping périodique

        Args:
            scan_function: Fonction async à exécuter
            interval_seconds: Intervalle en secondes
        """
        self.scheduler.add_job(
            scan_function,
            trigger=IntervalTrigger(seconds=interval_seconds),
            id='ping_scan',
            name='Scan Ping périodique',
            replace_existing=True
        )
        print(f"Tâche ping_scan configurée: toutes les {interval_seconds}s")

    def add_port_scan_job(self, scan_function: Callable, interval_seconds: int = 300):
        """
        Ajoute une tâche de scan de ports périodique

        Args:
            scan_function: Fonction async à exécuter
            interval_seconds: Intervalle en secondes
        """
        self.scheduler.add_job(
            scan_function,
            trigger=IntervalTrigger(seconds=interval_seconds),
            id='port_scan',
            name='Scan ports périodique',
            replace_existing=True
        )
        print(f"Tâche port_scan configurée: toutes les {interval_seconds}s")

    def add_cleanup_job(self, cleanup_function: Callable, interval_hours: int = 1):
        """
        Ajoute une tâche de nettoyage de l'historique

        Args:
            cleanup_function: Fonction async de nettoyage
            interval_hours: Intervalle en heures
        """
        self.scheduler.add_job(
            cleanup_function,
            trigger=IntervalTrigger(hours=interval_hours),
            id='history_cleanup',
            name='Nettoyage historique',
            replace_existing=True
        )
        print(f"Tâche cleanup configurée: toutes les {interval_hours}h")

    def remove_job(self, job_id: str):
        """
        Supprime une tâche planifiée

        Args:
            job_id: ID de la tâche
        """
        try:
            self.scheduler.remove_job(job_id)
            print(f"Tâche {job_id} supprimée")
        except Exception as e:
            print(f"Erreur suppression tâche {job_id}: {e}")

    def get_jobs(self):
        """Retourne la liste des tâches planifiées"""
        return self.scheduler.get_jobs()


# Instance globale du scheduler
scan_scheduler = ScanScheduler()