#!/usr/bin/env python3
# shxtrk.dev: content/, templates/ and static/ in, dist/ out; standard library only, the same tree giving the same bytes
# no refuse · rec a record · esc escape as HTML · bare an attribute value, quoted only where it has to be
# handle domain the names · root content templates static dist the tree · RELEASE a ledger row · ENTRY a feed entry
# DAY a date as written here, in ASCII digits
# split a file's meta lines and body · note obj a record from its directory · load records, newest first
# rev a note's earlier text, keyed by its last release · ledger the releases as written · where a digest's line in it
# fill a template · put write under dist · page a page in base.html · day a <time> · ul rows shelf ls index markup
# notes objects kinds news the records · digest the release digest · releases the ledger, newest first
import hashlib, re, shutil
from html import escape as esc
from pathlib import Path
from sys import exit as no
from types import SimpleNamespace as rec

handle, domain = "shxtrk", "shxtrk.dev"
root = Path(__file__).parent
content, templates, static, dist = (root / s for s in ("content", "templates", "static", "dist"))
RELEASE = '<li><time datetime="{date}">{date}</time> <code>{value}</code></li>'  # inv: sum.js reads these rows, quotes and all
DAY = r"[0-9]{4}-[0-9]{2}-[0-9]{2}"
ENTRY = ('<entry>\n  <title>{title}</title>\n  <link href="{link}"/>\n  <id>{id}</id>\n'
 '{pub}  <updated>{up}T00:00:00Z</updated>\n  {feed}\n</entry>')

def bare(s): return s if re.fullmatch(r"[^\t\n\f\r \"'=<>`]+", s) else f'"{s}"'  # HTML §13.1.2.3: unquoted values
def day(d, s=""): return f"<time datetime={bare(d)}>{s}{d}</time>"

def split(p):
 a = p.read_text(encoding="utf-8").splitlines()
 n = next((i for i, s in enumerate(a) if not s.strip()), len(a))
 for i, s in enumerate(a[:n], 1): ":" in s or no(f"{p}: line {i} is not `key: value`")
 return {k.strip(): v.strip() for k, _, v in (s.partition(":") for s in a[:n])}, "\n".join(a[n+1:]).strip()

def rev(p, x, d):
 s = f"notes/{p.name}/revisions/{x.name}"
 (x.suffix == ".html" and x.stem in where) or no(f"{s}: not named <digest>.html after a release in content/releases")
 meta, body = split(x)
 o = rec(i=where[x.stem], key=x.stem[:8], up=meta.get("replaced", ""), body=body)
 body or no(f"{s}: the earlier text is empty")
 ledger[o.i][0] < d and no(f"{s}: that release is older than the note")
 (re.fullmatch(DAY, o.up) and o.up >= ledger[o.i][0]) or no(f"{s}: `replaced:` is not a YYYY-MM-DD on or after that release")
 o.i + 1 < len(ledger) and o.up != ledger[o.i+1][0] and no(f"{s}: `replaced:` is not the day of the release after it")
 return o

def note(p):
 meta, body = split(p / "note.html")
 "revised" in meta and no(f"notes/{p.name}/note.html: an earlier version is revisions/<release digest>.html, not `revised:`")
 title, d, u = esc(meta["title"]), meta["date"], f"/notes/{p.name}/"
 a = sorted((rev(p, x, d) for x in sorted((p / "revisions").glob("[!.]*"))), key=lambda r: r.i)
 up = max([d, *(r.up for r in a)])
 return rec(slug=p.name, url=u, link=f"https://{domain}{u}", title=title, date=d, up=up, revs=a,
  meta=" · ".join([day(d), *([f"revised {day(up)}", "earlier versions " + ", ".join(
   f"<a href={bare(u + r.key + '/')}>{r.key}</a>" for r in a)] if a else [])]),
  body=body, time=day(d), tail="", desc=esc(meta.get("description", "")), id=f"tag:{domain},{d}:notes/{p.name}",
  pub=f"  <published>{d}T00:00:00Z</published>\n", feed=f'<content type="html">{esc(body)}</content>')

def obj(p):
 meta, _ = split(p / "meta")
 ("date" in meta or "updated" not in meta) and no(f"objects/{p.name}/meta: an object has `updated:`, not a publication date")
 d = meta["updated"]
 re.fullmatch(DAY, d) or no(f"objects/{p.name}/meta: `updated:` is not YYYY-MM-DD")
 (p / "index.html").is_file() or no(f"objects/{p.name}: missing index.html")
 s = (p / "index.html").read_text(encoding="utf-8")
 re.search(rf'datetime=("{d}"|{d}[\t\n\f\r >])', s) or no(f"objects/{p.name}: index.html does not show updated {d}")
 title, summary, u = esc(meta["title"]), esc(meta["summary"]), f"/objects/{p.name}/"
 return rec(slug=p.name, url=u, link=f"https://{domain}{u}", title=title, date=d, up=d, time=day(d, "updated "),
  files=sorted(x for x in p.iterdir() if x.is_file() and x.name != "meta"),
  tail=f" <span class=summary>{summary}</span>", pub="", feed=f"<summary>{summary}</summary>",
  id=f"tag:{domain},2026-09-27:objects/{p.name}")  # RFC 4151: a day the domain was held; one fixed day keeps object ids

def load(kind, f):
 return sorted((f(p) for p in sorted((content / kind).iterdir()) if p.is_dir()), key=lambda r: r.date, reverse=True)

def fill(name, **slots):
 s = (templates / name).read_text(encoding="utf-8")
 for k, v in slots.items(): s = s.replace("{{" + k + "}}", v)
 a = re.findall(r"\{\{(\w+)\}\}", s)
 a and no(f"{name}: unfilled placeholders: {', '.join(sorted(set(a)))}")
 return s

def put(path, s):
 p = dist / path.lstrip("/")
 p.parent.mkdir(parents=True, exist_ok=True); p.write_text(s.rstrip() + "\n", encoding="utf-8")

def page(path, title, main, header=f"<a class=mark href=/>{handle}</a>", og="website", desc=""):
 u = f"https://{domain}{path.removesuffix('index.html')}"
 head = "\n".join([f"<link rel=canonical href={bare(u)}>", *(f"<meta {k} content={bare(v)}>" for k, v in (
  ("name=description", desc), ("property=og:title", title), ("property=og:description", desc), ("property=og:url", u),
  ("property=og:type", og), ("property=og:site_name", domain)) if v)])
 put(path, fill("base.html", title=title, head=head, header=header, main=main))

def ul(a): return "<ul class=index>\n" + "\n".join(a) + "\n</ul>"
def rows(a): return ul(f"<li>{r.time} <a href={bare(r.url)}>{r.title}</a>{r.tail}" for r in a)
def shelf(k, a): return f"<h2><a href=/{k}/>{k}</a></h2>\n{rows(a)}" if a else ""
def ls(a):
 return ul(f"<li><a href={bare(p.name + '.txt')}>{esc(p.name)}</a> <span class=summary>{p.stat().st_size} bytes</span>" for p in a)

p, ledger = content / "releases", []
for i, s in enumerate(p.read_text(encoding="utf-8").splitlines() if p.is_file() else [], 1):
 a = s.split()
 if not a: continue
 len(a) != 2 and no(f"content/releases: line {i} is not `date digest`")
 re.fullmatch(DAY, a[0]) or no(f"content/releases: line {i} does not start with a YYYY-MM-DD")
 ledger and a[0] < ledger[-1][0] and no(f"content/releases: line {i} is dated before the line above it")
 ledger.append(a)
where = {v: i for i, (_, v) in enumerate(ledger)}
len(where) < len(ledger) and no("content/releases: a digest is on two lines; a redeploy of the same build is not a new release")
notes, objects = load("notes", note), load("objects", obj)
if dist.exists(): shutil.rmtree(dist)
dist.mkdir()
for p in static.iterdir(): shutil.copy2(p, dist / p.name)
notes or objects or no("nothing to publish: content/ holds no notes and no objects")

kinds, s = {"objects": objects, "notes": notes}, "Working objects, and notes about them."
page("/index.html", handle, fill("home.html", handle=handle, tagline=s, **{k: shelf(k, a) for k, a in kinds.items()}),
 "", desc=s)
for k, a in kinds.items():
 if a: page(f"/{k}/index.html", f"{k} · {handle}", fill("list.html", title=k, items=rows(a)))
for r in notes:
 page(f"{r.url}index.html", f"{r.title} · {handle}", fill("note.html", title=r.title, meta=r.meta, notice="",
  body=r.body), og="article", desc=r.desc)
 for x in r.revs:
  page(f"{r.url}{x.key}/index.html", f"{r.title} ({x.key}) · {handle}", fill("note.html", title=r.title, meta=r.time,
   notice=f"<p class=notice>This is <a href={bare(r.url)}>{r.title}</a> as last served in release <code>{x.key}</code>. It changed on {day(x.up)}.</p>",
   body=x.body), og="article")
for r in objects:
 out = dist / "objects" / r.slug
 (out / "source").mkdir(parents=True, exist_ok=True)
 for p in r.files: shutil.copy2(p, out / p.name); (out / "source" / f"{p.name}.txt").write_bytes(p.read_bytes())
 page(f"{r.url}source/index.html", f"{r.title} source · {handle}",
  fill("source.html", title=r.title, url=bare(r.url), files=ls(r.files)))
me = Path(__file__).resolve()
(dist / "source").mkdir(parents=True, exist_ok=True); (dist / "source" / f"{me.name}.txt").write_bytes(me.read_bytes())
page("/source/index.html", f"source · {handle}",
 fill("build.html", files=ls([me]), body=split(content / "build.html")[1]))
news = sorted([*notes, *objects], key=lambda r: r.up, reverse=True)
put("/feed.xml", fill("feed.xml", updated=f"{news[0].up}T00:00:00Z",
 entries="\n".join(ENTRY.format_map(vars(r)) for r in news)))
page("/404.html", f"not here · {handle}", fill("notfound.html"))

manifest = "\n".join(f"{hashlib.sha256((dist / s).read_bytes()).hexdigest()}  {s}"
 for s in sorted(p.relative_to(dist).as_posix() for p in dist.rglob("*") if p.is_file())
 if s not in {"colophon/index.html", "manifest.txt", "_headers", "_redirects"}) + "\n"
(dist / "manifest.txt").write_text(manifest, encoding="utf-8")
digest = hashlib.sha256(manifest.encode("utf-8")).hexdigest()

# inv: newest first within a day as well; sorting whole pairs would order a day's releases by digest
releases = sorted(ledger[::-1], key=lambda a: a[0], reverse=True)
page("/colophon/index.html", f"colophon · {handle}", fill("colophon.html", body=split(content / "colophon.html")[1],
 notes=str(len(notes)), objects=str(len(objects)), latest=news[0].up, digest=digest,
 releases=ul(RELEASE.format(date=d, value=v) for d, v in releases) if releases else "<p>Nothing has been released yet.</p>"))
print(f"{len(notes)} notes, {len(objects)} objects → {dist.relative_to(root)}/"); print(f"digest {digest}")