DOSSIER/rhino/elemente_uebersicht.py

#! python 3
# -*- coding: utf-8 -*-
# SPDX-License-Identifier: AGPL-3.0-or-later
# Copyright (C) 2026 Karim Gabriele Varano
"""
elemente_uebersicht.py
BIM-artiger Project Browser: alle Smart-Elemente in einem Tree
gruppiert nach Geschoss → Kind → Element. Eigene Satellite-Window
(Eto.Form + WebView), liest seine Daten direkt aus dem ActiveDoc
via elemente._read_meta. Klick auf eine Zeile selektiert das Objekt
in Rhino.
"""
import os
import sys
import Rhino
import scriptcontext as sc

_HERE = os.path.dirname(os.path.abspath(__file__))
if _HERE not in sys.path:
    sys.path.insert(0, _HERE)

import panel_base
import elemente as _elm


_KIND_MAP = {
    "wand_axis":                "wand",
    "decke_outline":            "decke",
    "dach_outline":             "dach",
    "treppe_axis":              "treppe",
    "stuetze_point":            "stuetze",
    "traeger_axis":             "traeger",
    "raum_outline":             "raum",
    "stempel":                  "stempel",
    "decke_aussparung_outline": "aussparung",
    "oeffnung_point":           "oeffnung",  # wird zu fenster/tuer aufgeloest
}


def _safe_float(v, default=None):
    try: return float(v)
    except Exception: return default


def _build_overview(doc):
    """Sammelt alle Smart-Element-Sources, gruppiert nach Geschoss +
    Kind. Returns dict mit 'geschosse' (geordnete Liste) + 'items'
    (Flat-Liste pro Geschoss/Kind). Frontend baut den Tree."""
    if doc is None:
        return {"geschosse": [], "items": []}
    geschosse = _elm._load_geschosse(doc) or []
    items = []
    seen = set()
    for obj in doc.Objects:
        meta = _elm._read_meta(obj)
        if meta is None: continue
        t = meta.get("type")
        if t not in _elm.SOURCE_TYPES: continue
        if meta["id"] in seen: continue
        seen.add(meta["id"])

        kind = _KIND_MAP.get(t, t)
        if t == "oeffnung_point":
            kind = meta.get("oeff_typ", "fenster")

        g = _elm._geschoss_by_id(doc, meta.get("geschoss"))
        g_id = (g.get("id") if g else "") or "__keingeschoss__"
        g_name = g.get("name") if g else "(kein Geschoss)"

        # Kompakte Property-Zusammenfassung pro Element-Typ
        info = ""
        try:
            if kind == "wand":
                info = "d {:.2f} m".format(meta.get("dicke", 0) or 0)
            elif kind == "decke":
                info = "d {:.2f} m".format(meta.get("dicke", 0) or 0)
            elif kind == "dach":
                info = "d {:.2f} m · {:.0f}°".format(
                    meta.get("dicke", 0) or 0, meta.get("neigung", 0) or 0)
            elif kind in ("fenster", "tuer"):
                info = "{:.2f}×{:.2f} m".format(
                    meta.get("oeff_breite", 0) or 0,
                    meta.get("oeff_hoehe", 0) or 0)
            elif kind == "treppe":
                info = "{} St".format(meta.get("treppe_n_stufen", "?"))
            elif kind in ("stuetze", "traeger"):
                profil = meta.get("trag_profil", "?")
                info = "{}".format(profil)
            elif kind == "raum":
                info = meta.get("raum_name", "") or "Raum"
            elif kind == "aussparung":
                info = "Aussparung"
        except Exception: pass

        items.append({
            "id":          meta["id"],
            "objectId":    str(obj.Id),
            "kind":        kind,
            "geschossId":  g_id,
            "geschossName": g_name,
            "name":        meta.get("raum_name") or "",
            "info":        info,
            "selected":    obj.IsSelected(False) > 0,
        })

    # Geschoss-Liste (geordnet wie in doc.Strings)
    out_geschosse = []
    for g in geschosse:
        if not isinstance(g, dict): continue
        out_geschosse.append({
            "id":   g.get("id") or "",
            "name": g.get("name") or "?",
            "okff": _safe_float(g.get("okff"), 0.0),
        })
    # "(kein Geschoss)" anhaengen wenn es Elemente ohne Geschoss gibt
    if any(it["geschossId"] == "__keingeschoss__" for it in items):
        out_geschosse.append({
            "id": "__keingeschoss__", "name": "(kein Geschoss)", "okff": None,
        })

    # SIA-416 Bilanz pro Geschoss: aggregiert alle raum_outline-Flaechen
    # nach raum_sia-Klassifikation. Räume ohne SIA-Tag landen in "ohne".
    # NF = HNF + NNF (Nutzflaeche). Wird im Frontend als Tabelle gerendert.
    sia_bilanz = {}  # {geschossId: {hnf, nnf, vf, ff, ohne, nf, total, count}}
    for obj in doc.Objects:
        meta = _elm._read_meta(obj)
        if meta is None: continue
        if meta.get("type") != "raum_outline": continue
        try:
            area, _, _ = _elm._raum_amp(obj.Geometry)
        except Exception: continue
        if not area or area <= 0: continue
        g_id = meta.get("geschoss") or "__keingeschoss__"
        sia = (meta.get("raum_sia") or "").lower()
        if sia not in ("hnf", "nnf", "vf", "ff", "gf", "agf"):
            sia = "ohne"
        b = sia_bilanz.setdefault(g_id, {
            "hnf": 0.0, "nnf": 0.0, "vf": 0.0, "ff": 0.0,
            "gf":  0.0, "agf": 0.0,
            "ohne": 0.0, "count": 0,
        })
        b[sia] += float(area)
        b["count"] += 1
    # NF/NGF/Total ableiten
    for b in sia_bilanz.values():
        b["nf"] = b["hnf"] + b["nnf"]
        b["ngf"] = b["nf"] + b["vf"] + b["ff"]
        b["total"] = (b["hnf"] + b["nnf"] + b["vf"] + b["ff"]
                       + b["gf"] + b["agf"] + b["ohne"])

    return {"geschosse": out_geschosse, "items": items,
            "siaBilanz": sia_bilanz}


class ElementeUebersichtBridge(panel_base.BaseBridge):
    def __init__(self):
        panel_base.BaseBridge.__init__(self, "elemente_uebersicht")

    def _send_state(self):
        doc = Rhino.RhinoDoc.ActiveDoc
        self.send("STATE", _build_overview(doc))

    def _on_ready(self):
        self._send_state()

    def handle(self, data):
        if not isinstance(data, dict): return
        t = data.get("type", "")
        p = data.get("payload") or {}
        if not isinstance(p, dict): p = {}
        doc = Rhino.RhinoDoc.ActiveDoc

        if t == "READY" or t == "REQUEST_STATE":
            self._on_ready()
        elif t == "SELECT_ELEMENT":
            obj_id_str = p.get("objectId") or ""
            try:
                import System
                guid = System.Guid(obj_id_str)
                obj = doc.Objects.FindId(guid)
                if obj is not None:
                    doc.Objects.UnselectAll()
                    obj.Select(True)
                    try: doc.Views.Redraw()
                    except Exception: pass
            except Exception as ex:
                print("[UEBERSICHT] select:", ex)
            self._send_state()
        elif t == "ZOOM_TO_ELEMENT":
            obj_id_str = p.get("objectId") or ""
            try:
                import System
                guid = System.Guid(obj_id_str)
                obj = doc.Objects.FindId(guid)
                if obj is not None:
                    doc.Objects.UnselectAll()
                    obj.Select(True)
                    try:
                        vp = doc.Views.ActiveView.ActiveViewport
                        bb = obj.Geometry.GetBoundingBox(True)
                        if bb.IsValid:
                            bb.Inflate(bb.Diagonal.Length * 0.5,
                                       bb.Diagonal.Length * 0.5,
                                       bb.Diagonal.Length * 0.5)
                            vp.ZoomBoundingBox(bb)
                            doc.Views.Redraw()
                    except Exception as ex:
                        print("[UEBERSICHT] zoom:", ex)
            except Exception as ex:
                print("[UEBERSICHT] zoom find:", ex)


def open_as_window():
    """Oeffnet die Element-Uebersicht als Satellite-Window."""
    b = ElementeUebersichtBridge()
    sc.sticky["elemente_uebersicht_bridge"] = b
    panel_base.open_satellite_window(
        "elemente_uebersicht",
        title="Elemente — Übersicht",
        size=(540, 720),
        bridge=b)