#!/usr/bin/env python3
"""MacLustr node pages — live metrics + maintenance schedule.
Stdlib only (Python 3.9+). Runs on m2u64, serves http://0.0.0.0:8003.
Each node label QR -> https://node.maclustr.io/<slug>."""
import json, os, subprocess, threading, time, html
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import urlparse

HERE = os.path.dirname(os.path.abspath(__file__))
PORT = 8003
SELF_SLUG = "m2u64"          # this server runs ON m2u64 -> collect locally
KEY = os.path.expanduser("~/.ssh/id_ed25519")
MAINT_FILE = os.path.join(HERE, "maintenance.json")

NODES = json.load(open(os.path.join(HERE, "nodes.json")))
BY_SLUG = {n["slug"]: n for n in NODES}

# recurring maintenance schedule (checklist) — (title, frequency, detail)
TASKS = [
    ("Dust / ventilation cleaned", "Quarterly",
     "Blow out vents & fans, clear dust from intakes and exhaust grilles."),
    ("macOS updated", "Monthly",
     "Install latest security + OS updates; reboot if the installer requires it."),
    ("Disk space checked (>15% free)", "Monthly",
     "Verify the boot volume keeps >15% free; purge caches/old logs if low."),
    ("Scheduled reboot performed", "Monthly",
     "Clean reboot to clear memory pressure and apply pending updates."),
    ("SSH / network connectivity tested", "Monthly",
     "Confirm SSH key login, ping, and tunnel / ngrok reachability."),
    ("Backup / Time Machine verified", "Weekly",
     "Confirm the last backup completed and a test file restores correctly."),
    ("Temperatures / throttling checked", "Quarterly",
     "Check pmset therm and Activity Monitor for sustained thermal throttling."),
    ("Cabling & power inspected", "Quarterly",
     "Inspect power / USB / Ethernet cables, UPS, and surge protection."),
    ("System logs reviewed (Console)", "Monthly",
     "Scan Console for kernel panics, repeated errors, hardware warnings."),
    ("External SSD health checked", "Quarterly",
     "Review SMART status and free space on attached external SSDs."),
]

# dropdown vocabularies for the maintenance form
STATUS_OPTS = [
    ("", "— Set status —"),
    ("done", "✅ Done"),
    ("progress", "🔧 In progress"),
    ("scheduled", "📅 Scheduled"),
    ("skip", "⏭️ N/A · Skipped"),
    ("attention", "⚠️ Needs attention"),
    ("failed", "❌ Failed"),
]
STATUS_COLOR = {
    "done": "#16a34a", "progress": "#2563eb", "scheduled": "#7c3aed",
    "skip": "#9ca3af", "attention": "#d97706", "failed": "#dc2626", "": "transparent",
}
CONDITION_OPTS = [
    ("", "— Overall condition —"),
    ("excellent", "🟢 Excellent"),
    ("good", "🟢 Good"),
    ("fair", "🟡 Fair"),
    ("poor", "🟠 Poor — service soon"),
    ("critical", "🔴 Needs service now"),
]
BY_SUGGEST = ["SPB", "Remote", "On-site"]   # datalist suggestions for "performed by"
STATUS_LABEL = {v: lbl for v, lbl in STATUS_OPTS}
CONDITION_LABEL = {v: lbl for v, lbl in CONDITION_OPTS}

# ---- live metrics collector (runs on the target node) ----
COLLECT = r'''
PAGESIZE=$(sysctl -n hw.pagesize 2>/dev/null || echo 16384)
CPULINE=$(top -l 2 -n 0 2>/dev/null | grep "CPU usage" | tail -1)
USR=$(echo "$CPULINE" | sed -E 's/.*: ([0-9.]+)% user.*/\1/')
SYS=$(echo "$CPULINE" | sed -E 's/.*user, ([0-9.]+)% sys.*/\1/')
IDLE=$(echo "$CPULINE" | sed -E 's/.*[, ]([0-9.]+)% idle.*/\1/')
NCPU=$(sysctl -n hw.ncpu 2>/dev/null)
LOAD=$(sysctl -n vm.loadavg 2>/dev/null | tr -d '{}')
MEMTOTAL=$(sysctl -n hw.memsize 2>/dev/null)
VM=$(vm_stat 2>/dev/null)
g(){ echo "$VM" | awk -F: "/$1/{gsub(/[^0-9]/,\"\",\$2); print \$2}"; }
ACTIVE=$(g "Pages active"); WIRED=$(g "Pages wired down"); COMP=$(g "Pages occupied by compressor")
FREE=$(g "Pages free"); SPEC=$(g "Pages speculative")
DF=$(df -k / 2>/dev/null | awk 'NR==2{print $2","$3","$4","$5}')
SWAPT=$(sysctl -n vm.swapusage 2>/dev/null | sed -E 's/.*total = ([0-9.]+)M.*/\1/')
SWAPU=$(sysctl -n vm.swapusage 2>/dev/null | sed -E 's/.*used = ([0-9.]+)M.*/\1/')
UP=$(uptime | sed -E 's/^.*up *//; s/, *[0-9]+ users?.*//; s/, *load.*//')
BOOT=$(sysctl -n kern.boottime 2>/dev/null | sed -E 's/.*sec = ([0-9]+).*/\1/')
NPROC=$(ps -A 2>/dev/null | wc -l | tr -d ' ')
TOP=$(ps -Aceo pcpu,comm -r 2>/dev/null | awk 'NR>1 && NR<=6{printf "%s|%s;", $1, $2}')
TOPMEM=$(ps -Aceo rss,comm -m 2>/dev/null | awk 'NR>1 && NR<=6{printf "%s|%s;", $1, $2}')
IP=$(ipconfig getifaddr en0 2>/dev/null || ipconfig getifaddr en1 2>/dev/null)
THERM=$(pmset -g therm 2>/dev/null | sed -nE 's/.*CPU_Speed_Limit = ([0-9]+).*/\1/p')
BATT=$(pmset -g batt 2>/dev/null | grep -oE '[0-9]+%' | head -1)
OSV=$(sw_vers -productVersion 2>/dev/null)
BUILD=$(sw_vers -buildVersion 2>/dev/null)
printf "USR=%s\nSYS=%s\nIDLE=%s\nNCPU=%s\nLOAD=%s\nMEMTOTAL=%s\nPAGESIZE=%s\nACTIVE=%s\nWIRED=%s\nCOMP=%s\nFREE=%s\nSPEC=%s\nDF=%s\nSWAPT=%s\nSWAPU=%s\nUPTIME=%s\nBOOT=%s\nNPROC=%s\nTOP=%s\nTOPMEM=%s\nIP=%s\nTHERM=%s\nBATT=%s\nOSV=%s\nBUILD=%s\n" \
 "$USR" "$SYS" "$IDLE" "$NCPU" "$LOAD" "$MEMTOTAL" "$PAGESIZE" "$ACTIVE" "$WIRED" "$COMP" "$FREE" "$SPEC" "$DF" "$SWAPT" "$SWAPU" "$UP" "$BOOT" "$NPROC" "$TOP" "$TOPMEM" "$IP" "$THERM" "$BATT" "$OSV" "$BUILD"
'''

_cache = {}
_cache_lock = threading.Lock()
TTL = 4

def _run(slug, node):
    if slug == SELF_SLUG:
        cmd = ["bash", "-c", COLLECT]; inp = None
    else:
        cmd = ["ssh", "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=no",
               "-o", "UserKnownHostsFile=/dev/null", "-o", "ConnectTimeout=8",
               "-i", KEY, node["fqdn"], "bash -s"]; inp = COLLECT
    try:
        p = subprocess.run(cmd, input=inp, capture_output=True, text=True, timeout=20)
        if p.returncode != 0:
            return {"online": False, "error": (p.stderr or "ssh failed").strip()[:200]}
        kv = {}
        for line in p.stdout.splitlines():
            if "=" in line:
                k, v = line.split("=", 1); kv[k] = v
        return _parse(kv)
    except subprocess.TimeoutExpired:
        return {"online": False, "error": "timeout"}
    except Exception as e:
        return {"online": False, "error": str(e)[:200]}

def _f(x, d=0.0):
    try: return float(x)
    except: return d

def _procs(s):
    out = []
    for chunk in (s or "").split(";"):
        if "|" in chunk:
            a, b = chunk.split("|", 1); out.append((a, b))
    return out

def _parse(kv):
    pg = _f(kv.get("PAGESIZE"), 16384)
    memtot = _f(kv.get("MEMTOTAL"))
    app = _f(kv.get("ACTIVE")) * pg
    wired = _f(kv.get("WIRED")) * pg
    comp = _f(kv.get("COMP")) * pg
    used = app + wired + comp
    idle = _f(kv.get("IDLE"))
    df = (kv.get("DF") or "0,0,0,0%").split(",")
    dtot = _f(df[0]) * 1024 if len(df) > 0 else 0
    dused = _f(df[1]) * 1024 if len(df) > 1 else 0
    dfree = _f(df[2]) * 1024 if len(df) > 2 else 0
    dpct = _f("".join(ch for ch in (df[3] if len(df) > 3 else "0") if ch.isdigit() or ch == "."))
    load = (kv.get("LOAD") or "").split()
    g = lambda b: round(b / 1e9, 1)
    topcpu = [{"v": a, "name": b} for a, b in _procs(kv.get("TOP"))][:5]
    topmem = [{"v": str(round(_f(a) / 1024)), "name": b} for a, b in _procs(kv.get("TOPMEM"))][:5]
    therm = kv.get("THERM", "")
    return {
        "online": True,
        "cpu_pct": round(max(0.0, min(100.0, 100.0 - idle)), 1),
        "cpu_user": round(_f(kv.get("USR")), 1),
        "cpu_sys": round(_f(kv.get("SYS")), 1),
        "ncpu": kv.get("NCPU", "?"),
        "mem_pct": round(used / memtot * 100, 1) if memtot else 0,
        "mem_used_gb": g(used), "mem_total_gb": g(memtot),
        "mem_app_gb": g(app), "mem_wired_gb": g(wired), "mem_comp_gb": g(comp),
        "disk_pct": round(dpct, 1),
        "disk_used_gb": g(dused), "disk_free_gb": g(dfree), "disk_total_gb": g(dtot),
        "load": load[:3],
        "swap_used": kv.get("SWAPU", "0"), "swap_total": kv.get("SWAPT", "0"),
        "uptime": (kv.get("UPTIME") or "?").strip(),
        "nproc": kv.get("NPROC", "?"),
        "osv": kv.get("OSV", "?"), "build": kv.get("BUILD", "?"),
        "ip": kv.get("IP", ""),
        "batt": kv.get("BATT", ""),
        "thermal": "Throttled (" + therm + "%)" if (therm and therm != "100") else ("Nominal" if therm else ""),
        "topcpu": topcpu, "topmem": topmem,
        "ts": int(time.time()),
    }

def live(slug):
    node = BY_SLUG[slug]; now = time.time()
    with _cache_lock:
        c = _cache.get(slug)
        if c and now - c[0] < TTL:
            return c[1]
    data = _run(slug, node)
    with _cache_lock:
        _cache[slug] = (now, data)
    return data

# ---- maintenance persistence ----
_maint_lock = threading.Lock()
def load_maint():
    try: return json.load(open(MAINT_FILE))
    except: return {}
def save_maint(d):
    with _maint_lock:
        json.dump(d, open(MAINT_FILE, "w"), indent=2)
def get_maint(slug):
    return load_maint().get(slug, {"tasks": {}, "next": "", "log": "",
                                   "condition": "", "inspected_by": "", "reports": []})

def _build_report(payload, when):
    """Snapshot of what was done at save time -> a dated maintenance report."""
    tasks = payload.get("tasks", {}) or {}
    items = []
    for i, (title, fr, det) in enumerate(TASKS):
        t = tasks.get(str(i)) or tasks.get(i) or {}
        status = t.get("status") or ("done" if t.get("done") else "")
        if status or t.get("note") or t.get("date"):
            items.append({"title": title, "status": status,
                          "date": t.get("date", ""), "by": t.get("by", ""),
                          "note": t.get("note", "")})
    return {"at": when, "by": payload.get("inspected_by", ""),
            "condition": payload.get("condition", ""),
            "next": payload.get("next", ""), "log": payload.get("log", ""),
            "items": items}

def set_maint(slug, payload):
    d = load_maint()
    now = time.strftime("%Y-%m-%d %H:%M")
    prev = d.get(slug, {})
    reports = list(prev.get("reports", []))
    reports.insert(0, _build_report(payload, now))   # newest first
    reports = reports[:60]                            # keep last 60 reports
    d[slug] = {"tasks": payload.get("tasks", {}), "next": payload.get("next", ""),
               "log": payload.get("log", ""),
               "condition": payload.get("condition", ""),
               "inspected_by": payload.get("inspected_by", ""),
               "reports": reports,
               "saved_at": now}
    save_maint(d); return d[slug]

def esc(s): return html.escape(str(s))

CSS = """
:root{--bg:#f2f3f7;--card:#fff;--ink:#1d1d1f;--mut:#6b7280;--line:#e6e8ef;--acc:#7c3aed;
--green:#16a34a;--amber:#d97706;--red:#dc2626;--shadow:0 1px 3px rgba(16,24,40,.06),0 1px 2px rgba(16,24,40,.04)}
*{box-sizing:border-box;margin:0;padding:0}
html{-webkit-text-size-adjust:100%}
body{font-family:-apple-system,BlinkMacSystemFont,"SF Pro Text",Helvetica,Arial,sans-serif;background:var(--bg);color:var(--ink);line-height:1.5;-webkit-font-smoothing:antialiased}
a{color:var(--acc);text-decoration:none}
.wrap{max-width:1080px;margin:0 auto;padding:18px 16px 64px}
.bar-top{display:flex;align-items:center;gap:12px;margin-bottom:18px}
.bar-top .logo{width:42px;height:42px;border-radius:11px;box-shadow:var(--shadow)}
.bar-top .brand{font-weight:800;letter-spacing:.4px;font-size:13px;color:var(--mut)}
.bar-top .back{margin-left:auto;font-size:13px;font-weight:600;color:var(--mut)}
.hero{background:var(--card);border:1px solid var(--line);border-radius:18px;padding:20px 22px;box-shadow:var(--shadow);
display:flex;align-items:center;gap:16px;flex-wrap:wrap}
.hero h1{font-size:clamp(34px,9vw,58px);font-weight:850;letter-spacing:-1.5px;line-height:1}
.hero .meta{color:var(--mut);font-size:14px;margin-top:6px}
.badge{padding:7px 16px;border-radius:10px;color:#fff;font-weight:800;font-size:16px;margin-left:auto}
.chiptag{display:inline-block;background:#111;color:#fff;font-weight:800;font-size:13px;padding:4px 12px;border-radius:8px;margin-top:8px}
.status{display:flex;align-items:center;gap:8px;margin:26px 2px 12px;font-size:13px;color:var(--mut)}
.dot{width:10px;height:10px;border-radius:50%;background:#9ca3af;display:inline-block}
.dot.on{background:var(--green);box-shadow:0 0 0 4px rgba(22,163,74,.15)}
.dot.off{background:var(--red);box-shadow:0 0 0 4px rgba(220,38,38,.15)}
h2{font-size:13px;font-weight:800;text-transform:uppercase;letter-spacing:1px;color:var(--mut);margin:30px 4px 12px}
.grid{display:grid;gap:12px}
.g-metric{grid-template-columns:repeat(auto-fit,minmax(160px,1fr))}
.g-spec{grid-template-columns:repeat(auto-fit,minmax(150px,1fr))}
.g-two{grid-template-columns:1fr 1fr}
@media(max-width:560px){.g-two{grid-template-columns:1fr}}
.card{background:var(--card);border:1px solid var(--line);border-radius:14px;padding:15px 16px;box-shadow:var(--shadow)}
.k{font-size:11px;font-weight:800;letter-spacing:.6px;text-transform:uppercase;color:var(--mut)}
.v{font-size:30px;font-weight:850;margin-top:4px;font-variant-numeric:tabular-nums}
.v small{font-size:14px;color:var(--mut);font-weight:700}
.sub{color:var(--mut);font-size:12.5px;margin-top:3px}
.bar{height:8px;border-radius:5px;background:#eceef4;overflow:hidden;margin-top:10px}
.bar>i{display:block;height:100%;border-radius:5px;width:0;transition:width .6s ease}
.row{display:flex;justify-content:space-between;font-size:13.5px;padding:7px 0;border-bottom:1px solid var(--line)}
.row:last-child{border-bottom:0}
.row b{font-weight:700}
.proc{display:flex;justify-content:space-between;font-size:13px;padding:5px 0;border-bottom:1px solid var(--line);font-variant-numeric:tabular-nums}
.proc:last-child{border-bottom:0}
.proc .nm{color:var(--ink);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:72%}
.proc .pc{color:var(--mut);font-weight:700}
.mwrap{background:var(--card);border:1px solid var(--line);border-radius:14px;box-shadow:var(--shadow);overflow:hidden}
.mhead{display:grid;grid-template-columns:150px 1fr 140px 130px 1.1fr;gap:12px;padding:11px 16px;border-bottom:1px solid var(--line);
background:#fafafe;font-size:10.5px;font-weight:800;letter-spacing:.6px;text-transform:uppercase;color:var(--mut)}
.mrow{display:grid;grid-template-columns:150px 1fr 140px 130px 1.1fr;gap:12px;align-items:start;padding:12px 16px;border-bottom:1px solid var(--line);border-left:4px solid transparent;transition:border-left-color .25s}
.mrow:last-child{border-bottom:0}
.mrow .t{font-weight:600;font-size:14.5px}
.mrow .freq{display:inline-block;font-size:10px;color:var(--acc);font-weight:800;text-transform:uppercase;letter-spacing:.4px;background:rgba(124,58,237,.09);padding:2px 7px;border-radius:6px;margin-top:4px}
.mrow .det{font-size:12px;color:var(--mut);margin-top:5px;line-height:1.4}
@media(max-width:620px){.mhead{display:none}.mrow{grid-template-columns:1fr;row-gap:9px}}
input[type=checkbox]{width:22px;height:22px;accent-color:var(--green);cursor:pointer}
input[type=date],input[type=text],textarea,select{background:#fbfbfd;border:1px solid #d8dbe6;color:var(--ink);border-radius:9px;padding:9px 10px;font-size:14px;width:100%;font-family:inherit}
input:focus,textarea:focus,select:focus{outline:none;border-color:var(--acc);box-shadow:0 0 0 3px rgba(124,58,237,.12)}
textarea{min-height:80px;resize:vertical}
select{-webkit-appearance:none;appearance:none;cursor:pointer;padding-right:30px;
background-image:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='12' height='8' viewBox='0 0 12 8'><path d='M1 1l5 5 5-5' fill='none' stroke='%236b7280' stroke-width='1.8' stroke-linecap='round'/></svg>");
background-repeat:no-repeat;background-position:right 11px center}
.savebar{display:flex;align-items:center;gap:14px;margin-top:16px;flex-wrap:wrap}
.btn{background:var(--acc);color:#fff;border:0;border-radius:11px;padding:13px 26px;font-weight:800;font-size:15px;cursor:pointer;box-shadow:var(--shadow)}
.btn:active{transform:translateY(1px)}
.saved{color:var(--green);font-weight:700;opacity:0;transition:opacity .3s}
.muted{color:var(--mut);font-size:13px}
.rcard{background:var(--card);border:1px solid var(--line);border-radius:14px;padding:14px 16px;box-shadow:var(--shadow);margin-bottom:12px}
.rhead{display:flex;align-items:center;gap:10px;flex-wrap:wrap;padding-bottom:10px;margin-bottom:10px;border-bottom:1px solid var(--line)}
.rhead b{font-size:15px;font-variant-numeric:tabular-nums}
.rby{font-size:12.5px;color:var(--mut);font-weight:700}
.rcond{margin-left:auto;font-size:12.5px;font-weight:800;background:#f4f4fb;border:1px solid var(--line);padding:3px 10px;border-radius:8px}
.ritem{display:flex;align-items:center;gap:9px;flex-wrap:wrap;padding:7px 0;border-bottom:1px dashed var(--line)}
.ritem:last-child{border-bottom:0}
.ritem .rt{font-size:13.5px;font-weight:600}
.ritem .rd{font-size:12px;color:var(--mut);font-variant-numeric:tabular-nums}
.ritem .rb{font-size:12px;color:var(--mut);font-weight:700}
.ritem .rn{flex-basis:100%;font-size:12.5px;color:var(--mut);padding-left:2px}
.schip{font-size:11px;font-weight:800;padding:2px 9px;border-radius:7px;white-space:nowrap}
.rlog{margin-top:10px;font-size:13px;color:var(--ink);background:#fafafe;border:1px solid var(--line);border-radius:9px;padding:9px 11px;white-space:pre-wrap}
.rnext{margin-top:8px;font-size:12.5px;color:var(--acc);font-weight:700}
.foot{margin-top:34px;color:var(--mut);font-size:12px;text-align:center}
"""

def node_page(n):
    slug = n["slug"]; tc = n["tcolor"]
    storage = f'{n["internal"]} SSD' + (f' + {n["external"]} external' if n["external"] else "")
    status_opts = "".join(f'<option value="{esc(v)}">{esc(lbl)}</option>' for v, lbl in STATUS_OPTS)
    rows = "".join(
        f'<div class="mrow">'
        f'<select data-i="{i}" class="mstatus" onchange="colorRow(this)">{status_opts}</select>'
        f'<div><div class="t">{esc(t)}</div><span class="freq">{esc(fr)}</span>'
        f'<div class="det">{esc(det)}</div></div>'
        f'<input type="date" data-i="{i}" class="md mdate">'
        f'<input type="text" data-i="{i}" class="mby" list="bylist" placeholder="performed by">'
        f'<input type="text" data-i="{i}" class="mn mnote" placeholder="note">'
        f'</div>'
        for i, (t, fr, det) in enumerate(TASKS))
    cond_opts = "".join(f'<option value="{esc(v)}">{esc(lbl)}</option>' for v, lbl in CONDITION_OPTS)
    by_datalist = "".join(f'<option value="{esc(b)}">' for b in BY_SUGGEST)
    return f"""<!doctype html><html lang="en"><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
<meta name="theme-color" content="#f2f3f7">
<title>{esc(n['alias'])} · MacLustr</title><style>{CSS}</style></head><body><div class="wrap">

<div class="bar-top"><img class="logo" src="/logo.svg" alt="">
<span class="brand">MACLUSTR · COMPUTE CLUSTER</span>
<a class="back" href="/">All nodes →</a></div>

<div class="hero">
  <div>
    <h1>{esc(n['alias'])}</h1>
    <div class="meta">{esc(n['fqdn'])} · {esc(n['model'])} ({esc(n['modelid'])})</div>
    <span class="chiptag">{esc(n['chip'])}</span>
  </div>
  <span class="badge" style="background:{tc}">{esc(n['tier'])}</span>
</div>

<div class="status"><span id="dot" class="dot"></span><span id="stattxt">Connecting…</span></div>
<div class="grid g-metric">
  <div class="card"><div class="k">CPU Load</div><div class="v"><span id="cpu">–</span><small>%</small></div>
    <div class="bar"><i id="cpubar" style="background:var(--acc)"></i></div>
    <div class="sub"><span id="cpuus">–</span>% user · <span id="cpusy">–</span>% sys · <span id="ncpu">–</span> cores</div></div>
  <div class="card"><div class="k">Memory</div><div class="v"><span id="mem">–</span><small>%</small></div>
    <div class="bar"><i id="membar" style="background:#2563eb"></i></div>
    <div class="sub"><span id="memu">–</span> / <span id="memt">–</span> GB used</div></div>
  <div class="card"><div class="k">Disk /</div><div class="v"><span id="disk">–</span><small>%</small></div>
    <div class="bar"><i id="diskbar" style="background:#0891b2"></i></div>
    <div class="sub"><span id="dfree">–</span> GB free of <span id="dtot">–</span> GB</div></div>
  <div class="card"><div class="k">Load Average</div><div class="v" style="font-size:24px" id="load">–</div>
    <div class="sub">1 / 5 / 15 min</div></div>
  <div class="card"><div class="k">Uptime</div><div class="v" style="font-size:20px" id="uptime">–</div>
    <div class="sub">processes: <span id="nproc">–</span></div></div>
  <div class="card"><div class="k">Health</div><div class="v" style="font-size:20px" id="health">–</div>
    <div class="sub">swap <span id="swap">–</span> · <span id="ipv">–</span></div></div>
</div>

<div class="grid g-two" style="margin-top:12px">
  <div class="card"><div class="k">Top processes — CPU</div><div id="topcpu" style="margin-top:8px"></div></div>
  <div class="card"><div class="k">Top processes — Memory</div><div id="topmem" style="margin-top:8px"></div></div>
</div>

<h2>Hardware specifications (capacity)</h2>
<div class="grid g-spec">
  <div class="card"><div class="k">CPU</div><div class="v">{n['ncpu']}<small> cores</small></div><div class="sub">{n['nperf']} performance + {n['neff']} efficiency</div></div>
  <div class="card"><div class="k">Memory</div><div class="v">{n['mem']}<small> GB</small></div><div class="sub">unified · {esc(n['bw'])}</div></div>
  <div class="card"><div class="k">GPU</div><div class="v">{n['gpu']}<small> cores</small></div></div>
  <div class="card"><div class="k">Neural Engine</div><div class="v">{n['ne']}<small> cores</small></div></div>
  <div class="card"><div class="k">Storage</div><div class="v" style="font-size:19px">{esc(storage)}</div></div>
  <div class="card"><div class="k">Tier · Role</div><div class="v" style="font-size:19px">{esc(n['tier'])} · {esc(n['role'])}</div></div>
</div>

<h2>System</h2>
<div class="card">
  <div class="row"><span>macOS</span><b><span id="s_os">{esc(n['osv'])}</span> (<span id="s_build">{esc(n['build'])}</span>)</b></div>
  <div class="row"><span>Model identifier</span><b>{esc(n['modelid'])}</b></div>
  <div class="row"><span>Serial number</span><b>{esc(n['serial'])}</b></div>
  <div class="row"><span>Local IP</span><b id="s_ip">–</b></div>
  <div class="row"><span>Hostname</span><b>{esc(n['fqdn'])}</b></div>
</div>

<h2>Maintenance schedule</h2>
<p class="muted" style="margin:0 4px 12px">Set a status from the dropdown, the date it was done, who performed it, and a note. Saved on m2u64 — shared with everyone who opens this page.</p>
<datalist id="bylist">{by_datalist}</datalist>
<div class="mwrap">
  <div class="mhead"><span>Status</span><span>Task</span><span>Date</span><span>By</span><span>Note</span></div>
  {rows}
</div>
<div class="grid g-spec" style="margin-top:12px">
  <div class="card"><div class="k">Overall condition</div><select id="cond" style="margin-top:9px">{cond_opts}</select></div>
  <div class="card"><div class="k">Inspected by</div><input type="text" id="by_all" list="bylist" placeholder="name / initials" style="margin-top:9px"></div>
  <div class="card"><div class="k">Next maintenance due</div><input type="date" id="next" style="margin-top:9px"></div>
</div>
<div class="card" style="margin-top:12px"><div class="k">Log / notes</div><textarea id="log" placeholder="Notes, incidents, parts replaced…" style="margin-top:9px"></textarea></div>
<div class="savebar"><button class="btn" onclick="saveM()">Submit maintenance report</button>
  <span class="saved" id="saved">Saved ✓</span><span class="muted" id="savedat"></span></div>

<h2>Maintenance reports <span id="repcount" class="muted" style="font-weight:700;text-transform:none;letter-spacing:0"></span></h2>
<p class="muted" style="margin:0 4px 12px">Every time you submit, a dated report of what was done is added here.</p>
<div id="reports"></div>

<div class="foot">MacLustr node page · auto-refreshes every 5s · <a href="/">cluster overview</a></div>
</div>
<script>
const SLUG="{slug}";
const $=id=>document.getElementById(id);
function bar(id,p){{const e=$(id);e.style.width=Math.min(100,p)+'%';
  e.style.background=p>90?'var(--red)':p>75?'var(--amber)':e.dataset.c||e.style.background;
  if(!e.dataset.c)e.dataset.c=e.style.background;}}
function plist(el,arr,unit){{el.innerHTML=(arr||[]).map(p=>
  `<div class="proc"><span class="nm">${{p.name}}</span><span class="pc">${{p.v}}${{unit}}</span></div>`).join('')||'<div class="muted">—</div>';}}
async function refresh(){{
 try{{const d=await (await fetch('/api/'+SLUG+'/live')).json();
  if(!d.online){{$('dot').className='dot off';$('stattxt').textContent='Offline — '+(d.error||'no response');return;}}
  $('dot').className='dot on';
  $('cpu').textContent=d.cpu_pct;bar('cpubar',d.cpu_pct);$('cpuus').textContent=d.cpu_user;$('cpusy').textContent=d.cpu_sys;$('ncpu').textContent=d.ncpu;
  $('mem').textContent=d.mem_pct;bar('membar',d.mem_pct);$('memu').textContent=d.mem_used_gb;$('memt').textContent=d.mem_total_gb;
  $('disk').textContent=d.disk_pct;bar('diskbar',d.disk_pct);$('dfree').textContent=d.disk_free_gb;$('dtot').textContent=d.disk_total_gb;
  $('load').textContent=(d.load||[]).join('  ');
  $('uptime').textContent=d.uptime;$('nproc').textContent=d.nproc;
  $('health').textContent=d.thermal||'OK';
  $('swap').textContent=d.swap_used+'M';$('ipv').textContent=d.ip||'';
  $('s_ip').textContent=d.ip||'–';$('s_os').textContent=d.osv;$('s_build').textContent=d.build;
  plist($('topcpu'),d.topcpu,'%');plist($('topmem'),d.topmem,' MB');
  $('stattxt').textContent='Live · updated '+new Date(d.ts*1000).toLocaleTimeString();
 }}catch(e){{$('dot').className='dot off';$('stattxt').textContent='Connection error';}}
}}
const SCOLOR={json.dumps(STATUS_COLOR)};
const SLABEL={json.dumps(STATUS_LABEL)};
const CLABEL={json.dumps(CONDITION_LABEL)};
function esc(s){{return (s==null?'':String(s)).replace(/[&<>"]/g,c=>({{'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}}[c]));}}
function colorRow(sel){{const r=sel.closest('.mrow');if(r)r.style.borderLeftColor=SCOLOR[sel.value]||'transparent';}}
function statusChip(s){{const c=SCOLOR[s]||'#9ca3af';const l=SLABEL[s]||'—';
 return `<span class="schip" style="background:${{c}}1f;color:${{c}};border:1px solid ${{c}}55">${{esc(l)}}</span>`;}}
function renderReports(reps){{const el=$('reports'),cn=$('repcount');reps=reps||[];
 cn.textContent=reps.length?`· ${{reps.length}} on record`:'';
 if(!reps.length){{el.innerHTML='<p class="muted" style="margin:4px">No maintenance reports yet — submit one above.</p>';return;}}
 el.innerHTML=reps.map(r=>{{
  const items=(r.items||[]).map(it=>
    `<div class="ritem">${{statusChip(it.status)}}<span class="rt">${{esc(it.title)}}</span>`+
    (it.date?`<span class="rd">${{esc(it.date)}}</span>`:'')+
    (it.by?`<span class="rb">· ${{esc(it.by)}}</span>`:'')+
    (it.note?`<div class="rn">“${{esc(it.note)}}”</div>`:'')+`</div>`
   ).join('')||'<div class="muted" style="padding:6px 0">No tasks were marked in this report.</div>';
  const cond=r.condition?`<span class="rcond">${{esc(CLABEL[r.condition]||r.condition)}}</span>`:'';
  return `<div class="rcard"><div class="rhead"><b>${{esc(r.at)}}</b>`+
   (r.by?`<span class="rby">by ${{esc(r.by)}}</span>`:'')+cond+`</div>`+items+
   (r.log?`<div class="rlog">${{esc(r.log)}}</div>`:'')+
   (r.next?`<div class="rnext">Next maintenance due: ${{esc(r.next)}}</div>`:'')+`</div>`;
 }}).join('');}}
async function loadM(){{const d=await (await fetch('/api/'+SLUG+'/maintenance')).json();const t=d.tasks||{{}};
 document.querySelectorAll('.mstatus').forEach(c=>{{const v=t[c.dataset.i]||{{}};
   c.value=v.status||(v.done?'done':'');colorRow(c);}});
 document.querySelectorAll('.mdate').forEach(c=>c.value=(t[c.dataset.i]||{{}}).date||'');
 document.querySelectorAll('.mby').forEach(c=>c.value=(t[c.dataset.i]||{{}}).by||'');
 document.querySelectorAll('.mnote').forEach(c=>c.value=(t[c.dataset.i]||{{}}).note||'');
 $('next').value=d.next||'';$('log').value=d.log||'';
 $('cond').value=d.condition||'';$('by_all').value=d.inspected_by||'';
 renderReports(d.reports);
 if(d.saved_at)$('savedat').textContent='last saved '+d.saved_at;}}
async function saveM(){{const tasks={{}};
 document.querySelectorAll('.mstatus').forEach(c=>tasks[c.dataset.i]={{status:c.value,done:c.value==='done'}});
 document.querySelectorAll('.mdate').forEach(c=>tasks[c.dataset.i].date=c.value);
 document.querySelectorAll('.mby').forEach(c=>tasks[c.dataset.i].by=c.value);
 document.querySelectorAll('.mnote').forEach(c=>tasks[c.dataset.i].note=c.value);
 const d=await (await fetch('/api/'+SLUG+'/maintenance',{{method:'POST',headers:{{'Content-Type':'application/json'}},
  body:JSON.stringify({{tasks,next:$('next').value,log:$('log').value,
   condition:$('cond').value,inspected_by:$('by_all').value}})}})).json();
 renderReports(d.reports);
 const s=$('saved');s.style.opacity=1;setTimeout(()=>s.style.opacity=0,1800);
 if(d.saved_at)$('savedat').textContent='last saved '+d.saved_at;}}
refresh();loadM();setInterval(refresh,5000);
</script></body></html>"""

def index_page():
    tc = sum(n["ncpu"] for n in NODES); tg = sum(n["gpu"] for n in NODES); tr = sum(n["mem"] for n in NODES)
    cards = "".join(
        f'<a class="card" style="display:block;color:inherit" href="/{n["slug"]}">'
        f'<div style="display:flex;align-items:center;gap:8px"><span class="dot" id="d_{n["slug"]}"></span>'
        f'<b style="font-size:19px">{esc(n["alias"])}</b>'
        f'<span class="badge" style="background:{n["tcolor"]};font-size:11px;padding:3px 9px;margin-left:auto">{esc(n["tier"])}</span></div>'
        f'<div class="sub" style="margin-top:7px">{esc(n["chip"])}</div>'
        f'<div class="sub">{n["ncpu"]} cores · {n["mem"]} GB · {n["gpu"]} GPU</div>'
        f'<div class="sub" id="s_{n["slug"]}" style="margin-top:7px;font-variant-numeric:tabular-nums">CPU – · MEM –</div>'
        f'</a>'
        for n in NODES)
    return f"""<!doctype html><html lang="en"><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
<meta name="theme-color" content="#f2f3f7"><title>MacLustr · Cluster</title><style>{CSS}</style></head><body><div class="wrap">
<div class="bar-top"><img class="logo" src="/logo.svg"><span class="brand">MACLUSTR</span></div>
<div class="hero"><div><h1 style="font-size:42px">Cluster</h1>
<div class="meta">{len(NODES)} nodes · {tc} CPU cores · {tr} GB RAM · {tg} GPU cores</div></div></div>
<h2>Nodes</h2>
<div class="grid g-spec">{cards}</div>
<div class="foot">Scan a label QR to open a node's live page.</div>
</div><script>
const S={json.dumps([n["slug"] for n in NODES])},$=id=>document.getElementById(id);
async function poll(s){{try{{const d=await (await fetch('/api/'+s+'/live')).json();
 const dot=$('d_'+s),t=$('s_'+s);
 if(d.online){{dot.className='dot on';t.textContent='CPU '+d.cpu_pct+'% · MEM '+d.mem_pct+'%';}}
 else{{dot.className='dot off';t.textContent='offline';}}}}catch(e){{}}}}
function all(){{S.forEach((s,i)=>setTimeout(()=>poll(s),i*100));}}
all();setInterval(all,8000);
</script></body></html>"""

LOGO_PATH = os.path.join(HERE, "logo.svg")
LOGO = open(LOGO_PATH).read() if os.path.exists(LOGO_PATH) else "<svg/>"

class H(BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def _send(self, code, body, ctype="text/html; charset=utf-8"):
        b = body.encode() if isinstance(body, str) else body
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(b)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        try: self.wfile.write(b)
        except (BrokenPipeError, ConnectionResetError): pass
    def do_GET(self):
        path = urlparse(self.path).path.strip("/")
        if path == "": return self._send(200, index_page())
        if path in ("health", "healthz"): return self._send(200, "ok", "text/plain")
        if path == "logo.svg": return self._send(200, LOGO, "image/svg+xml")
        if path.startswith("api/"):
            parts = path.split("/")
            if len(parts) == 3 and parts[1].lower() in BY_SLUG:
                slug = parts[1].lower()
                if parts[2] == "live": return self._send(200, json.dumps(live(slug)), "application/json")
                if parts[2] == "maintenance": return self._send(200, json.dumps(get_maint(slug)), "application/json")
            return self._send(404, "{}", "application/json")
        if path.lower() in BY_SLUG: return self._send(200, node_page(BY_SLUG[path.lower()]))
        return self._send(404, "<h1>404</h1><p><a href='/'>cluster</a></p>")
    def do_POST(self):
        parts = urlparse(self.path).path.strip("/").split("/")
        if len(parts) == 3 and parts[0] == "api" and parts[2] == "maintenance" and parts[1].lower() in BY_SLUG:
            try:
                n = int(self.headers.get("Content-Length", 0))
                payload = json.loads(self.rfile.read(n) or b"{}")
                return self._send(200, json.dumps(set_maint(parts[1].lower(), payload)), "application/json")
            except Exception as e:
                return self._send(400, json.dumps({"error": str(e)}), "application/json")
        return self._send(404, "{}", "application/json")

if __name__ == "__main__":
    srv = ThreadingHTTPServer(("0.0.0.0", PORT), H)
    print(f"MacLustr node pages on :{PORT} ({len(NODES)} nodes, self={SELF_SLUG})")
    srv.serve_forever()