# -*- coding: utf-8 -*-
"""
Basis-Klasse für Event-Daten.
"""

import uuid
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any


@dataclass
class EventData:
    """
    Basisklasse für alle Event-Daten.

    Jedes Event trägt Metadaten wie eindeutige ID, Zeitstempel,
    Quelle und Abbruch-Status.

    Attributes:
        event_id: Eindeutige ID des Events
        timestamp: Zeitpunkt der Event-Erstellung
        source: Quelle des Events (z.B. Service-Name)
        cancelled: Ob das Event abgebrochen wurde
        metadata: Zusätzliche Metadaten
    """
    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: datetime = field(default_factory=datetime.now)
    source: str = ""
    cancelled: bool = field(default=False, repr=False)
    metadata: dict[str, Any] = field(default_factory=dict, repr=False)

    def cancel(self) -> None:
        """Bricht das Event ab (verhindert weitere Handler-Ausführung)."""
        self.cancelled = True

    def is_cancelled(self) -> bool:
        """Prüft, ob das Event abgebrochen wurde."""
        return self.cancelled

    # Dict-ähnlicher Zugriff auf metadata für einfache Nutzung
    def get(self, key: str, default: Any = None) -> Any:
        """Gibt einen Wert aus metadata zurück."""
        return self.metadata.get(key, default)

    def __getitem__(self, key: str) -> Any:
        """Ermöglicht data["key"] Zugriff."""
        return self.metadata[key]

    def __setitem__(self, key: str, value: Any) -> None:
        """Ermöglicht data["key"] = value."""
        self.metadata[key] = value

    def __contains__(self, key: str) -> bool:
        """Ermöglicht 'key' in data."""
        return key in self.metadata

    def keys(self):
        """Gibt die Schlüssel der metadata zurück."""
        return self.metadata.keys()

    def values(self):
        """Gibt die Werte der metadata zurück."""
        return self.metadata.values()

    def items(self):
        """Gibt die Items der metadata zurück."""
        return self.metadata.items()

    @classmethod
    def event_name(cls) -> str:
        """
        Gibt den kanonischen Event-Namen zurück.

        Standard: Klassenname in snake_case.
        Kann in Unterklassen überschrieben werden.
        """
        name = cls.__name__
        # CamelCase zu snake_case
        result = []
        for i, char in enumerate(name):
            if char.isupper() and i > 0:
                result.append("_")
            result.append(char.lower())
        return "".join(result)