#!/usr/bin/env python3
"""Pokretač pogleda kampanje "prikazi i tlocrti": gradi scenu s konceptom, postavlja kameru i Sunce,
renderira prolaze i, za montaže, uklapa koncept u fotografiju (scripts/viz/montaza.py).

Status: AI građanski koncept · PRIJEDLOG · nije projekt. Render i montaža nisu dokaz. Opis postupka:
research/viz/model/MONTAZA.md; popis pogleda: research/viz/pogledi.json.

Treba Python s modulom bpy (kao scena.py). Naredbe:
    python scripts/viz/pogledi.py popis
    python scripts/viz/pogledi.py izradi P01 --sirina 1600 --uzorci 64 --program research/viz/program.json \
        --izlaz dist/assets/viz/pogledi --predmemorija <mapa izvan repoa> --foto-mapa <mapa s izvornicima>
    python scripts/viz/pogledi.py sve --izlaz ... --predmemorija ...

Kamera pogleda redom: research/viz/kamere/<id>.json (riješena), research/viz/model/validacija_kamere.json
(P01), približna kamera iz ZADANO_POGLEDI ili iz opisa u pogledi.json, EXIF/XMP DJI snimke. Montaža na
kameri koja nije riješena na kontrolne točke radi se samo uz --priblizna i nosi to na traci i u JSON-u.
"""
from __future__ import annotations

import json
import math
import os
import re
import sys
import tempfile
import time
from pathlib import Path

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
import kamera as KAM  # noqa: E402
import koordinate as K  # noqa: E402
import montaza as M  # noqa: E402

KORIJEN = Path(__file__).resolve().parents[2]
VIZ = KORIJEN / "research" / "viz"
POGLEDI_JSON = VIZ / "pogledi.json"
KAMERE = VIZ / "kamere"
VALIDACIJA = VIZ / "model" / "validacija_kamere.json"
PROGRAM_ZADANO = VIZ / "program.json"
IZLAZ_ZADANO = KORIJEN / "dist" / "assets" / "viz" / "pogledi"
USPOREDBA_MAPA = None  # mapa izvan repoa za umanjenu snimku Grada bez montaže (--usporedba); None = ne spremaj
USPOREDBA_NAPOMENA = ("Par danas/vizija (<id>_danas_vizija.jpg) objavljuje se uz montažu s istim navodom Grada (odluka autora M31, "
                      "15.11.2026.). Umanjena snimka Grada bez montaže sama se ne sprema u repo i ne objavljuje.")
SUNCE_ZADANO = ("2026-06-21 17:30", "ljeto")  # rano ljeto, kasno poslijepodne (pogledi.json, meta.napomena)

# Postavke pogleda koje opis u pogledi.json ne nosi. Sve su PRETPOSTAVKA dok ih ne zamijeni
# research/viz/kamere/<id>.json ili blok "montaza" u pogledi.json. Poligoni su u pikselima zadane fotografije.
ZADANO_POGLEDI = {
    "P01": {
        # postavke montaže P01 (poligoni, izmaglica, krošnje) su u research/viz/kamere/P01.json
        "kamera_validacija": "DJI_0015_2020",
        "koncept_zaklon": True,
    },
    "P06": {
        # približna kamera: staza uz sjevernu obalu Prvog maksimirskog jezera (kandidati.json, blizu-06), visina
        # očiju; smjer i žarišna duljina procijenjeni preklopom obrisa modela na fotografiju (MONTAZA.md)
        "kamera": {"enu_n": [15.0, 257.0], "visina_iznad_tla": 1.6, "azimut_deg": 186.0, "nagib_deg": 3.0,
                   "f35_mm": 35.0, "status": "PRETPOSTAVKA: približna, nije riješena na kontrolne točke"},
        "koncept_zaklon": False,
        "montaza": {
            "vidljivost_km": 12.0,
            "prednji_plan": {"vegetacija": True, "tanko": True, "tanko_px": 11, "samo_iznad_neba": False,
                             "tamno_percentil": 50},
            # oblačno: meka i slaba sjena; odraz koncepta u Prvom jezeru
            "sjena_jakost": 0.2, "sjena_zamucenje_px": 4.0,
            "odraz": {"jakost": 0.55, "zatamni": 0.75},
            # staklena zgrada i dva stupa rasvjete dio su postojećeg kompleksa koji koncept zamjenjuje
            "poligoni_ukloni": [[[2957, 629], [3840, 643], [3840, 828], [2957, 828]], [[2246, 629], [2988, 629], [2988, 1603], [2246, 1603]], [[2292, 12], [2592, 12], [2592, 396], [2472, 396], [2472, 660], [2352, 660], [2352, 396], [2292, 396]], [[1452, 612], [1613, 612], [1613, 840], [1536, 840], [1536, 1044], [1464, 1044], [1464, 840], [1452, 840]]],
            # obris današnje istočne tribine: njezina tamna sjena nije krošnja
            "poligoni_pozadina": [[[888, 1056], [1128, 888], [2304, 1380], [2304, 1613], [960, 1613]]],
            # gusta skupina golih stabala desno: boja ne odvaja grane od stakla iza njih, zato ručni zaklon
            "poligoni_zaklon": [[[2832, 1008], [2916, 840], [3024, 792], [3192, 828], [3360, 792], [3552, 816], [3744, 768], [3840, 792], [3840, 1680], [2832, 1680]]],
            "poligoni_voda": [[[0, 1709], [1680, 1709], [2640, 1733], [3120, 1776], [3840, 1781], [3840, 1992], [3312, 2040], [2256, 2172], [1680, 2244], [1200, 2304], [1152, 2424], [720, 2544], [0, 2628]]],
        },
    },
}


def _log(*a):
    print("[pogledi]", *a, flush=True)


def ucitaj_poglede():
    return json.loads(POGLEDI_JSON.read_text(encoding="utf-8"))


def pogled(pid):
    """Pogled iz pogledi.json. "<id>-zamjena" je isti pogled na zamjenskoj snimci (fotografija.zamjena): kamera i
    postavke iz research/viz/kamere/<id>-zamjena.json, izlaz <id>-zamjena_*.jpg."""
    osnova, _, inacica = pid.partition("-")
    for p in ucitaj_poglede()["pogledi"]:
        if p["id"] == osnova:
            if not inacica:
                return p
            f = dict(p.get("fotografija") or {})
            if inacica != "zamjena" or not f.get("zamjena"):
                raise KeyError(f"pogled {osnova} nema inačice {inacica} (fotografija.zamjena)")
            f["datoteka"] = f.pop("zamjena")
            f.pop("drive_id", None)
            f["kamera"] = f"research/viz/kamere/{pid}.json"
            return {**p, "id": pid, "naziv": f"{p['naziv']} (zamjenska snimka)", "fotografija": f}
    raise KeyError(f"nema pogleda {pid} u {POGLEDI_JSON.relative_to(KORIJEN)}")


def _spoji(*dicts):
    out = {}
    for d in dicts:
        for k, v in (d or {}).items():
            if isinstance(v, dict) and isinstance(out.get(k), dict):
                out[k] = _spoji(out[k], v)
            else:
                out[k] = v
    return out


# ključevi postavki koje research/viz/kamere/<id>.json smije nadjačati; ostalo u toj datoteci je zapis rješavanja
# kamere (točke, pogreške, "sunce" kao rječnik, "status" kamere) i ne ulazi u postavke pogleda
KLJUCEVI_POSTAVKI = ("montaza", "koncept_zaklon", "sezona", "kamera_validacija", "montaza_opis", "krosnje")


def kamera_iz_datoteke(kam):
    """Riješena kamera iz research/viz/kamere/<id>.json: ključ "kamera" (P02, P03, P06, P07) ili
    "rijesena_kamera" (P04, P05, zapis kamera.rijesi_kameru)."""
    return kam.get("kamera") or kam.get("rijesena_kamera")


def postavke_pogleda(p):
    """ZADANO_POGLEDI <- blok "montaza"/"kamera" iz pogledi.json <- research/viz/kamere/<id>.json."""
    vlastito = {k: p[k] for k in ("montaza", "koncept_zaklon") if k in p}
    datoteka = KAMERE / f"{p['id']}.json"
    kam = json.loads(datoteka.read_text(encoding="utf-8")) if datoteka.exists() else {}
    return _spoji(ZADANO_POGLEDI.get(p["id"], {}), vlastito, {k: v for k, v in kam.items() if k in KLJUCEVI_POSTAVKI}), kam


# ---------------------------------------------------------------------------
# Fotografija, navodi, Sunce
# ---------------------------------------------------------------------------

def _mape_fotografija(dodatne):
    mape = [Path(m) for m in dodatne or []]
    mape += [Path(m) for m in os.environ.get("VIZ_FOTO_MAPE", "").split(os.pathsep) if m]
    return mape


def nadji_fotografiju(p, mape):
    f = p.get("fotografija") or {}
    dat = f.get("datoteka")
    if not dat:
        return None
    if (KORIJEN / dat).exists():
        return KORIJEN / dat
    stem, nast = Path(dat).stem, Path(dat).suffix
    god = re.search(r"(20\d\d)", f.get("izvor", ""))
    imena = [dat]
    if god:
        imena += [f"{god.group(1)}_{dat}", f"{stem}_{god.group(1)}{nast}"]
    for m in _mape_fotografija(mape):
        for ime in imena:
            if (m / ime).exists():
                return m / ime
    return None


def meta_fotografije(p, foto):
    """Podaci za navod: Gradove snimke (M21) ili zapis iz kandidati.json uz slobodnu fotografiju."""
    f = p.get("fotografija") or {}
    if "Grad Zagreb" in f.get("izvor", ""):
        god = re.search(r"(20\d\d)", f.get("izvor", ""))
        return {"izvor": "grad", "godina": int(god.group(1)) if god else None, "datoteka": f.get("datoteka"),
                "prava": "M21: montaža smije u repo i javno uz navod; fotografija se ne relicencira"}
    meta = {"autor": f.get("autor"), "licenca": f.get("licenca", "").split(" (")[0], "godina": f.get("godina"),
            "datoteka": f.get("datoteka")}
    kand = (KORIJEN / f["datoteka"]).parent / "kandidati.json" if f.get("datoteka") else None
    if kand and kand.exists():
        for k in json.loads(kand.read_text(encoding="utf-8")).get("kandidati", []):
            if k.get("datoteka") == f.get("datoteka"):
                meta.update({x: k.get(x) for x in ("autor", "naslov", "licenca", "licenca_url", "izvor_url")
                             if k.get(x)})
                meta["datum_snimanja"] = k.get("datum_snimanja")
                meta["id_kandidata"] = k.get("id")
    return meta


def _datum_exif(foto):
    try:
        from PIL import Image

        ex = Image.open(foto).getexif()
        t = str(ex.get_ifd(0x8769).get(0x9003) or ex.get(0x0132) or "")
        m = re.match(r"(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2})", t)
        return f"{m.group(1)}-{m.group(2)}-{m.group(3)} {m.group(4)}:{m.group(5)}" if m else None
    except Exception:  # noqa: BLE001
        return None


def sunce_pogleda(p, postavke, meta, foto, kam=None):
    """(kada, sezona, izvor): vrijeme snimanja fotografije ako je poznato, inače zadano (rano ljeto, kasno
    poslijepodne). EXIF vrijeme uzima se kao lokalno (PRETPOSTAVKA: sat fotoaparata na lokalnom vremenu).
    Redom: "sunce" (tekst) u postavkama pogleda, vrijeme iz research/viz/kamere/<id>.json (provjereno sjenama
    pri rješavanju kamere), validacija_kamere.json, kandidati.json, EXIF izvornika."""
    if isinstance(postavke.get("sunce"), str):
        return postavke["sunce"], postavke.get("sezona", "datum"), "zadano u postavkama pogleda"
    if p.get("vrsta") == "montaza" and isinstance((kam or {}).get("sunce"), dict):
        sn = kam["sunce"]
        t = str(sn.get("vrijeme_lokalno") or sn.get("lokalno") or "")
        if re.match(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}", t):
            return (t[:16], postavke.get("sezona", "datum"),
                    f"vrijeme snimke, lokalno (research/viz/kamere/{p['id']}.json; provjereno smjerom sjene)")
    if p.get("vrsta") == "montaza":
        val = postavke.get("kamera_validacija")
        if val:
            for sn in json.loads(VALIDACIJA.read_text(encoding="utf-8"))["snimke"]:
                if sn["naziv"] == val and sn.get("sunce_lokalno"):
                    return sn["sunce_lokalno"][:16], "datum", "vrijeme snimke (validacija_kamere.json)"
        t = (meta or {}).get("datum_snimanja")
        if t and re.match(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}", t):
            return t[:16], "datum", "EXIF DateTimeOriginal izvornika (kandidati.json)"
        if foto:
            t = _datum_exif(foto)
            if t:
                return t, "datum", "EXIF DateTimeOriginal"
    return SUNCE_ZADANO[0], SUNCE_ZADANO[1], "zadano: rano ljeto, kasno poslijepodne (PRETPOSTAVKA)"


# ---------------------------------------------------------------------------
# Kamere
# ---------------------------------------------------------------------------

def _broj(t):
    return float(str(t).replace(",", "."))


def kamera_iz_opisa(opis):
    """Početna kamera iz teksta opisa ("lat .., lon .., relativna visina .. m, smjer leta ..°, nagib ..°")."""
    if not isinstance(opis, str):
        return None
    lat = re.search(r"lat\s+([0-9.,]+)", opis)
    lon = re.search(r"lon\s+([0-9.,]+)", opis)
    if not (lat and lon):
        return None
    d = {"lat": _broj(lat.group(1).rstrip(",")), "lon": _broj(lon.group(1).rstrip(","))}
    v = re.search(r"relativna visina\s+([0-9.,]+)", opis)
    if v:
        d["visina_iznad_tla"] = _broj(v.group(1).rstrip(","))
    s = re.search(r"(?:smjer leta|smjer|os kadra oko)\s+(-?[0-9.,]+)", opis)
    if s:
        d["azimut_deg"] = _broj(s.group(1).rstrip(","))
    n = re.search(r"nagib\s+(-?[0-9.,]+)", opis)
    if n:
        d["nagib_deg"] = _broj(n.group(1).rstrip(","))
    f = re.search(r"([0-9]+)\s*mm ekv", opis)
    if f:
        d["f35_mm"] = float(f.group(1))
    return d


def _iz_polozaja(d, sirina, omjer, tlo, naziv, izvor):
    d = dict(d)
    kw = {}
    if "enu_n" in d:
        kw["x"], kw["y"] = (float(v) for v in K.m_iz_n(*d["enu_n"]))
    elif "x" in d and "y" in d:
        kw["x"], kw["y"] = float(d["x"]), float(d["y"])
    else:
        kw["lat"], kw["lon"] = d["lat"], d["lon"]
    if "kota_oka" in d:
        kw["kota_oka"] = d["kota_oka"]
    else:
        kw["visina_iznad_tla"] = d.get("visina_iznad_tla", 1.7)
        kw["tlo"] = tlo
    f35 = d.get("f35_mm", 24.0)
    f35 = f35[0] if isinstance(f35, list) else f35
    return KAM.iz_polozaja(azimut_deg=d.get("azimut_deg", 0.0), nagib_deg=d.get("nagib_deg", 0.0),
                           zakret_deg=d.get("zakret_deg", 0.0), f35_mm=f35, sirina_px=sirina, omjer=omjer,
                           naziv=naziv, izvor=izvor, **kw)


def kamera_pogleda(p, postavke, kam_datoteka, sirina, tlo, foto=None):
    """(Kamera u zadanoj širini, status, izvor). Za montažu je omjer kao na fotografiji."""
    omjer = 16 / 9
    if foto is not None:
        from PIL import Image

        w, h = Image.open(foto).size
        omjer = w / h
    if kamera_iz_datoteke(kam_datoteka):
        if kam_datoteka.get("upotrebljiva") is False:
            return None, f"OTVORENO: research/viz/kamere/{p['id']}.json nije upotrebljiva", None
        k = KAM.Kamera.iz_rjecnika(kamera_iz_datoteke(kam_datoteka)).u_mjerilu(sirina)
        status = "PRETPOSTAVKA-IZRAČUN: riješena na kontrolne točke"
        # P04, P05: "pogreske" na vrhu; P02, P03 (zapis kamera.py validacija): u snimke[0]
        pogr = kam_datoteka.get("pogreske") or ((kam_datoteka.get("snimke") or [{}])[0].get("pogreske") or {})
        rms = pogr.get("rms_posto_sirine")
        if rms is not None:
            status += f" (RMS {str(rms).replace('.', ',')} % širine)"
        rec = ((kam_datoteka.get("provjera_recenzenta") or {}).get("presuda")
               or ((kam_datoteka.get("montaza_opis") or {}).get("provjera_kamere") or {}).get("presuda"))
        if rec:
            status += f"; neovisna provjera drugog agenta: {rec}"
        if not str(kam_datoteka.get("status", "")).startswith("PRETPOSTAVKA-IZRAČUN"):
            status = kam_datoteka.get("status", "riješena (research/viz/kamere)")
        return k, status, f"research/viz/kamere/{p['id']}.json"
    if postavke.get("kamera_validacija"):
        for sn in json.loads(VALIDACIJA.read_text(encoding="utf-8"))["snimke"]:
            if sn["naziv"] == postavke["kamera_validacija"]:
                k = KAM.Kamera.iz_rjecnika(sn["rijesena_kamera"]).u_mjerilu(sirina)
                return (k, "PRETPOSTAVKA-IZRAČUN: riješena na kontrolne točke (RMS 0,12 % širine)",
                        "research/viz/model/validacija_kamere.json")
    if postavke.get("kamera"):
        d = postavke["kamera"]
        return (_iz_polozaja(d, sirina, omjer, tlo, p["id"], "ZADANO_POGLEDI (pogledi.py)"),
                d.get("status", "PRETPOSTAVKA: približna"), "scripts/viz/pogledi.py ZADANO_POGLEDI")
    if isinstance(p.get("kamera"), dict) and any(x in p["kamera"] for x in ("lat", "enu_n")):
        return (_iz_polozaja(p["kamera"], sirina, omjer, tlo, p["id"], "pogledi.json"),
                "PRIJEDLOG: zadano stajalište pogleda", "research/viz/pogledi.json")
    opis = (p.get("fotografija") or {}).get("kamera")
    if foto is not None and str(foto).upper().endswith(".JPG") and "DJI" in foto.name.upper():
        try:
            k = KAM.iz_dji(foto, tlo=tlo, naziv=p["id"], smjer="FlightYawDegree" if "smjer leta" in str(opis)
                           else "GimbalYawDegree")
            return k.u_mjerilu(sirina), "PRETPOSTAVKA: EXIF/XMP DJI, nije riješena na kontrolne točke", "EXIF/XMP"
        except Exception as e:  # noqa: BLE001
            _log(f"{p['id']}: EXIF kamera nije dostupna ({e})")
    d = kamera_iz_opisa(opis)
    if d:
        return (_iz_polozaja(d, sirina, omjer, tlo, p["id"], "opis u pogledi.json"),
                "PRETPOSTAVKA: početna vrijednost iz opisa, nije riješena", "research/viz/pogledi.json")
    return None, "OTVORENO: kamera nije zadana ni riješena", None


def kamera_iz_opisa_scene(p, s, sirina):
    """Pogledi bez stajališta (P14, P15) iz opisa i modela koncepta. PRETPOSTAVKA."""
    import koncept as KON

    pv = s.povrsina
    st = s.program.stadion
    cn = np.asarray(st["sredina"], float) if st else np.asarray([pv.F.centroid.x, pv.F.centroid.y])
    cx, cy = K.m_iz_n(float(cn[0]), float(cn[1]))
    zp = pv.kota_podija if pv.kota_podija is not None else 128.5
    if p["id"] == "P15":
        return KAM.pogled_na((cx - 60.0, cy + 40.0, zp), azimut_od_cilja_deg=135.0, udaljenost_m=900.0,
                             kota_oka=float(s.kota_tla(cx, cy)) + 350.0, f35_mm=35.0, sirina_px=sirina,
                             naziv="P15"), "PRETPOSTAVKA: iz opisa (jugoistok, oko 350 m iznad tla)"
    if p["id"] == "P14":
        u = np.asarray(s.site["park_maksimir"]["glavni_ulaz"]["sredina"], float)
        d = (cn - u) / max(np.hypot(*(cn - u)), 1e-9)
        q = u + d * 28.0
        z = float(pv.kota(q[0], q[1])[0]) + 1.7
        qx, qy = K.m_iz_n(float(q[0]), float(q[1]))
        az = math.degrees(math.atan2(cx - qx, cy - qy)) % 360.0
        return KAM.iz_polozaja(x=qx, y=qy, kota_oka=z, azimut_deg=az, nagib_deg=4.0, f35_mm=28.0, sirina_px=sirina,
                               naziv="P14", izvor="opis P14"), "PRETPOSTAVKA: iz opisa (pokrov iznad glavnog ulaza)"
    k = KON.pogledi(s, sirina_px=sirina)
    return k.get("zrak_jug"), "PRETPOSTAVKA: zamjenski pogled zrak_jug"


# ---------------------------------------------------------------------------
# Izrada
# ---------------------------------------------------------------------------

def _rel(put):
    try:
        return str(Path(put).resolve().relative_to(KORIJEN))
    except ValueError:
        return Path(put).name


def _program_meta(program):
    import hashlib

    sirovo = Path(program).read_bytes()
    d = json.loads(sirovo.decode("utf-8")).get("meta", {})
    return {"datoteka": _rel(program), **{k: d.get(k) for k in ("naziv", "verzija", "datum", "status")},
            "sha256": hashlib.sha256(sirovo).hexdigest()}


OGRANICENJA_MONTAZE = [
    "Montaža nije dokaz položaja, visine, vidljivosti, statike ni izvedivosti; geometrija je model iz program.json.",
    "Materijali i boje koncepta su ilustracija (M25), ne arhitektonsko rješenje; stadion je rotacijski model.",
    "Drveće na pokrovu prikazuje namjeru, ne nosivost ni dubinu tla; mlada stabla 6-13 m.",
    "Uklonjeni dijelovi postojećeg stanja ispunjeni su iz okoline iste fotografije: ispuna nije snimka.",
    "Sjena koncepta pada samo na tlo i vodu modela (teren 20 m), ne na postojeće krošnje i zgrade.",
    "Ljudi i vozila na konceptu su niskopoligonalni i nasumični, ne prikaz očekivane posjećenosti.",
]


def _pretpostavke(vrsta, kam_status, sunce_izvor):
    p = ["Geometrija koncepta je model iz program.json (scripts/viz/koncept.py): PRIJEDLOG i PRETPOSTAVKA, nije projekt.",
         f"Kamera: {kam_status}.", f"Sunce: {sunce_izvor}.",
         "Teren je DGU model 20 m, drveće i visine zgrada su procjene (research/viz/model/README.md)."]
    if vrsta == "montaza":
        p += ["Zakloni iz modela su grubi (proceduralno drveće, ravni krovovi); zakloni iz fotografije su obrada "
              "slike po boji i svjetlini uz ručne poligone.",
              "Sjena i svjetlo su približni; boja je usklađena statistički, ne fizikalno.",
              "Montaža nije dokaz položaja, visine, vidljivosti ni izvedivosti."]
    return p


def _zaklon_presjek(m):
    """"koncept_zaklon": "presjek": prolaz koncepta sa zaklonom modela i dodatni prolaz <id>_bez bez zaklona; montaža
    drži zaklon modela samo gdje fotografija pokazuje vegetaciju (montaza.uklopi, koncept_bez_zaklona)."""
    return m["post"].get("koncept_zaklon") == "presjek"


def _zaklon_rendera(m):
    z = m["post"].get("koncept_zaklon", True)
    return True if z == "presjek" else z


def _zavrsi_montazu(m, rad, izlaz, sirina, uzorci, prog_meta):
    """Uklapa prolaze iz predmemorije u fotografiju i piše viziju, par danas/vizija i popratni JSON; umanjenu snimku
    bez montaže samo za fotografije sa slobodnom licencom (za snimke Grada jedino uz --usporedba, izvan repoa)."""
    pid = m["p"]["id"]
    osnova = rad / pid
    rpop = json.loads((rad / f"{pid}.json").read_text(encoding="utf-8"))
    mj = rad / f"{pid}_mjerenje.json"
    vrijeme = json.loads(mj.read_text(encoding="utf-8")).get("vrijeme_rendera_s") if mj.exists() else None
    pr = M.ucitaj_prolaze(osnova)
    pr["postojece_maska"] = M.ucitaj_prolaze(rad / f"{pid}_postojece")["maska"]
    mpost = dict(m["post"].get("montaza", {}))
    mpost["sirina"] = sirina
    mpost.setdefault("zaklon_modela", bool(m["post"].get("koncept_zaklon", True)))
    if m["meta"].get("izvor") != "grad" and mpost.get("zamuti"):
        m["meta"]["zamuceno"] = True
    bez = M.ucitaj_prolaze(rad / f"{pid}_bez")["koncept"] if _zaklon_presjek(m) else None
    slika, info = M.uklopi(m["foto"], pr["koncept"], pr["pokrivenost"], pr["dubina"], maska=pr["maska"],
                           slika_modela=pr["slika"], postojece_maska=pr["postojece_maska"],
                           koncept_bez_zaklona=bez, **mpost)
    M.spremi_maske(info, rad / f"{pid}_maske.png")
    info.pop("maske", None)
    navod = M.navod_fotografije(m["meta"])
    podloge = (M.PODLOGE_MODELA_ISPUNA if info["ispuna"].get("detalj_iz_modela") else M.PODLOGE_MODELA)
    podloge += f" · Koncept: {prog_meta['datoteka']}"
    napomena = (None if m["status"].startswith(("PRETPOSTAVKA-IZRAČUN", "riješena")) else
                "Kamera je približna (nije riješena na kontrolne točke): položaj koncepta na slici je okviran.")
    izl = {"vizija": M.spremi(M.traka(slika, navod, podloge=podloge, napomena=napomena), izlaz / f"{pid}_vizija.jpg")}
    # Snimke Grada: montaža (M21) i par danas/vizija s istim navodom (M31) idu u repo; umanjena snimka bez montaže
    # sama ne ide u repo (uz --usporedba sprema se u mapu izvan repoa). Slobodno licencirane fotografije: sve uz montažu.
    grad = m["meta"].get("izvor") == "grad"
    d = M.danas(m["foto"], slika.shape[1], navod, mpost.get("zamuti"))
    izl["danas_vizija"] = M.spremi(M.danas_vizija(d, slika, navod, podloge=podloge, napomena=napomena),
                                   izlaz / f"{pid}_danas_vizija.jpg")
    cilj = USPOREDBA_MAPA if grad else izlaz
    if cilj is not None:
        cilj.mkdir(parents=True, exist_ok=True)
        danas = M.spremi(M.traka(d, M.navod_fotografije(m["meta"], danas=True), oznaka=M.OZNAKA_DANAS),
                         cilj / f"{pid}_danas.jpg")
        if not grad:
            izl["danas"] = danas
    pop = {
        "id": pid, "naziv": m["p"]["naziv"], "vrsta": "montaza", "oznaka": M.OZNAKA,
        "status": "AI građanski koncept; montaža nije dokaz položaja, visine, statike ni izvedivosti",
        "kamera": {**m["k"].u_rjecnik(), "status": m["status"], "izvor": m["izvor"]},
        "sunce": {**(rpop.get("sunce") or {}), "izvor": m["sunce_izvor"]},
        "program": prog_meta,
        "fotografija": {k_: v for k_, v in m["meta"].items() if k_ != "zamuceno"},
        "navod": navod, "podloge": podloge,
        "licenca_izlaza": ("CC BY-SA 4.0" if M.je_by_sa(m["meta"].get("licenca")) else
                           ("fotografija se ne relicencira (M21, RIGHTS.md)" if m["meta"].get("izvor") == "grad"
                            else "kao projekt (LICENSE.md); fotografija pod svojom licencom")),
        "montaza": info,
        "render": {"uzorci": rpop.get("prikaz", {}).get("uzorci", uzorci), "sirina": sirina,
                   "koncept_zaklon": m["post"].get("koncept_zaklon", True), "vrijeme_s": vrijeme,
                   "prolaz_slika": ((rad / f"{pid}_slika_izvor.txt").read_text(encoding="utf-8")
                                    if (rad / f"{pid}_slika_izvor.txt").exists() else "renderiran s konceptom")},
        "atribucije_modela": rpop.get("atribucije"),
        "pretpostavke": _pretpostavke("montaza", m["status"], m["sunce_izvor"])
        + list((m["post"].get("montaza_opis") or {}).get("pretpostavke", [])),
        "ogranicenja": OGRANICENJA_MONTAZE + list((m["post"].get("montaza_opis") or {}).get("ogranicenja", [])),
        "sto_pokazuje": (m["post"].get("montaza_opis") or {}).get("sto_pokazuje", m["p"].get("sto_pokazuje")),
        "za_objavu": (m["post"].get("montaza_opis") or {}).get("za_objavu"),
        "izlaz": {k_: Path(v).name for k_, v in izl.items()},
        "sha256_izlaza": {Path(v).name: __import__("hashlib").sha256(Path(v).read_bytes()).hexdigest()
                          for v in izl.values()},
        "ponovljivost": (f"python scripts/viz/pogledi.py izradi {pid} --sirina {sirina} --uzorci {uzorci} --izlaz <mapa> "
                         "--predmemorija <mapa izvan repoa> --foto-mapa <izvornici izvan repoa>; uz prolaze u "
                         "predmemoriji --samo-montaza ponavlja samo montažu, a --zadrzi-sliku zadržava prolaz slika "
                         "(MONTAZA.md). Izvornik snimke nije u repou (sha256_izvornika); postavke montaže i poligoni su "
                         f"u research/viz/kamere/{pid}.json."),
    }
    if grad:
        pop["usporedba"] = USPOREDBA_NAPOMENA
    (izlaz / f"{pid}.json").write_text(json.dumps(pop, ensure_ascii=False, indent=1, default=str) + "\n",
                                       encoding="utf-8")
    _log(f"{pid}: gotovo")
    return {"izlaz": pop["izlaz"], "kamera": m["status"]}


def _registriraj_krosnje(pid, krosnje, sezona):
    """Vlastito godišnje doba krošnji i trave za montažu ("krosnje" u research/viz/kamere/<id>.json):
    {"boje": 4 linearne RGB boje rampe krošnje, "prozirnost": 0..1, "trava": [zasićenost, svjetlina]}.
    Upisuje se u scena.SEZONE i ScenaKoncepta.SEZONA_TRAVE pod imenom "<id>_snimka" i vrijedi samo u ovom
    procesu (krošnje scene i koncepta dijele materijal). PRETPOSTAVKA: izgled usklađen s krošnjama na snimci."""
    if not krosnje:
        return sezona
    import koncept as KON
    import scena as SC

    ime = f"{pid}_snimka"
    boje = [tuple(float(c) for c in b) for b in krosnje["boje"]]
    SC.SEZONE[ime] = (boje, float(krosnje.get("prozirnost", SC.SEZONE["zima"][1])))
    KON.ScenaKoncepta.SEZONA_TRAVE[ime] = tuple(krosnje.get("trava", KON.ScenaKoncepta.SEZONA_TRAVE["zima"]))
    return ime


def izradi(ids, program=PROGRAM_ZADANO, sirina=1600, uzorci=48, izlaz=IZLAZ_ZADANO, predmemorija=None,
           foto_mape=(), priblizna=False, samo_montaza=False, zadrzi_sliku=False):
    """Izrađuje zadane poglede. Redoslijed: maske postojećeg stanja za montaže (jedna scena), zatim scena s
    konceptom (jedna za sve montaže i rendere), zatim sheme (vlastite scene u koncept.py).

    zadrzi_sliku: ako u predmemoriji već postoji prolaz slika (<id>.png) iste kamere, ne renderira se ponovno
    (oko 25 min na 2400 px); ponovno se renderiraju dubina, maska, pokrivenost i koncept. Montaža prolaz slika
    koristi samo IZVAN koncepta (usklađenje boje, oštrina, detalj ispune), pa vrijedi dok se scena postojećeg
    stanja i kamera ne mijenjaju; promjena izgleda koncepta ga ne dira. Zapisuje se u popratni JSON."""
    import koncept as KON
    import scena as SC

    izlaz = Path(izlaz)
    izlaz.mkdir(parents=True, exist_ok=True)
    pred = Path(predmemorija or Path(tempfile.gettempdir()) / "viz-pogledi")
    pred.mkdir(parents=True, exist_ok=True)
    rad = pred / "rad"
    rad.mkdir(exist_ok=True)
    popis = [pogled(i) for i in ids]
    rezultati = {}
    teren = SC.Teren()

    # --- priprema montaža ------------------------------------------------
    montaze = []
    for p in popis:
        if p["vrsta"] != "montaza":
            continue
        post, kam_dat = postavke_pogleda(p)
        foto = nadji_fotografiju(p, foto_mape)
        if foto is None:
            rezultati[p["id"]] = {"preskoceno": "fotografija nije pronađena (zadaj --foto-mapa)"}
            _log(f"{p['id']}: fotografija nije pronađena")
            continue
        k, status, izvor = kamera_pogleda(p, post, kam_dat, sirina, teren.kota_m, foto)
        if k is None or (not status.startswith(("PRETPOSTAVKA-IZRAČUN", "riješena")) and not priblizna
                         and not kamera_iz_datoteke(kam_dat)):
            rezultati[p["id"]] = {"preskoceno": f"kamera: {status} (montaža samo uz --priblizna)"}
            _log(f"{p['id']}: preskočeno, kamera {status}")
            continue
        meta = meta_fotografije(p, foto)
        if meta.get("izvor") == "grad":
            import hashlib

            meta["sha256_izvornika"] = hashlib.sha256(Path(foto).read_bytes()).hexdigest()
            meta["izvornik"] = ("nije u repou (M21); par danas/vizija je u repou (M31), umanjena snimka bez montaže "
                                "nije (može se izraditi izvan repoa s --usporedba)")
            meta["navod"] = M.NAVOD_GRAD
        kada, sezona, sunce_izvor = sunce_pogleda(p, post, meta, foto, kam_dat)
        montaze.append(dict(p=p, post=post, foto=foto, k=k, status=status, izvor=izvor, meta=meta, kada=kada,
                            sezona=sezona, sunce_izvor=sunce_izvor))
    for m in montaze:
        m["sezona"] = _registriraj_krosnje(m["p"]["id"], m["post"].get("krosnje"), m["sezona"])
    za_render = [m for m in montaze if not (samo_montaza and (rad / f"{m['p']['id']}_koncept.png").exists()
                                            and (rad / f"{m['p']['id']}_postojece_maska.png").exists())]
    if za_render:
        t0 = time.time()
        s = SC.izgradi_scenu(predmemorija=pred)
        for m in za_render:
            s.postavi_kameru(m["k"])
            s.postavi_sunce(m["kada"], sezona=m["sezona"])
            s.renderiraj(rad / f"{m['p']['id']}_postojece.png", prolazi=("maska",), vidljivost_km=None,
                         traka=False, mjerenja=False)
        _log(f"maske postojećeg stanja: {time.time() - t0:.1f} s")
        del s

    # --- scena s konceptom ------------------------------------------------
    prog_meta = _program_meta(program)
    za_bez = [m for m in montaze if _zaklon_presjek(m) and (m in za_render or not (rad / f"{m['p']['id']}_bez_koncept.png").exists())]
    trebaju_scenu = za_render or za_bez or any(p["vrsta"] == "render" for p in popis)
    if trebaju_scenu:
        t0 = time.time()
        s = KON.izgradi(str(program), predmemorija=pred)
        _log(f"scena s konceptom: {time.time() - t0:.1f} s")
        for m in za_render:
            pid = m["p"]["id"]
            s.postavi_kameru(m["k"])
            s.postavi_sunce(m["kada"], sezona=m["sezona"])
            zadrzana = zadrzi_sliku and (rad / f"{pid}.png").exists()
            prol = ("dubina", "maska", "pokrivenost", "koncept") if zadrzana else ("slika", "dubina", "maska", "pokrivenost", "koncept")
            if zadrzana:
                import shutil

                stara = rad / f"{pid}_slika_zadrzana.png"
                shutil.copy2(rad / f"{pid}.png", stara)
            s.renderiraj(rad / f"{pid}.png", uzorci=uzorci, prolazi=prol,
                         vidljivost_km=None, traka=False, koncept_zaklon=_zaklon_rendera(m))
            if zadrzana:
                stara.replace(rad / f"{pid}.png")
                import datetime as _dt

                # uvijek prepisati: datum je datum zadržanog prolaza slika
                (rad / f"{pid}_slika_izvor.txt").write_text(
                    "prolaz slika zadržan iz ranijeg rendera iste kamere i scene ("
                    + _dt.datetime.fromtimestamp((rad / f"{pid}.png").stat().st_mtime).strftime("%d.%m.%Y.")
                    + "); u montaži se koristi samo izvan koncepta", encoding="utf-8")
            else:
                # puni render: prolaz slika je nov, stara bilješka o zadržavanju više ne vrijedi
                (rad / f"{pid}_slika_izvor.txt").unlink(missing_ok=True)
        for m in za_bez:
            pid = m["p"]["id"]
            s.postavi_kameru(m["k"])
            s.postavi_sunce(m["kada"], sezona=m["sezona"])
            s.renderiraj(rad / f"{pid}_bez.png", uzorci=uzorci, prolazi=("koncept",), vidljivost_km=None, traka=False,
                         mjerenja=False, koncept_zaklon=False)
        for p in popis:
            if p["vrsta"] != "render":
                continue
            post, kam_dat = postavke_pogleda(p)
            f35 = (p.get("kamera") or {}).get("f35_mm", 24.0)
            zarisne = f35 if isinstance(f35, list) else [f35]
            kada, sezona, sunce_izvor = sunce_pogleda(p, post, None, None)
            sun = s.postavi_sunce(kada, sezona=sezona)
            izl = []
            for f in zarisne:
                pk = dict(p.get("kamera") or {})
                pk["f35_mm"] = f
                p2 = {**p, "kamera": pk}
                k, status, izvor = kamera_pogleda(p2, post, kam_dat, sirina, teren.kota_m)
                if k is None:
                    k, status = kamera_iz_opisa_scene(p, s, sirina)
                    izvor = "opis pogleda"
                if k is None:
                    rezultati[p["id"]] = {"preskoceno": status}
                    break
                ime = f"{p['id']}_{int(f)}mm.jpg" if len(zarisne) > 1 else f"{p['id']}.jpg"
                s.postavi_kameru(k)
                s.renderiraj(izlaz / ime, uzorci=uzorci, prolazi=("slika",), vidljivost_km=70.0, mjerenja=False,
                             dodatno={"pogled": p["id"], "kamera_status": status, "sunce_izvor": sunce_izvor,
                                      "program": prog_meta, "pretpostavke": _pretpostavke("render", status, sunce_izvor)})
                izl.append(ime)
            rezultati.setdefault(p["id"], {"izlaz": izl})
        del s
    for m in montaze:
        rezultati[m["p"]["id"]] = _zavrsi_montazu(m, rad, izlaz, sirina, uzorci, prog_meta)
    for p in popis:
        if p["vrsta"] != "shema":
            continue
        ime = izlaz / f"{p['id']}.png"
        if p["id"] == "P16":
            KON.rastavljeni_prikaz(str(program), ime, sirina_px=sirina, uzorci=uzorci, predmemorija=pred)
        elif p["id"] == "P17":
            KON.presjecna_perspektiva(str(program), ime, sirina_px=sirina, uzorci=uzorci, predmemorija=pred)
        else:
            rezultati[p["id"]] = {"preskoceno": "nepoznata shema"}
            continue
        rezultati[p["id"]] = {"izlaz": [ime.name]}
    return rezultati


def popis(foto_mape=()):
    from scena import Teren

    teren = Teren()
    redovi = []
    for p in ucitaj_poglede()["pogledi"]:
        post, kam = postavke_pogleda(p)
        foto = nadji_fotografiju(p, foto_mape) if p["vrsta"] == "montaza" else None
        if p["vrsta"] == "shema":
            stanje = "shema iz koncept.py"
        else:
            k, status, _ = kamera_pogleda(p, post, kam, 960, teren.kota_m, foto)
            stanje = status if k is not None else "kamera iz opisa scene (PRETPOSTAVKA)" if p["vrsta"] == "render" \
                else status
        if p["vrsta"] == "montaza" and foto is None:
            stanje += "; fotografija nije pronađena"
        redovi.append((p["id"], p["vrsta"], p["naziv"], stanje))
    for r in redovi:
        print(" | ".join(r))
    return redovi


def main(argv=None):
    import argparse

    ap = argparse.ArgumentParser(description="Pokretač pogleda: renderi, montaže i sheme iz research/viz/pogledi.json")
    ap.add_argument("naredba", choices=["popis", "izradi", "sve"])
    ap.add_argument("id", nargs="*", help="id pogleda (P01 ...), uz izradi")
    ap.add_argument("--sirina", type=int, default=1600)
    ap.add_argument("--uzorci", type=int, default=64)
    ap.add_argument("--program", default=str(PROGRAM_ZADANO))
    ap.add_argument("--izlaz", default=str(IZLAZ_ZADANO))
    ap.add_argument("--predmemorija", default=None, help="mapa izvan repoa za prolaze i privremene datoteke")
    ap.add_argument("--foto-mapa", action="append", default=[], help="mapa s izvornicima fotografija (više puta)")
    ap.add_argument("--priblizna", action="store_true", help="dopusti montažu na kameri koja nije riješena")
    ap.add_argument("--usporedba", default=None,
                    help="mapa IZVAN repoa za umanjenu snimku Grada bez montaže (u repo se ne sprema)")
    ap.add_argument("--zadrzi-sliku", action="store_true",
                    help="zadrži postojeći prolaz slika iz predmemorije (koristi se samo izvan koncepta)")
    ap.add_argument("--samo-montaza", action="store_true",
                    help="ponovi samo montažu iz prolaza u predmemoriji (bez rendera), npr. nakon promjene poligona")
    a = ap.parse_args(argv)
    if a.usporedba:
        global USPOREDBA_MAPA
        USPOREDBA_MAPA = Path(a.usporedba).resolve()
        if USPOREDBA_MAPA == KORIJEN or KORIJEN in USPOREDBA_MAPA.parents:
            ap.error("--usporedba mora biti mapa izvan repoa")
    if a.naredba == "popis":
        popis(a.foto_mapa)
        return 0
    ids = a.id if a.naredba == "izradi" else [p["id"] for p in ucitaj_poglede()["pogledi"]]
    if not ids:
        ap.error("zadaj id pogleda")
    r = izradi(ids, program=a.program, sirina=a.sirina, uzorci=a.uzorci, izlaz=a.izlaz, predmemorija=a.predmemorija,
               foto_mape=a.foto_mapa, priblizna=a.priblizna, samo_montaza=a.samo_montaza,
               zadrzi_sliku=a.zadrzi_sliku)
    print(json.dumps(r, ensure_ascii=False, indent=1))
    return 0


if __name__ == "__main__":
    sys.exit(main())
