plant2dxf/lib/handler_context.py

"""
Handler Context für DXF-Elementgenerierung.
Vereinfacht die Aufrufe der handle-Funktionen und bietet Debug-Unterstützung.
"""


class HandlerContext:
    """
    Kontextobjekt für Handler-Funktionsaufrufe.

    Speichert alle Parameter für handle-Funktionen und bietet:
    - Vereinfachte Aufrufe
    - Schöne String-Repräsentation für Debugging
    - Einfachen Zugriff auf alle Parameter
    """

    def __init__(
        self,
        msp,
        teileid,
        merkmale,
        x,
        y,
        doc,
        lib_doc,
        verbose=False,
        symbols=None,
        strecken_nachbarn=None,
        config=None,
        config_allgemein=None,
    ):
        self.msp = msp
        self.teileid = teileid
        self.merkmale = merkmale if merkmale is not None else {}
        self.x = x
        self.y = y
        self.doc = doc
        self.lib_doc = lib_doc
        self.verbose = verbose
        self.symbols = symbols if symbols is not None else []
        self.strecken_nachbarn = (
            strecken_nachbarn if strecken_nachbarn is not None else []
        )
        self.config = config
        self.config_allgemein = config_allgemein

    def call(self, handler_func):
        """
        Ruft eine Handler-Funktion mit allen gespeicherten Parametern auf.

        Args:
            handler_func: Die Handler-Funktion (z.B. handle_ils_2_0_kreisel)

        Returns:
            Rückgabewert der Handler-Funktion
        """
        return handler_func(
            self.msp,
            self.teileid,
            self.merkmale,
            self.x,
            self.y,
            self.doc,
            self.lib_doc,
            self.verbose,
            self.symbols,
            self.strecken_nachbarn,
            self.config,
            self.config_allgemein,
        )

    def __str__(self):
        """String-Repräsentation für Debugging."""
        lines = [
            "=" * 80,
            "HandlerContext:",
            "=" * 80,
            f"TeileId:     {self.teileid}",
            f"Position:    x={self.x:.2f}, y={self.y:.2f}",
            f"Verbose:     {self.verbose}",
            "-" * 80,
            "Merkmale:",
        ]

        if self.merkmale:
            for key, value in self.merkmale.items():
                lines.append(f"  {key:20s}: {value}")
        else:
            lines.append("  (keine)")

        lines.append("-" * 80)
        lines.append(f"Symbols:     {len(self.symbols)} Einträge")
        if self.symbols:
            for i, sym in enumerate(self.symbols, 1):
                lines.append(f"  [{i}] {sym}")

        lines.append("-" * 80)
        lines.append(f"Nachbarn:    {len(self.strecken_nachbarn)} Einträge")

        lines.append("-" * 80)
        lines.append(f"doc:         {type(self.doc).__name__}")
        lines.append(
            f"lib_doc:     {type(self.lib_doc).__name__ if self.lib_doc else 'None'}"
        )
        lines.append(f"msp:         {type(self.msp).__name__}")
        lines.append(f"config:      {'vorhanden' if self.config else 'None'}")
        lines.append(f"config_allg: {'vorhanden' if self.config_allgemein else 'None'}")
        lines.append("=" * 80)

        return "\n".join(lines)

    def __repr__(self):
        """Kurze Repräsentation."""
        return (
            f"HandlerContext(teileid={self.teileid!r}, "
            f"x={self.x:.2f}, y={self.y:.2f}, "
            f"merkmale={len(self.merkmale)} items)"
        )

    def to_dict(self):
        """
        Gibt alle Parameter als Dictionary zurück (ohne Objekt-Referenzen).
        Nützlich für Logging oder Serialisierung.
        """
        return {
            "teileid": self.teileid,
            "x": self.x,
            "y": self.y,
            "verbose": self.verbose,
            "merkmale": self.merkmale.copy(),
            "symbols_count": len(self.symbols),
            "symbols": self.symbols,
            "nachbarn_count": len(self.strecken_nachbarn),
            "has_config": self.config is not None,
            "has_config_allgemein": self.config_allgemein is not None,
            "has_lib_doc": self.lib_doc is not None,
        }

    @property
    def position(self):
        """Gibt Position als Tuple zurück."""
        return (self.x, self.y)

    @property
    def has_library(self):
        """Prüft, ob eine Bibliothek verfügbar ist."""
        return self.lib_doc is not None

    def get_merkmal(self, key, default=None):
        """
        Holt ein Merkmal mit Fallback-Wert.

        Args:
            key: Merkmal-Schlüssel
            default: Standardwert, falls Merkmal nicht existiert

        Returns:
            Merkmalwert oder default
        """
        return self.merkmale.get(key, default)


def create_context_from_row(
    row,
    msp,
    doc,
    lib_doc,
    strecken_nachbarn,
    config,
    config_allgemein,
    symbols=None,
    verbose=False,
):
    """
    Factory-Funktion: Erstellt HandlerContext aus einer CSV-Zeile.

    Args:
        row: Dictionary mit CSV-Daten
        msp: Modelspace
        doc: DXF-Dokument
        lib_doc: Bibliotheks-Dokument
        strecken_nachbarn: Liste der Nachbarn
        config: Config-Parser
        config_allgemein: Allgemeine Config
        symbols: Symbol-Liste (optional)
        verbose: Debug-Modus (optional)

    Returns:
        HandlerContext-Instanz
    """
    from arbeiten_mit_csv import parse_merkmale, extract_coords

    bezeichner = row["Bezeichnung"].strip()
    teileid = row["TeileId"].strip()
    planquadrat = row["Planquadrat"]
    merkmale = parse_merkmale(row.get("Merkmale", ""))
    merkmale["bezeichner"] = bezeichner

    x, y = extract_coords(planquadrat)

    return HandlerContext(
        msp=msp,
        teileid=teileid,
        merkmale=merkmale,
        x=x,
        y=y,
        doc=doc,
        lib_doc=lib_doc,
        verbose=verbose,
        symbols=symbols if symbols is not None else [],
        strecken_nachbarn=strecken_nachbarn,
        config=config,
        config_allgemein=config_allgemein,
    )