gline_sync.py

"""
Sentinel IRC Bot - Module de synchronisation G-Line
Thread qui synchronise les G-Lines toutes les 5 minutes
"""

import threading
import time
import logging
from parser import parse_stats_g_response

logger = logging.getLogger(__name__)


class GLineSyncer(threading.Thread):
    """Thread de synchronisation des G-Lines"""

    def __init__(self, irc_client, database, config):
        """
        Initialise le syncer

        Args:
            irc_client: Client IRC pour envoyer les commandes
            database: Instance DatabaseManager
            config (dict): Configuration de synchronisation
        """
        super().__init__(daemon=True)
        self.irc_client = irc_client
        self.database = database
        self.config = config
        self.running = False
        self.interval = config.get('interval', 300)  # 5 minutes par défaut
        self.gline_buffer = []
        self.collecting = False
        self.lock = threading.Lock()

        logger.info(f"GLineSyncer initialisé (intervalle: {self.interval}s)")

    def run(self):
        """Boucle principale du thread"""
        self.running = True
        logger.info("Thread de synchronisation G-Line démarré")

        # Attendre que le bot soit connecté avant la première sync
        time.sleep(10)

        while self.running:
            try:
                self.sync_glines()
            except Exception as e:
                logger.error(f"Erreur lors de la synchronisation G-Line: {e}")

            # Attendre l'intervalle avant la prochaine sync
            for _ in range(self.interval):
                if not self.running:
                    break
                time.sleep(1)

        logger.info("Thread de synchronisation G-Line arrêté")

    def stop(self):
        """Arrête le thread de synchronisation"""
        logger.info("Arrêt du thread de synchronisation G-Line...")
        self.running = False

    def sync_glines(self):
        """
        Effectue une synchronisation complète des G-Lines
        1. Envoie /stats g
        2. Collecte les réponses
        3. Parse les G-Lines
        4. Vide et remplit la table
        """
        try:
            logger.info("Début de la synchronisation G-Line")

            # Réinitialiser le buffer
            with self.lock:
                self.gline_buffer = []
                self.collecting = True

            # Envoyer la commande /stats g
            self.irc_client.connection.send_raw(f"STATS g")
            logger.debug("Commande STATS g envoyée")

            # Attendre que la réponse soit complète (max 10 secondes)
            timeout = 10
            elapsed = 0
            while self.collecting and elapsed < timeout:
                time.sleep(0.5)
                elapsed += 0.5

            # Si timeout, on arrête la collecte
            if elapsed >= timeout:
                logger.warning("Timeout lors de la collecte des G-Lines")
                with self.lock:
                    self.collecting = False

            # Parser les G-Lines collectées
            with self.lock:
                glines = parse_stats_g_response(self.gline_buffer)

            # Synchroniser avec la base de données
            if self.database.sync_glines(glines):
                logger.info(f"Synchronisation G-Line réussie: {len(glines)} entrées")
            else:
                logger.error("Échec de la synchronisation G-Line")

        except Exception as e:
            logger.error(f"Erreur lors de sync_glines: {e}", exc_info=True)

    def add_line(self, line):
        """
        Ajoute une ligne au buffer de collecte

        Args:
            line (str): Ligne de réponse du serveur
        """
        with self.lock:
            if self.collecting:
                # Logger TOUTES les lignes reçues pendant la collecte pour debug
                logger.info(f"[STATS G Response] {line}")

                # Vérifier si c'est une ligne de G-Line (code 223)
                if ' 223 ' in line:
                    self.gline_buffer.append(line)
                    logger.info(f"Ligne G-Line collectée: {line}")

                # Vérifier si c'est la fin de la liste (code 219)
                elif ' 219 ' in line and 'g' in line.lower():
                    logger.info("Fin de la liste G-Line détectée")
                    self.collecting = False

    def force_sync(self):
        """Force une synchronisation immédiate (appelé par commande admin)"""
        logger.info("Synchronisation G-Line forcée")
        sync_thread = threading.Thread(target=self.sync_glines, daemon=True)
        sync_thread.start()

    def is_collecting(self):
        """Retourne True si on est en train de collecter des G-Lines"""
        with self.lock:
            return self.collecting


class GLineMonitor:
    """Moniteur pour détecter les changements de G-Lines"""

    def __init__(self, database):
        """
        Initialise le moniteur

        Args:
            database: Instance DatabaseManager
        """
        self.database = database
        self.last_count = 0
        self.last_check = None

    def check_changes(self):
        """
        Vérifie s'il y a eu des changements dans les G-Lines

        Returns:
            dict: Informations sur les changements
        """
        try:
            current_count = self.database.fetch_all("SELECT COUNT(*) as count FROM glines")[0]['count']

            changes = {
                'has_changes': False,
                'previous_count': self.last_count,
                'current_count': current_count,
                'diff': 0
            }

            if self.last_count != current_count:
                changes['has_changes'] = True
                changes['diff'] = current_count - self.last_count

                logger.info(f"Changement détecté dans les G-Lines: {self.last_count} -> {current_count} ({changes['diff']:+d})")

            self.last_count = current_count
            self.last_check = time.time()

            return changes

        except Exception as e:
            logger.error(f"Erreur lors de la vérification des changements: {e}")
            return {'has_changes': False, 'error': str(e)}

    def get_recent_glines(self, limit=10):
        """
        Récupère les G-Lines les plus récentes

        Args:
            limit (int): Nombre de G-Lines à retourner

        Returns:
            list: G-Lines récentes
        """
        query = """
            SELECT * FROM glines
            ORDER BY last_sync DESC
            LIMIT %s
        """
        return self.database.fetch_all(query, (limit,))

    def search_gline(self, mask):
        """
        Recherche une G-Line par masque

        Args:
            mask (str): Masque à rechercher

        Returns:
            dict: G-Line trouvée ou None
        """
        query = "SELECT * FROM glines WHERE mask LIKE %s"
        result = self.database.fetch_all(query, (f"%{mask}%",))
        return result[0] if result else None


def create_gline_report(glines):
    """
    Crée un rapport formaté des G-Lines

    Args:
        glines (list): Liste des G-Lines

    Returns:
        str: Rapport formaté
    """
    if not glines:
        return "Aucune G-Line trouvée"

    report = []
    report.append(f"=== Rapport G-Lines ({len(glines)} entrées) ===")
    report.append("")

    for gline in glines:
        report.append(f"Mask: {gline['mask']}")
        report.append(f"Raison: {gline['raison']}")
        report.append(f"Durée: {gline['duree']}s")
        if gline.get('serveur_source'):
            report.append(f"Serveur: {gline['serveur_source']}")
        report.append(f"Dernière sync: {gline['last_sync']}")
        report.append("-" * 50)

    return "\n".join(report)


def estimate_next_sync(syncer):
    """
    Estime le temps avant la prochaine synchronisation

    Args:
        syncer (GLineSyncer): Instance du syncer

    Returns:
        int: Secondes restantes
    """
    # Cette fonction est simplifiée, on retourne juste l'intervalle
    # Dans une vraie implémentation, on trackrait le timestamp de la dernière sync
    return syncer.interval


def get_sync_stats(database):
    """
    Récupère les statistiques de synchronisation

    Args:
        database: Instance DatabaseManager

    Returns:
        dict: Statistiques
    """
    stats = {}

    # Dernière synchronisation
    query = "SELECT MAX(last_sync) as last_sync FROM glines"
    result = database.fetch_all(query)
    stats['last_sync'] = result[0]['last_sync'] if result and result[0]['last_sync'] else None

    # Nombre total de G-Lines
    query = "SELECT COUNT(*) as count FROM glines"
    result = database.fetch_all(query)
    stats['total_glines'] = result[0]['count'] if result else 0

    # G-Lines par serveur
    query = """
        SELECT serveur_source, COUNT(*) as count
        FROM glines
        GROUP BY serveur_source
    """
    stats['by_server'] = database.fetch_all(query)

    return stats