#!/usr/bin/env python3
"""Vlastiti pokretač približnih montaža s tla (P06, P07) i radnih rendera za generativnu doradu.

AI građanski koncept · PRIJEDLOG · nije projekt. Ne mijenja scripts/viz/* (pogledi.py i montaza.py istodobno uređuje
drugi lanac): koristi njihove funkcije, a kameru, napomenu trake i popratni JSON zadaje sam.

    python montaze.py render  <cfg.json> <id,...> --sirina 960 --uzorci 48 --rad <mapa>
    python montaze.py montaza <cfg.json> <id,...> --sirina 2400 --rad <mapa> --izlaz <mapa>
    python montaze.py reference <cfg.json> <id,...> --sirina 1600 --uzorci 48 --izlaz <mapa>
"""
from __future__ import annotations

import argparse
import hashlib
import json
import sys
import time
from pathlib import Path

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
import zakrpe  # noqa: E402  (sjever stadiona iz programa, fizikalno staklo svjetlarnika)

KORIJEN = zakrpe.KORIJEN
import kamera as KAM  # noqa: E402
import koordinate as K  # noqa: E402
import montaza as M  # noqa: E402
import pogledi as PG  # noqa: E402

PROGRAM = KORIJEN / "research" / "viz" / "program.json"
NAPOMENA_PRIBLIZNA = ("kamera približna: položaj i veličina koncepta nisu provjereni (kamera nije potvrđena "
                      "na kontrolne točke u području koncepta); montaža nije dokaz")


def log(*a):
    print("[montaze]", time.strftime("%H:%M:%S"), *a, flush=True)


def kamera(d, sirina, omjer, tlo):
    if "rjecnik" in d:
        return KAM.Kamera.iz_rjecnika(d["rjecnik"]).u_mjerilu(sirina)
    kw = {}
    if "enu_n" in d:
        kw["x"], kw["y"] = (float(v) for v in K.m_iz_n(*d["enu_n"]))
    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.6)
        kw["tlo"] = tlo
    return KAM.iz_polozaja(azimut_deg=d["azimut_deg"], nagib_deg=d.get("nagib_deg", 0.0),
                           zakret_deg=d.get("zakret_deg", 0.0), f35_mm=d["f35_mm"], sirina_px=sirina, omjer=omjer,
                           naziv=d.get("ime", "k"), izvor=d.get("izvor", "zadano"), **kw)


def omjer_foto(v):
    from PIL import Image

    if v.get("foto"):
        w, h = Image.open(KORIJEN / v["foto"]).size
        return w / h
    return v.get("omjer", 16 / 9)


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 render(cfg, ids, sirina, uzorci, rad):
    import koncept as KON
    import scena as SC

    rad.mkdir(parents=True, exist_ok=True)
    teren = SC.Teren()
    pogledi = [cfg[i] for i in ids]
    for i, v in zip(ids, pogledi):
        v["_k"] = kamera(v["kamera"], sirina, omjer_foto(v), teren.kota_m)
        v["_sezona"] = PG._registriraj_krosnje(i, v.get("krosnje"), v.get("sezona", "datum"))
    mont = [(i, v) for i, v in zip(ids, pogledi) if v.get("foto")]
    if mont:
        t0 = time.time()
        s = SC.izgradi_scenu(predmemorija=rad / "tmp")
        for i, v in mont:
            s.postavi_kameru(v["_k"])
            s.postavi_sunce(v["kada"], sezona=v["_sezona"])
            s.renderiraj(rad / f"{i}_postojece.png", uzorci=max(8, uzorci // 4), prolazi=("slika", "maska"),
                         vidljivost_km=None, traka=False, mjerenja=False)
        log(f"postojeće: {time.time() - t0:.1f} s")
        del s
    t0 = time.time()
    s = KON.izgradi(str(PROGRAM), predmemorija=rad / "tmp", **cfg.get("_opcije_koncepta", {}))
    log(f"scena koncepta: {time.time() - t0:.1f} s")
    for i, v in zip(ids, pogledi):
        t0 = time.time()
        s.postavi_kameru(v["_k"])
        s.postavi_sunce(v["kada"], sezona=v["_sezona"])
        if v.get("foto"):
            s.renderiraj(rad / f"{i}.png", uzorci=uzorci, prolazi=("slika", "dubina", "maska", "pokrivenost", "koncept"),
                         vidljivost_km=None, traka=False, koncept_zaklon=v.get("koncept_zaklon", False))
        else:
            s.renderiraj(rad / f"{i}.png", uzorci=uzorci, prolazi=("slika", "maska"), vidljivost_km=v.get("vidljivost_km", 40.0),
                         traka=False)
        (rad / f"{i}_kamera.json").write_text(json.dumps({**v["_k"].u_rjecnik(), "status": v.get("kamera_status")},
                                                         ensure_ascii=False, indent=1), encoding="utf-8")
        log(f"{i}: {time.time() - t0:.1f} s")


def montaza(cfg, ids, sirina, rad, izlaz):
    izlaz.mkdir(parents=True, exist_ok=True)
    pm = program_meta()
    for i in ids:
        v = cfg[i]
        pid = v.get("pogled", i)
        pr = M.ucitaj_prolaze(rad / i)
        pr["postojece_maska"] = M.ucitaj_prolaze(rad / f"{i}_postojece")["maska"]
        mpost = dict(v.get("montaza", {}))
        mpost["sirina"] = sirina
        mpost.setdefault("zaklon_modela", bool(v.get("koncept_zaklon", False)))
        foto = KORIJEN / v["foto"]
        slika, info = M.uklopi(foto, pr["koncept"], pr["pokrivenost"], pr["dubina"], maska=pr["maska"],
                               slika_modela=pr["slika"], postojece_maska=pr["postojece_maska"], **mpost)
        M.spremi_maske(info, rad / f"{i}_maske.png")
        info.pop("maske", None)
        meta = dict(v["fotografija"])
        if mpost.get("zamuti"):
            meta["zamuceno"] = True
        navod = M.navod_fotografije(meta)
        podloge = (M.PODLOGE_MODELA_ISPUNA if info["ispuna"].get("detalj_iz_modela") else M.PODLOGE_MODELA)
        podloge += f" · Koncept: research/viz/program.json v{pm['verzija']}"
        napomena = NAPOMENA_PRIBLIZNA + (("; " + v["napomena_trake"]) if v.get("napomena_trake") else "") + "."
        ime = v.get("ime_izlaza", pid)
        izl = {"vizija": M.spremi(M.traka(slika, navod, podloge=podloge, napomena=napomena), izlaz / f"{ime}_vizija.jpg")}
        d = M.danas(foto, slika.shape[1], navod, mpost.get("zamuti"))
        izl["danas"] = M.spremi(M.traka(d, M.navod_fotografije(meta, danas=True), oznaka=M.OZNAKA_DANAS),
                                izlaz / f"{ime}_danas.jpg")
        izl["danas_vizija"] = M.spremi(M.danas_vizija(d, slika, navod, podloge=podloge, napomena=napomena),
                                       izlaz / f"{ime}_danas_vizija.jpg")
        rpop = json.loads((rad / f"{i}.json").read_text(encoding="utf-8"))
        kam = json.loads((rad / f"{i}_kamera.json").read_text(encoding="utf-8"))
        pop = {
            "id": pid, "naziv": v["naziv"], "vrsta": "montaza (približna)", "oznaka": M.OZNAKA,
            "status": "AI građanski koncept · PRIJEDLOG · nije projekt; približna montaža s tla, nije dokaz položaja, "
                      "visine, vidljivosti, statike ni izvedivosti",
            "kamera": {**kam, "status": v["kamera_status"], "izvor": v["kamera_izvor"]},
            "sunce": {**(rpop.get("sunce") or {}), "izvor": v["sunce_izvor"]},
            "program": pm,
            "fotografija": {k: x for k, x in meta.items() if k != "zamuceno"},
            "navod": navod, "podloge": podloge, "napomena_trake": napomena,
            "licenca_izlaza": ("CC BY-SA 4.0" if M.je_by_sa(meta.get("licenca")) else
                               "kao projekt (LICENSE.md); fotografija pod svojom licencom (CC BY 2.0), navod obvezan"),
            "montaza": info,
            "render": {"uzorci": rpop.get("prikaz", {}).get("uzorci"), "koncept_zaklon": v.get("koncept_zaklon", False)},
            "atribucije_modela": rpop.get("atribucije"),
            "udio_slojeva_rendera": rpop.get("udio_slojeva") or rpop.get("udio_piksela"),
            "pretpostavke": v.get("pretpostavke", []) + PG._pretpostavke("montaza", v["kamera_status"], v["sunce_izvor"]),
            "ogranicenja": PG.OGRANICENJA_MONTAZE + v.get("ogranicenja", []),
            "sto_pokazuje": v.get("sto_pokazuje"),
            "za_objavu": v.get("za_objavu"),
            "razlog_za_objavu": v.get("razlog_za_objavu"),
            "izlaz": {k: Path(x).name for k, x in izl.items()},
        }
        (izlaz / f"{ime}.json").write_text(json.dumps(pop, ensure_ascii=False, indent=1, default=str) + "\n",
                                           encoding="utf-8")
        for x in izl.values():
            assert not M.ima_exif(x), x
        log(f"{i}: montaža gotova -> {izlaz}")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("naredba", choices=["render", "montaza"])
    ap.add_argument("cfg")
    ap.add_argument("ids")
    ap.add_argument("--sirina", type=int, default=960)
    ap.add_argument("--uzorci", type=int, default=48)
    ap.add_argument("--rad", required=True)
    ap.add_argument("--izlaz", default=None)
    a = ap.parse_args()
    cfg = json.loads(Path(a.cfg).read_text(encoding="utf-8"))
    ids = a.ids.split(",")
    if a.naredba == "render":
        render(cfg, ids, a.sirina, a.uzorci, Path(a.rad))
    else:
        montaza(cfg, ids, a.sirina, Path(a.rad), Path(a.izlaz))


if __name__ == "__main__":
    main()
