#!/usr/bin/env python3
import fcntl, argparse, time, subprocess, json, os, math, random
from datetime import datetime
from pathlib import Path
from PIL import Image

import psutil
import torch
from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler

BASE = Path("/home/pi/wunderkammer")
DIR_256 = BASE / "data" / "wunderkammer256"
DIR_64  = BASE / "data" / "wunderkammer64"
DIR_WEB = BASE / "data" / "prompt"

LOG_TSV     = DIR_WEB / "prompts.tsv"
INDEX_HTML  = DIR_WEB / "index.html"
HELP_HTML   = DIR_WEB / "help.html"
STATS_HTML  = DIR_WEB / "stats.html"
PROC_HTML   = DIR_WEB / "process.html"
STATUS_JSON = DIR_WEB / "status.json"
LOCKFILE    = BASE / ".gen.lock"

PROMPT_SCRIPT = BASE / "bin" / "prompt_wunderkammer.py"
VENV_PY = Path("/home/pi/pixel/.venv/bin/python")

BASE_POS = (
    "pixel art, wunderkammer object, single object centered, high contrast, "
    "no frame, no border, no panel, no split image, no collage, no text"
)

BASE_NEG = (
    "multiple objects, collage, diptych, triptych, split panel, comic, grid, "
    "frame, border, screenshot, UI, interface, caption, subtitle, text, letters, numbers, "
    "room, cabinet, shelf, display case, table, background clutter, "
    "blurry, low contrast, smooth gradients, watermark, signature, logo"
)

ASCII_GLYPHS = " .:-=+*#%@"

def ensure_dirs():
    DIR_256.mkdir(parents=True, exist_ok=True)
    DIR_64.mkdir(parents=True, exist_ok=True)
    DIR_WEB.mkdir(parents=True, exist_ok=True)

def downscale_dither(img: Image.Image, palette_colors: int = 32) -> Image.Image:
    small = img.resize((64, 64), resample=Image.LANCZOS)
    pal = small.convert("P", palette=Image.ADAPTIVE, colors=palette_colors, dither=Image.FLOYDSTEINBERG)
    return pal.convert("RGB")

def clean_tsv(s: str) -> str:
    return s.replace("\t", " ").replace("\n", " ").replace("\r", " ")

def now_stamp_human() -> str:
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def clamp_custom(raw: str, limit_chars: int = 260) -> str:
    """
    Keep custom prompts short enough to avoid CLIP truncation + ugly overprompting.
    - collapses whitespace
    - hard character limit
    """
    if raw is None:
        return ""
    txt = " ".join(raw.strip().split())
    if len(txt) > limit_chars:
        txt = txt[:limit_chars].rstrip()
    return txt

def write_status(payload: dict):
    tmp = STATUS_JSON.with_suffix(".json.tmp")
    tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    os.replace(tmp, STATUS_JSON)

def get_system_stats():
    cpu = psutil.cpu_percent(interval=None)
    load1, load5, load15 = os.getloadavg()
    vm = psutil.virtual_memory()
    du = psutil.disk_usage(str(BASE))

    temp_c = None
    try:
        out = subprocess.check_output(["vcgencmd", "measure_temp"], text=True).strip()
        if out.startswith("temp="):
            temp_c = float(out.split("=")[1].split("'")[0])
    except Exception:
        pass

    throttled = None
    try:
        throttled = subprocess.check_output(["vcgencmd", "get_throttled"], text=True).strip()
    except Exception:
        pass

    return {
        "cpu_percent": cpu,
        "load": {"1": load1, "5": load5, "15": load15},
        "mem": {"total": vm.total, "used": vm.used, "available": vm.available, "percent": vm.percent},
        "disk": {"total": du.total, "used": du.used, "free": du.free, "percent": du.percent, "path": str(BASE)},
        "temp_c": temp_c,
        "throttled": throttled,
        "ts": now_stamp_human(),
    }

def get_unique_prompt(seed: int) -> str:
    res = subprocess.run([str(VENV_PY), str(PROMPT_SCRIPT), "--seed", str(seed)], check=True, capture_output=True, text=True)
    return res.stdout.strip()

def shorten_unique_for_model(unique_prompt: str, max_chars: int = 140) -> str:
    # chars != tokens, so we keep this aggressively short
    if len(unique_prompt) <= max_chars:
        return unique_prompt
    parts = [p.strip() for p in unique_prompt.split(",")]
    out = []
    total = 0
    for p in parts:
        add = (", " if out else "") + p
        if total + len(add) > max_chars:
            break
        out.append(p)
        total += len(add)
    if len(out) < 3 and len(parts) >= 3:
        out = parts[:3]
    return ", ".join(out)

def make_ascii_block(seed: int, step: int, steps: int, prompt: str) -> list[str]:
    r = random.Random((seed ^ (step + 1) * 0x9E3779B97F4A7C15) & 0xFFFFFFFFFFFFFFFF)
    w = 44
    h = 10
    p = (step + 1) / max(1, steps)
    bar_n = int(p * w)
    bar = "[" + ("#" * bar_n).ljust(w) + "]"
    hx = f"{seed & 0xFFFFFFFF:08x}{(seed>>32) & 0xFFFFFFFF:08x}"
    hx2 = "".join(r.choice("0123456789abcdef") for _ in range(24))
    snip = prompt.strip()
    if len(snip) > 72:
        snip = snip[:69] + "…"

    lines = []
    lines.append(f"WK//GEN  step {step+1:02d}/{steps:02d}  p={p:0.2f}  id={hx}")
    lines.append(bar)
    lines.append(f"SIG {hx2}  Δt={r.randint(9,99)}ms  noise={int((1-p)*100):02d}")
    lines.append(f"PROMPT {snip}")
    lines.append("")
    for y in range(h):
        row = []
        for x in range(w):
            v = (math.sin((x + step) * 0.35) + math.cos((y + step) * 0.55)) * 0.5
            v += (r.random() - 0.5) * (1.0 - p)
            v = (v + 1) / 2
            idx = max(0, min(len(ASCII_GLYPHS)-1, int(v * (len(ASCII_GLYPHS)-1))))
            row.append(ASCII_GLYPHS[idx])
        lines.append("".join(row))
    return lines

def write_glitch_build_image(seed: int, step: int, steps: int):
    p = (step + 1) / max(1, steps)
    r = random.Random((seed + step*1337) & 0xFFFFFFFFFFFFFFFF)
    img = Image.new("RGB", (64, 64), (0, 0, 0))
    px = img.load()
    for y in range(64):
        for x in range(64):
            n = r.random()
            cx, cy = 32, 32
            d = math.sqrt((x-cx)**2 + (y-cy)**2) / 45.0
            shape = max(0.0, 1.0 - d)
            v = (0.65 * shape + 0.35 * n)
            v = v * p + n * (1.0 - p) * 0.35
            t = 0.5 + 0.15 * math.sin((x + step) * 0.6) * math.cos((y + step) * 0.4)
            on = v > t
            c = 255 if on else 0
            px[x, y] = (c, int(c * (0.8 + 0.2 * p)), int(c * (0.6 + 0.4 * p)))
    img.save(DIR_64 / "current_build.png")

def append_log(ts_human: str, seed: int, mode: str, unique_prompt: str, fname256: str, fname64: str):
    header = "timestamp\tseed\tmode\tepoch\tclass\tprompt\tfile_256\tfile_64\n"
    if not LOG_TSV.exists():
        LOG_TSV.write_text(header, encoding="utf-8")

    if mode == "custom":
        epoch, cls = "CUSTOM", "CUSTOM"
    else:
        parts = [p.strip() for p in unique_prompt.split(",")]
        epoch = parts[0] if len(parts) >= 1 else ""
        cls   = parts[1] if len(parts) >= 2 else ""

    line = (
        f"{clean_tsv(ts_human)}\t{seed}\t{clean_tsv(mode)}\t"
        f"{clean_tsv(epoch)}\t{clean_tsv(cls)}\t{clean_tsv(unique_prompt)}\t"
        f"{clean_tsv(fname256)}\t{clean_tsv(fname64)}\n"
    )
    with LOG_TSV.open("a", encoding="utf-8") as f:
        f.write(line)

def html_escape(s: str) -> str:
    return (s.replace("&","&amp;").replace("<","&lt;").replace(">","&gt;")
              .replace('"',"&quot;").replace("'","&#39;"))

def build_help_page():
    HELP_HTML.write_text(
        "<!doctype html><html><head><meta charset='utf-8'>"
        "<meta name='viewport' content='width=device-width,initial-scale=1'>"
        "<title>Help</title></head><body style='background:#070a0f;color:#d7e6ff;"
        "font-family:ui-monospace,Menlo,Consolas,monospace;padding:18px;line-height:1.35rem;'>"
        f"<h1 style='margin:0 0 10px 0;'>Wunderkammer — Help</h1>"
        f"<div style='color:#8aa2c7;font-size:12px;'>generated {now_stamp_human()}</div>"
        "<ul>"
        "<li><code>index.html</code> gallery + custom prompt</li>"
        "<li><code>process.html</code> generation visualizer (blinking squares)</li>"
        "<li><code>stats.html</code> classic stats w/ sparklines</li>"
        "</ul>"
        "</body></html>",
        encoding="utf-8"
    )

def build_stats_page():
    # keep your existing stats page (sparklines) – as a separate nice subpage
    # NOTE: no f-strings here.
    STATS_HTML.write_text(open_stats_template(), encoding="utf-8")

def build_process_page():
    # fancy CPU/MEM visualizer subpage (blinking BW squares)
    PROC_HTML.write_text(open_process_template(), encoding="utf-8")

def build_gallery(max_items: int = 500):
    if not LOG_TSV.exists():
        INDEX_HTML.write_text("<h1>No entries yet</h1>", encoding="utf-8")
        return

    lines = LOG_TSV.read_text(encoding="utf-8").splitlines()
    if len(lines) <= 1:
        INDEX_HTML.write_text("<h1>No entries yet</h1>", encoding="utf-8")
        return

    entries = lines[1:][-max_items:]
    entries.reverse()

    latest_ts = ""
    latest_seed = ""

    cards_html = []
    for idx, row in enumerate(entries):
        parts = row.split("\t")
        if len(parts) < 8:
            continue
        ts, seed_s, mode, epoch, cls, prompt, f256, f64 = parts[:8]
        prompt_text = prompt
        if idx == 0:
            latest_ts = ts
            latest_seed = seed_s

        img64_rel  = "../wunderkammer64/"  + html_escape(f64)
        img256_rel = "../wunderkammer256/" + html_escape(f256)

        badges = []
        if mode == "custom":
            badges.append("<span class='badge badgeCustom'>CUSTOM</span>")
        badges.append("<span class='badge'>seed " + html_escape(seed_s) + "</span>")
        badges.append("<span class='badge'>" + html_escape(epoch) + "</span>")
        badges.append("<span class='badge'>" + html_escape(cls) + "</span>")

        cards_html.append(
            "<article class='card' data-prompt='" + html_escape(prompt_text).lower() + "'>"
              "<div class='head'>"
                "<div class='lefthead'>"
                  "<div class='ts'>" + html_escape(ts) + "</div>"
                  "<div class='badges'>" + "".join(badges) + "</div>"
                "</div>"
                "<div class='links'>"
                  "<a href='" + img64_rel + "' target='_blank'>64×64</a>"
                  "<a href='" + img256_rel + "' target='_blank'>256×256</a>"
                "</div>"
              "</div>"
              "<div class='content'>"
                "<figure class='pane'>"
                  "<div class='label'>64×64</div>"
                  "<img class='pix64' src='" + img64_rel + "' width='64' height='64' loading='lazy'>"
                "</figure>"
                "<figure class='pane'>"
                  "<div class='label'>256×256</div>"
                  "<img class='orig' src='" + img256_rel + "' width='256' height='256' loading='lazy'>"
                "</figure>"
              "</div>"
              "<div class='prompt'>" + html_escape(prompt_text) + "</div>"
            "</article>"
        )

    tpl = open_index_template()
    page = tpl.replace("__LATEST_TS__", html_escape(latest_ts)) \
              .replace("__LATEST_SEED__", html_escape(latest_seed)) \
              .replace("__CARDS__", "\n".join(cards_html))
    INDEX_HTML.write_text(page, encoding="utf-8")



def open_index_template() -> str:
    # MAIN PAGE: clean gallery (no search, no HUD dots, no custom prompt UI)
    return """<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Wunderkammer Archive</title>
<style>
:root{--bg:#070a0f;--text:#d7e6ff;--muted:#8aa2c7;--accent:#7cffb2;--b:rgba(255,255,255,.08);--shadow:rgba(0,0,0,.35);--custom:#ff7ad9;}
*{box-sizing:border-box;}
body{margin:0;color:var(--text);background:
radial-gradient(900px 650px at 15% 10%, rgba(124,255,178,.10), transparent 55%),
radial-gradient(900px 650px at 85% 0%, rgba(215,230,255,.08), transparent 55%),
var(--bg);
font-family:ui-monospace,Menlo,Consolas,monospace;}
header{position:sticky;top:0;z-index:10;padding:14px 16px;border-bottom:1px solid var(--b);background:rgba(7,10,15,.92);backdrop-filter:blur(6px);}
h1{margin:0;font-size:18px;letter-spacing:.4px;}
.sub{color:var(--muted);font-size:12px;margin-top:6px;display:flex;gap:10px;flex-wrap:wrap;align-items:center;justify-content:space-between;}
a{color:var(--accent);text-decoration:none;border-bottom:1px dashed rgba(124,255,178,.35);}
a:hover{border-bottom-style:solid;}
.bar{display:flex;gap:10px;align-items:center;margin-top:10px;flex-wrap:wrap;}
.pill,.pillbtn{padding:8px 10px;border:1px solid rgba(124,255,178,.25);color:var(--accent);background:rgba(124,255,178,.06);border-radius:999px;font-size:12px;white-space:nowrap;}
.pillbtn{cursor:pointer;}

main{max-width:1200px;margin:0 auto;padding:16px;}
.grid{display:grid;grid-template-columns:1fr;gap:12px;}
@media(min-width:900px){.grid{grid-template-columns:1fr 1fr;}}
.card{background:linear-gradient(180deg, rgba(12,17,26,.92), rgba(10,15,22,.92));border:1px solid var(--b);border-radius:16px;box-shadow:0 14px 40px var(--shadow);padding:12px;}
.head{display:flex;justify-content:space-between;gap:10px;align-items:flex-start;margin-bottom:10px;}
.lefthead{display:flex;flex-direction:column;gap:6px;}
.ts{color:var(--muted);font-size:11px;}
.badges{display:flex;gap:8px;flex-wrap:wrap;}
.badge{font-size:11px;color:var(--accent);border:1px solid rgba(124,255,178,.25);background:rgba(124,255,178,.06);padding:4px 8px;border-radius:999px;}
.badgeCustom{color:var(--custom);border-color:rgba(255,122,217,.35);background:rgba(255,122,217,.08);}
.links a{color:var(--accent);font-size:12px;text-decoration:none;border-bottom:1px dashed rgba(124,255,178,.35);margin-left:10px;}
.links a:hover{border-bottom-style:solid;}
.content{display:grid;grid-template-columns:1fr 1fr;gap:10px;align-items:start;}
.pane{margin:0;padding:10px;border-radius:14px;background:rgba(0,0,0,.20);border:1px solid rgba(255,255,255,.06);}
.label{font-size:11px;color:var(--muted);margin-bottom:8px;}
img.pix64{image-rendering:pixelated;image-rendering:crisp-edges;width:128px;height:128px;border-radius:10px;border:1px solid rgba(255,255,255,.08);background:#000;}
img.orig{width:256px;height:256px;border-radius:12px;border:1px solid rgba(255,255,255,.08);background:#000;object-fit:cover;}
.prompt{margin-top:10px;font-size:13px;line-height:1.25rem;word-break:break-word;}
</style>
</head>
<body>
<header>
  <h1>Wunderkammer Archive</h1>

  <div class="sub">
    <div>
      <span>gallery</span>
      <span> • </span><a href="./process.html">process</a>
      <span> • </span><a href="./stats.html">
      <span> • </span><a href="./help.html">help</a>
    </div>
    <div class="pill" id="lastPill">last: __LATEST_TS__ (seed __LATEST_SEED__)</div>
  </div>

  <div class="bar">
    <button id="auto" class="pillbtn" type="button">Auto-Refresh: OFF</button>
    <div class="pill">Tip: custom prompt lives on “process” page</div>
  </div>
</header>

<main>
  <section class="grid" id="grid">
    __CARDS__
  </section>
</main>

<script>
const autoBtn = document.getElementById('auto');
let auto = (localStorage.getItem('wk_auto') === '1');
autoBtn.textContent = auto ? 'Auto-Refresh: ON' : 'Auto-Refresh: OFF';
autoBtn.addEventListener('click', () => {
  auto = !auto;
  localStorage.setItem('wk_auto', auto ? '1' : '0');
  autoBtn.textContent = auto ? 'Auto-Refresh: ON' : 'Auto-Refresh: OFF';
});

let latestSeed = "__LATEST_SEED__";
async function poll(){
  try{
    const res = await fetch("./status.json?_=" + Date.now(), {cache:"no-store"});
    if(!res.ok) return;
    const s = await res.json();
    if (auto && s.latest_seed && s.latest_seed !== latestSeed) location.reload();
    if (s.latest_seed) latestSeed = s.latest_seed;
  }catch(e){}
}
poll();
setInterval(poll, 1000);
</script>
</body></html>
"""



def open_process_template() -> str:
    # PROCESS PAGE: Phase 2 visuals + Custom Generate UI (short + safe)
    return """<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Process</title>
<style>
:root{--bg:#070a0f;--text:#d7e6ff;--muted:#8aa2c7;--accent:#7cffb2;--b:rgba(255,255,255,.08);--warn:#ffcc66;--err:#ff6b6b;}
*{box-sizing:border-box;}
body{margin:0;color:var(--text);background:var(--bg);font-family:ui-monospace,Menlo,Consolas,monospace;}
header{padding:16px;border-bottom:1px solid var(--b);background:rgba(12,17,26,.92);position:sticky;top:0;z-index:10;backdrop-filter:blur(6px);}
h1{margin:0;font-size:18px;}
.sub{margin-top:6px;color:var(--muted);font-size:12px;display:flex;gap:12px;flex-wrap:wrap;align-items:center;}
a{color:var(--accent);text-decoration:none;border-bottom:1px dashed rgba(124,255,178,.35);}
a:hover{border-bottom-style:solid;}
main{max-width:1200px;margin:0 auto;padding:16px;}
.grid{display:grid;grid-template-columns:1fr;gap:12px;}
@media(min-width:900px){.grid{grid-template-columns:1.25fr .75fr;}}
.card{background:rgba(12,17,26,.92);border:1px solid var(--b);border-radius:16px;padding:14px;}
.row{display:flex;justify-content:space-between;gap:10px;margin:6px 0;color:var(--muted);font-size:12px;}
.val{color:var(--text);}
.prog{height:10px;border-radius:999px;background:rgba(255,255,255,.06);border:1px solid rgba(255,255,255,.06);overflow:hidden;margin-top:8px;}
.fill{height:100%;width:0%;background:rgba(124,255,178,.6);transition:width .2s ease;}
/* Custom UI */
.customBox{padding:12px;border-radius:14px;background:rgba(0,0,0,.22);border:1px solid rgba(255,255,255,.06);margin-top:10px;}
.customTop{display:flex;justify-content:space-between;gap:10px;align-items:center;flex-wrap:wrap;}
.customTitle{font-size:12px;color:var(--muted);}
.counter{font-size:11px;color:var(--muted);}
.counter.bad{color:var(--err);}
textarea{width:100%;margin-top:10px;min-height:64px;max-height:140px;resize:vertical;padding:10px 12px;border-radius:12px;border:1px solid rgba(255,255,255,.10);background:rgba(12,17,26,.92);color:var(--text);outline:none;font-family:inherit;font-size:12px;line-height:1.25rem;}
.customRow{display:flex;gap:10px;align-items:center;flex-wrap:wrap;margin-top:10px;}
.btn{padding:10px 12px;border-radius:999px;border:1px solid rgba(124,255,178,.35);background:rgba(124,255,178,.10);color:var(--accent);cursor:pointer;font-size:12px;white-space:nowrap;}
.btn:disabled{opacity:.5;cursor:not-allowed;}
.msg{font-size:11px;color:var(--muted);}
/* quads */
.quads{display:grid;grid-template-columns:1fr 1fr 1fr;gap:10px;margin-top:12px;}
@media(max-width:900px){.quads{grid-template-columns:1fr 1fr;}}
.qcard{padding:10px;border-radius:14px;background:rgba(0,0,0,.22);border:1px solid rgba(255,255,255,.06);}
.qtitle{display:flex;justify-content:space-between;gap:10px;font-size:11px;color:var(--muted);margin-bottom:8px;}
.matrix{display:grid;grid-template-columns:repeat(20, 9px);grid-auto-rows:9px;gap:2px;padding:10px;border-radius:14px;background:rgba(0,0,0,.25);border:1px solid rgba(255,255,255,.06);}
.cell{width:9px;height:9px;border-radius:2px;background:#000;opacity:.92;}
/* spectrum */
.spec{display:flex;gap:6px;align-items:flex-end;height:150px;padding:10px;border-radius:14px;background:rgba(0,0,0,.25);border:1px solid rgba(255,255,255,.06);}
.bar{width:18px;background:#000;border-radius:6px;opacity:.95;transition:height .15s ease, opacity .15s ease;}
/* images */
img.prev{width:256px;height:256px;border-radius:14px;border:1px solid rgba(255,255,255,.08);background:#000;object-fit:cover;}
img.pix{image-rendering:pixelated;image-rendering:crisp-edges;width:128px;height:128px;border-radius:10px;border:1px solid rgba(255,255,255,.08);background:#000;}
/* ascii */
.ascii{white-space:pre;font-size:11px;line-height:1.05rem;color:rgba(215,230,255,.85);background:rgba(0,0,0,.25);border:1px solid rgba(255,255,255,.06);border-radius:14px;padding:10px;overflow:auto;max-height:340px;}
</style></head><body>
<header>
  <h1>Wunderkammer — Process</h1>
  <div class="sub">
    <span>custom prompt here • visuals below</span>
    <a href="./index.html">gallery</a>
    <a href="./stats.html">
    <a href="./help.html">help</a>
  </div>
</header>

<main>
  <div class="grid">
    <div class="card">
      <div class="row"><span>Status</span><span class="val" id="st">–</span></div>
      <div class="row"><span>Seed</span><span class="val" id="seed">–</span></div>
      <div class="row"><span>Step</span><span class="val" id="step">–</span></div>
      <div class="prog"><div class="fill" id="fill"></div></div>

      <div class="customBox">
        <div class="customTop">
          <div class="customTitle">Generate CUSTOM (short on purpose). Hard limit avoids CLIP truncation.</div>
          <div class="counter" id="ctr">0/260</div>
        </div>
        <textarea id="cp" placeholder="Example: 17th-century Baroque Wunderkammer, Bestiaria, a coiled serpent with iridescent scales, isolated specimen, irregular silhouette, pixel art, high contrast, dark neutral background, dramatic chiaroscuro lighting"></textarea>
        <div class="customRow">
          <button class="btn" id="go">Generate (Custom)</button>
          <div class="msg" id="msg">—</div>
        </div>
      </div>

      <div class="row" style="margin-top:10px;"><span>Latent</span><span class="val" id="lat">mean/std/abs</span></div>
      <div class="row"><span>Prompt</span><span class="val" id="pr">–</span></div>

      <div class="quads">
        <div class="qcard">
          <div class="qtitle"><span>CPU</span><span id="cpuLab">–</span></div>
          <div class="matrix" id="mxCPU"></div>
        </div>
        <div class="qcard">
          <div class="qtitle"><span>MEM</span><span id="memLab">–</span></div>
          <div class="matrix" id="mxMEM"></div>
        </div>
        <div class="qcard">
          <div class="qtitle"><span>DISK</span><span id="dskLab">–</span></div>
          <div class="matrix" id="mxDSK"></div>
        </div>
        <div class="qcard">
          <div class="qtitle"><span>TEMP</span><span id="tmpLab">–</span></div>
          <div class="matrix" id="mxTMP"></div>
        </div>
        <div class="qcard">
          <div class="qtitle"><span>ENTROPY SPECTRUM</span><span>8 bins</span></div>
          <div class="spec" id="spec"></div>
        </div>
      </div>

      <div class="row" style="margin-top:12px;"><span>BUILD / FINAL</span><span class="val">live</span></div>
      <div style="display:flex;gap:12px;flex-wrap:wrap;align-items:flex-start;">
        <div>
          <div class="row"><span>BUILD 64×64</span><span class="val">current_build.png</span></div>
          <img class="pix" id="b64" src="../wunderkammer64/current_build.png" alt="build 64"/>
        </div>
        <div>
          <div class="row"><span>FINAL 256</span><span class="val">current.png</span></div>
          <img class="prev" id="b256" src="../wunderkammer256/current.png" alt="current 256"/>
        </div>
      </div>
    </div>

    <div class="card">
      <div class="row"><span>ASCII</span><span class="val">step-linked</span></div>
      <div class="ascii" id="ascii">(waiting...)</div>
    </div>
  </div>
</main>

<script>
// ---------- Custom prompt UI ----------
const cp = document.getElementById('cp');
const ctr = document.getElementById('ctr');
const go = document.getElementById('go');
const msg = document.getElementById('msg');
const LIMIT = 260;

function updateCounter(){
  const n = (cp.value || "").length;
  ctr.textContent = n + "/" + LIMIT;
  if (n > LIMIT) ctr.classList.add("bad"); else ctr.classList.remove("bad");
  go.disabled = (n === 0) || (n > LIMIT);
}
cp.addEventListener("input", updateCounter);
updateCounter();

async function submitCustom(){
  const txt = (cp.value || "").trim();
  if (!txt){ msg.textContent = "Type something."; return; }
  if (txt.length > LIMIT){ msg.textContent = "Too long. Keep it under " + LIMIT + " chars."; return; }

  msg.textContent = "Submitting…";
  go.disabled = true;

  try{
    const res = await fetch("/api/generate", {
      method: "POST",
      headers: {"Content-Type":"application/json"},
      body: JSON.stringify({prompt: txt})
    });
    const j = await res.json().catch(()=>({}));
    if (res.status === 202 && j.ok) msg.textContent = "Accepted. Watch the quads + build.";
    else if (res.status === 409) msg.textContent = "Busy: generator is running.";
    else msg.textContent = "Error: " + (j.message || j.error || ("HTTP " + res.status));
  } catch(e){
    msg.textContent = "Network error: " + e;
  } finally {
    setTimeout(()=>{ go.disabled = false; updateCounter(); }, 1200);
  }
}
go.addEventListener("click", submitCustom);

// ---------- Phase 2 visuals ----------
const W=20, H=14;
function mkGrid(id){
  const el=document.getElementById(id);
  const cells=[];
  for(let i=0;i<W*H;i++){
    const d=document.createElement('div'); d.className='cell';
    el.appendChild(d); cells.push(d);
  }
  return cells;
}
const cpuC = mkGrid("mxCPU");
const memC = mkGrid("mxMEM");
const dskC = mkGrid("mxDSK");
const tmpC = mkGrid("mxTMP");

const spec = document.getElementById("spec");
const bars = [];
for(let i=0;i<8;i++){
  const b=document.createElement("div");
  b.className="bar"; b.style.height="10px";
  spec.appendChild(b); bars.push(b);
}

const ascii = document.getElementById('ascii');
const st = document.getElementById('st');
const seed = document.getElementById('seed');
const step = document.getElementById('step');
const fill = document.getElementById('fill');
const pr = document.getElementById('pr');
const lat = document.getElementById('lat');

const cpuLab = document.getElementById('cpuLab');
const memLab = document.getElementById('memLab');
const dskLab = document.getElementById('dskLab');
const tmpLab = document.getElementById('tmpLab');

const b64 = document.getElementById('b64');
const b256 = document.getElementById('b256');

let S=null;

function hash32(x){
  x = (x ^ (x >>> 16)) >>> 0;
  x = Math.imul(x, 0x7feb352d) >>> 0;
  x = (x ^ (x >>> 15)) >>> 0;
  x = Math.imul(x, 0x846ca68b) >>> 0;
  x = (x ^ (x >>> 16)) >>> 0;
  return x >>> 0;
}
function clamp(v,a,b){ return Math.max(a, Math.min(b,v)); }
function rnd01(h){ return (h & 0xfffffff) / 0xfffffff; }

function entropyLevel(){
  if(!S) return 0.25;
  const L = S.latent || {};
  const std = (L.std==null) ? 0.6 : Math.abs(L.std);
  const abs = (L.absmean==null) ? 0.6 : Math.abs(L.absmean);
  let e = 1 - Math.exp(-(std*0.9 + abs*0.35));
  return clamp(e, 0.05, 1.0);
}

function updateLabels(){
  if(!S || !S.stats) return;
  const cpu = S.stats.cpu_percent ?? 0;
  const mem = (S.stats.mem && S.stats.mem.percent) ? S.stats.mem.percent : 0;
  const dsk = (S.stats.disk && S.stats.disk.percent) ? S.stats.disk.percent : 0;
  const tmp = (S.stats.temp_c == null) ? null : S.stats.temp_c;
  cpuLab.textContent = cpu.toFixed(0);
  memLab.textContent = mem.toFixed(0);
  dskLab.textContent = dsk.toFixed(0);
  tmpLab.textContent = (tmp==null) ? "—" : tmp.toFixed(0);
}

function spectrumUpdate(){
  const e = entropyLevel();
  const bins = (S && Array.isArray(S.latent_bins)) ? S.latent_bins : null;
  for(let i=0;i<8;i++){
    let v = bins ? (bins[i] || 0) : 0.12;
    v = clamp(v, 0, 1);
    const h = 12 + (v * (120 + 40*e));
    bars[i].style.height = h.toFixed(0) + "px";
    const on = (Math.random() < (0.03 + 0.12*e)) ? 1 : 0;
    bars[i].style.background = on ? "#fff" : "#000";
    bars[i].style.opacity = (0.7 + 0.3*Math.random()).toFixed(2);
  }
}

function rasterbarX(prog){
  return Math.floor(prog * (W-1));
}

function drawQuad(cells, level, prog, e, phase){
  const col = rasterbarX(prog);
  const runSeed = S && S.current_seed ? (parseInt(S.current_seed) >>> 0) : 1337;
  const stepN = S && S.step ? (S.step >>> 0) : 0;

  for(let y=0;y<H;y++){
    for(let x=0;x<W;x++){
      const i = y*W + x;

      let prob = 0.03 + 0.60*level + 0.22*e;

      const fx=x/(W-1), fy=y/(H-1);
      const diag = fx*0.6 + fy*0.4;
      const band = Math.abs(diag - prog);
      const inBand = (band < 0.055);

      const beat=(Date.now()%850)/850;
      const osc=0.65 + 0.35*Math.sin(beat*2*Math.PI + x*0.22 + y*0.28 + phase);
      prob *= osc;

      const h = hash32((runSeed ^ (stepN*0x9e3779b9) ^ (i*0x85ebca6b)) >>> 0);
      const r = rnd01(h);
      const burst = (r < (0.01 + 0.05*e)) ? (0.25 + 0.55*rnd01(hash32(h^0x1234567))) : 0.0;
      prob += burst;

      let on = (Math.random() < prob);

      if (x === col) on = !on;
      if (inBand) on = !on;

      cells[i].style.background = on ? "#fff" : "#000";
      const op = on ? (0.55 + 0.45*Math.random()) : (0.85 + 0.12*Math.random());
      cells[i].style.opacity = op.toFixed(2);
    }
  }
}

function animate(){
  let cpu=0, mem=0, dsk=0, tmp=0, prog=0, e=0.25;
  if(S && S.stats){
    cpu = clamp(S.stats.cpu_percent || 0, 0, 100)/100;
    mem = clamp((S.stats.mem && S.stats.mem.percent) ? S.stats.mem.percent : 0, 0, 100)/100;
    dsk = clamp((S.stats.disk && S.stats.disk.percent) ? S.stats.disk.percent : 0, 0, 100)/100;
    if (S.stats.temp_c != null) tmp = clamp((S.stats.temp_c-35)*2.2, 0, 100)/100;
    prog = clamp((typeof S.progress === "number") ? S.progress : 0, 0, 1);
    e = entropyLevel();
  } else {
    prog = ((Date.now()%4000)/4000);
    e = 0.25;
  }
  drawQuad(cpuC, cpu, prog, e, 0.0);
  drawQuad(memC, mem, prog, e, 1.3);
  drawQuad(dskC, dsk, prog, e, 2.1);
  drawQuad(tmpC, tmp, prog, e, 3.0);
  spectrumUpdate();
}

async function poll(){
  try{
    const res = await fetch("./status.json?_=" + Date.now(), {cache:"no-store"});
    if(!res.ok) return;
    S = await res.json();

    st.textContent = S.generating ? "generating" : "idle";
    seed.textContent = S.current_seed || "—";
    if (S.step && S.steps) step.textContent = S.step + "/" + S.steps; else step.textContent = "—";
    if (typeof S.progress === "number") fill.style.width = (S.progress*100).toFixed(1) + "%";
    pr.textContent = (S.current_prompt || "—").slice(0, 140);

    if (S.latent){
      const m = (S.latent.mean==null) ? "—" : S.latent.mean.toFixed(4);
      const sd = (S.latent.std==null) ? "—" : S.latent.std.toFixed(4);
      const am = (S.latent.absmean==null) ? "—" : S.latent.absmean.toFixed(4);
      lat.textContent = m + " / " + sd + " / " + am;
    } else lat.textContent = "—";

    updateLabels();

    if (S.ascii && Array.isArray(S.ascii)) ascii.textContent = S.ascii.join("\\n");
    else ascii.textContent = "(no ascii)";

    const b = Date.now();
    if (S.generating){
      b64.src = "../wunderkammer64/current_build.png?b=" + b;
      b256.src = "../wunderkammer256/current.png?b=" + b;
      go.disabled = true;
    } else {
      go.disabled = ((cp.value||"").length === 0) || ((cp.value||"").length > LIMIT);
      if ((b/1000|0) % 5 === 0){
        b64.src = "../wunderkammer64/current.png?b=" + b;
        b256.src = "../wunderkammer256/current.png?b=" + b;
      }
    }
  }catch(e){}
}

poll();
setInterval(poll, 1000);
setInterval(animate, 50);
</script>
</body></html>
"""
def open_stats_template() -> str:
    # your existing stats template (sparklines) from earlier – kept as dedicated page
    # (shortened version; still fine)
    return """<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Stats</title>
<style>
:root{--bg:#070a0f;--text:#d7e6ff;--muted:#8aa2c7;--accent:#7cffb2;--b:rgba(255,255,255,.08);--shadow:rgba(0,0,0,.35);}
*{box-sizing:border-box;}
body{margin:0;color:var(--text);background:var(--bg);font-family:ui-monospace,Menlo,Consolas,monospace;}
header{padding:16px;border-bottom:1px solid var(--b);background:rgba(12,17,26,.92);position:sticky;top:0;z-index:10;backdrop-filter:blur(6px);}
h1{margin:0;font-size:18px;}
.sub{margin-top:6px;color:var(--muted);font-size:12px;display:flex;gap:12px;flex-wrap:wrap;align-items:center;}
a{color:var(--accent);text-decoration:none;border-bottom:1px dashed rgba(124,255,178,.35);}
a:hover{border-bottom-style:solid;}
main{max-width:1100px;margin:0 auto;padding:16px;}
.grid{display:grid;grid-template-columns:1fr;gap:12px;}
@media(min-width:900px){.grid{grid-template-columns:1fr 1fr;}}
.card{background:rgba(12,17,26,.92);border:1px solid var(--b);border-radius:16px;box-shadow:0 14px 40px var(--shadow);padding:14px;}
.krow{display:flex;justify-content:space-between;gap:10px;font-size:12px;margin:6px 0;color:var(--muted);}
.kval{color:var(--text);}
.bar2{height:10px;border-radius:999px;background:rgba(255,255,255,.06);overflow:hidden;border:1px solid rgba(255,255,255,.06);}
.fill{height:100%;background:rgba(124,255,178,.55);width:0%;transition:width .25s ease;}
canvas{width:100%;height:56px;border-radius:12px;background:rgba(0,0,0,.18);border:1px solid rgba(255,255,255,.06);}
</style></head><body>
<header>
  <h1>Wunderkammer — Stats</h1>
  <div class="sub"><span>poll status.json every 1s</span><a href="./index.html">back</a></div>
</header>
<main>
<div class="grid">
  <div class="card">
    <div class="krow"><span>Status</span><span class="kval" id="modeTxt">–</span></div>
    <div class="krow"><span>Seed</span><span class="kval" id="seedTxt">–</span></div>
    <div class="krow"><span>CPU</span><span class="kval" id="cpuTxt">–</span></div>
    <div class="bar2"><div class="fill" id="cpuFill"></div></div>
    <canvas id="cpuCv" width="600" height="120"></canvas>
  </div>
  <div class="card">
    <div class="krow"><span>Memory</span><span class="kval" id="memTxt">–</span></div>
    <div class="bar2"><div class="fill" id="memFill"></div></div>
    <canvas id="memCv" width="600" height="120"></canvas>
  </div>
</div>
</main>
<script>
const histN=120; const cpuH=[], memH=[];
function clamp(v,a,b){return Math.max(a,Math.min(b,v));}
function pctFill(el,pct){const p=clamp(pct,0,100); el.style.width=p.toFixed(0)+"%";}
function pushHist(arr,v){arr.push(v); while(arr.length>histN) arr.shift();}
function drawSpark(canvas, arr, maxY){
  const ctx=canvas.getContext('2d'); const w=canvas.width,h=canvas.height;
  ctx.clearRect(0,0,w,h);
  ctx.globalAlpha=0.2; ctx.strokeStyle="#fff"; ctx.beginPath();
  for(let i=0;i<=4;i++){const y=(h*i)/4; ctx.moveTo(0,y); ctx.lineTo(w,y);} ctx.stroke();
  if(arr.length<2) return;
  ctx.globalAlpha=0.9; ctx.beginPath();
  for(let i=0;i<arr.length;i++){
    const x=(w*i)/(histN-1); const v=clamp(arr[i],0,maxY); const y=h-(v/maxY)*h;
    if(i===0) ctx.moveTo(x,y); else ctx.lineTo(x,y);
  } ctx.stroke(); ctx.globalAlpha=1.0;
}
const modeTxt=document.getElementById('modeTxt');
const seedTxt=document.getElementById('seedTxt');
const cpuTxt=document.getElementById('cpuTxt');
const memTxt=document.getElementById('memTxt');
const cpuFill=document.getElementById('cpuFill');
const memFill=document.getElementById('memFill');
const cpuCv=document.getElementById('cpuCv');
const memCv=document.getElementById('memCv');

async function poll(){
  try{
    const res=await fetch("./status.json?_="+Date.now(),{cache:"no-store"});
    if(!res.ok) return;
    const s=await res.json();
    modeTxt.textContent = s.generating ? "generating" : "idle";
    seedTxt.textContent = s.current_seed || "—";
    if(s.stats){
      const cpu=s.stats.cpu_percent ?? 0;
      const mem=s.stats.mem?.percent ?? 0;
      cpuTxt.textContent = cpu.toFixed(1)+"%";
      memTxt.textContent = mem.toFixed(1)+"%";
      pctFill(cpuFill,cpu); pctFill(memFill,mem);
      pushHist(cpuH,cpu); pushHist(memH,mem);
      drawSpark(cpuCv,cpuH,100); drawSpark(memCv,memH,100);
    }
  }catch(e){}
}
poll(); setInterval(poll,1000);
</script>
</body></html>
"""

def parse_args():
    p = argparse.ArgumentParser()
    p.add_argument("--model", default="runwayml/stable-diffusion-v1-5")
    p.add_argument("--work", type=int, default=256)
    p.add_argument("--steps", type=int, default=20)
    p.add_argument("--guidance", type=float, default=7.0)
    p.add_argument("--palette", type=int, default=32)
    p.add_argument("--seed", type=int, default=0)
    p.add_argument("--max_gallery", type=int, default=500)
    p.add_argument("--max_prompt_chars", type=int, default=140)
    p.add_argument("--custom_prompt", default="")
    return p.parse_args()

def main():
    ensure_dirs()
    args = parse_args()

    with open(LOCKFILE, "w") as lf:
        fcntl.flock(lf, fcntl.LOCK_EX | fcntl.LOCK_NB)

        seed = args.seed if args.seed != 0 else time.time_ns()
        torch_seed = int(seed % (2**32))
        steps = int(args.steps)

        mode = "auto"
        if args.custom_prompt.strip():
            mode = "custom"
            unique_prompt = clamp_custom(args.custom_prompt)
        else:
            unique_prompt = get_unique_prompt(seed)

        prompt_short = shorten_unique_for_model(unique_prompt, max_chars=args.max_prompt_chars)

        print(f"RUN seed={seed} torch_seed={torch_seed} mode={mode} work={args.work} steps={args.steps} palette={args.palette}", flush=True)
        print(f"RUN unique_prompt={unique_prompt}", flush=True)
        print(f"RUN fed_prompt={prompt_short}", flush=True)

        # initial status
        write_status({
            "generating": True,
            "current_seed": str(seed),
            "current_prompt": unique_prompt,
            "mode": mode,
            "mode": mode,
            "latest_seed": "",
            "latest_ts": "",
            "progress": 0.0,
            "step": 0,
            "steps": steps,
            "ascii": make_ascii_block(seed, 0, steps, unique_prompt),
            "stats": get_system_stats(),
        })
        write_glitch_build_image(seed, 0, steps)

        pipe = StableDiffusionPipeline.from_pretrained(args.model, torch_dtype=torch.float32, safety_checker=None).to("cpu")
        pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config, use_karras_sigmas=True)
        g = torch.Generator(device="cpu").manual_seed(torch_seed)
        full_prompt = BASE_POS + ", " + prompt_short

        def cb(step: int, timestep: int, latents):
            prog = (step + 1) / max(1, steps)
            write_glitch_build_image(seed, step, steps)
            write_status({
                "generating": True,
                "current_seed": str(seed),
                "current_prompt": unique_prompt,
            "mode": mode,
            "mode": mode,
                "latest_seed": "",
                "latest_ts": "",
                "progress": float(prog),
                "step": int(step + 1),
                "steps": steps,
                "ascii": make_ascii_block(seed, step, steps, unique_prompt),
                "stats": get_system_stats(),
            })

        work_img = pipe(
            prompt=full_prompt,
            negative_prompt=BASE_NEG,
            width=args.work,
            height=args.work,
            num_inference_steps=args.steps,
            guidance_scale=args.guidance,
            generator=g,
            callback=cb,
            callback_steps=1,
        ).images[0]

        ts_file = datetime.now().strftime("%Y%m%d-%H%M%S")
        ts_human = now_stamp_human()

        prefix = "custom_" if mode == "custom" else ""
        fname256 = f"{prefix}{ts_file}_seed{seed}_work{args.work}_steps{args.steps}.png"
        fname64  = f"{prefix}{ts_file}_seed{seed}_pal{args.palette}.png"

        out256 = DIR_256 / fname256
        out64  = DIR_64 / fname64

        work_img.save(out256)
        img64 = downscale_dither(work_img, palette_colors=args.palette)
        img64.save(out64)

        # final "current"
        try:
            work_img.save(DIR_256 / "current.png")
            img64.save(DIR_64 / "current.png")
        except Exception:
            pass

        append_log(ts_human, seed, mode, unique_prompt, fname256, fname64)

        build_help_page()
        build_process_page()
        build_gallery(max_items=args.max_gallery)

        write_status({
            "generating": False,
            "current_seed": str(seed),
            "current_prompt": unique_prompt,
            "mode": mode,
            "mode": mode,
            "latest_seed": str(seed),
            "latest_ts": ts_human,
            "progress": 1.0,
            "step": steps,
            "steps": steps,
            "ascii": make_ascii_block(seed, max(0, steps-1), steps, unique_prompt),
            "stats": get_system_stats(),
        })

        print("OK", flush=True)
        print("web:", INDEX_HTML, flush=True)
        print("process:", PROC_HTML, flush=True)

if __name__ == "__main__":
    try:
        main()
    except BlockingIOError:
        pass
