#!/usr/bin/env python3
"""P16 (rastavljeni prikaz) i P17 (vektorski poprečni presjek) iz konačnog programa, s trakom oznake i podloga.
AI građanski koncept · PRIJEDLOG · nije projekt. Zove scripts/viz/koncept.py i dorađuje izlaz; zakrpe modela su od 15.11.2026. ugrađene u koncept.py (zakrpe.py ih samo popisuje).
P17: tri reza sjever-jug iz koncept.poprecni_presjek, stupac razina programa i četvrti rez istok-zapad kroz Sportski
brijeg (dvorane M28) i garažu jug P0 do P3 (M29) s trening-terenom na krovu.

    python sheme.py p17 --izlaz <mapa>            # SVG + JPG + JSON
    python sheme.py p16 --izlaz <mapa> --uzorci 128
"""
from __future__ import annotations

import argparse
import hashlib
import json
import re
import sys
import time
from pathlib import Path
from xml.sax.saxutils import escape
import math

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
import zakrpe  # noqa: E402  (primjenjuje zakrpe na koncept.py u ovom procesu)

KORIJEN = zakrpe.KORIJEN
import koncept as KON  # noqa: E402
import montaza as M  # noqa: E402

PROGRAM = KORIJEN / "research" / "viz" / "program.json"
OZNAKA = "AI građanski koncept · PRIJEDLOG · nije projekt"


def program_meta():
    sirovo = PROGRAM.read_bytes()
    d = json.loads(sirovo.decode("utf-8"))["meta"]
    return {"datoteka": "research/viz/program.json", "naziv": d.get("naziv"), "verzija": d.get("verzija"),
            "datum": d.get("datum"), "status": d.get("status"), "sha256": hashlib.sha256(sirovo).hexdigest()}


def podloge_tekst(pm, teren=True):
    t = (f"Podloge: program po razinama research/viz/program.json v{pm['verzija']} (AI sinteza, PRIJEDLOG; "
         f"sha256 {pm['sha256'][:12]}…), crtan na OSM podlozi (© OpenStreetMap contributors, ODbL) i stvarnim "
         "kotama iz službene situacije (GEL-33/2025, prilog 7.1)")
    if teren:
        t += ("; današnje tlo: DGU Visine INSPIRE (Otvorena dozvola, https://data.gov.hr/otvorena-dozvola; "
              "izmijenjeno: isječak, preuzorkovanje)")
    return t + "."


def razine_u_rezu(x_n):
    from shapely.geometry import LineString, Polygon

    d = json.loads(PROGRAM.read_text(encoding="utf-8"))
    st = Polygon(d["stadion"]["vanjski_obris"])
    _, sy0, _, sy1 = st.bounds
    # isti raspon kao panel "kroz središte stadiona" u koncept.poprecni_presjek (os Maksimirske je sjeverno od stadiona)
    lin = LineString([(x_n, sy0 - 45.0), (x_n, max(sy1, 95.0) + 70.0)])
    u = set()
    for q in d["prostori"]:
        try:
            p = Polygon(q["poligon"], q.get("rupe") or []).buffer(0)
        except Exception:  # noqa: BLE001
            continue
        if p.intersects(lin) and p.intersection(lin).length >= 1.0:
            u.add(q["razina"])
    return d["razine"], u


def p17(izlaz, sirina=2160, ekstra=300):
    izlaz.mkdir(parents=True, exist_ok=True)
    rad = izlaz / "p17_rad"
    rad.mkdir(exist_ok=True)
    pop = KON.poprecni_presjek(str(PROGRAM), rad / "poprecni.png", sirina_px=sirina)
    svg = (rad / "poprecni.svg").read_text(encoding="utf-8")
    W0 = sirina
    H0 = int(re.search(r'height="(\d+)"', svg).group(1))
    W = W0 + ekstra
    # mjerilo gornjeg panela (stadion) iz natpisa mreže kota
    prvi = svg.index('fill="#f6f7f8"')
    panel = re.search(r'<rect x="([\d.]+)" y="([\d.]+)" width="([\d.]+)" height="([\d.]+)" fill="#f6f7f8"', svg)
    px0, py0, pw, ph = (float(v) for v in panel.groups())
    oznake = re.findall(r'<text x="[\d.]+" y="([\d.]+)" font-size="10" font-weight="normal" fill="#80858c" '
                        r'text-anchor="end">(\d+)</text>', svg[prvi:])
    oznake = [(float(y) - 4.0, float(z)) for y, z in oznake if py0 - 2 <= float(y) - 4.0 <= py0 + ph + 2]
    (y1, z1), (y2, z2) = oznake[0], oznake[-1]
    sy = lambda z: y1 + (z - z1) * (y2 - y1) / (z2 - z1)  # noqa: E731
    razine, u_rezu = razine_u_rezu(pop["rezovi_x_enu_n"][1])
    dod = []
    xr = px0 + pw
    xt = W0 - 40
    dod.append(f'<text x="{xt:.1f}" y="{py0 + 4:.1f}" font-size="12" font-weight="bold" fill="#1c2026">Razine programa</text>')
    dod.append(f'<text x="{xt:.1f}" y="{py0 + 19:.1f}" font-size="10" fill="#50555c">kota poda, m n. v.</text>')
    zadnji = 1e9
    redovi = sorted(razine, key=lambda r: -r["kota_poda_mnv"])
    for r in redovi:
        z = r["kota_poda_mnv"]
        Y = sy(z)
        ty = Y + 4
        if ty < py0 + 36:
            ty = py0 + 36
        # od vrha prema dnu: natpis najmanje 15 px ispod prethodnog
        if zadnji < 1e8:
            ty = max(ty, zadnji + 15)
        zadnji = ty
        u = r["id"] in u_rezu
        boja = "#1c2026" if u else "#8a8f96"
        tekst = f"{r['id']} · {r['naziv']} {z:.1f}".replace(".", ",")
        dod.append(f'<line x1="{xr - 10:.1f}" y1="{Y:.1f}" x2="{xr:.1f}" y2="{Y:.1f}" stroke="#30353b" stroke-width="1"/>')
        dod.append(f'<polyline points="{xr:.1f},{Y:.1f} {xt - 8:.1f},{ty - 4:.1f} {xt - 3:.1f},{ty - 4:.1f}" fill="none" '
                   f'stroke="#9aa0a8" stroke-width="0.6"/>')
        dod.append(f'<text x="{xt:.1f}" y="{ty:.1f}" font-size="11" fill="{boja}">{escape(tekst)}</text>')
    dod.append(f'<text x="{xt:.1f}" y="{zadnji + 22:.1f}" font-size="9.5" fill="#8a8f96">sivo: razina ne siječe ovaj rez</text>')
    dod.append(f'<text x="{xt:.1f}" y="{zadnji + 35:.1f}" font-size="9.5" fill="#8a8f96">krov stadiona nije razina programa</text>')
    # nova traka: oznaka i podloge, dva retka
    pm = program_meta()
    svg = re.sub(r'<rect x="0" y="\d+" width="\d+" height="30" fill="#12161c"/>\s*<text[^>]*>AI građanski koncept[^<]*</text>',
                 "", svg)
    rez4, h4 = rez_istok_zapad(W, H0 - 30 + 24)
    dod += rez4
    H = H0 + 34 + h4
    traka = [f'<rect x="0" y="{H - 64}" width="{W}" height="64" fill="#12161c"/>',
             f'<text x="70.0" y="{H - 40}" font-size="14" font-weight="bold" fill="#ffffff">{escape(OZNAKA)} · shema iz '
             f'programa, nije izvedbeni presjek · kote PRETPOSTAVKA-IZRAČUN na plohi modela</text>',
             f'<text x="70.0" y="{H - 16}" font-size="11" fill="#cdd2d8">{escape(podloge_tekst(pm))}</text>']
    svg = re.sub(r'width="\d+" height="\d+" viewBox="0 0 \d+ \d+"', f'width="{W}" height="{H}" viewBox="0 0 {W} {H}"', svg, count=1)
    svg = svg.replace("</svg>", "\n".join(dod + traka) + "\n</svg>")
    svg_put = izlaz / "P17.svg"
    svg_put.write_text(svg, encoding="utf-8")
    png = rad / "P17.png"
    alat = KON._svg_u_png(svg_put, png, W, H)
    slika = M.ucitaj_sliku(png)
    jpg = M.spremi(slika, izlaz / "P17_vizija.jpg", kvaliteta=92)
    return {"svg": svg_put, "jpg": jpg, "pop": pop, "pretvorba": alat, "velicina": [W, H], "razine_u_rezu": sorted(u_rezu),
            "program": pm}


Y_REZ4 = -300.0
KRATKO = {"D-MULTI": "višenamjenska dvorana", "D-RUK-TRENING": "trenažna dvorana", "D-ARENA": "rukometna arena",
          "TP-BRIJEG-I": "", "DVOR-ARENA": "dvorište", "GAR-J-P0": "garaža jug P0", "GAR-J-P1": "P1",
          "GAR-J-P2": "P2", "GAR-J-P3": "P3", "TP-NAV2": "", "SERVISNA-CESTA": "", "LOKALI-AVENIJA": ""}


def rez_istok_zapad(W, Y_top, y_n=Y_REZ4, xa=-425.0, xb=-15.0, rub=70.0):
    """Četvrti rez: istok-zapad na y = y_n (ENU-N) kroz Sportski brijeg i garažu jug. Vraća SVG elemente i visinu."""
    import shapely
    from shapely.geometry import LineString

    P = KON.Program(str(PROGRAM))
    o = dict(KON.ZADANO_KONCEPT)
    site = json.loads((KORIJEN / "research" / "viz" / "site.json").read_text(encoding="utf-8"))
    import scena as SC

    teren = SC.Teren()
    pv = KON.Povrsina(P, teren.kota_n, o, site)
    xs = np.arange(xa, xb + 0.01, 0.5)
    ys = np.full(len(xs), y_n)
    tlo = np.asarray(teren.kota_n(xs, ys), dtype=np.float64)
    i, j = pv.celija(xs, ys)
    L = pv.L[i, j]
    park = np.full(len(xs), np.nan)
    for k in np.unique(L[L >= 0]):
        m = L == k
        park[m] = pv.z_prostora(pv.pl[int(k)], xs[m], ys[m])
    svj = L == -2
    zv = np.where(np.isnan(park), pv.z_vrha(xs, ys), park)
    lin = LineString([(xa, y_n), (xb, y_n)])
    nize = []
    for q in P.prostori:
        if q["razina"] >= P.i_park or q["pod"] is None:
            continue
        pr = q["geom"].intersection(lin)
        for g in getattr(pr, "geoms", [pr]):
            if g.is_empty or g.geom_type != "LineString" or g.length < 1.0:
                continue
            xx = [c[0] for c in g.coords]
            h = q["visina"] or (P.razine[q["razina"]]["visina"] or o["visina_zatvorenog_m"] if q["kat"] in KON.ZATVORENE else 0.3)
            nize.append({"x0": min(xx), "x1": max(xx), "z0": q["pod"], "z1": q["pod"] + h, "kat": q["kat"], "id": q["id"]})
    z0, z1 = 112.0, 138.0
    s_m = (W - 2 * rub - 300) / (xb - xa)
    X0, Y0 = rub, Y_top + 40
    w, h = (xb - xa) * s_m, (z1 - z0) * s_m
    sx = lambda x: X0 + (x - xa) * s_m  # noqa: E731
    sy = lambda z: Y0 + (z1 - z) * s_m  # noqa: E731
    e = []

    def T(x, y, t, vel=11, deb=False, boja="#1c2026", sidro="start"):
        e.append(f'<text x="{x:.1f}" y="{y:.1f}" font-size="{vel}" font-weight="{"bold" if deb else "normal"}" '
                 f'fill="{boja}" text-anchor="{sidro}">{escape(t)}</text>')

    def put(p):
        return " ".join(f"{a:.1f},{b:.1f}" for a, b in p)

    T(X0, Y_top + 22, f"Rez istok-zapad kroz Sportski brijeg i garažu jug (y = {y_n:.0f} m, ENU-N; "
                      f"pogled s juga, zapad lijevo, istok desno)", 14, True)
    e.append(f'<rect x="{X0:.1f}" y="{Y0:.1f}" width="{w:.1f}" height="{h:.1f}" fill="#f6f7f8" stroke="#c9ccd0" stroke-width="0.8"/>')
    for zz in range(115, 136, 5):
        e.append(f'<line x1="{X0:.1f}" y1="{sy(zz):.1f}" x2="{X0 + w:.1f}" y2="{sy(zz):.1f}" stroke="#e1e3e6" stroke-width="0.6"/>')
        T(X0 - 6, sy(zz) + 4, f"{zz}", 10, False, "#80858c", "end")
    # tlo današnje (ispuna) i ploča parka nad prostorima (od vrha prostora do plohe parka)
    pts = [(sx(x), sy(z)) for x, z in zip(xs, tlo)]
    e.append(f'<polygon points="{put(pts + [(sx(xs[-1]), sy(z0)), (sx(xs[0]), sy(z0))])}" fill="#d9cfbf" fill-opacity="0.55"/>')
    for q in sorted(nize, key=lambda q: q["z0"]):
        b = KON.BOJE_KAT.get(q["kat"], "#cccccc")
        e.append(f'<rect x="{sx(q["x0"]):.1f}" y="{sy(q["z1"]):.1f}" width="{(q["x1"] - q["x0"]) * s_m:.1f}" '
                 f'height="{max((q["z1"] - q["z0"]) * s_m, 1.0):.1f}" fill="{b}" fill-opacity="0.8" stroke="#8a8f96" stroke-width="0.5"/>')
    # krov dvorana i garaže: od vrha najvišeg prostora ispod do plohe parka (debljina iz razlike kota)
    vrh_ispod = np.full(len(xs), np.nan)
    for q in nize:
        m = (xs >= q["x0"]) & (xs <= q["x1"])
        vrh_ispod[m] = np.fmax(vrh_ispod[m], q["z1"])
    ok = ~np.isnan(park) & ~np.isnan(vrh_ispod) & (park - vrh_ispod > 0.3)
    m = np.r_[False, ok, False]
    d = np.diff(m.astype(np.int8))
    for a, b in zip(np.nonzero(d == 1)[0], np.nonzero(d == -1)[0]):
        gor = [(sx(xs[k]), sy(park[k])) for k in range(a, b)]
        dol = [(sx(xs[k]), sy(vrh_ispod[k])) for k in range(b - 1, a - 1, -1)]
        e.append(f'<polygon points="{put(gor + dol)}" fill="#a9acb0" stroke="#5f6368" stroke-width="0.6"/>')
    ima = ~np.isnan(park)
    m = np.r_[False, ima, False]
    d = np.diff(m.astype(np.int8))
    for a, b in zip(np.nonzero(d == 1)[0], np.nonzero(d == -1)[0]):
        e.append(f'<polyline points="{put([(sx(xs[k]), sy(park[k])) for k in range(a, b)])}" fill="none" stroke="#3d7a2a" stroke-width="2.4"/>')
    m = np.r_[False, svj, False]
    d = np.diff(m.astype(np.int8))
    for a, b in zip(np.nonzero(d == 1)[0], np.nonzero(d == -1)[0]):
        zz = float(np.max(zv[a:b])) + 0.4
        e.append(f'<line x1="{sx(xs[a]):.1f}" y1="{sy(zz):.1f}" x2="{sx(xs[b - 1]):.1f}" y2="{sy(zz):.1f}" stroke="#5cc3e6" stroke-width="3"/>')
    e.append(f'<polyline points="{put(pts)}" fill="none" stroke="#6b5a45" stroke-width="1.1" stroke-dasharray="5 3"/>')
    # natpisi prostora (unutar pravokutnika kad stanu)
    for q in nize:
        tx = KRATKO.get(q["id"], q["id"])
        if not tx:
            continue
        wq, hq = (q["x1"] - q["x0"]) * s_m, (q["z1"] - q["z0"]) * s_m
        cxq = sx((q["x0"] + q["x1"]) / 2)
        if q["kat"] == "garaza":
            t = f"{tx} {q['z0']:.1f}".replace(".", ",")
            T(sx(q["x0"]) + 4, sy(q["z0"]) - 1.5, t, 9, False, "#30353b")
        elif hq > 30 and wq > 80:
            T(cxq, sy(q["z1"]) + 16, tx, 11, True, "#30353b", "middle")
            T(cxq, sy(q["z1"]) + 30, f"pod {q['z0']:.1f}, svijetla visina {q['z1'] - q['z0']:.1f} m".replace(".", ","), 10, False,
              "#30353b", "middle")
        elif wq > 40:
            T(cxq, sy(q["z1"]) + 14, tx, 10, False, "#30353b", "middle")
    # kote parka
    for ime, x in (("Sportski brijeg", -300.0), ("trening-teren (krov garaže P3)", -90.0), ("padina", -400.0)):
        k = int(np.argmin(np.abs(xs - x)))
        if np.isnan(park[k]):
            continue
        X, Y = sx(xs[k]), sy(park[k])
        e.append(f'<polygon points="{put([(X, Y), (X - 4, Y - 6), (X + 4, Y - 6)])}" fill="#c0392b"/>')
        T(X + 7, Y - 7, f"{ime} {park[k]:.2f}".replace(".", ","), 11, True, "#a12a1e")
    T(X0, Y0 + h + 15, "zapad", 10, False, "#50555c")
    T(X0 + w, Y0 + h + 15, "istok", 10, False, "#50555c", "end")
    mj = 50
    e.append(f'<line x1="{X0 + w - mj * s_m - 8:.1f}" y1="{Y0 + h + 24:.1f}" x2="{X0 + w - 8:.1f}" y2="{Y0 + h + 24:.1f}" stroke="#1c2026" stroke-width="2"/>')
    T(X0 + w - mj * s_m - 14, Y0 + h + 28, f"{mj} m (vodoravno i okomito)", 10, False, "#30353b", "end")
    # mali opis desno
    xt = X0 + w + 24
    for n, t in enumerate(["Dvorane Sportskog brijega (M28):", "pod 116,0, svijetla visina 9 i 12 m;",
                           "zeleni krov 132,0 (park).", "Garaža jug P0 do P3 (M29):", "118,0 · 121,3 · 124,6 · 127,9;",
                           "na krovu trening-teren 131,5.", "Sivo: krov i tlo zelenog krova,", "debljina iz razlike kota",
                           "(PRETPOSTAVKA)."]):
        T(xt, Y0 + 12 + 15 * n, t, 10.5, n in (0, 3), "#30353b")
    return e, int(h + 120)


def p16(izlaz, sirina=1920, uzorci=128, samo_traka=False):
    izlaz.mkdir(parents=True, exist_ok=True)
    rad = izlaz / "p16_rad"
    rad.mkdir(exist_ok=True)
    if samo_traka and (rad / "rastavljeni.json").exists():
        r = {"popratno": json.loads((rad / "rastavljeni.json").read_text(encoding="utf-8"))}
    else:
        r = KON.rastavljeni_prikaz(str(PROGRAM), rad / "rastavljeni.png", sirina_px=sirina, uzorci=uzorci,
                               predmemorija=rad / "tmp")
    a = M.ucitaj_sliku(rad / "rastavljeni.png")
    # unutarnja traka (tamni redovi na dnu) zamjenjuje se trakom s oznakom i podlogama
    tamno = (a[..., :3].mean(axis=2) < 0.15).mean(axis=1) > 0.4
    n = 0
    while n < len(tamno) and tamno[-1 - n]:
        n += 1
    a = a[: len(a) - n]
    pm = program_meta()
    t = M.traka(a, [f"Shema iz programa po razinama; razmak između razina nije u mjerilu, visine prostora su svijetle "
                    f"visine iz programa ili zadane (PRETPOSTAVKA). Krov stadiona (166,5 m n. v., PRETPOSTAVKA) nije razina "
                    f"programa i nije prikazan; vidi poprečni presjek P17."],
                podloge=podloge_tekst(pm, teren=False), oznaka=OZNAKA + " · shema, render nije dokaz")
    jpg = M.spremi(t, izlaz / "P16_vizija.jpg", kvaliteta=92)
    return {"jpg": jpg, "pop": r["popratno"], "odrezano_px": n, "program": pm}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("sto", choices=["p16", "p17"])
    ap.add_argument("--izlaz", required=True)
    ap.add_argument("--uzorci", type=int, default=128)
    ap.add_argument("--sirina", type=int, default=None)
    ap.add_argument("--samo-traka", action="store_true")
    a = ap.parse_args()
    t0 = time.time()
    if a.sto == "p17":
        r = p17(Path(a.izlaz), sirina=a.sirina or 2160)
    else:
        r = p16(Path(a.izlaz), sirina=a.sirina or 1920, uzorci=a.uzorci, samo_traka=a.samo_traka)
    r["vrijeme_s"] = round(time.time() - t0, 1)
    (Path(a.izlaz) / f"{a.sto}_rez.json").write_text(json.dumps(r, ensure_ascii=False, indent=1, default=str), encoding="utf-8")
    print(json.dumps({k: v for k, v in r.items() if k != "pop"}, ensure_ascii=False, default=str))


if __name__ == "__main__":
    main()
