#!/usr/bin/env python3
"""Alat za provjeru, bilancu i pregled programa po razinama (format: research/viz/README.md).

AI građanski koncept, PRIJEDLOG. Alat je gruba mehanička provjera crteža programa; nije projektna
kontrola, nije provjera požarne sigurnosti, statike ni propisa i ne zamjenjuje ovlaštenog projektanta.

Naredbe:
  provjeri <program.json> [--site research/viz/site.json] [--zone zone.json] [--kote kote.json|ne] [--json]
      izlaz 0 ako nema pogrešaka, inače 1 (2 = datoteka se ne može pročitati)
  bilanca  <program.json> [--md datoteka] [--csv datoteka]
  pregled  <program.json> --out <mapa> [--site research/viz/site.json]
  test     [--mapa research/viz/program/primjeri]
      provjerava alat na primjerima: valjani mora proći, neispravni moraju pasti s očekivanim kodom

Područja današnjeg tla ("ništa se ne ukopava") uzimaju se ovim redom: --zone datoteka; ključ
"zone_tla" u site.json; objekti u site.json čije ime sadrži "bazen" ili "Borongaj"; inače orijentiri iz
README-a. Oblik: {"tlo_zadano_mnv": 118.0, "zone_tla": [{"naziv": "...", "min_kota_poda_mnv": 116.0,
"poligon": [[x, y], ...]}]}. Alat uvijek ispiše koje je granice upotrijebio.

Ovisnosti: shapely, pillow (obje u scripts/viz/requirements.txt). JSON shema se provjerava ugrađenim
malim validatorom, pa paket jsonschema nije potreban.
"""
from __future__ import annotations

import argparse
import csv
import hashlib
import json
import math
import re
import sys
import unicodedata
from pathlib import Path

from shapely.geometry import LineString, Point, Polygon, box
from shapely.ops import polylabel, unary_union
from shapely.validation import explain_validity

KORIJEN = Path(__file__).resolve().parents[2]
SHEMA = KORIJEN / 'research' / 'viz' / 'program.schema.json'
SPORTOVI = Path(__file__).resolve().parent / 'sportovi_dimenzije.json'
PRIMJERI = KORIJEN / 'research' / 'viz' / 'program' / 'primjeri'
KOTE = KORIJEN / 'research' / 'viz' / 'geodezija' / 'kote_situacija.json'
OZNAKA = 'AI građanski koncept, PRIJEDLOG, nije projekt'

KATEGORIJE = ['stadion', 'igraliste', 'tribine', 'sport_zatvoreni', 'sport_otvoreni', 'zdravlje', 'kultura',
              'javne_sluzbe', 'komercijala', 'ugostiteljstvo', 'garaza', 'promet_tramvaj', 'promet_bus',
              'promet_cesta', 'topli_put', 'trg_predvorje', 'tehnika', 'logistika', 'park_zelenilo', 'staza',
              'svjetlarnik', 'voda', 'dvoriste', 'postojece']
TIPOVI_VEZA = ['topli_put', 'dizalo', 'stubiste', 'pokretne_stube', 'rampa', 'svjetlarnik', 'ulaz', 'kolni_ulaz',
               'evakuacija']
STATUSI = ['POTVRĐENO', 'PRIJEDLOG', 'PRETPOSTAVKA-IZRAČUN', 'OTVORENO']
POLJA = {
    'korijen': {'meta', 'razine', 'prostori', 'veze', 'kote_terena', 'stadion'},
    'razina': {'id', 'naziv', 'kota_poda_mnv', 'svijetla_visina_m', 'obris', 'opis', 'status'},
    'prostor': {'id', 'razina', 'naziv', 'kategorija', 'poligon', 'rupe', 'kota_poda_mnv', 'svijetla_visina_m',
                'sportovi', 'olimpijski_razred', 'kapacitet', 'odluke', 'status', 'izvor', 'napomena'},
    'veza': {'id', 'tip', 'razine', 'linija', 'tocka', 'sirina_m', 'nagib_posto', 'napomena'},
}
# Zatvoreni (unutarnji) prostori: za grubu provjeru evakuacije i udio zatvorenih sportskih površina.
ZATVORENE = {'sport_zatvoreni', 'zdravlje', 'kultura', 'javne_sluzbe', 'komercijala', 'ugostiteljstvo', 'garaza',
             'promet_tramvaj', 'promet_bus', 'topli_put', 'tehnika', 'logistika'}
# Prostori bez stropa: ne provjerava im se visinski sudar.
OTVORENE = {'igraliste', 'tribine', 'stadion', 'park_zelenilo', 'staza', 'sport_otvoreni', 'dvoriste', 'voda',
            'svjetlarnik'}
NE_SMIJU_BITI_PREKRIVENI = {'igraliste', 'dvoriste', 'sport_otvoreni', 'voda'}
SPORTSKE = {'sport_zatvoreni', 'sport_otvoreni', 'igraliste'}

# Pragovi iz zadatka i README-a.
TOL_OBRIS_M = 0.5
PRAG_PREKLAPANJA_M2 = 1.0
MIN_POVRSINA_M2 = 1.0
KONSTRUKCIJA_M = 1.2
GARAZA_M2_PO_MJESTU = (25.0, 35.0)
EVAKUACIJA_M = 60.0
TLO_ZADANO = 118.0
TLO_NAJNIZE = 115.5
TOL_KOTE = 0.05
KANON = {
    'igraliste': (118.0, 119.0),       # odluka M1
    'podij': 128.5,                    # odluka M2 (V2 = 130,5 samo kontrolno)
    'podij_v2': 130.5,
    'pokrov': (127.1, 128.2),          # docs/17, PRETPOSTAVKA-IZRAČUN
    'borongaj_pod': 115.5,             # odluka M4
    'borongaj_park': (123.0, 125.0),   # "oko 124": ovdje 124 ± 1,0 (docs/18 navodi 123,0 do 123,5)
    'bazen': 116.0,                    # odluka M7
    'vrh_krova': 166.5,                # docs/20, PRETPOSTAVKA iz montaže
}
# Orijentiri iz README-a (OSM, orijentacijski): x_min, y_min, x_max, y_max.
ORIJENTIRI = {
    'postojeći stadion': (-169, -124, 75, 145),
    'SRC Svetice': (-416, -403, -162, 26),
    'bazen Svetice': (-233, -223, -171, -104),
    'okretište linije 5': (-309, 61, -236, 101),
    'glavni ulaz u park': (-231, 99, -218, 106),
}
# Os Maksimirske između Svetica i Hondlove. Cesta NIJE u smjeru istok-zapad (azimut oko 72°): README daje samo
# x krajeva i odmak od sjeverne tribine, pa su točke prepisane iz research/viz/site.json
# (izvedeno.os_maksimirske, OSM, PRETPOSTAVKA-IZRAČUN, 13.11.2026.) i vrijede kad site.json nije zadan.
OS_MAKSIMIRSKE = [(-428.7, 11.6), (-369.2, 32.8), (-317.2, 51.3), (-255.3, 73.0), (-224.1, 83.3), (2.0, 156.8),
                  (103.9, 190.0), (196.8, 220.1), (256.2, 239.6)]
SIRINA_KORIDORA_M = 28.0                            # docs/15: koridor Maksimirske približno 28 m
# README nema orijentir za Borongaj. Pravokutnik je PRETPOSTAVKA: obuhvaća tramvajsku petlju i perone
# (OSM, očitano 13.11.2026.: tračnice x -18..69, y -529..-460; peroni x -45..148, y -571..-434) uz oko 100 m.
BORONGAJ_ZAMJENSKI = (-150, -650, 250, -400)


# ----------------------------------------------------------------------------------------------- pomoćno
def norm(s) -> str:
    s = str(s).lower().replace('đ', 'd').replace('ð', 'd')
    s = ''.join(c for c in unicodedata.normalize('NFKD', s) if not unicodedata.combining(c))
    return re.sub(r'[^a-z0-9]+', '_', s).strip('_')


def br(x, dec=0) -> str:
    """Broj s hrvatskim decimalnim zarezom i točkom za tisućice."""
    if x is None:
        return '–'
    s = f'{x:,.{dec}f}'
    return s.replace(',', ' ').replace('.', ',').replace(' ', '.')


def ucitaj_json(put):
    with open(put, encoding='utf-8') as f:
        return json.load(f)


def je_broj(v) -> bool:
    return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)


def tocke(v):
    """Vrati popis (x, y) ili None ako zapis nije niz brojčanih parova."""
    if not isinstance(v, list):
        return None
    out = []
    for p in v:
        if not (isinstance(p, (list, tuple)) and len(p) >= 2 and je_broj(p[0]) and je_broj(p[1])):
            return None
        out.append((float(p[0]), float(p[1])))
    return out


def napravi_poligon(vanjski, rupe=None):
    """Vrati (Polygon | None, [opis pogreške])."""
    t = tocke(vanjski)
    if t is None:
        return None, ['poligon nije niz točaka [x, y]']
    if len(t) > 1 and t[0] == t[-1]:
        t = t[:-1]
    if len(set(t)) < 3:
        return None, [f'manje od 3 različite točke ({len(set(t))})']
    prstenovi = []
    for i, r in enumerate(rupe or []):
        tr = tocke(r)
        if tr is None or len(set(tr)) < 3:
            return None, [f'rupa {i + 1} nema 3 valjane točke']
        prstenovi.append(tr)
    try:
        g = Polygon(t, prstenovi)
    except Exception as e:  # noqa: BLE001
        return None, [f'poligon se ne može sastaviti: {e}']
    if not g.is_valid:
        return None, [f'samopresijecanje ili nevaljan prsten ({explain_validity(g)})']
    if g.area < MIN_POVRSINA_M2:
        return None, [f'površina {br(g.area, 2)} m² je ispod {MIN_POVRSINA_M2:g} m²']
    return g, []


# ------------------------------------------------------------------------------------- mali validator sheme
def _tip_ok(v, t) -> bool:
    if t == 'object':
        return isinstance(v, dict)
    if t == 'array':
        return isinstance(v, list)
    if t == 'string':
        return isinstance(v, str)
    if t == 'number':
        return je_broj(v)
    if t == 'integer':
        return je_broj(v) and float(v).is_integer()
    if t == 'boolean':
        return isinstance(v, bool)
    if t == 'null':
        return v is None
    return True


def provjeri_shemu(v, shema, korijen, put='$'):
    """Podskup JSON Scheme 2020-12 koji koristi program.schema.json. Vraća [(put, ključna riječ, poruka)]."""
    g = []
    if '$ref' in shema:
        cilj = korijen
        for dio in shema['$ref'].lstrip('#/').split('/'):
            cilj = cilj[dio]
        return provjeri_shemu(v, cilj, korijen, put)
    if 'type' in shema:
        tipovi = shema['type'] if isinstance(shema['type'], list) else [shema['type']]
        if not any(_tip_ok(v, t) for t in tipovi):
            return [(put, 'type', f'očekivan tip {" ili ".join(tipovi)}, a nađeno {type(v).__name__}')]
    if 'enum' in shema and v not in shema['enum']:
        g.append((put, 'enum', f'vrijednost {v!r} nije u zatvorenom popisu'))
    if 'anyOf' in shema and not any(not provjeri_shemu(v, s, korijen, put) for s in shema['anyOf']):
        g.append((put, 'anyOf', 'ne zadovoljava nijednu dopuštenu inačicu (npr. veza mora imati liniju ili točku)'))
    if isinstance(v, dict):
        for k in shema.get('required', []):
            if k not in v:
                g.append((put, 'required', f'nedostaje obvezno polje "{k}"'))
        for k, s in shema.get('properties', {}).items():
            if k in v:
                g += provjeri_shemu(v[k], s, korijen, f'{put}.{k}')
    if isinstance(v, list):
        if 'minItems' in shema and len(v) < shema['minItems']:
            g.append((put, 'minItems', f'najmanje {shema["minItems"]} stavki, a ima ih {len(v)}'))
        if 'maxItems' in shema and len(v) > shema['maxItems']:
            g.append((put, 'maxItems', f'najviše {shema["maxItems"]} stavki, a ima ih {len(v)}'))
        if 'items' in shema:
            for i, x in enumerate(v):
                g += provjeri_shemu(x, shema['items'], korijen, f'{put}[{i}]')
    if isinstance(v, str) and len(v) < shema.get('minLength', 0):
        g.append((put, 'minLength', 'prazan tekst'))
    if je_broj(v):
        if 'minimum' in shema and v < shema['minimum']:
            g.append((put, 'minimum', f'{v} je manje od {shema["minimum"]}'))
        if 'exclusiveMinimum' in shema and v <= shema['exclusiveMinimum']:
            g.append((put, 'exclusiveMinimum', f'{v} mora biti veće od {shema["exclusiveMinimum"]}'))
    return g


# --------------------------------------------------------------------------------------------------- model
class Model:
    """Tolerantno učitan program: ono što se ne može protumačiti preskače se, a pogreška se bilježi."""

    def __init__(self, p: dict):
        self.p = p if isinstance(p, dict) else {}
        self.pogreske_geometrije = []  # (vrsta, id, opis)
        self.razine, self.razina_po_id = [], {}
        for i, r in enumerate(self.p.get('razine') or []):
            if not isinstance(r, dict):
                continue
            rid = str(r.get('id', f'#razina{i}'))
            geom, gr = napravi_poligon(r.get('obris'))
            for e in gr:
                self.pogreske_geometrije.append(('razina', rid, f'obris: {e}'))
            z = {'id': rid, 'naziv': str(r.get('naziv', rid)), 'geom': geom, 'raw': r, 'i': i,
                 'kota': float(r['kota_poda_mnv']) if je_broj(r.get('kota_poda_mnv')) else None,
                 'visina': float(r['svijetla_visina_m']) if je_broj(r.get('svijetla_visina_m')) else None}
            self.razine.append(z)
            self.razina_po_id.setdefault(rid, z)
        self.prostori = []
        for i, s in enumerate(self.p.get('prostori') or []):
            if not isinstance(s, dict):
                continue
            sid = str(s.get('id', f'#prostor{i}'))
            geom, gr = napravi_poligon(s.get('poligon'), s.get('rupe'))
            for e in gr:
                self.pogreske_geometrije.append(('prostor', sid, e))
            raz = self.razina_po_id.get(str(s.get('razina')))
            pod = float(s['kota_poda_mnv']) if je_broj(s.get('kota_poda_mnv')) else (raz['kota'] if raz else None)
            vis = float(s['svijetla_visina_m']) if je_broj(s.get('svijetla_visina_m')) else (
                raz['visina'] if raz and s.get('kategorija') not in OTVORENE else None)  # otvoreni nemaju strop
            self.prostori.append({'id': sid, 'razina': str(s.get('razina')), 'raz': raz, 'i': i,
                                  'naziv': str(s.get('naziv', sid)), 'kat': s.get('kategorija'), 'geom': geom,
                                  'pod': pod, 'visina': vis, 'raw': s,
                                  'sportovi': [x for x in (s.get('sportovi') or []) if isinstance(x, str)]})
        self.veze = []
        for i, v in enumerate(self.p.get('veze') or []):
            if not isinstance(v, dict):
                continue
            geom = None
            lin, toc = tocke(v.get('linija')), tocke([v.get('tocka')]) if v.get('tocka') is not None else None
            if lin and len(lin) >= 2:
                geom = LineString(lin)
            elif toc:
                geom = Point(toc[0])
            raz = [str(x) for x in v.get('razine')] if isinstance(v.get('razine'), list) else []
            self.veze.append({'id': str(v.get('id', f'#veza{i}')), 'tip': v.get('tip'), 'razine': raz,
                              'geom': geom, 'raw': v, 'i': i})

    def prostori_razine(self, rid):
        return [s for s in self.prostori if s['razina'] == rid]

    def okvir(self, rub=25.0):
        g = [r['geom'] for r in self.razine if r['geom'] is not None] + \
            [s['geom'] for s in self.prostori if s['geom'] is not None]
        if not g:
            return (-450.0, -450.0, 300.0, 200.0)
        a = unary_union(g).bounds
        return (a[0] - rub, a[1] - rub, a[2] + rub, a[3] + rub)


# ------------------------------------------------------------------------------------- postojeće stanje
def _lat_lon_u_enu(lon, lat):
    lat0, lon0 = 45.8187, 16.0185
    return ((lon - lon0) * math.cos(math.radians(lat0)) * 111320.0, (lat - lat0) * 110574.0)


def _klasa(tekst: str) -> str:
    t = norm(tekst)
    for kl, uz in (('ostalo', r'parkiral|parking'), ('tracnice', r'trac|rail|tram|prug|kolosijek|zeljezn'),
                   ('zgrada', r'zgrad|build|objekt|stadion|bazen'), ('voda', r'vod[ae]|jezer|water|potok'),
                   ('park', r'park|sum[ae]|zelen|leisure|wood|forest'), ('staza', r'pjesack|staz|path|footway'),
                   ('cesta', r'cest|road|highway|ulic|kolnik')):
        if re.search(uz, t):
            return kl
    return 'ostalo'


class Site:
    """Postojeće stanje iz site.json (scripts/viz/gradi_site.py). Čita se tolerantno: prolazi se cijelo
    stablo i uzima svaki niz parova brojeva pod ključevima poligon/obris/linija; vrsta se određuje iz puta
    ključeva (zgrade, ceste, tramvaj, park...), a tek onda iz oznaka. Izvedeni slojevi (namjene, zone
    natječaja, ograde) ne crtaju se u pozadini, ali se po imenu mogu naći."""

    GEOM_KLJUCEVI = {'poligon', 'obris', 'linija', 'tocke', 'geometrija', 'geometry', 'coords', 'coordinates',
                     'koordinate', 'xy'}
    NE_CRTAJ = {'meta', 'namjene', 'izvedeno', 'orijentiri', 'ograde', 'stajalista'}

    def __init__(self, put=None):
        self.put, self.raw = put, None
        self.objekti = []  # (klasa, geometrija, naziv, crtaj u pozadini)
        if put and Path(put).is_file():
            try:
                self.raw = ucitaj_json(put)
                self._hodaj(self.raw, '', '', None, True)
            except Exception as e:  # noqa: BLE001
                print(f'NAPOMENA: site.json se ne može pročitati ({e}); nastavljam bez njega.', file=sys.stderr)
                self.raw, self.objekti = None, []

    @property
    def ima(self):
        return self.raw is not None and bool(self.objekti)

    @property
    def poligoni(self):
        return [(k, g, n) for k, g, n, c in self.objekti if c and g.geom_type == 'Polygon']

    @property
    def linije(self):
        return [(k, g, n) for k, g, n, c in self.objekti if c and g.geom_type == 'LineString']

    @staticmethod
    def _prstenovi(v):
        """Vrati popis nizova točaka iz v (niz parova, niz prstenova ili multipoligon)."""
        t = tocke(v)
        if t is not None and len(t) >= 2:
            return [t]
        out = []
        if isinstance(v, list):
            for x in v:
                out += Site._prstenovi(x)
        return out

    def _dodaj(self, pr, staza, cvor, kljuc, crtaj):
        if all(abs(x) < 30 and 40 < abs(y) < 50 for x, y in pr):  # zapisano kao lon, lat
            pr = [_lat_lon_u_enu(x, y) for x, y in pr]
        cvor = cvor if isinstance(cvor, dict) else {}
        oznake = ' '.join(str(cvor.get(k, '')) for k in ('tip', 'vrsta', 'klasa', 'kategorija', 'razred', 'highway',
                                                         'railway', 'building', 'leisure', 'natural', 'type'))
        naziv = str(cvor.get('naziv') or cvor.get('name') or cvor.get('ime') or '')
        kl = _klasa(staza)
        if kl == 'ostalo' and _klasa(oznake) in ('zgrada', 'voda', 'park', 'cesta', 'staza'):
            kl = _klasa(oznake)  # oznake odlučuju samo kad put ključeva ništa ne kaže
        zatvoren = len(pr) >= 4 and pr[0] == pr[-1]
        kao_poligon = kljuc in ('poligon', 'obris') or (zatvoren and kl in ('zgrada', 'park', 'voda', 'ostalo'))
        rupe = [r for r in (tocke(x) for x in cvor.get('rupe') or []) if r and len(set(r)) >= 3] \
            if kljuc == 'poligon' and isinstance(cvor.get('rupe'), list) else []
        try:
            if kao_poligon and len(set(pr)) >= 3:
                g = Polygon(pr, rupe)
                g = g if g.is_valid else g.buffer(0)
                for d in (g.geoms if hasattr(g, 'geoms') else [g]):
                    if d.geom_type == 'Polygon' and not d.is_empty:
                        self.objekti.append((kl, d, naziv, crtaj))
            elif len(pr) >= 2:
                self.objekti.append((kl, LineString(pr), naziv, crtaj))
        except Exception:  # noqa: BLE001
            pass

    def _hodaj(self, v, staza, kljuc, roditelj, crtaj):
        if isinstance(v, dict):
            for k, x in v.items():
                c = crtaj and k not in self.NE_CRTAJ and not str(k).startswith('_')
                if k == 'rupe':
                    continue  # rupe se oduzimaju od poligona istog zapisa
                if k in self.GEOM_KLJUCEVI and not (isinstance(x, dict) and 'coordinates' not in x):
                    for pr in self._prstenovi(x.get('coordinates') if isinstance(x, dict) else x):
                        self._dodaj(pr, staza, v, k, c)
                elif isinstance(x, (dict, list)):
                    self._hodaj(x, f'{staza}/{k}', k, v, c)
        elif isinstance(v, list):  # goli nizovi točaka (npr. položaji stabala) nisu linije: ne crtaju se
            for x in v:
                if isinstance(x, (dict, list)):
                    self._hodaj(x, staza, kljuc, roditelj, crtaj)

    def nadji(self, uzorak):
        return [g for _, g, n, _ in self.objekti if n and re.search(uzorak, norm(n))]

    def _izravno(self, *kljucevi):
        v = self.raw
        for k in kljucevi:
            v = v.get(k) if isinstance(v, dict) else None
        return v

    def os_maksimirske(self):
        """Os Maksimirske: izvedeno.os_maksimirske.linija iz gradi_site.py, inače ceste s tim imenom."""
        t = tocke(self._izravno('izvedeno', 'os_maksimirske', 'linija'))
        if t and len(t) >= 2:
            return LineString(t)
        l = [g for g in self.nadji(r'maksimirska') if g.geom_type == 'LineString']
        return unary_union(l) if l else None

    def bazen(self):
        t = tocke(self._izravno('bazen_svetice', 'obris', 'poligon'))
        if t and len(set(t)) >= 3:
            g = Polygon(t)
            return g if g.is_valid else g.buffer(0)
        l = [g for g in self.nadji(r'bazen') if g.geom_type == 'Polygon']
        return unary_union(l) if l else None


def ucitaj_zone(site: Site, zone_put=None, rub_m=10.0):
    """Vrati (zone, zadano tlo, opisi). Zona = {'naziv', 'min', 'geom', 'izvor'}; izvan zona vrijedi zadano."""
    def iz_zapisa(d, izvor):
        zone = []
        for z in d.get('zone_tla') or d.get('podrucja_tla') or []:
            if not isinstance(z, dict):
                continue
            mn = next((z[k] for k in ('min_kota_poda_mnv', 'kota_tla_mnv', 'kota') if je_broj(z.get(k))), None)
            g = None
            if z.get('poligon') is not None:
                g, _ = napravi_poligon(z['poligon'])
            elif isinstance(z.get('bbox'), list) and len(z['bbox']) == 4:
                g = box(*z['bbox'])
            if g is not None and mn is not None:
                zone.append({'naziv': str(z.get('naziv', 'zona')), 'min': float(mn), 'geom': g, 'izvor': izvor})
        zad = d.get('tlo_zadano_mnv')
        return zone, float(zad) if je_broj(zad) else TLO_ZADANO

    if zone_put:
        zone, zad = iz_zapisa(ucitaj_json(zone_put), f'--zone {zone_put}')
        if zone:
            return zone, zad, _opisi_zona(zone, zad)
    if site.raw is not None and isinstance(site.raw, dict):
        zone, zad = iz_zapisa(site.raw, f'{site.put}: zone_tla')
        if zone:
            return zone, zad, _opisi_zona(zone, zad)
    zone = []
    baz = site.bazen() if site.ima else None
    if baz is not None and not baz.is_empty:
        zone.append({'naziv': 'bazen Svetice', 'min': KANON['bazen'], 'geom': baz.buffer(rub_m, join_style=2),
                     'izvor': f'{site.put}: obris bazenskog kompleksa, prošireno {rub_m:g} m'})
    else:
        a = ORIJENTIRI['bazen Svetice']
        zone.append({'naziv': 'bazen Svetice', 'min': KANON['bazen'],
                     'geom': box(a[0] - rub_m, a[1] - rub_m, a[2] + rub_m, a[3] + rub_m),
                     'izvor': f'orijentir iz README-a (OSM, orijentacijski), prošireno {rub_m:g} m'})
    bor = [g for k, g, nz, _ in site.objekti if k != 'cesta' and g.geom_type == 'LineString'
           and re.search(r'borongaj', norm(nz))
           and not re.search(r'borongajsk|cest|ulic|aerodrom', norm(nz))] if site.ima else []
    if bor:
        ok = unary_union(bor).envelope.bounds
        if ok[2] - ok[0] > 500 or ok[3] - ok[1] > 500:  # ime je zahvatilo nešto drugo; ne vjeruj okviru
            bor = []
    if bor:
        zone.append({'naziv': 'Borongaj (zona D)', 'min': KANON['borongaj_pod'],
                     'geom': unary_union(bor).envelope.buffer(60.0 + rub_m, join_style=2),
                     'izvor': f'PRETPOSTAVKA: {site.put}: okvir kolosijeka i perona s imenom "Borongaj", '
                              f'prošireno {60 + rub_m:g} m'})
    else:
        a = BORONGAJ_ZAMJENSKI
        zone.append({'naziv': 'Borongaj (zona D)', 'min': KANON['borongaj_pod'],
                     'geom': box(a[0] - rub_m, a[1] - rub_m, a[2] + rub_m, a[3] + rub_m),
                     'izvor': 'PRETPOSTAVKA: README nema orijentir za Borongaj; pravokutnik oko tramvajske petlje '
                              f'i perona prema OSM-u (očitano 13.11.2026.), prošireno {rub_m:g} m'})
    return zone, TLO_ZADANO, _opisi_zona(zone, TLO_ZADANO)


def _opisi_zona(zone, zad):
    out = []
    for z in zone:
        a = z['geom'].bounds
        out.append(f'  {z["naziv"]}: pod najniže {br(z["min"], 1)} m n. v.; x {a[0]:.0f}..{a[2]:.0f}, '
                   f'y {a[1]:.0f}..{a[3]:.0f}; izvor: {z["izvor"]}')
    out.append(f'  svugdje drugdje: pod najniže {br(zad, 1)} m n. v. (zadano pravilo zadatka)')
    return out


def zona_po_nazivu(zone, uzorak):
    return next((z for z in zone if re.search(uzorak, norm(z['naziv']))), None)


# --------------------------------------------------------------------------------------------------- sport
class Sportovi:
    def __init__(self, put=SPORTOVI):
        self.popis = ucitaj_json(put)['sportovi'] if Path(put).is_file() else []
        self.indeks = {}
        for s in self.popis:
            s.setdefault('skupina', s['id'])
            for k in [s['id'], s.get('naziv', '')] + list(s.get('aliasi') or []):
                if k:
                    self.indeks.setdefault(norm(k), s)

    def nadji(self, naziv):
        return self.indeks.get(norm(naziv))

    @staticmethod
    def potrebno(s):
        """Najmanji pravokutnik (duža, kraća stranica) = igraća površina + ukupni dodaci, ili None."""
        ip = s.get('igraca_povrsina_m')
        if not ip:
            return None
        sp = s.get('sigurnosni_pojas_m') or {}
        a = ip[0] + float(sp.get('uzduzno_ukupno') or 0)
        b = ip[1] + float(sp.get('poprecno_ukupno') or 0)
        return (max(a, b), min(a, b))


def stranice_opisanog_pravokutnika(g):
    r = g.minimum_rotated_rectangle
    if r.geom_type != 'Polygon':
        return (0.0, 0.0)
    c = list(r.exterior.coords)
    a, b = math.dist(c[0], c[1]), math.dist(c[1], c[2])
    return (max(a, b), min(a, b))


def smjesteni_sportovi(m: Model, sp: Sportovi):
    """skupina -> [(sport, prostor)]; glavno igralište stadiona računa se kao smješten nogomet."""
    out = {}
    for s in m.prostori:
        for naziv in s['sportovi']:
            e = sp.nadji(naziv)
            if e:
                out.setdefault(e['skupina'], []).append((e, s))
        if s['kat'] == 'igraliste' and sp.nadji('nogomet') and not any(
                x is s for _, x in out.get('nogomet', [])):
            out.setdefault('nogomet', []).append((sp.nadji('nogomet'), s))
    return out


# ------------------------------------------------------------------------------------------------ provjera
class Nalazi:
    def __init__(self):
        self.popis = []

    def pogreska(self, kod, oid, tekst):
        self.popis.append({'razina': 'POGREŠKA', 'kod': kod, 'id': oid, 'tekst': tekst})

    def upozorenje(self, kod, oid, tekst):
        self.popis.append({'razina': 'UPOZORENJE', 'kod': kod, 'id': oid, 'tekst': tekst})

    def broj(self, razina):
        return sum(1 for n in self.popis if n['razina'] == razina)


def _tekst_prostora(s):
    return norm(f'{s["id"]} {s["naziv"]}')


def _je_kosina(s):
    return bool(re.search(r'kosin|padin|ramp|nagib|spust|pokos', norm(f'{s["naziv"]} {s["raw"].get("napomena") or ""}')))


def _udio_u(g, zona):
    return g.intersection(zona).area / g.area if g is not None and g.area > 0 else 0.0


def ucitaj_kote(put):
    """Kote terena iz research/viz/geodezija/kote_situacija.json: [(x, y, z)] za točke vrste "teren"."""
    if not put or not Path(put).is_file():
        return []
    try:
        return [(float(k['x']), float(k['y']), float(k['z'])) for k in ucitaj_json(put).get('tocke', [])
                if isinstance(k, dict) and k.get('vrsta') == 'teren' and all(je_broj(k.get(a)) for a in 'xyz')]
    except Exception as e:  # noqa: BLE001
        print(f'NAPOMENA: kote terena se ne mogu pročitati ({e}).', file=sys.stderr)
        return []


def provjeri(program, site: Site, zone, tlo_zadano, sp: Sportovi, izmjereno=None) -> Nalazi:
    n = Nalazi()
    # 1. shema
    if SHEMA.is_file():
        shema = ucitaj_json(SHEMA)
        for put, kljucna, poruka in provjeri_shemu(program, shema, shema):
            if (kljucna == 'enum' and re.search(r'\.(kategorija|tip)$', put)) or \
                    (kljucna == 'minItems' and re.search(r'\.(poligon|obris)$', put)):
                continue  # prijavljuje se niže, jasnijom porukom
            mm = re.match(r'^\$\.(prostori|razine|veze)\[(\d+)\]', put)
            stavka = program[mm.group(1)][int(mm.group(2))] if mm and isinstance(program, dict) else None
            oid = str(stavka['id']) if isinstance(stavka, dict) and stavka.get('id') else put
            n.pogreska('SHEMA', oid, poruka if oid == put else f'{put}: {poruka}')
    else:
        n.upozorenje('SHEMA', '-', f'shema {SHEMA} ne postoji; oblik zapisa nije provjeren')
    if not isinstance(program, dict):
        return n
    m = Model(program)

    # 2. nepoznata polja (upozorenje), kategorije, tipovi veza, dvostruki id, razine
    for k in set(program) - POLJA['korijen']:
        n.upozorenje('NEPOZNATO_POLJE', '-', f'polje "{k}" nije u formatu i zanemaruje se')
    for vrsta, popis, polja in (('razina', m.razine, POLJA['razina']), ('prostor', m.prostori, POLJA['prostor']),
                                ('veza', m.veze, POLJA['veza'])):
        vidjeni = {}
        for o in popis:
            for k in sorted(set(o['raw']) - polja):
                n.upozorenje('NEPOZNATO_POLJE', o['id'], f'polje "{k}" nije u formatu ({vrsta}) i zanemaruje se')
            if o['id'] in vidjeni:
                n.pogreska('DVOSTRUKI_ID', o['id'], f'{vrsta}: id se ponavlja (stavke {vidjeni[o["id"]] + 1} i '
                                                    f'{o["i"] + 1})')
            vidjeni.setdefault(o['id'], o['i'])
    for s in m.prostori:
        if s['kat'] not in KATEGORIJE:
            n.pogreska('KATEGORIJA', s['id'], f'nepoznata kategorija {s["kat"]!r}; dopušteno: {", ".join(KATEGORIJE)}')
        if s['raz'] is None:
            n.pogreska('RAZINA', s['id'], f'razina {s["razina"]!r} ne postoji; postoje: '
                                          f'{", ".join(r["id"] for r in m.razine) or "nijedna"}')
    for v in m.veze:
        if v['tip'] not in TIPOVI_VEZA:
            n.pogreska('TIP_VEZE', v['id'], f'nepoznat tip veze {v["tip"]!r}; dopušteno: {", ".join(TIPOVI_VEZA)}')
        for rid in v['razine']:
            if rid not in m.razina_po_id:
                n.pogreska('RAZINA', v['id'], f'veza navodi razinu {rid!r} koja ne postoji')
        if v['geom'] is None:
            n.pogreska('POLIGON', v['id'], 'veza nema valjanu liniju (najmanje 2 točke) ni točku')
    kote = [r['kota'] for r in m.razine if r['kota'] is not None]
    if kote != sorted(kote):
        n.upozorenje('REDOSLIJED_RAZINA', '-', 'razine nisu poredane od najniže prema najvišoj koti poda')

    # 3. poligoni
    for vrsta, oid, opis in m.pogreske_geometrije:
        n.pogreska('POLIGON', oid, f'nevaljan poligon ({vrsta}): {opis}')

    # 4. prostor izvan obrisa razine
    for s in m.prostori:
        if s['geom'] is None or s['raz'] is None or s['raz']['geom'] is None:
            continue
        van = s['geom'].difference(s['raz']['geom'].buffer(TOL_OBRIS_M)).area
        if van > 0.01:
            n.pogreska('IZVAN_OBRISA', s['id'], f'{br(van, 1)} m² prostora je izvan obrisa razine {s["razina"]} '
                                                f'(tolerancija {br(TOL_OBRIS_M, 1)} m)')

    # 5. preklapanje na istoj razini, 7. visinski sudar, prekriveni otvoreni prostori
    valjani = [s for s in m.prostori if s['geom'] is not None]
    for i, a in enumerate(valjani):
        ab = a['geom'].bounds
        for b in valjani[i + 1:]:
            bb = b['geom'].bounds
            if ab[2] <= bb[0] or bb[2] <= ab[0] or ab[3] <= bb[1] or bb[3] <= ab[1]:
                continue
            p = a['geom'].intersection(b['geom']).area
            if p <= PRAG_PREKLAPANJA_M2:
                continue
            if a['razina'] == b['razina']:
                n.pogreska('PREKLAPANJE', a['id'], f'preklapa se s prostorom {b["id"]} na razini {a["razina"]}: '
                                                   f'{br(p, 1)} m² (prag {br(PRAG_PREKLAPANJA_M2, 0)} m²)')
                continue
            if a['pod'] is None or b['pod'] is None:
                continue
            donji, gornji = (a, b) if a['pod'] < b['pod'] else (b, a)
            if gornji['pod'] - donji['pod'] < 0.01:
                continue
            if donji['kat'] in OTVORENE:
                if donji['kat'] in NE_SMIJU_BITI_PREKRIVENI and gornji['kat'] != 'svjetlarnik':
                    n.upozorenje('OTVORENO_PREKRIVENO', donji['id'],
                                 f'otvoreni prostor ({donji["kat"]}) tlocrtno prekriva prostor {gornji["id"]} s '
                                 f'razine {gornji["razina"]} na {br(p, 0)} m²; ako je to namjerno, upiši rupu')
                continue
            if donji['visina'] is None or gornji['kat'] == 'svjetlarnik':
                continue
            vrh = donji['pod'] + donji['visina'] + KONSTRUKCIJA_M
            if vrh > gornji['pod'] + 1e-6:
                n.pogreska('VISINSKI_SUDAR', donji['id'],
                           f'pod {br(donji["pod"], 2)} + svijetla visina {br(donji["visina"], 2)} + konstrukcija '
                           f'{br(KONSTRUKCIJA_M, 1)} = {br(vrh, 2)} m n. v., a pod prostora {gornji["id"]} iznad '
                           f'njega (razina {gornji["razina"]}) je na {br(gornji["pod"], 2)}; višak '
                           f'{br(vrh - gornji["pod"], 2)} m na {br(p, 0)} m² tlocrta')

    # 6. pod ispod današnjeg tla
    sve_zone = unary_union([z['geom'] for z in zone]) if zone else None
    for r in m.razine:
        if r['kota'] is not None and r['kota'] < TLO_NAJNIZE - TOL_KOTE:
            n.pogreska('ISPOD_TLA', r['id'], f'kota poda razine {br(r["kota"], 2)} je ispod najniže današnje kote '
                                             f'obuhvata ({br(TLO_NAJNIZE, 1)} m n. v.); ništa se ne ukopava')
    for s in valjani:
        if s['pod'] is None:
            continue
        dijelovi = []
        if s['pod'] < tlo_zadano - TOL_KOTE:
            ost = s['geom'].difference(sve_zone).area if sve_zone is not None else s['geom'].area
            if ost > 1.0:
                dijelovi.append(f'{br(ost, 0)} m² izvan nižih područja, gdje je tlo najniže {br(tlo_zadano, 1)}')
        for z in zone:
            if s['pod'] < z['min'] - TOL_KOTE:
                niza = [y['geom'] for y in zone if y['min'] <= s['pod'] + TOL_KOTE]
                dio = s['geom'].intersection(z['geom'])
                if niza:
                    dio = dio.difference(unary_union(niza))
                if dio.area > 1.0:
                    dijelovi.append(f'{br(dio.area, 0)} m² u području "{z["naziv"]}", gdje je tlo najniže '
                                    f'{br(z["min"], 1)}')
        if dijelovi:
            n.pogreska('ISPOD_TLA', s['id'], f'pod na {br(s["pod"], 2)} m n. v. je ispod današnjeg tla: '
                                             f'{"; ".join(dijelovi)} (ništa se ne ukopava)')
    # dodatno, samo kao upozorenje: usporedba s izmjerenim kotama terena (ako su zadane)
    if izmjereno:
        for s in valjani:
            if s['pod'] is None or s['kat'] == 'postojece':
                continue
            okolina = s['geom'].buffer(15.0)
            a = okolina.bounds
            zs = sorted(z for x, y, z in izmjereno if a[0] <= x <= a[2] and a[1] <= y <= a[3]
                        and okolina.contains(Point(x, y)))
            if len(zs) >= 3:
                med = zs[len(zs) // 2]
                if s['pod'] < med - 0.5:
                    n.upozorenje('ISPOD_IZMJERENOG_TERENA', s['id'],
                                 f'pod na {br(s["pod"], 2)} je {br(med - s["pod"], 2)} m ispod medijana izmjerenih '
                                 f'kota terena ({br(med, 2)} m n. v.; {len(zs)} točaka u prostoru i 15 m oko njega; '
                                 f'raspon {br(zs[0], 2)} do {br(zs[-1], 2)})')
    for i, k in enumerate(program.get('kote_terena') or []):
        if isinstance(k, dict) and all(je_broj(k.get(a)) for a in 'xyz'):
            mn = min([z['min'] for z in zone if z['geom'].contains(Point(k['x'], k['y']))] or [tlo_zadano])
            if k['z'] < mn - TOL_KOTE:
                n.upozorenje('KOTA_TERENA', f'kote_terena[{i}]', f'kota {br(k["z"], 2)} je ispod današnjeg tla '
                                                                 f'({br(mn, 1)}) na tom mjestu')

    # 8. kanonske kote
    z_bor, z_baz = zona_po_nazivu(zone, r'borongaj'), zona_po_nazivu(zone, r'bazen')
    os_m = site.os_maksimirske() if site.ima else None
    koridor = (os_m if os_m is not None and not os_m.is_empty else LineString(OS_MAKSIMIRSKE)).buffer(
        SIRINA_KORIDORA_M / 2)

    def izvan(v, raspon):
        return v < raspon[0] - TOL_KOTE or v > raspon[1] + TOL_KOTE

    for r in m.razine:
        t = norm(f'{r["id"]} {r["naziv"]}')
        if r['kota'] is not None and re.search(r'(^|_)podij', t) and not re.search(r'pod_podij|ispod_podij', t):
            _provjeri_podij(n, r['id'], r['kota'], t + norm(str(r['raw'].get('opis') or '')), 'razina')
    for s in valjani:
        if s['pod'] is None:
            continue
        t, kat, pod = _tekst_prostora(s), s['kat'], s['pod']
        if kat == 'igraliste' and izvan(pod, KANON['igraliste']):
            n.pogreska('KANONSKA_KOTA', s['id'], f'igralište na {br(pod, 2)} m n. v.; odluka M1 traži '
                                                 f'{br(KANON["igraliste"][0], 0)} do {br(KANON["igraliste"][1], 0)}')
        if re.search(r'(^|_)podij', t) and not re.search(r'pod_podij|ispod_podij', t) and \
                kat in ('trg_predvorje', 'staza', 'park_zelenilo', 'stadion'):
            _provjeri_podij(n, s['id'], pod, t + norm(str(s['raw'].get('napomena') or '')), 'prostor')
        gornji = kat in ('park_zelenilo', 'staza', 'svjetlarnik', 'trg_predvorje', 'sport_otvoreni')
        if gornji and 'pokrov' in t and izvan(pod, KANON['pokrov']):
            poruka = (f'park na pokrovu Maksimirske na {br(pod, 2)} m n. v.; kanonski raspon '
                      f'{br(KANON["pokrov"][0], 1)} do {br(KANON["pokrov"][1], 1)} (docs/17)')
            (n.upozorenje if _je_kosina(s) else n.pogreska)('KANONSKA_KOTA', s['id'], poruka)
        elif gornji and 'pokrov' not in t and pod > 122 and _udio_u(s['geom'], koridor) >= 0.8 and \
                izvan(pod, KANON['pokrov']) and not _je_kosina(s):
            n.upozorenje('KANONSKA_KOTA', s['id'], f'prostor leži nad koridorom Maksimirske, a pod mu je na '
                                                   f'{br(pod, 2)}; park na pokrovu je kanonski na '
                                                   f'{br(KANON["pokrov"][0], 1)} do {br(KANON["pokrov"][1], 1)}')
        if z_bor is not None and _udio_u(s['geom'], z_bor['geom']) >= 0.5:
            if kat in ('promet_tramvaj', 'promet_bus') and abs(pod - KANON['borongaj_pod']) > TOL_KOTE:
                n.pogreska('KANONSKA_KOTA', s['id'], f'hala okretišta na Borongaju ima pod na {br(pod, 2)}; '
                                                     f'odluka M4 traži {br(KANON["borongaj_pod"], 1)}')
            if kat in ('park_zelenilo', 'staza', 'trg_predvorje') and pod > 120 and izvan(pod, KANON['borongaj_park']):
                poruka = (f'park iznad Borongaja na {br(pod, 2)} m n. v.; odluka M4: oko 124 (ovdje '
                          f'{br(KANON["borongaj_park"][0], 0)} do {br(KANON["borongaj_park"][1], 0)})')
                (n.upozorenje if _je_kosina(s) else n.pogreska)('KANONSKA_KOTA', s['id'], poruka)
        if z_baz is not None and 'bazen' in t and kat in ('postojece', 'dvoriste', 'voda', 'sport_zatvoreni') and \
                _udio_u(s['geom'], z_baz['geom']) >= 0.5 and abs(pod - KANON['bazen']) > TOL_KOTE:
            n.pogreska('KANONSKA_KOTA', s['id'], f'bazen Svetice na {br(pod, 2)} m n. v.; odluka M7 traži '
                                                 f'{br(KANON["bazen"], 0)}')
    st = program.get('stadion') if isinstance(program.get('stadion'), dict) else {}
    for t in st.get('tribine') or []:
        if isinstance(t, dict) and je_broj(t.get('kota_dna_mnv')) and t['kota_dna_mnv'] < KANON['igraliste'][0] - TOL_KOTE:
            n.pogreska('ISPOD_TLA', f'stadion.tribine:{t.get("naziv", "?")}',
                       f'dno tribine na {br(t["kota_dna_mnv"], 2)} je ispod kote igrališta '
                       f'({br(KANON["igraliste"][0], 0)}); ništa se ne ukopava')
    vrh = (st.get('krov') or {}).get('kota_vrha_mnv') if isinstance(st.get('krov'), dict) else None
    if je_broj(vrh) and abs(vrh - KANON['vrh_krova']) > 1.0:
        n.upozorenje('KANONSKA_KOTA', 'stadion.krov', f'vrh krova na {br(vrh, 1)}; README navodi oko '
                                                      f'{br(KANON["vrh_krova"], 1)} (PRETPOSTAVKA iz montaže)')

    # ---- upozorenja
    for s in m.prostori:
        raw, nema = s['raw'], []
        if not raw.get('status'):
            nema.append('statusa')
        if not raw.get('izvor'):
            nema.append('izvora')
        if not raw.get('odluke') and s['kat'] != 'postojece':
            nema.append('odluke')
        if nema:
            n.upozorenje('BEZ_STATUSA_IZVORA_ODLUKE', s['id'], f'prostor bez {", ".join(nema)}')
    for s in valjani:
        if s['kat'] != 'garaza':
            continue
        kap = s['raw'].get('kapacitet')
        if not (isinstance(kap, dict) and je_broj(kap.get('broj')) and kap['broj'] > 0):
            n.upozorenje('GARAZA_M2', s['id'], 'garaža nema kapacitet (broj mjesta), pa se m² po mjestu ne može '
                                               'provjeriti')
            continue
        po = s['geom'].area / kap['broj']
        if not GARAZA_M2_PO_MJESTU[0] <= po <= GARAZA_M2_PO_MJESTU[1]:
            n.upozorenje('GARAZA_M2', s['id'], f'{br(s["geom"].area, 0)} m² / {br(kap["broj"], 0)} mjesta = '
                                               f'{br(po, 1)} m² po mjestu; očekivano {GARAZA_M2_PO_MJESTU[0]:g} do '
                                               f'{GARAZA_M2_PO_MJESTU[1]:g}')
    for s in valjani:
        for naziv in s['sportovi']:
            e = sp.nadji(naziv)
            if e is None:
                n.upozorenje('SPORT_NEPOZNAT', s['id'], f'sport "{naziv}" nije u {SPORTOVI.name}; dimenzije se ne '
                                                        'provjeravaju')
                continue
            tr = Sportovi.potrebno(e)
            if tr:
                a, b = stranice_opisanog_pravokutnika(s['geom'])
                if a < tr[0] - 0.05 or b < tr[1] - 0.05 or s['geom'].area < tr[0] * tr[1] - 1.0:
                    n.upozorenje('SPORT_DIMENZIJE', s['id'],
                                 f'{e["naziv"]}: treba najmanje {br(tr[0], 2)} x {br(tr[1], 2)} m (igraća površina '
                                 f'i pojas), a najmanji opisani pravokutnik prostora je {br(a, 1)} x {br(b, 1)} m, '
                                 f'površina {br(s["geom"].area, 0)} m² [{e.get("status_dimenzija")}]')
            hmin = e.get('min_svijetla_visina_m')
            if hmin and s['kat'] not in OTVORENE:
                if s['visina'] is None:
                    n.upozorenje('SPORT_VISINA', s['id'], f'{e["naziv"]}: treba svijetlu visinu najmanje '
                                                          f'{br(hmin, 2)} m, a prostor je nema upisanu')
                elif s['visina'] < hmin - 0.01:
                    n.upozorenje('SPORT_VISINA', s['id'], f'{e["naziv"]}: svijetla visina {br(s["visina"], 2)} m je '
                                                          f'ispod najmanje {br(hmin, 2)} m [{e.get("status_visine")}]')
    # gruba provjera evakuacije: najdalja točka prostora do najbliže veze ili toplog puta/predvorja iste razine
    for s in valjani:
        if s['kat'] not in ZATVORENE:
            continue
        ciljevi = [v['geom'] for v in m.veze if v['geom'] is not None and s['razina'] in v['razine']
                   and v['tip'] != 'svjetlarnik']
        ciljevi += [x['geom'] for x in valjani if x is not s and x['razina'] == s['razina']
                    and x['kat'] in ('topli_put', 'trg_predvorje')]
        if not ciljevi:
            n.upozorenje('EVAKUACIJA_60M', s['id'], f'na razini {s["razina"]} nema nijedne veze, izlaza ni toplog '
                                                    'puta')
            continue
        d = najdalja_tocka(s['geom'], unary_union(ciljevi))
        if d > EVAKUACIJA_M:
            n.upozorenje('EVAKUACIJA_60M', s['id'], f'najdalja točka prostora je {br(d, 0)} m zračne crte od '
                                                    f'najbližeg izlaza ili veze (gruba granica {EVAKUACIJA_M:g} m)')
    # sportovi razreda A i B koji nisu smješteni
    smj = smjesteni_sportovi(m, sp)
    for razred in ('A', 'B'):
        skupine = {}
        for e in sp.popis:
            if e.get('razred') == razred and e.get('obvezan_smjestaj', True):
                skupine.setdefault(e['skupina'], e)
        for sk, e in skupine.items():
            if sk not in smj:
                naziv = e['naziv'] if e['skupina'] == e['id'] else sk.replace('_', ' ')
                n.upozorenje('SPORT_NIJE_SMJESTEN', '-', f'sport razreda {razred} iz docs/19 nije nigdje smješten: '
                                                         f'{naziv}')
    return n


def _provjeri_podij(n: Nalazi, oid, kota, tekst, vrsta):
    if abs(kota - KANON['podij']) <= TOL_KOTE:
        return
    if abs(kota - KANON['podij_v2']) <= TOL_KOTE and re.search(r'kontroln|v2', tekst):
        n.upozorenje('KANONSKA_KOTA', oid, f'podij na {br(kota, 1)} (V2) dopušten je samo kao kontrolni scenarij '
                                           '(odluka M2)')
        return
    n.pogreska('KANONSKA_KOTA', oid, f'podij ({vrsta}) na {br(kota, 2)} m n. v.; odluka M2 traži '
                                     f'{br(KANON["podij"], 1)}')


def najdalja_tocka(g, ciljevi, korak=5.0):
    """Najveća udaljenost točke poligona do skupa ciljeva (vrhovi i mreža točaka na 5 m)."""
    pts = [Point(c) for c in g.exterior.coords]
    a = g.bounds
    korak = max(korak, math.sqrt((a[2] - a[0]) * (a[3] - a[1]) / 4000.0))
    y = a[1] + korak / 2
    while y < a[3]:
        x = a[0] + korak / 2
        while x < a[2]:
            p = Point(x, y)
            if g.contains(p):
                pts.append(p)
            x += korak
        y += korak
    return max(p.distance(ciljevi) for p in pts)


def ispis_provjere(n: Nalazi, put, opisi_zona, kao_json=False):
    if kao_json:
        print(json.dumps({'program': str(put), 'pogreske': n.broj('POGREŠKA'), 'upozorenja': n.broj('UPOZORENJE'),
                          'zone_tla': opisi_zona, 'nalazi': n.popis}, ensure_ascii=False, indent=1))
        return
    print(f'Provjera programa: {put}')
    print('Područja današnjeg tla (najniža dopuštena kota poda; "ništa se ne ukopava"):')
    print('\n'.join(opisi_zona))
    for razina in ('POGREŠKA', 'UPOZORENJE'):
        for x in n.popis:
            if x['razina'] == razina:
                print(f'{razina} [{x["kod"]}] {x["id"]}: {x["tekst"]}')
    print(f'Ukupno: pogreške {n.broj("POGREŠKA")}, upozorenja {n.broj("UPOZORENJE")}. '
          f'{"PROLAZI" if not n.broj("POGREŠKA") else "NE PROLAZI"}. Gruba mehanička provjera, nije projektna kontrola.')


# ------------------------------------------------------------------------------------------------- bilanca
def bilanca(program, put, sp: Sportovi):
    m = Model(program)
    valjani = [s for s in m.prostori if s['geom'] is not None]
    po_rk, po_r, po_k = {}, {}, {}
    for s in valjani:
        a = s['geom'].area
        k = (s['razina'], s['kat'])
        po_rk[k] = (po_rk.get(k, (0.0, 0))[0] + a, po_rk.get(k, (0.0, 0))[1] + 1)
        po_r[s['razina']] = po_r.get(s['razina'], 0.0) + a
        po_k[s['kat']] = po_k.get(s['kat'], 0.0) + a
    ukupno = sum(s['geom'].area for s in valjani)
    garaze = []
    for s in valjani:
        if s['kat'] == 'garaza':
            kap = s['raw'].get('kapacitet')
            broj = kap['broj'] if isinstance(kap, dict) and je_broj(kap.get('broj')) else None
            garaze.append((s, broj))
    smj = smjesteni_sportovi(m, sp)
    sport_z = po_k.get('sport_zatvoreni', 0.0)
    zatvoreno = sum(v for k, v in po_k.items() if k in ZATVORENE)
    sport_svi = sum(v for k, v in po_k.items() if k in SPORTSKE)
    sha = hashlib.sha256(Path(put).read_bytes()).hexdigest()
    return {'m': m, 'valjani': valjani, 'po_rk': po_rk, 'po_r': po_r, 'po_k': po_k, 'ukupno': ukupno,
            'garaze': garaze, 'smj': smj, 'sport_z': sport_z, 'zatvoreno': zatvoreno, 'sport_svi': sport_svi,
            'sha': sha, 'put': put, 'nevaljani': [s['id'] for s in m.prostori if s['geom'] is None]}


def bilanca_md(b, sp: Sportovi) -> str:
    m, meta = b['m'], b['m'].p.get('meta') or {}
    L = [f'# Bilanca programa: {meta.get("naziv", Path(b["put"]).name)}', '',
         f'**{OZNAKA}.** Površine su izračunate iz poligona u `{Path(b["put"]).name}` (lokalni ENU, metri); to su '
         'tlocrtne površine crteža, ne neto ili bruto površine projekta. Verzija programa: '
         f'{meta.get("verzija", "–")}; datum: {meta.get("datum", "–")}; status: {meta.get("status", "–")}.', '']
    if b['nevaljani']:
        L += [f'Prostori s nevaljanim poligonom nisu uračunati: {", ".join(b["nevaljani"])}.', '']
    L += ['## Razine', '', '| Razina | Kota poda (m n. v.) | Površina prostora (m²) | Udio obrisa razine |',
          '| --- | --- | --- | --- |']
    for r in m.razine:
        ob = r['geom'].area if r['geom'] is not None else None
        ud = f'{br(100 * b["po_r"].get(r["id"], 0) / ob, 1)} % od {br(ob, 0)} m²' if ob else '–'
        L.append(f'| {r["id"]}: {r["naziv"]} | {br(r["kota"], 1)} | {br(b["po_r"].get(r["id"], 0), 0)} | {ud} |')
    L += ['', '## Površine po razini i kategoriji', '', '| Razina | Kategorija | Površina (m²) | Broj prostora |',
          '| --- | --- | --- | --- |']
    for r in m.razine:
        for k in KATEGORIJE + sorted({x[1] for x in b['po_rk'] if x[1] not in KATEGORIJE}, key=str):
            if (r['id'], k) in b['po_rk']:
                a, c = b['po_rk'][(r['id'], k)]
                L.append(f'| {r["id"]} | {k} | {br(a, 0)} | {c} |')
    L += ['', '## Površine po kategoriji (sve razine)', '', '| Kategorija | Površina (m²) | Udio |', '| --- | --- | --- |']
    for k, a in sorted(b['po_k'].items(), key=lambda x: -x[1]):
        L.append(f'| {k} | {br(a, 0)} | {br(100 * a / b["ukupno"], 1) if b["ukupno"] else "–"} % |')
    L += ['', '## Garaže', '']
    if b['garaze']:
        L += ['| Prostor | Površina (m²) | Mjesta | m² po mjestu |', '| --- | --- | --- | --- |']
        for s, broj in b['garaze']:
            L.append(f'| {s["id"]} ({s["razina"]}) | {br(s["geom"].area, 0)} | {br(broj, 0)} | '
                     f'{br(s["geom"].area / broj, 1) if broj else "–"} |')
        zb = sum(x for _, x in b['garaze'] if x)
        pov = sum(s['geom'].area for s, _ in b['garaze'])
        L += ['', f'Ukupno garažnih mjesta: **{br(zb, 0)}** na {br(pov, 0)} m² (prosjek '
                  f'{br(pov / zb, 1) if zb else "–"} m² po mjestu). Program natječaja traži oko 800 mjesta u zoni C i '
                  'oko 1.500 u zoni D (odluka M5); usporedba je informativna.']
    else:
        L.append('Nema prostora kategorije garaza.')
    L += ['', '## Sportovi po razredu', '',
          'Razredi A i B prema docs/19_zdravi_grad.md (odluka M13); M8 su dodatni sadržaji iz odluke M8.', '',
          '| Razred | Sport | Smještaj | Površina i visina |', '| --- | --- | --- | --- |']
    for razred in ('A', 'B', 'M8'):
        vidjene = set()
        for e in sp.popis:
            if e.get('razred') != razred or e['skupina'] in vidjene:
                continue
            vidjene.add(e['skupina'])
            naziv = e['naziv'] if e['skupina'] == e['id'] else e['skupina'].replace('_', ' ')
            mj = b['smj'].get(e['skupina'], [])
            if not mj:
                gdje = 'NIJE SMJEŠTEN' if e.get('obvezan_smjestaj', True) and razred != 'M8' else 'nije smješten'
                L.append(f'| {razred} | {naziv} | {gdje} | – |')
                continue
            vid = []
            for _, s in mj:
                if s['id'] not in vid:
                    vid.append(s['id'])
            gdje = ', '.join(f'{x} ({next(s["razina"] for _, s in mj if s["id"] == x)})' for x in vid)
            det = '; '.join(f'{br(s["geom"].area, 0)} m², h {br(s["visina"], 1) if s["visina"] else "–"} m'
                            for s in [next(s for _, s in mj if s['id'] == x) for x in vid] if s['geom'] is not None)
            L.append(f'| {razred} | {naziv} | {gdje} | {det or "–"} |')
    nepoz = sorted({x for s in b['valjani'] for x in s['sportovi'] if sp.nadji(x) is None})
    if nepoz:
        L += ['', f'Sportovi u programu koji nisu u {SPORTOVI.name}: {", ".join(nepoz)}.']
    L += ['', '## Udio zatvorenih sportskih površina', '',
          f'- zatvoreni sport (kategorija sport_zatvoreni): {br(b["sport_z"], 0)} m²',
          f'- svi zatvoreni prostori ({", ".join(sorted(ZATVORENE))}): {br(b["zatvoreno"], 0)} m²',
          f'- udio zatvorenog sporta u zatvorenim prostorima: {br(b["sport_z"], 0)} / {br(b["zatvoreno"], 0)} = '
          f'**{br(100 * b["sport_z"] / b["zatvoreno"], 1) if b["zatvoreno"] else "–"} %**',
          f'- udio zatvorenog sporta u svim sportskim površinama (sport_zatvoreni, sport_otvoreni, igraliste): '
          f'{br(b["sport_z"], 0)} / {br(b["sport_svi"], 0)} = '
          f'**{br(100 * b["sport_z"] / b["sport_svi"], 1) if b["sport_svi"] else "–"} %**',
          '', '## Kontrolni zbroj', '',
          f'- zbroj po razinama: {br(sum(b["po_r"].values()), 1)} m²',
          f'- zbroj po kategorijama: {br(sum(b["po_k"].values()), 1)} m²',
          f'- zbroj svih prostora ({len(b["valjani"])}): {br(b["ukupno"], 1)} m²',
          f'- slaganje: {"DA" if _zbroj_ok(b) else "NE"}',
          f'- SHA-256 datoteke programa: `{b["sha"][:16]}…`', '',
          'Prostori različitih razina koji leže jedan iznad drugoga zbrajaju se svaki za sebe; zbroj nije tlocrt '
          'zauzeća zemljišta.', '']
    return '\n'.join(L)


def _zbroj_ok(b) -> bool:
    return abs(sum(b['po_r'].values()) - b['ukupno']) < 0.01 and abs(sum(b['po_k'].values()) - b['ukupno']) < 0.01


def bilanca_csv(b, put, sp: Sportovi):
    with open(put, 'w', newline='', encoding='utf-8') as f:
        w = csv.writer(f)
        w.writerow(['odjeljak', 'razina', 'kljuc', 'naziv', 'povrsina_m2', 'broj', 'napomena'])
        for (rid, k), (a, c) in sorted(b['po_rk'].items(), key=lambda x: (x[0][0], str(x[0][1]))):
            w.writerow(['razina_kategorija', rid, k, '', f'{a:.1f}', c, ''])
        for s in b['valjani']:
            w.writerow(['prostor', s['razina'], s['id'], s['naziv'], f'{s["geom"].area:.1f}', '',
                        f'kategorija={s["kat"]}; pod={s["pod"]}; visina={s["visina"]}'])
        for s, broj in b['garaze']:
            w.writerow(['garaza', s['razina'], s['id'], s['naziv'], f'{s["geom"].area:.1f}', broj if broj else '',
                        f'm2_po_mjestu={s["geom"].area / broj:.1f}' if broj else ''])
        for sk, mj in sorted(b['smj'].items()):
            for e, s in mj:
                w.writerow(['sport', s['razina'], e['id'], e['naziv'],
                            f'{s["geom"].area:.1f}' if s['geom'] is not None else '', '',
                            f'razred={e.get("razred")}; prostor={s["id"]}'])
        w.writerow(['kontrola', '', 'zbroj_prostora', '', f'{b["ukupno"]:.1f}', len(b['valjani']),
                    f'slaganje={"DA" if _zbroj_ok(b) else "NE"}; sha256={b["sha"]}'])


# ------------------------------------------------------------------------------------------------- crtanje
BOJE = {  # ispuna, rub
    'stadion': ('#c9d7f2', '#3b5ba9'), 'igraliste': ('#a8d99a', '#3d8b37'), 'tribine': ('#9db4e6', '#2f4f9e'),
    'sport_zatvoreni': ('#ffd08a', '#c77700'), 'sport_otvoreni': ('#d6ec9c', '#6f9a1c'),
    'zdravlje': ('#f7b6c4', '#c2255c'), 'kultura': ('#d9bdf0', '#7b3fb5'), 'javne_sluzbe': ('#b9e3e8', '#1c7c8c'),
    'komercijala': ('#f9e08c', '#a68a00'), 'ugostiteljstvo': ('#f6c19a', '#c05a14'),
    'garaza': ('#cfcfcf', '#666666'), 'promet_tramvaj': ('#9fc5f8', '#1c5fb8'), 'promet_bus': ('#b7d3c0', '#2f7d4f'),
    'promet_cesta': ('#b8b8c4', '#4a4a5a'), 'topli_put': ('#ff9d7a', '#d9480f'),
    'trg_predvorje': ('#efe6d2', '#8c7a4f'), 'tehnika': ('#d5d0c8', '#7a6f60'), 'logistika': ('#c9c2b0', '#6b6142'),
    'park_zelenilo': ('#cdeac0', '#4f9a3f'), 'staza': ('#eadfc8', '#a08f63'), 'svjetlarnik': ('#d6f3fb', '#2aa3c7'),
    'voda': ('#a9dcf5', '#1b84b8'), 'dvoriste': ('#e7f3dc', '#7fa35f'), 'postojece': ('#e2e2e2', '#8a8a8a'),
}
NAZIVI_KAT = {
    'stadion': 'stadion', 'igraliste': 'igralište', 'tribine': 'tribine', 'sport_zatvoreni': 'sport, zatvoreni',
    'sport_otvoreni': 'sport, otvoreni', 'zdravlje': 'zdravlje', 'kultura': 'kultura',
    'javne_sluzbe': 'javne službe', 'komercijala': 'komercijala', 'ugostiteljstvo': 'ugostiteljstvo',
    'garaza': 'garaža', 'promet_tramvaj': 'promet: tramvaj', 'promet_bus': 'promet: autobus',
    'promet_cesta': 'promet: cesta', 'topli_put': 'topli put', 'trg_predvorje': 'trg i predvorje',
    'tehnika': 'tehnika', 'logistika': 'logistika', 'park_zelenilo': 'park i zelenilo', 'staza': 'staza',
    'svjetlarnik': 'svjetlarnik', 'voda': 'voda', 'dvoriste': 'dvorište', 'postojece': 'postojeće',
}
VEZE_STIL = {  # boja, slovo, naziv
    'topli_put': ('#d9480f', 'T', 'topli put'), 'dizalo': ('#1c5fb8', 'D', 'dizalo'),
    'stubiste': ('#5f3dc4', 'S', 'stubište'), 'pokretne_stube': ('#0b7285', 'P', 'pokretne stube'),
    'rampa': ('#7048e8', 'R', 'rampa'), 'svjetlarnik': ('#2aa3c7', 'O', 'svjetlarnik'),
    'ulaz': ('#2b8a3e', 'U', 'ulaz'), 'kolni_ulaz': ('#343a40', 'K', 'kolni ulaz'),
    'evakuacija': ('#c92a2a', 'E', 'evakuacija'),
}
SITE_STIL = {'zgrada': ('#e4e4e4', '#b4b4b4'), 'park': ('#eef3ea', '#c9d4c2'), 'voda': ('#e6eef2', '#bccbd3'),
             'ostalo': ('#f0f0f0', '#c4c4c4'), 'tracnice': ('#ececec', '#b4b4b4'), 'cesta': ('#ececec', '#c4c4c4'),
             'staza': ('#f0f0f0', '#d4d4d4')}
FONTOVI = ['/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', '/usr/share/fonts/dejavu/DejaVuSans.ttf',
           '/Library/Fonts/DejaVuSans.ttf', 'DejaVuSans.ttf']
_font_cache = {}


def font(vel, bold=False):
    from PIL import ImageFont
    k = (round(vel * 4) / 4, bold)
    if k not in _font_cache:
        f = None
        for put in FONTOVI:
            try:
                f = ImageFont.truetype(put.replace('DejaVuSans.ttf', 'DejaVuSans-Bold.ttf') if bold else put, k[0])
                break
            except OSError:
                continue
        _font_cache[k] = f or ImageFont.load_default(k[0])
    return _font_cache[k]


def sirina_teksta(s, vel, bold=False):
    try:
        return font(vel, bold).getlength(s)
    except Exception:  # noqa: BLE001
        return 0.6 * vel * len(s)


def _esc(s):
    return str(s).replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')


class Platno:
    """Mali sloj crtanja: iste naredbe daju SVG i PNG (Pillow), bez vanjskog pretvarača."""

    def __init__(self, w, h):
        self.w, self.h, self.ops = w, h, []

    def poligon(self, prstenovi, ispuna=None, rub=None, deb=1.0, crt=None):
        self.ops.append(('p', prstenovi, ispuna, rub, deb, crt))

    def linija(self, pts, boja, deb=1.0, crt=None):
        self.ops.append(('l', pts, boja, deb, crt))

    def krug(self, x, y, r, ispuna=None, rub=None, deb=1.0):
        self.ops.append(('k', x, y, r, ispuna, rub, deb))

    def tekst(self, x, y, s, vel=10.0, boja='#222222', sidro='start', bold=False):
        self.ops.append(('t', x, y, str(s), vel, boja, sidro, bold))

    def pravokutnik(self, x, y, w, h, ispuna=None, rub=None, deb=1.0):
        self.poligon([[(x, y), (x + w, y), (x + w, y + h), (x, y + h)]], ispuna, rub, deb)

    def geom(self, g, tr, ispuna=None, rub=None, deb=1.0, crt=None):
        """Nacrtaj shapely geometriju (poligon, linija ili zbirka) kroz transformaciju tr."""
        if g is None or g.is_empty:
            return
        if g.geom_type == 'Polygon':
            self.poligon([[tr(*c[:2]) for c in g.exterior.coords]] +
                         [[tr(*c[:2]) for c in r.coords] for r in g.interiors], ispuna, rub, deb, crt)
        elif g.geom_type == 'LineString':
            self.linija([tr(*c[:2]) for c in g.coords], rub or ispuna, deb, crt)
        elif hasattr(g, 'geoms'):
            for x in g.geoms:
                self.geom(x, tr, ispuna, rub, deb, crt)

    def svg(self) -> str:
        o = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {self.w} {self.h}" width="{self.w}" '
             f'height="{self.h}" font-family="DejaVu Sans, Arial, sans-serif">',
             f'<title>{_esc(OZNAKA)}</title>', f'<rect width="{self.w}" height="{self.h}" fill="#ffffff"/>']
        for op in self.ops:
            if op[0] == 'p':
                _, pr, isp, rub, deb, crt = op
                d = ' '.join('M' + ' L'.join(f'{x:.1f},{y:.1f}' for x, y in r) + ' Z' for r in pr if len(r) >= 3)
                o.append(f'<path d="{d}" fill="{isp or "none"}" fill-rule="evenodd" stroke="{rub or "none"}" '
                         f'stroke-width="{deb:g}" stroke-linejoin="round"'
                         + (f' stroke-dasharray="{crt[0]:g},{crt[1]:g}"' if crt else '') + '/>')
            elif op[0] == 'l':
                _, pts, boja, deb, crt = op
                o.append(f'<polyline points="{" ".join(f"{x:.1f},{y:.1f}" for x, y in pts)}" fill="none" '
                         f'stroke="{boja}" stroke-width="{deb:g}" stroke-linecap="round" stroke-linejoin="round"'
                         + (f' stroke-dasharray="{crt[0]:g},{crt[1]:g}"' if crt else '') + '/>')
            elif op[0] == 'k':
                _, x, y, r, isp, rub, deb = op
                o.append(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="{r:g}" fill="{isp or "none"}" '
                         f'stroke="{rub or "none"}" stroke-width="{deb:g}"/>')
            elif op[0] == 't':
                _, x, y, s, vel, boja, sidro, bold = op
                o.append(f'<text x="{x:.1f}" y="{y:.1f}" font-size="{vel:g}" fill="{boja}" text-anchor="{sidro}"'
                         + (' font-weight="bold"' if bold else '') + f'>{_esc(s)}</text>')
        o.append('</svg>')
        return '\n'.join(o)

    def png(self, put, max_px=2400, ss=2):
        from PIL import Image, ImageDraw
        k = max_px / max(self.w, self.h) * ss
        W, H = round(self.w * k), round(self.h * k)
        img = Image.new('RGB', (W, H), '#ffffff')
        d = ImageDraw.Draw(img)

        def sk(pts):
            return [(x * k, y * k) for x, y in pts]

        def crta(pts, boja, deb, crt):
            deb = max(1, round(deb * k))
            if not crt:
                d.line(pts, fill=boja, width=deb, joint='curve')
                return
            puno, prazno, crtam, ost = crt[0] * k, crt[1] * k, True, crt[0] * k
            for (x1, y1), (x2, y2) in zip(pts, pts[1:]):
                duz, poz = math.dist((x1, y1), (x2, y2)), 0.0
                while duz - poz > 1e-9:
                    kor = min(ost, duz - poz)
                    if crtam:
                        a, b = poz / duz, (poz + kor) / duz
                        d.line([(x1 + (x2 - x1) * a, y1 + (y2 - y1) * a), (x1 + (x2 - x1) * b, y1 + (y2 - y1) * b)],
                               fill=boja, width=deb)
                    poz, ost = poz + kor, ost - kor
                    if ost <= 1e-9:
                        crtam = not crtam
                        ost = puno if crtam else prazno

        for op in self.ops:
            if op[0] == 'p':
                _, pr, isp, rub, deb, crt = op
                pr = [sk(r) for r in pr if len(r) >= 3]
                if not pr:
                    continue
                if isp:
                    if len(pr) == 1:
                        d.polygon(pr[0], fill=isp)
                    else:
                        xs = [x for r in pr for x, _ in r]
                        ys = [y for r in pr for _, y in r]
                        x0, y0 = max(0, int(min(xs)) - 1), max(0, int(min(ys)) - 1)
                        x1, y1 = min(W, int(max(xs)) + 2), min(H, int(max(ys)) + 2)
                        if x1 > x0 and y1 > y0:
                            maska = Image.new('L', (x1 - x0, y1 - y0), 0)
                            md = ImageDraw.Draw(maska)
                            md.polygon([(x - x0, y - y0) for x, y in pr[0]], fill=255)
                            for r in pr[1:]:
                                md.polygon([(x - x0, y - y0) for x, y in r], fill=0)
                            img.paste(Image.new('RGB', maska.size, isp), (x0, y0), maska)
                if rub:
                    for r in pr:
                        crta(r + [r[0]], rub, deb, crt)
            elif op[0] == 'l':
                _, pts, boja, deb, crt = op
                if len(pts) >= 2:
                    crta(sk(pts), boja, deb, crt)
            elif op[0] == 'k':
                _, x, y, r, isp, rub, deb = op
                d.ellipse([(x - r) * k, (y - r) * k, (x + r) * k, (y + r) * k], fill=isp, outline=rub,
                          width=max(1, round(deb * k)))
            elif op[0] == 't':
                _, x, y, s, vel, boja, sidro, bold = op
                d.text((x * k, y * k), s, font=font(vel * k, bold), fill=boja,
                       anchor={'start': 'ls', 'middle': 'ms', 'end': 'rs'}[sidro])
        if ss != 1:
            img = img.resize((round(W / ss), round(H / ss)), Image.LANCZOS)
        img.save(put, optimize=True)


def _prelomi(s, redaka):
    """Podijeli tekst na najviše zadani broj redaka podjednake duljine."""
    rijeci = s.split()
    if redaka <= 1 or len(rijeci) < 2:
        return [s]
    cilj, out, red = len(s) / redaka, [], ''
    for r in rijeci:
        if red and len(red) + 1 + len(r) > cilj + 2 and len(out) < redaka - 1:
            out.append(red)
            red = r
        else:
            red = f'{red} {r}'.strip()
    out.append(red)
    return out


def _natpis(P: Platno, g_px, naziv, povrsina, kota=None):
    """Upiši naziv i površinu u poligon ako stanu; vrati True ako je natpis upisan."""
    try:
        sred = polylabel(g_px, tolerance=1.0)
    except Exception:  # noqa: BLE001
        sred = g_px.representative_point()
    pov = f'{br(povrsina, 0)} m²' + (f' · kota {br(kota, 1)}' if kota is not None else '')
    for vel in (11, 10, 9, 8, 7, 6.5):
        for redaka, s_pov in ((1, True), (2, True), (3, True), (1, False), (2, False), (3, False)):
            redovi = _prelomi(naziv, redaka) + ([pov] if s_pov else [])
            w = max(sirina_teksta(r, vel, bold=not (s_pov and i == len(redovi) - 1))
                    for i, r in enumerate(redovi)) + 6
            h = len(redovi) * vel * 1.2 + 2
            if g_px.contains(box(sred.x - w / 2, sred.y - h / 2, sred.x + w / 2, sred.y + h / 2)):
                y = sred.y - h / 2 + vel * 1.05
                for i, r in enumerate(redovi):
                    zadnji = s_pov and i == len(redovi) - 1
                    P.tekst(sred.x, y + i * vel * 1.2, r, vel, '#444444' if zadnji else '#111111', 'middle',
                            bold=not zadnji)
                return True
    return False


def _prosiri(okvir, w, h):
    """Proširi okvir na omjer stranica crtaćeg polja, da podloga ispuni cijelo polje."""
    ex, ey = okvir[2] - okvir[0], okvir[3] - okvir[1]
    if ex / ey < w / h:
        d = (ey * w / h - ex) / 2
        return (okvir[0] - d, okvir[1], okvir[2] + d, okvir[3])
    d = (ex * h / w - ey) / 2
    return (okvir[0], okvir[1] - d, okvir[2], okvir[3] + d)


def _transformacija(okvir, x0, y0, w, h):
    ex, ey = okvir[2] - okvir[0], okvir[3] - okvir[1]
    s = min(w / ex, h / ey)
    ox, oy = x0 + (w - ex * s) / 2, y0 + (h - ey * s) / 2
    return (lambda x, y: (ox + (x - okvir[0]) * s, oy + (okvir[3] - y) * s)), s


def _podloga(P: Platno, site: Site, okvir, tr, natpisi=True):
    """Postojeće stanje sivo u pozadini; bez site.json crtaju se orijentiri iz README-a."""
    okv = box(*okvir)
    if site.ima:
        for kl in ('park', 'voda', 'ostalo', 'staza', 'cesta', 'tracnice', 'zgrada'):
            for k, g, _ in site.poligoni:
                if k == kl:
                    P.geom(g.intersection(okv), tr, SITE_STIL[kl][0], SITE_STIL[kl][1], 0.6)
        for k, g, _ in site.linije:
            c = g.intersection(okv)
            if k == 'tracnice':
                P.geom(c, tr, None, '#9a9a9a', 1.0, (5, 3))
            elif k == 'cesta':
                P.geom(c, tr, None, '#c6c6c6', 1.6)
            else:
                P.geom(c, tr, None, '#dedede', 0.6)
        return
    for naziv, a in ORIJENTIRI.items():
        g = box(*a).intersection(okv)
        if g.is_empty:
            continue
        P.geom(g, tr, '#f1f1f1', '#b0b0b0', 0.8, (4, 3))
        if natpisi:
            x, y = tr(g.bounds[0], g.bounds[3])
            P.tekst(x + 3, y + 10, naziv, 7.5, '#8a8a8a')
    os_c = LineString(OS_MAKSIMIRSKE).intersection(okv)
    if not os_c.is_empty:
        P.geom(os_c, tr, None, '#b0b0b0', 1.2, (8, 4))
        if natpisi:
            x, y = tr(*list(os_c.coords)[0])
            P.tekst(x + 4, y - 4, 'os Maksimirske (orijentir)', 7.5, '#8a8a8a')


def _mreza(P: Platno, okvir, tr, x0, y0, w, h, korak=50.0, oznake=True):
    gx = math.ceil(okvir[0] / korak) * korak
    while gx <= okvir[2]:
        px = tr(gx, okvir[1])[0]
        if x0 <= px <= x0 + w:
            P.linija([(px, y0), (px, y0 + h)], '#e3e6ea', 0.5)
            if oznake and round(gx) % 100 == 0:
                P.tekst(px, y0 + h + 10, f'{gx:.0f}', 7, '#888888', 'middle')
        gx += korak
    gy = math.ceil(okvir[1] / korak) * korak
    while gy <= okvir[3]:
        py = tr(okvir[0], gy)[1]
        if y0 <= py <= y0 + h:
            P.linija([(x0, py), (x0 + w, py)], '#e3e6ea', 0.5)
            if oznake and round(gy) % 100 == 0:
                P.tekst(x0 - 4, py + 2.5, f'{gy:.0f}', 7, '#888888', 'end')
        gy += korak


def _sjever_i_mjerilo(P: Platno, x0, y0, w, h, s):
    cx, cy = x0 + w - 28, y0 + 46
    P.poligon([[(cx, cy - 26), (cx + 9, cy + 8), (cx, cy + 2), (cx - 9, cy + 8)]], '#222222', '#222222', 0.5)
    P.tekst(cx, cy + 22, 'S', 12, '#222222', 'middle', bold=True)
    duz = 100.0 if 100 * s < w * 0.35 else 50.0
    bx, by = x0 + 14, y0 + h - 16
    P.pravokutnik(bx - 6, by - 20, duz * s + 46, 32, '#ffffff', '#bbbbbb', 0.5)
    P.pravokutnik(bx, by - 4, duz * s / 2, 5, '#222222', '#222222', 0.6)
    P.pravokutnik(bx + duz * s / 2, by - 4, duz * s / 2, 5, '#ffffff', '#222222', 0.6)
    for i, t in enumerate(('0', f'{duz / 2:.0f}', f'{duz:.0f} m')):
        P.tekst(bx + i * duz * s / 2, by - 8, t, 8, '#222222', 'middle' if i < 2 else 'start')
    P.tekst(bx, by + 9, 'mreža 50 m', 7, '#666666')


def _crtaj_razinu(P: Platno, m: Model, r, tr, s, natpisi=True):
    """Prostori, obris razine i veze; vrati popis prostora koji su dobili broj umjesto natpisa."""
    brojevi = []
    prostori = sorted([x for x in m.prostori_razine(r['id']) if x['geom'] is not None],
                      key=lambda x: -x['geom'].area)
    for x in prostori:
        isp, rub = BOJE.get(x['kat'], ('#ffffff', '#cc0000'))
        P.geom(x['geom'], tr, isp, rub, 1.0)
    if r['geom'] is not None:
        P.geom(r['geom'], tr, None, '#555555', 1.4, (7, 3))
    veze = [v for v in m.veze if v['geom'] is not None and r['id'] in v['razine']]
    prepreke = []
    for v in veze:
        if v['geom'].geom_type != 'LineString':
            continue
        boja = VEZE_STIL.get(v['tip'], ('#cc0000', '?', ''))[0]
        sir = v['raw'].get('sirina_m')
        deb = max(1.6, min(6.0, (sir if je_broj(sir) else 3.0) * s * 0.6))
        P.geom(v['geom'], tr, None, boja, deb, None if v['tip'] == 'topli_put' else (6, 3))
        prepreke.append(LineString([tr(*c[:2]) for c in v['geom'].coords]).buffer(deb / 2 + 2))
    if natpisi:
        zauzeto = unary_union(prepreke) if prepreke else None
        for x in prostori:
            g_px = Polygon([tr(*c[:2]) for c in x['geom'].exterior.coords],
                           [[tr(*c[:2]) for c in rr.coords] for rr in x['geom'].interiors])
            if not g_px.is_valid:
                g_px = g_px.buffer(0)
            if zauzeto is not None:  # natpis ne smije pasti na liniju veze
                g_px = g_px.difference(zauzeto)
            if hasattr(g_px, 'geoms'):
                dijelovi = [d for d in g_px.geoms if d.geom_type == 'Polygon']
                g_px = max(dijelovi, key=lambda d: d.area) if dijelovi else None
            if g_px is None or g_px.is_empty or g_px.geom_type != 'Polygon':
                continue
            kota = x['pod'] if x['pod'] is not None and r['kota'] is not None and abs(x['pod'] - r['kota']) > 0.01 \
                else None
            if not _natpis(P, g_px, x['naziv'], x['geom'].area, kota):
                brojevi.append(x)
                c = g_px.representative_point()
                P.krug(c.x, c.y, 6.5, '#ffffff', '#222222', 0.7)
                P.tekst(c.x, c.y + 2.8, str(len(brojevi)), 7.5, '#111111', 'middle', bold=True)
    for v in veze:
        if v['geom'].geom_type != 'Point':
            continue
        boja, slovo, _ = VEZE_STIL.get(v['tip'], ('#cc0000', '?', ''))
        x, y = tr(v['geom'].x, v['geom'].y)
        if natpisi:
            P.krug(x, y, 5.5, boja, '#ffffff', 0.8)
            P.tekst(x, y + 2.6, slovo, 7, '#ffffff', 'middle', bold=True)
        else:
            P.krug(x, y, 2.0, boja)
    return brojevi


def _okvir_lista(P: Platno, naslov, podnaslov, podnozje):
    W, H = P.w, P.h
    P.pravokutnik(8, 8, W - 16, H - 16, None, '#222222', 1.2)
    P.tekst(24, 40, naslov, 20, '#111111', bold=True)
    P.tekst(24, 62, podnaslov, 12, '#333333')
    w = sirina_teksta(OZNAKA, 12, True) + 24
    P.pravokutnik(W - 24 - w, 20, w, 28, '#fff3bf', '#e67700', 1.2)
    P.tekst(W - 24 - w / 2, 39, OZNAKA, 12, '#8a3b00', 'middle', bold=True)
    P.tekst(24, H - 22, podnozje, 8.5, '#555555')
    P.tekst(W - 24, H - 22, OZNAKA, 8.5, '#8a3b00', 'end', bold=True)


def _podnozje(m: Model, put, site: Site):
    meta = m.p.get('meta') or {}
    pod = f'postojeće stanje iz {Path(site.put).name} (OSM, sivo)' if site.ima else \
        'orijentiri iz research/viz/README.md (OSM, orijentacijski, sivo)'
    return (f'Izvor: {Path(put).name}, verzija {meta.get("verzija", "–")}, {meta.get("datum", "–")}; lokalni ENU u '
            f'metrima, x istok, y sjever; podloga: {pod}. Shema programa, ne geodetska ni projektna podloga.')


def list_razine(m: Model, r, site: Site, okvir, put):
    P = Platno(1600, 1130)
    meta = m.p.get('meta') or {}
    x0, y0, w, h = 44, 84, 1180, 990
    okvir = _prosiri(okvir, w, h)
    tr, s = _transformacija(okvir, x0, y0, w, h)
    vis = f'; svijetla visina {br(r["visina"], 1)} m' if r['visina'] else ''
    mjerilo = 1000.0 / (s * 420.0 / P.w)
    _okvir_lista(P, f'{meta.get("naziv", "Program po razinama")}',
                 f'Razina {r["id"]}: {r["naziv"]}; kota poda {br(r["kota"], 1)} m n. v.{vis}; mjerilo približno '
                 f'1 : {round(mjerilo / 50) * 50:.0f} pri ispisu na A3', _podnozje(m, put, site))
    P.pravokutnik(x0, y0, w, h, '#ffffff', None)
    _mreza(P, okvir, tr, x0, y0, w, h)
    P.geom(r['geom'], tr, '#fbfbf6', None)
    _podloga(P, site, okvir, tr)
    brojevi = _crtaj_razinu(P, m, r, tr, s)
    P.pravokutnik(x0, y0, w, h, None, '#444444', 0.8)
    _sjever_i_mjerilo(P, x0, y0, w, h, s)
    # desni stupac: legenda kategorija, veze, popis brojeva
    lx, ly = x0 + w + 22, y0 + 12
    P.tekst(lx, ly, 'Kategorije na ovoj razini', 11, '#111111', bold=True)
    ly += 8
    po_k = {}
    for x in m.prostori_razine(r['id']):
        if x['geom'] is not None:
            po_k[x['kat']] = po_k.get(x['kat'], 0.0) + x['geom'].area
    for k in [k for k in KATEGORIJE if k in po_k] + [k for k in po_k if k not in KATEGORIJE]:
        isp, rub = BOJE.get(k, ('#ffffff', '#cc0000'))
        P.pravokutnik(lx, ly, 16, 11, isp, rub, 0.9)
        P.tekst(lx + 22, ly + 9.5, f'{NAZIVI_KAT.get(k, str(k))}: {br(po_k[k], 0)} m²', 9.5, '#222222')
        ly += 16
    P.tekst(lx, ly + 10, f'Ukupno prostora: {br(sum(po_k.values()), 0)} m²', 9.5, '#222222', bold=True)
    ly += 30
    tipovi = [t for t in TIPOVI_VEZA if any(v['tip'] == t and r['id'] in v['razine'] for v in m.veze)]
    if tipovi:
        P.tekst(lx, ly, 'Veze', 11, '#111111', bold=True)
        ly += 8
        for t in tipovi:
            boja, slovo, naziv = VEZE_STIL[t]
            oblici = {v['geom'].geom_type for v in m.veze if v['tip'] == t and r['id'] in v['razine']
                      and v['geom'] is not None}
            if 'LineString' in oblici:
                P.linija([(lx, ly + 6), (lx + 16, ly + 6)], boja, 3.0, None if t == 'topli_put' else (6, 3))
            else:
                P.krug(lx + 8, ly + 6, 5.5, boja, '#ffffff', 0.8)
                P.tekst(lx + 8, ly + 8.6, slovo, 7, '#ffffff', 'middle', bold=True)
            P.tekst(lx + 22, ly + 9.5, naziv + (' (točka: ' + slovo + ')' if len(oblici) > 1 else ''), 9.5,
                    '#222222')
            ly += 16
        ly += 14
    P.linija([(lx, ly), (lx + 30, ly)], '#555555', 1.4, (7, 3))
    P.tekst(lx + 36, ly + 3.5, 'obris razine', 9.5, '#222222')
    ly += 24
    if brojevi:
        P.tekst(lx, ly, 'Prostori označeni brojem', 11, '#111111', bold=True)
        ly += 14
        for i, x in enumerate(brojevi, 1):
            if ly > y0 + h - 14:
                P.tekst(lx, ly, f'… i još {len(brojevi) - i + 1} (vidi bilancu)', 8.5, '#555555')
                break
            kt = f'; kota {br(x["pod"], 1)}' if x['pod'] is not None and r['kota'] is not None and \
                abs(x['pod'] - r['kota']) > 0.01 else ''
            t = f'{i}  {x["naziv"]} ({br(x["geom"].area, 0)} m²{kt})'
            while sirina_teksta(t, 8.5) > P.w - lx - 22 and len(t) > 8:
                t = t[:-2].rstrip() + '…'
            P.tekst(lx, ly, t, 8.5, '#222222')
            ly += 12.5
    return P


def zbirni_list(m: Model, site: Site, okvir, put):
    P = Platno(1600, 1130)
    meta = m.p.get('meta') or {}
    n = max(1, len(m.razine))
    stup = 1 if n == 1 else (2 if n <= 4 else 3)
    red = math.ceil(n / stup)
    _okvir_lista(P, f'{meta.get("naziv", "Program po razinama")}: zbirni list',
                 f'Sve razine ({n}) u istom okviru i mjerilu, od najniže prema najvišoj; mreža 50 m',
                 _podnozje(m, put, site))
    X0, Y0, Wk, Hk = 44, 84, 1250, 990
    pw, ph = Wk / stup, Hk / red
    okvir = _prosiri(okvir, pw - 12, ph - 30)
    svi = {}
    for i, r in enumerate(m.razine):
        x0, y0 = X0 + (i % stup) * pw + 6, Y0 + (i // stup) * ph + 22
        w, h = pw - 12, ph - 30
        tr, s = _transformacija(okvir, x0, y0, w, h)
        P.pravokutnik(x0, y0, w, h, '#ffffff', None)
        _mreza(P, okvir, tr, x0, y0, w, h, oznake=False)
        P.geom(r['geom'], tr, '#fbfbf6', None)
        _podloga(P, site, okvir, tr, natpisi=False)
        _crtaj_razinu(P, m, r, tr, s, natpisi=False)
        P.pravokutnik(x0, y0, w, h, None, '#666666', 0.7)
        pov = sum(x['geom'].area for x in m.prostori_razine(r['id']) if x['geom'] is not None)
        P.tekst(x0, y0 - 6, f'{r["id"]}: {r["naziv"]}; kota {br(r["kota"], 1)} m n. v.; prostori {br(pov, 0)} m²',
                10.5, '#111111', bold=True)
        if i == 0:
            _sjever_i_mjerilo(P, x0, y0, w, h, s)
        for x in m.prostori_razine(r['id']):
            if x['geom'] is not None:
                svi[x['kat']] = svi.get(x['kat'], 0.0) + x['geom'].area
    lx, ly = X0 + Wk + 14, Y0 + 12
    P.tekst(lx, ly, 'Kategorije (sve razine)', 11, '#111111', bold=True)
    ly += 8
    for k in [k for k in KATEGORIJE if k in svi] + [k for k in svi if k not in KATEGORIJE]:
        isp, rub = BOJE.get(k, ('#ffffff', '#cc0000'))
        P.pravokutnik(lx, ly, 16, 11, isp, rub, 0.9)
        P.tekst(lx + 22, ly + 9.5, f'{NAZIVI_KAT.get(k, str(k))}: {br(svi[k], 0)} m²', 9, '#222222')
        ly += 16
    P.tekst(lx, ly + 10, f'Ukupno: {br(sum(svi.values()), 0)} m²', 9.5, '#222222', bold=True)
    return P


def pregled(program, put, out, site: Site):
    m = Model(program)
    out = Path(out)
    out.mkdir(parents=True, exist_ok=True)
    okvir = m.okvir()
    datoteke = []
    for r in m.razine:
        P = list_razine(m, r, site, okvir, put)
        ime = f'razina_{re.sub(r"[^A-Za-z0-9_-]+", "_", r["id"])}'
        (out / f'{ime}.svg').write_text(P.svg(), encoding='utf-8')
        P.png(out / f'{ime}.png')
        datoteke += [out / f'{ime}.svg', out / f'{ime}.png']
    P = zbirni_list(m, site, okvir, put)
    (out / 'zbirni_list.svg').write_text(P.svg(), encoding='utf-8')
    P.png(out / 'zbirni_list.png')
    return datoteke + [out / 'zbirni_list.svg', out / 'zbirni_list.png']


# ---------------------------------------------------------------------------------------------------- CLI
def _ucitaj_program(put):
    try:
        return ucitaj_json(put)
    except (OSError, json.JSONDecodeError) as e:
        print(f'POGREŠKA [DATOTEKA] {put}: ne može se pročitati kao JSON ({e})', file=sys.stderr)
        sys.exit(2)


def _site(put):
    if put and not Path(put).is_file():
        print(f'NAPOMENA: {put} ne postoji; radim bez postojećeg stanja (orijentiri iz README-a).', file=sys.stderr)
    return Site(put)


def cmd_provjeri(a):
    program, site, sp = _ucitaj_program(a.program), _site(a.site), Sportovi()
    zone, zad, opisi = ucitaj_zone(site, a.zone, a.rub_zone)
    kote_put = None if a.kote == 'ne' else (a.kote or (KOTE if KOTE.is_file() else None))
    kote = ucitaj_kote(kote_put)
    opisi.append(f'  izmjerene kote terena (samo upozorenje, prag 0,5 m ispod medijana): {len(kote)} točaka iz '
                 f'{kote_put}' if kote else '  izmjerene kote terena: nisu učitane')
    n = provjeri(program, site, zone, zad, sp, kote)
    ispis_provjere(n, a.program, opisi, a.json)
    return 1 if n.broj('POGREŠKA') else 0


def cmd_bilanca(a):
    program, sp = _ucitaj_program(a.program), Sportovi()
    b = bilanca(program, a.program, sp)
    md = bilanca_md(b, sp)
    if a.md:
        Path(a.md).parent.mkdir(parents=True, exist_ok=True)
        Path(a.md).write_text(md, encoding='utf-8')
        print(f'Bilanca (Markdown): {a.md}')
    if a.csv:
        Path(a.csv).parent.mkdir(parents=True, exist_ok=True)
        bilanca_csv(b, a.csv, sp)
        print(f'Bilanca (CSV): {a.csv}')
    if not a.md and not a.csv:
        print(md)
    return 0


def cmd_pregled(a):
    program = _ucitaj_program(a.program)
    for d in pregled(program, a.program, a.out, _site(a.site)):
        print(d)
    return 0


def cmd_test(a):
    mapa = Path(a.mapa)
    ocekivano = ucitaj_json(mapa / 'ocekivano.json')
    sp, site = Sportovi(), Site(None)
    zone, zad, _ = ucitaj_zone(site, None, 10.0)
    sve_ok = True
    for ime, oc in ocekivano['primjeri'].items():
        n = provjeri(ucitaj_json(mapa / ime), site, zone, zad, sp)
        kodovi = {x['kod'] for x in n.popis if x['razina'] == 'POGREŠKA'}
        izlaz = 1 if kodovi else 0
        ok = izlaz == oc['izlaz'] and set(oc.get('kodovi_pogresaka', [])) == kodovi
        sve_ok &= ok
        print(f'{"OK  " if ok else "PAD "} {ime}: izlaz {izlaz} (očekivano {oc["izlaz"]}); pogreške: '
              f'{", ".join(sorted(kodovi)) or "nema"}; očekivane: {", ".join(oc.get("kodovi_pogresaka", [])) or "nema"}')
    print('TEST PROLAZI' if sve_ok else 'TEST NE PROLAZI')
    return 0 if sve_ok else 1


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__.split('\n\n')[0])
    sub = ap.add_subparsers(dest='naredba', required=True)
    p = sub.add_parser('provjeri', help='provjera programa; izlaz 0 bez pogrešaka, inače 1')
    p.add_argument('program')
    p.add_argument('--site', default=None, help='postojeće stanje (research/viz/site.json); neobvezno')
    p.add_argument('--zone', default=None, help='JSON s područjima današnjeg tla (zone_tla); neobvezno')
    p.add_argument('--rub-zone', type=float, default=10.0,
                   help='proširenje orijentacijskih područja tla u metrima (zadano 10)')
    p.add_argument('--kote', default=None,
                   help='kote terena (zadano research/viz/geodezija/kote_situacija.json ako postoji; "ne" isključuje)')
    p.add_argument('--json', action='store_true', help='strojno čitljiv ispis')
    p.set_defaults(f=cmd_provjeri)
    p = sub.add_parser('bilanca', help='površine po razini i kategoriji, garaže, sportovi, kontrolni zbroj')
    p.add_argument('program')
    p.add_argument('--md')
    p.add_argument('--csv')
    p.set_defaults(f=cmd_bilanca)
    p = sub.add_parser('pregled', help='SVG i PNG po razini i zbirni list')
    p.add_argument('program')
    p.add_argument('--out', required=True)
    p.add_argument('--site', default=None)
    p.set_defaults(f=cmd_pregled)
    p = sub.add_parser('test', help='provjera alata na primjerima')
    p.add_argument('--mapa', default=str(PRIMJERI))
    p.set_defaults(f=cmd_test)
    a = ap.parse_args(argv)
    return a.f(a)


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