parser.py

"""
Sentinel IRC Bot - Module de parsing
Parse les messages IRC et les réponses de commandes
"""

import re
import logging
from datetime import datetime

logger = logging.getLogger(__name__)


def parse_connection_message(message):
    """
    Parse un message de connexion du format:
    <pseudo> {uniqueIdBaboon: xxx, hardware: yyy, ...}

    Args:
        message (str): Message brut du canal #services_infos

    Returns:
        dict: Données parsées ou None si échec
    """
    try:
        # Pattern pour extraire le pseudo et le contenu entre accolades
        pattern = r'<(\S+)>\s+\{(.+)\}'
        match = re.search(pattern, message)

        if not match:
            logger.debug(f"Message ne correspond pas au format de connexion: {message}")
            return None

        nick = match.group(1)
        data_str = match.group(2)

        # Parser les paires clé:valeur
        data = {'nickactuel': nick}

        # Pattern pour extraire les paires clé: valeur
        # Gère les virgules à l'intérieur des valeurs et les espaces
        field_pattern = r'(\w+):\s*([^,]+?)(?=,\s*\w+:|$)'
        fields = re.findall(field_pattern, data_str)

        for key, value in fields:
            # Nettoyer la valeur (retirer espaces de début/fin)
            value = value.strip()
            data[key] = value

        # Validation des champs requis
        required_fields = ['uniqueIdBaboon', 'hardware', 'publicIPAddressHardware']
        for field in required_fields:
            if field not in data:
                logger.warning(f"Champ requis manquant: {field} dans le message: {message}")
                return None

        # Nettoyer/normaliser certains champs
        if 'Iddevice' not in data or data['Iddevice'] == 'unknown':
            data['Iddevice'] = None

        logger.debug(f"Message parsé avec succès pour {nick}: {data.get('publicIPAddressHardware')}")
        return data

    except Exception as e:
        logger.error(f"Erreur lors du parsing du message: {e}")
        logger.debug(f"Message problématique: {message}")
        return None


def parse_stats_g_response(lines):
    """
    Parse la réponse de la commande /stats g
    Format réel: :irc.example.com 223 Sentinel G *@203.0.113.0 1092 85308 irc.example.com :Proxy/Drone detected...

    Args:
        lines (list): Liste des lignes de réponse

    Returns:
        list: Liste de dictionnaires contenant les G-Lines parsées
    """
    glines = []

    try:
        for line in lines:
            # Pattern pour parser une ligne de G-Line
            # Format: :server 223 botname G mask timestamp1 timestamp2 source :raison
            pattern = r':(\S+)\s+223\s+\S+\s+[GZ]\s+(\S+)\s+(\d+)\s+(\d+)\s+(\S+)\s+:(.+)$'
            match = re.search(pattern, line)

            if match:
                serveur_source = match.group(5)  # Serveur source (5ème groupe)
                mask = match.group(2)
                timestamp1 = int(match.group(3))  # Premier timestamp (date de création probable)
                timestamp2 = int(match.group(4))  # Second timestamp (durée)
                raison = match.group(6).strip()

                # Le timestamp1 semble être la date de création (epoch ou relatif)
                # Le timestamp2 semble être la durée en secondes
                date_creation = datetime.now()
                duree = timestamp2  # Durée directement en secondes

                gline = {
                    'mask': mask,
                    'raison': raison,
                    'date_creation': date_creation,
                    'duree': duree,
                    'serveur_source': serveur_source
                }

                glines.append(gline)
                logger.debug(f"G-Line parsée: {mask} - {raison} (durée: {duree}s)")

        logger.info(f"{len(glines)} G-Lines parsées depuis /stats g")
        return glines

    except Exception as e:
        logger.error(f"Erreur lors du parsing des G-Lines: {e}", exc_info=True)
        return []


def parse_privmsg(message):
    """
    Parse un message privé IRC
    Format: :nick!user@host PRIVMSG target :message

    Args:
        message (str): Message IRC brut

    Returns:
        dict: Informations parsées (nick, user, host, target, message)
    """
    try:
        # Pattern pour un PRIVMSG standard
        pattern = r':(\S+)!(\S+)@(\S+)\s+PRIVMSG\s+(\S+)\s+:(.+)'
        match = re.search(pattern, message)

        if match:
            return {
                'nick': match.group(1),
                'user': match.group(2),
                'host': match.group(3),
                'target': match.group(4),
                'message': match.group(5).strip()
            }
    except Exception as e:
        logger.error(f"Erreur lors du parsing du PRIVMSG: {e}")

    return None


def parse_channel_message(message):
    """
    Parse un message de canal IRC
    Format: :nick!user@host PRIVMSG #channel :message

    Args:
        message (str): Message IRC brut

    Returns:
        dict: Informations parsées (nick, channel, message)
    """
    try:
        pattern = r':(\S+)!\S+@\S+\s+PRIVMSG\s+(#\S+)\s+:(.+)'
        match = re.search(pattern, message)

        if match:
            return {
                'nick': match.group(1),
                'channel': match.group(2),
                'message': match.group(3).strip()
            }
    except Exception as e:
        logger.error(f"Erreur lors du parsing du message de canal: {e}")

    return None


def extract_ip_from_hostname(hostname):
    """
    Extrait une IP d'un hostname reverse DNS si possible
    Ex: 1.2.0.192.rev.example.com -> 192.0.2.1

    Args:
        hostname (str): Hostname

    Returns:
        str: IP extraite ou None
    """
    try:
        # Pattern pour hostname reverse style: a.b.c.d.provider.net
        pattern = r'^(\d+)\.(\d+)\.(\d+)\.(\d+)\..*$'
        match = re.search(pattern, hostname)

        if match:
            # Inverser l'ordre des octets
            ip = f"{match.group(4)}.{match.group(3)}.{match.group(2)}.{match.group(1)}"
            return ip
    except Exception as e:
        logger.debug(f"Impossible d'extraire IP de {hostname}: {e}")

    return None


def sanitize_mask(mask):
    """
    Nettoie et valide un masque de ban IRC

    Args:
        mask (str): Masque brut

    Returns:
        str: Masque nettoyé ou None si invalide
    """
    try:
        mask = mask.strip()

        # Vérifier le format basique: *!*@* ou nick!user@host
        if '@' not in mask:
            # Si pas de @, on assume que c'est juste un host
            mask = f"*!*@{mask}"

        # Valider le format
        pattern = r'^[^!]+![^@]+@.+$'
        if re.match(pattern, mask):
            return mask

        logger.warning(f"Masque invalide: {mask}")
        return None

    except Exception as e:
        logger.error(f"Erreur lors de la validation du masque: {e}")
        return None


def create_ban_mask_from_ip(ip):
    """
    Crée un masque de ban à partir d'une IP

    Args:
        ip (str): Adresse IP

    Returns:
        str: Masque de ban
    """
    return f"*!*@{ip}"


def create_ban_mask_from_hostname(hostname):
    """
    Crée un masque de ban à partir d'un hostname

    Args:
        hostname (str): Hostname

    Returns:
        str: Masque de ban
    """
    return f"*!*@{hostname}"


def parse_duration(duration_str):
    """
    Parse une durée en format humain (ex: 1h, 30m, 2d)

    Args:
        duration_str (str): Durée en format texte

    Returns:
        int: Durée en secondes ou None si invalide
    """
    try:
        duration_str = duration_str.strip().lower()

        # Pattern pour extraire nombre et unité
        pattern = r'^(\d+)([smhd])$'
        match = re.match(pattern, duration_str)

        if match:
            value = int(match.group(1))
            unit = match.group(2)

            multipliers = {
                's': 1,           # secondes
                'm': 60,          # minutes
                'h': 3600,        # heures
                'd': 86400        # jours
            }

            return value * multipliers[unit]

        # Si c'est juste un nombre, on assume des secondes
        if duration_str.isdigit():
            return int(duration_str)

        logger.warning(f"Format de durée invalide: {duration_str}")
        return None

    except Exception as e:
        logger.error(f"Erreur lors du parsing de la durée: {e}")
        return None


def format_duration(seconds):
    """
    Formate une durée en secondes en format lisible

    Args:
        seconds (int): Durée en secondes

    Returns:
        str: Durée formatée
    """
    try:
        if seconds < 60:
            return f"{seconds}s"
        elif seconds < 3600:
            return f"{seconds // 60}m"
        elif seconds < 86400:
            return f"{seconds // 3600}h"
        else:
            return f"{seconds // 86400}d"
    except Exception:
        return "N/A"


def validate_ip(ip):
    """
    Valide une adresse IP v4

    Args:
        ip (str): Adresse IP

    Returns:
        bool: True si valide
    """
    try:
        pattern = r'^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$'
        match = re.match(pattern, ip)

        if match:
            # Vérifier que chaque octet est entre 0 et 255
            octets = [int(match.group(i)) for i in range(1, 5)]
            return all(0 <= octet <= 255 for octet in octets)

        return False

    except Exception:
        return False


def normalize_nick(nick):
    """
    Normalise un pseudo IRC (supprime les caractères spéciaux)

    Args:
        nick (str): Pseudo

    Returns:
        str: Pseudo normalisé
    """
    try:
        # Retirer les caractères non-alphanumériques sauf _ - [ ] { } \ | ^
        nick = re.sub(r'[^\w\[\]{}\\|\^-]', '', nick)
        return nick.strip()
    except Exception:
        return nick