#!/usr/bin/env python3
"""P17 presječna perspektiva: model odrezan okomitom ravninom sjever-jug kroz središte stadiona (postupak kao
koncept.presjecna_perspektiva, vlastiti kadar), sa zakrpama (sjever iz stadion.sjever, staklo) i sa zatvorenim
presjekom: presječene plohe (tribine, sjeverna kosa ploha, ploča pokrova, ploča parka, prostori nižih razina) dobivaju
svijetlu ispunu iz istih podataka kao vektorski rez P17. Dodatno svjetlo s istoka služi samo čitljivosti presjeka.
AI građanski koncept · PRIJEDLOG · nije projekt.

    python persp.py --izlaz <mapa> --sirina 960 --uzorci 48 --kadrovi G
"""
import argparse
import json
import math
import sys
import time
from pathlib import Path

import numpy as np

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

KORIJEN = zakrpe.KORIJEN
import kamera as KAM  # noqa: E402
import koncept as KON  # noqa: E402
import koordinate as K  # noqa: E402

PROGRAM = KORIJEN / "research" / "viz" / "program.json"
KADROVI = {
    "G": dict(cilj=(0.0, 130.0, 125.0), az=100.0, ud=115.0, oko=134.0, f35=24.0, shift_y=0.0),
}
SVJETLO_ISTOK = {"azimut_deg": 95.0, "visina_deg": 28.0, "jakost": 3.0}
ISPUNA = {"tribina": (205, 214, 232), "sjever": (196, 208, 236), "pokrov": (214, 212, 206), "park": (200, 214, 190)}


def hex_rgb(h):
    h = h.lstrip("#")
    return tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))


def zatvori_presjek(s, pn, x_ravnine_m):
    """Ispune presjeka iz panela vektorskog reza (ENU-N) na ravnini x = x_ravnine_m (ENU-M)."""
    x_n = float(pn["x"])
    deb = float(KON.ZADANO_KONCEPT["debljina_pokrova_m"])

    def tocka(y, z):
        _, ym = K.m_iz_n(x_n, float(y))
        return (x_ravnine_m, float(ym), float(z))

    grupe = {}

    def dodaj(boja, poli):
        v, f = grupe.setdefault(boja, ([], []))
        i0 = len(v)
        v.extend(tocka(y, z) for y, z in poli)
        f.append(tuple(range(i0, i0 + len(poli))))

    ys = pn["ys"]
    sd = pn["stad"]
    if sd:
        for a, b, zd, zg in sd["trib"]:
            dodaj(ISPUNA["tribina"], [(a, zd), (b, zg), (b, zd)])
        if sd.get("sjever"):
            sy_, sz_ = sd["sjever"]["y"], sd["sjever"]["z"]
            for i in range(len(sy_) - 1):
                dodaj(ISPUNA["sjever"], [(sy_[i], sz_[i]), (sy_[i + 1], sz_[i + 1]), (sy_[i + 1], sz_[i + 1] - 1.2),
                                         (sy_[i], sz_[i] - 1.2)])
    ima = ~np.isnan(pn["park"])
    pod = pn["pod"] & ima
    for i in range(len(ys) - 1):
        if not (ima[i] and ima[i + 1]):
            continue
        if pod[i] and pod[i + 1]:
            dodaj(ISPUNA["pokrov"], [(ys[i], pn["park"][i]), (ys[i + 1], pn["park"][i + 1]),
                                     (ys[i + 1], pn["zv"][i + 1] - deb), (ys[i], pn["zv"][i] - deb)])
        else:
            dodaj(ISPUNA["park"], [(ys[i], pn["park"][i]), (ys[i + 1], pn["park"][i + 1]),
                                   (ys[i + 1], pn["park"][i + 1] - 1.2), (ys[i], pn["park"][i] - 1.2)])
    for q in pn["nize"]:
        b = hex_rgb(KON.BOJE_KAT.get(q["kat"], "#cccccc"))
        dodaj(tuple(int(0.55 * c + 0.45 * 235) for c in b), [(q["y0"], q["z0"] + 0.05), (q["y1"], q["z0"] + 0.05),
                                                           (q["y1"], q["z1"] - 0.3), (q["y0"], q["z1"] - 0.3)])
    for n, (boja, (v, f)) in enumerate(grupe.items()):
        s.dodaj_mrezu(f"ispuna_presjeka_{n}", v, f, sloj="koncept", boja=KON.lin(boja))
    return {"skupina": len(grupe), "ploha": sum(len(f) for _, f in grupe.values())}


def svjetlo_istok(s):
    bpy = s.bpy
    L = bpy.data.lights.new("svjetlo_s_istoka", type="SUN")
    L.energy = SVJETLO_ISTOK["jakost"]
    L.angle = math.radians(8.0)
    ob = bpy.data.objects.new("svjetlo_s_istoka", L)
    s.scene.collection.objects.link(ob)
    az, vis = math.radians(SVJETLO_ISTOK["azimut_deg"]), math.radians(SVJETLO_ISTOK["visina_deg"])
    d = np.array([math.sin(az) * math.cos(vis), math.cos(az) * math.cos(vis), math.sin(vis)])   # prema svjetlu
    # Sunce u Blenderu svijetli duž -Z objekta: -Z mora gledati u -d
    import mathutils

    ob.rotation_euler = mathutils.Vector((-d[0], -d[1], -d[2])).to_track_quat("-Z", "Y").to_euler()
    return dict(SVJETLO_ISTOK)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--izlaz", required=True)
    ap.add_argument("--sirina", type=int, default=960)
    ap.add_argument("--uzorci", type=int, default=48)
    ap.add_argument("--kadrovi", default="G")
    ap.add_argument("--kada", default="2026-06-21 11:00")
    ap.add_argument("--jakost-istok", type=float, default=None)
    a = ap.parse_args()
    if a.jakost_istok is not None:
        SVJETLO_ISTOK["jakost"] = a.jakost_istok
    out = Path(a.izlaz)
    out.mkdir(parents=True, exist_ok=True)
    pred = out / "tmp"
    pred.mkdir(exist_ok=True)
    pop = KON.poprecni_presjek(str(PROGRAM), pred / "rez.png", sirina_px=1200)
    pn = next(p for p in pop["_paneli"] if p["stad"])
    s = KON.izgradi(str(PROGRAM), slojevi_scene=("teren_blizu", "teren_regija", "teren_daleko", "zgrade", "drvece"),
                    predmemorija=pred, unutrasnjost=True)
    P = s.program
    cn = P.stadion["sredina"]
    cx, cy = K.m_iz_n(float(cn[0]), float(cn[1]))
    obrisano = {"materijala_s_rezom": KON._odrezi_istok(s, float(cx), float(cy))}
    ys = np.arange(cy - 1400.0, cy + 1400.0, 2.0)
    xn, yn = K.n_iz_m(np.full(len(ys), float(cx)), ys)
    zt = np.asarray(s.tlo_n(xn, yn), dtype=np.float64)
    vrh = [(float(cx) - 0.05, float(y), float(z)) for y, z in zip(ys, zt)]
    z_baze = float(np.floor(zt.min())) - 8.0
    dno = [(float(cx) - 0.05, float(y), z_baze) for y in ys]
    n = len(ys)
    plohe = [(i, i + 1, n + i + 1, n + i) for i in range(n - 1)]
    s.dodaj_mrezu("presjek_tla", vrh + dno, plohe, sloj="koncept", boja=KON.lin((58, 46, 36)))
    x0_, x1_, y0_, y1_ = float(cx) - 0.05, float(cx) + 1400.0, float(cy) - 1400.0, float(cy) + 1400.0
    s.dodaj_mrezu("presjek_podloga", [(x0_, y0_, z_baze), (x1_, y0_, z_baze), (x1_, y1_, z_baze), (x0_, y1_, z_baze)],
                  [(0, 1, 2, 3)], sloj="koncept", boja=KON.lin((196, 194, 188)))
    ispuna = zatvori_presjek(s, pn, float(cx) - 0.08)
    # oko je iznad odrezanog (prozirnog) istočnog dijela: geometrijska provjera kamere vidi stražnje strane
    # odrezanih kutija i nije mjerodavna za ovaj kadar
    s.provjeri_kameru = lambda *x, **y: None
    s.postavi_sunce(a.kada)
    ist = svjetlo_istok(s)
    for ime in a.kadrovi.split(","):
        k = KADROVI[ime]
        t0 = time.time()
        kam = KAM.pogled_na((float(cx) + k["cilj"][0], float(cy) + k["cilj"][1], k["cilj"][2]),
                            azimut_od_cilja_deg=k["az"], udaljenost_m=k["ud"], kota_oka=k["oko"], f35_mm=k["f35"],
                            sirina_px=a.sirina, omjer=16 / 9, naziv=f"presjek_{ime}")
        s.postavi_kameru(kam)
        s.scene.camera.data.shift_y = k["shift_y"]
        s.renderiraj(out / f"persp_{ime}.png", uzorci=a.uzorci, prolazi=("slika",), traka=False, mjerenja=False,
                     dodatno={"presjek": {"ravnina": "okomita, sjever-jug, kroz središte stadiona",
                                          "x_enu_m": round(float(cx), 1), "rez": obrisano, "kadar": k,
                                          "ispuna_presjeka": ispuna, "svjetlo_s_istoka": ist,
                                          "zakrpe": list(zakrpe.PRIMIJENJENO),
                                          "sjever": s.kstat.get("stadion", {}).get("sjever")}})
        print("kadar", ime, round(time.time() - t0, 1), "s", flush=True)


if __name__ == "__main__":
    main()
