#!/usr/bin/env python3
"""Listovi zona: tlocrti razina u mjerilu 1 : 1.500 (A3) s potpunim popisom prostora po listu.

AI građanski koncept, PRIJEDLOG; nije projekt. Dopuna pregleda iz scripts/viz/program_alat.py (ispravak 17
sinteze, kritika krug 1, defekt 7): alatov list razine je u mjerilu oko 1 : 3.500 i reže popis prostora.
Ovdje je svaka razina razrezana na okvire od oko 394 x 390 m; svaki prostor koji ulazi u okvir dobiva naziv u
poligonu ili broj s nazivom, površinom cijelog prostora i kotom u popisu uz rub lista. Crtanje (boje, veze,
podloga) preuzima se iz alata, pa listovi izgledaju kao njegovi.

    python research/viz/program/pregled/listovi_zona.py [--program research/viz/program.json]
                                                        [--out research/viz/program/pregled/zone]
"""
from __future__ import annotations

import argparse
import math
import sys
from pathlib import Path

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

KORIJEN = Path(__file__).resolve().parents[4]
sys.path.insert(0, str(KORIJEN / 'scripts' / 'viz'))
import program_alat as A  # noqa: E402

MJERILO = 1500.0
W_PX, H_PX = 1600, 1130                      # A3 položeno: 420 mm = 1600 px
MM_PO_PX = 420.0 / W_PX
X0, Y0, MW, MH = 44, 84, 1000, 990           # polje karte u px
S = 1000.0 / MJERILO / MM_PO_PX              # px po metru
OKV_W, OKV_H = MW / S, MH / S                # okvir u metrima (oko 394 x 390)
PREKLOP = 20.0


def okviri(g):
    """Pravokutni okviri koji pokrivaju geometriju razine; prazni se izostavljaju."""
    a = g.bounds
    nx = max(1, math.ceil((a[2] - a[0] - PREKLOP) / (OKV_W - PREKLOP)))
    ny = max(1, math.ceil((a[3] - a[1] - PREKLOP) / (OKV_H - PREKLOP)))
    korak_x = (a[2] - a[0] - OKV_W) / (nx - 1) if nx > 1 else 0.0
    korak_y = (a[3] - a[1] - OKV_H) / (ny - 1) if ny > 1 else 0.0
    cx0 = (a[0] + a[2]) / 2 if nx == 1 else None
    cy0 = (a[1] + a[3]) / 2 if ny == 1 else None
    out = []
    for j in range(ny):                       # od sjevera prema jugu
        for i in range(nx):
            x0 = cx0 - OKV_W / 2 if cx0 is not None else a[0] + i * korak_x
            y1 = cy0 + OKV_H / 2 if cy0 is not None else a[3] - j * korak_y
            o = (x0, y1 - OKV_H, x0 + OKV_W, y1)
            if g.intersection(box(*o)).area > 150.0:
                out.append(((j, i, ny, nx), o))
    return out


def naziv_okvira(j, i, ny, nx):
    sj = {1: [''], 2: ['sjever', 'jug'], 3: ['sjever', 'sredina', 'jug']}.get(ny, [f'red {k + 1}' for k in range(ny)])
    zi = {1: [''], 2: ['zapad', 'istok'], 3: ['zapad', 'sredina', 'istok']}.get(nx, [f'stupac {k + 1}' for k in range(nx)])
    t = ' '.join(x for x in (sj[j], zi[i]) if x)
    return t or 'cijela razina'


def mjesto_broja(g, n, zauzete):
    """Točka za broj: u izduženim prostorima (trake ceste, kolosijeci) raspoređena uzduž, da se brojevi susjednih
    traka ne preklapaju; inače reprezentativna točka. Izbjegava već postavljene brojeve ako može."""
    kandidati = [g.representative_point()]
    mrr = g.minimum_rotated_rectangle
    if mrr.geom_type == 'Polygon':
        c = list(mrr.exterior.coords)
        a_, b_ = math.dist(c[0], c[1]), math.dist(c[1], c[2])
        if max(a_, b_) > 3.0 * max(1.0, min(a_, b_)):
            if a_ >= b_:
                os_ = LineString([((c[0][0] + c[3][0]) / 2, (c[0][1] + c[3][1]) / 2),
                                  ((c[1][0] + c[2][0]) / 2, (c[1][1] + c[2][1]) / 2)])
            else:
                os_ = LineString([((c[0][0] + c[1][0]) / 2, (c[0][1] + c[1][1]) / 2),
                                  ((c[3][0] + c[2][0]) / 2, (c[3][1] + c[2][1]) / 2)])
            redom = [0.5, 0.3, 0.7, 0.15, 0.85, 0.4, 0.6, 0.22, 0.78]
            kandidati = [os_.interpolate(f, normalized=True) for f in redom[n % 3:] + redom[:n % 3]]
            kandidati = [q if g.contains(q) else g.exterior.interpolate(g.exterior.project(q)) for q in kandidati]
    zu = unary_union(zauzete) if zauzete else None
    for q in kandidati:
        if zu is None or not zu.contains(q):
            return q
    return kandidati[0]


def crtaj(P, m, r, okv, tr):
    """Prostori, obris i veze razine u okviru; vrati prostore koji su dobili broj."""
    ok = box(*okv)
    prostori = sorted([x for x in m.prostori_razine(r['id']) if x['geom'] is not None
                       and x['geom'].intersection(ok).area > 1.0], key=lambda x: -x['geom'].area)
    for x in prostori:
        isp, rub = A.BOJE.get(x['kat'], ('#ffffff', '#cc0000'))
        P.geom(x['geom'].intersection(ok), tr, isp, rub, 1.0)
    if r['geom'] is not None:
        P.geom(r['geom'].exterior.intersection(ok), 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'] and v['geom'].intersects(ok)]
    prepreke = []
    for v in veze:
        if v['geom'].geom_type != 'LineString':
            continue
        boja = A.VEZE_STIL.get(v['tip'], ('#cc0000', '?', ''))[0]
        sir = v['raw'].get('sirina_m')
        deb = max(1.6, min(7.0, (sir if A.je_broj(sir) else 3.0) * S * 0.45))
        c = v['geom'].intersection(ok)
        P.geom(c, tr, None, boja, deb, None if v['tip'] == 'topli_put' else (6, 3))
        for dio in getattr(c, 'geoms', [c]):
            if dio.geom_type == 'LineString':
                prepreke.append(LineString([tr(*q[:2]) for q in dio.coords]).buffer(deb / 2 + 2))
    zauzeto = unary_union(prepreke) if prepreke else None
    # prepreke za brojeve (kritika krug 2: broj 7 preko natpisa LOK-7 i ikona jezgre): natpisi i ikone veza
    ikone = [Point(*tr(v['geom'].x, v['geom'].y)).buffer(6.5) for v in veze if v['geom'].geom_type == 'Point']
    natpisi = []
    _tekst = P.tekst

    def tekst_s_okvirom(x, y, s, vel=10.0, boja='#222222', sidro='start', bold=False):
        w_ = A.sirina_teksta(s, vel, bold)
        x0_ = x - w_ / 2 if sidro == 'middle' else x
        natpisi.append(box(x0_ - 1, y - vel, x0_ + w_ + 1, y + vel * 0.3))
        return _tekst(x, y, s, vel, boja, sidro, bold)
    brojevi, zauzete = [], []
    for x in prostori:
        g = x['geom'].intersection(ok)
        dijelovi = [d for d in getattr(g, 'geoms', [g]) if d.geom_type == 'Polygon']
        if not dijelovi:
            continue
        g = max(dijelovi, key=lambda d: d.area)
        g_px = Polygon([tr(*c[:2]) for c in g.exterior.coords], [[tr(*c[:2]) for c in rr.coords] for rr in g.interiors])
        if not g_px.is_valid:
            g_px = g_px.buffer(0)
        if zauzeto is not None:
            g_px = g_px.difference(zauzeto)
        if ikone:                                  # natpis ne ide preko ikona veza (kritika krug 2)
            g_px = g_px.difference(unary_union(ikone))
        if hasattr(g_px, 'geoms'):
            d_ = [d for d in g_px.geoms if d.geom_type == 'Polygon']
            g_px = max(d_, key=lambda d: d.area) if d_ else None
        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
        P.tekst = tekst_s_okvirom
        try:
            upisan = g_px is not None and not g_px.is_empty and g_px.geom_type == 'Polygon' and \
                A._natpis(P, g_px, x['naziv'], x['geom'].area, kota)
        finally:
            P.tekst = _tekst
        if upisan:
            continue
        brojevi.append(x)
        sid = g_px if g_px is not None and not g_px.is_empty else Polygon(
            [tr(*c[:2]) for c in g.exterior.coords]).buffer(0)
        c = mjesto_broja(sid, len(brojevi), zauzete)
        n = str(len(brojevi))
        rr = 6.5 if len(n) < 2 else 7.5
        prep = unary_union(natpisi + ikone + zauzete) if (natpisi or ikone or zauzete) else None
        if prep is not None and Point(c.x, c.y).buffer(rr).intersects(prep):
            # broj izvan prostora s crtom: prvo slobodno mjesto na prstenovima oko točke
            for rad in (16.0, 22.0, 28.0, 36.0, 46.0):
                nadjen = None
                for k in range(16):
                    a_ = math.radians(90.0 + k * 22.5)
                    q = Point(c.x + rad * math.cos(a_), c.y - rad * math.sin(a_))
                    if not q.buffer(rr + 1.0).intersects(prep) and X0 + rr < q.x < X0 + MW - rr \
                            and Y0 + rr < q.y < Y0 + MH - rr:
                        nadjen = q
                        break
                if nadjen is not None:
                    P.linija([(c.x, c.y), (nadjen.x, nadjen.y)], '#222222', 0.7)
                    P.krug(c.x, c.y, 1.6, '#222222', '#222222', 0.5)
                    c = nadjen
                    break
        zauzete.append(Point(c.x, c.y).buffer(9.0))
        P.krug(c.x, c.y, rr, '#ffffff', '#222222', 0.7)
        P.tekst(c.x, c.y + 2.8, n, 7.5 if len(n) < 3 else 6.5, '#111111', 'middle', bold=True)
    for v in veze:
        if v['geom'].geom_type != 'Point':
            continue
        boja, slovo, _ = A.VEZE_STIL.get(v['tip'], ('#cc0000', '?', ''))
        x, y = tr(v['geom'].x, v['geom'].y)
        P.krug(x, y, 5.0, boja, '#ffffff', 0.8)
        P.tekst(x, y + 2.4, slovo, 6.5, '#ffffff', 'middle', bold=True)
    return prostori, brojevi, veze


def popis(P, r, prostori, brojevi, lx, ly, sirina, dno):
    """Popis prostora označenih brojem u jednom do tri stupca; prilagođava veličinu slova."""
    redovi = []
    for i, x in enumerate(brojevi, 1):
        kt = f'; {A.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 ''
        redovi.append(f'{i}  {x["naziv"]} ({A.br(x["geom"].area, 0)} m²{kt})')
    for vel, stup in ((8.5, 1), (8.0, 2), (7.5, 2), (7.0, 3), (6.5, 3), (6.0, 3)):
        po_stup = int((dno - ly) // (vel * 1.42))
        if po_stup * stup >= len(redovi):
            break
    sw = sirina / stup
    for k, t in enumerate(redovi):
        s_, rd = divmod(k, po_stup)
        if s_ >= stup:
            P.tekst(lx, dno + 2, f'… popis se nastavlja (još {len(redovi) - k}); vidi bilanca.csv', 7, '#aa0000')
            break
        while A.sirina_teksta(t, vel) > sw - 8 and len(t) > 8:
            t = t[:-2].rstrip() + '…'
        P.tekst(lx + s_ * sw, ly + rd * vel * 1.42, t, vel, '#222222')
    return len(redovi)


def lokator(P, m, r, okv, x, y, w, h):
    """Mali prikaz cijele razine s položajem okvira."""
    g = unary_union([s['geom'] for s in m.prostori_razine(r['id']) if s['geom'] is not None])
    a = g.union(box(*okv)).bounds
    o = A._prosiri((a[0] - 10, a[1] - 10, a[2] + 10, a[3] + 10), w, h)
    tr, _ = A._transformacija(o, x, y, w, h)
    P.pravokutnik(x, y, w, h, '#ffffff', '#999999', 0.6)
    P.geom(g, tr, '#d9dee6', '#9aa3ad', 0.4)
    P.geom(box(*okv), tr, None, '#d9480f', 1.6)


def list_zone(m, r, site, okv, oznaka, br_lista, uk_listova, put):
    P = A.Platno(W_PX, H_PX)
    meta = m.p.get('meta') or {}
    tr, s = A._transformacija(okv, X0, Y0, MW, MH)
    vis = f'; svijetla visina {A.br(r["visina"], 1)} m' if r['visina'] else ''
    A._okvir_lista(P, f'Razina {r["id"]}: {r["naziv"]}, list {br_lista} od {uk_listova} ({oznaka})',
                   f'Kota poda {A.br(r["kota"], 1)} m n. v.{vis}; mjerilo 1 : ' + f'{MJERILO:,.0f}'.replace(',', '.') +
                   ' pri ispisu na A3; brojevi u krugovima su u popisu desno',
                   A._podnozje(m, put, site) + f' {meta.get("naziv", "")}.')
    P.pravokutnik(X0, Y0, MW, MH, '#ffffff', None)
    A._mreza(P, okv, tr, X0, Y0, MW, MH)
    if r['geom'] is not None:
        P.geom(r['geom'].intersection(box(*okv)), tr, '#fbfbf6', None)
    A._podloga(P, site, okv, tr)
    prostori, brojevi, veze = crtaj(P, m, r, okv, tr)
    # maska izvan polja karte, pa ponovno okvir i natpisi lista
    P.pravokutnik(X0, Y0, MW, MH, None, '#444444', 0.8)
    A._sjever_i_mjerilo(P, X0, Y0, MW, MH, s)
    lx, lw = X0 + MW + 20, W_PX - (X0 + MW + 20) - 24
    lokator(P, m, r, okv, lx, Y0, 170, 120)
    ky = Y0 + 8
    kat = {}
    for x in prostori:
        kat[x['kat']] = kat.get(x['kat'], 0) + 1
    kx = lx + 182
    P.tekst(kx, ky + 4, 'Kategorije na listu', 9.5, '#111111', bold=True)
    ky += 12
    kk = [k for k in A.KATEGORIJE if k in kat]
    for n_, k in enumerate(kk):
        isp, rub = A.BOJE.get(k, ('#ffffff', '#cc0000'))
        cx, cy = kx + (n_ % 2) * 170, ky + (n_ // 2) * 12.5
        P.pravokutnik(cx, cy, 12, 8.5, isp, rub, 0.7)
        P.tekst(cx + 16, cy + 8, A.NAZIVI_KAT.get(k, k), 7.5, '#222222')
    ky = max(Y0 + 132, ky + math.ceil(len(kk) / 2) * 12.5 + 6)
    tipovi = [t for t in A.TIPOVI_VEZA if any(v['tip'] == t for v in veze)]
    vx = lx
    for t in tipovi:
        boja, slovo, naziv = A.VEZE_STIL[t]
        sw = A.sirina_teksta(naziv, 7.5) + 30
        if vx + sw > W_PX - 24:
            vx, ky = lx, ky + 13
        P.krug(vx + 5, ky + 4, 4.5, boja, '#ffffff', 0.6)
        P.tekst(vx + 5, ky + 6.3, slovo, 5.5, '#ffffff', 'middle', bold=True)
        P.tekst(vx + 13, ky + 7, naziv, 7.5, '#222222')
        vx += sw
    ky += 22
    P.tekst(lx, ky, f'Prostori na listu: {len(prostori)}; s nazivom u crtežu {len(prostori) - len(brojevi)}, '
                    f's brojem {len(brojevi)}', 9.5, '#111111', bold=True)
    P.tekst(lx, ky + 12, 'Površina je cijelog prostora (i dijela izvan lista); kota ako odstupa od razine.',
            7, '#555555')
    popis(P, r, prostori, brojevi, lx, ky + 28, lw, Y0 + MH - 4)
    return P, len(prostori), len(brojevi)


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__.split('\n\n')[0])
    ap.add_argument('--program', default=str(KORIJEN / 'research' / 'viz' / 'program.json'))
    ap.add_argument('--site', default=str(KORIJEN / 'research' / 'viz' / 'site.json'))
    ap.add_argument('--out', default=str(Path(__file__).resolve().parent / 'zone'))
    a = ap.parse_args(argv)
    m = A.Model(A.ucitaj_json(a.program))
    site = A.Site(a.site)
    out = Path(a.out)
    out.mkdir(parents=True, exist_ok=True)
    for f in out.glob('zona_*.*'):
        f.unlink()
    ukupno = 0
    for r in m.razine:
        g = unary_union([s['geom'] for s in m.prostori_razine(r['id']) if s['geom'] is not None])
        oks = okviri(g)
        vidjeni = set()
        for k, ((j, i, ny, nx), okv) in enumerate(oks, 1):
            P, n_pr, n_br = list_zone(m, r, site, okv, naziv_okvira(j, i, ny, nx), k, len(oks), a.program)
            ime = f'zona_{r["id"]}_{k}'
            (out / f'{ime}.svg').write_text(P.svg(), encoding='utf-8')
            P.png(out / f'{ime}.png')
            vidjeni |= {x['id'] for x in m.prostori_razine(r['id'])
                        if x['geom'] is not None and x['geom'].intersection(box(*okv)).area > 1.0}
            ukupno += 1
            print(f'{ime}: {n_pr} prostora, {n_br} s brojem')
        sve = {x['id'] for x in m.prostori_razine(r['id']) if x['geom'] is not None}
        if sve - vidjeni:
            print(f'UPOZORENJE razina {r["id"]}: prostori izvan svih listova: {", ".join(sorted(sve - vidjeni))}')
    print(f'Listova: {ukupno}; mjerilo 1 : {MJERILO:.0f} na A3; mapa: {out}')


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