crosspresent.py

#!/usr/bin/env python3
"""crossPresent — turn one Markdown file into a self-contained HTML presentation.

No dependencies. No build chain. No JS in the output (unless you opt into
mermaid diagrams). Charts are rendered to inline SVG at build time, so the
result is a single file that works offline, adapts to dark/light mode, and
prints one slide per page.

Usage (after `pip install .` — or run `python3 crosspresent.py` uninstalled):
    crosspresent new mydeck            # scaffold mydeck.md
    crosspresent build mydeck.md       # -> mydeck.html
    crosspresent build mydeck.md -t deck -o out/deck.html --open
    crosspresent serve mydeck.md       # live preview, reload on save

Templates: sidebar (TOC + scrolling sections, the default), deck
(full-screen snap-scrolling slides), doc (single-column report).
Palettes: default, ocean, forest, mono, crimson — `palette:` in frontmatter.
Charts can pull labels/values from CSV or JSON files via "data": "file.csv".
Speaker notes (```notes blocks) are stripped unless you pass --notes.
"""

import argparse
import base64
import csv
import glob
import html
import http.server
import json
import math
import mimetypes
import re
import sys
import tempfile
import threading
import time
import unicodedata
import webbrowser
from pathlib import Path

VERSION = "1.1.0"

# --------------------------------------------------------------------------
# Frontmatter
# --------------------------------------------------------------------------

def parse_frontmatter(text):
    """Parse a leading `--- key: value ... ---` block. Returns (meta, body)."""
    lines = text.split("\n")
    if not lines or lines[0].strip() != "---":
        return {}, text
    meta = {}
    for i in range(1, len(lines)):
        stripped = lines[i].strip()
        if stripped == "---":
            return meta, "\n".join(lines[i + 1:])
        if not stripped or stripped.startswith("#"):
            continue
        key, sep, value = lines[i].partition(":")
        if sep:
            meta[key.strip().lower()] = value.strip().strip('"').strip("'")
    return {}, text  # opening --- with no closing --- : treat as content


# --------------------------------------------------------------------------
# Inline markdown
# --------------------------------------------------------------------------

BADGE_ALIASES = {
    "good": "good", "green": "good", "pass": "good",
    "warn": "warn", "amber": "warn", "yellow": "warn",
    "bad": "bad", "red": "bad", "fail": "bad",
    "info": "info", "blue": "info",
    "accent": "accent", "orange": "accent",
    "purple": "purple", "teal": "teal",
    "dim": "dim", "gray": "dim", "grey": "dim",
}

_CODE_SPAN = re.compile(r"`([^`]+)`")


def render_inline(text):
    """Render inline markdown to HTML. Everything is escaped; the only HTML
    in the result is what this function generates."""
    spans = []

    def stash(match):
        spans.append("<code>%s</code>" % html.escape(match.group(1)))
        return "\x00%d\x00" % (len(spans) - 1)

    text = _CODE_SPAN.sub(stash, text)
    text = html.escape(text)

    # images: ![alt](src)
    text = re.sub(
        r"!\[([^\]]*)\]\(([^)\s]+)\)",
        r'<img src="\2" alt="\1">', text)

    # badges: [[TEXT]] or [[TEXT|class]]
    def badge(match):
        label, _, cls = match.group(1).partition("|")
        cls = BADGE_ALIASES.get(cls.strip().lower(),
                                re.sub(r"[^a-z0-9_-]", "", cls.strip().lower()))
        cls_attr = (" " + cls) if cls else ""
        return '<span class="badge%s">%s</span>' % (cls_attr, label.strip())

    text = re.sub(r"\[\[([^\]\[|]+(?:\|[^\]\[]*)?)\]\]", badge, text)

    # links: [text](href) — script-ish URL schemes degrade to plain text
    def link(match):
        text_part, href = match.group(1), match.group(2)
        if re.match(r"(?i)^\s*(javascript|vbscript|data)\s*:", href):
            return text_part
        return '<a href="%s">%s</a>' % (href, text_part)

    text = re.sub(r"\[([^\]]+)\]\(([^)\s]+)\)", link, text)

    # bold / italic
    text = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", text)
    text = re.sub(r"(?<!\*)\*([^*\n]+)\*(?!\*)", r"<em>\1</em>", text)

    return re.sub(r"\x00(\d+)\x00", lambda m: spans[int(m.group(1))], text)


def strip_markup(text):
    """Plain text version of an inline-markdown string (for TOC labels)."""
    text = re.sub(r"`([^`]+)`", r"\1", text)
    text = re.sub(r"\[\[([^\]\[|]+)(?:\|[^\]\[]*)?\]\]", r"\1", text)
    text = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", text)
    text = re.sub(r"\*\*?([^*]+)\*\*?", r"\1", text)
    return text.strip()


def slugify(text):
    text = strip_markup(text)
    text = unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode()
    text = re.sub(r"[^a-zA-Z0-9]+", "-", text).strip("-").lower()
    return text or "slide"


# --------------------------------------------------------------------------
# Charts (inline SVG)
# --------------------------------------------------------------------------

PALETTE = ["var(--c1)", "var(--c2)", "var(--c3)", "var(--c4)",
           "var(--c5)", "var(--c6)", "var(--c7)"]


def fmt_num(value):
    if value == 0:
        return "0"
    # compact notation keeps axis and bar labels inside the chart margins
    for div, suffix in ((1e12, "T"), (1e9, "B"), (1e6, "M"), (1e3, "k")):
        if abs(value) >= (div if div > 1e3 else 1e5):
            scaled = value / div
            text = "%.1f" % scaled if abs(scaled) < 10 else "%.0f" % scaled
            if "." in text:
                text = text.rstrip("0").rstrip(".")
            return text + suffix
    if abs(value - round(value)) < 1e-9:
        return str(int(round(value)))
    return "%.6g" % value


def nice_ticks(vmax, count=4):
    """Round tick values from 0 up to (at least) vmax."""
    if vmax <= 0:
        return [0, 1]
    raw_step = vmax / count
    magnitude = 10 ** math.floor(math.log10(raw_step))
    step = 10 * magnitude
    for mult in (1, 2, 2.5, 5, 10):
        if mult * magnitude * count >= vmax:
            step = mult * magnitude
            break
    ticks = max(1, math.ceil(vmax / step - 1e-9))
    return [i * step for i in range(ticks + 1)]


class ChartError(Exception):
    pass


def _number(value):
    try:
        number = float(value)
    except (TypeError, ValueError):
        raise ChartError("chart value %r is not a number" % (value,)) from None
    if not math.isfinite(number):
        raise ChartError("chart value %r is not finite" % (value,))
    return number


def _chart_height(spec, default=280):
    try:
        height = int(spec.get("height", default))
    except (TypeError, ValueError):
        raise ChartError(
            '"height" must be a number, got %r' % (spec.get("height"),)) from None
    if height < 80:
        raise ChartError('"height" must be at least 80')
    return height


def _series_of(spec):
    """Normalize a chart spec to (labels, [{name, values}])."""
    if "series" in spec:
        series = []
        for entry in spec["series"]:
            series.append({"name": str(entry.get("name", "")),
                           "values": [_number(v) for v in entry.get("values", [])]})
    elif "values" in spec:
        series = [{"name": str(spec.get("name", "")),
                   "values": [_number(v) for v in spec["values"]]}]
    else:
        raise ChartError('chart needs "values" or "series"')
    if not series or not any(s["values"] for s in series):
        raise ChartError("chart has no data points")
    count = max(len(s["values"]) for s in series)
    if any(s["values"] and len(s["values"]) != count for s in series):
        print("warning: chart series have unequal lengths — short ones "
              "padded with 0", file=sys.stderr)
    for s in series:
        s["values"] += [0.0] * (count - len(s["values"]))
    raw_labels = [str(x) for x in spec.get("labels", [])]
    if raw_labels and len(raw_labels) != count:
        print("warning: chart has %d labels but %d values per series"
              % (len(raw_labels), count), file=sys.stderr)
    labels = raw_labels[:count] + [""] * (count - len(raw_labels))
    return labels, series


def _legend(entries):
    """entries: [(label, color)] -> HTML legend."""
    keys = "".join(
        '<span class="key"><i style="background:%s"></i>%s</span>'
        % (color, html.escape(label)) for label, color in entries)
    return '<div class="legend">%s</div>' % keys


def _axis_grid(ticks, x0, x1, y_of):
    parts = []
    for tick in ticks:
        y = y_of(tick)
        parts.append('<line class="grid" x1="%g" y1="%g" x2="%g" y2="%g"/>'
                     % (x0, y, x1, y))
        parts.append('<text class="tick" x="%g" y="%g" text-anchor="end">%s</text>'
                     % (x0 - 6, y + 3.5, fmt_num(tick)))
    return parts


def _x_label_step(count, max_labels=14):
    return max(1, math.ceil(count / max_labels))


def chart_bar(spec, labels, series):
    width, height = 640, _chart_height(spec)
    ml, mr, mt, mb = 46, 12, 18, 26  # top margin leaves room for value labels
    plot_w, plot_h = width - ml - mr, height - mt - mb
    vmax = max(max(s["values"]) for s in series)
    ticks = nice_ticks(vmax)
    top = ticks[-1]

    def y_of(v):
        return mt + plot_h * (1 - v / top)

    parts = _axis_grid(ticks, ml, width - mr, y_of)
    n = len(labels)
    group_w = plot_w / n
    band = group_w * 0.66
    bar_w = band / len(series)
    show_values = len(series) == 1 and n <= 14
    step = _x_label_step(n)
    for i in range(n):
        gx = ml + i * group_w + (group_w - band) / 2
        for k, s in enumerate(series):
            value = s["values"][i]
            bx, by = gx + k * bar_w, y_of(value)
            parts.append(
                '<rect x="%g" y="%g" width="%g" height="%g" rx="2" fill="%s"/>'
                % (bx, by, max(bar_w - 2, 1), y_of(0) - by, PALETTE[k % len(PALETTE)]))
            if show_values and value > 0:
                parts.append(
                    '<text class="val" x="%g" y="%g" text-anchor="middle">%s</text>'
                    % (bx + bar_w / 2, by - 4, fmt_num(value)))
        if labels[i] and i % step == 0:
            parts.append(
                '<text class="tick" x="%g" y="%g" text-anchor="middle">%s</text>'
                % (ml + i * group_w + group_w / 2, height - 8, html.escape(labels[i])))
    svg = ('<svg viewBox="0 0 %d %d" role="img">%s</svg>'
           % (width, height, "".join(parts)))
    legend = _legend([(s["name"], PALETTE[k % len(PALETTE)])
                      for k, s in enumerate(series)]) if len(series) > 1 else ""
    return svg, legend


_HBAR_LABEL_CHARS = 30


def chart_hbar(spec, labels, series):
    if len(series) > 1:
        raise ChartError('hbar charts take a single series — '
                         'use "values", or type "bar" for grouped series')
    values = series[0]["values"]
    n = len(values)
    shown = [label if len(label) <= _HBAR_LABEL_CHARS
             else label[:_HBAR_LABEL_CHARS - 1] + "…" for label in labels]
    longest = max((len(s) for s in shown), default=0)
    ml = min(16 + _HBAR_LABEL_CHARS * 7, 16 + longest * 7)
    row_h = 30
    width, height = 640, n * row_h + 14
    mr, mt = 46, 6
    plot_w = width - ml - mr
    vmax = max(values)
    top = nice_ticks(vmax)[-1]
    parts = []
    for i, value in enumerate(values):
        y = mt + i * row_h
        bar_len = plot_w * value / top
        parts.append('<rect x="%g" y="%g" width="%g" height="%g" rx="3" fill="%s"/>'
                     % (ml, y + 5, max(bar_len, 1), row_h - 12,
                        PALETTE[i % len(PALETTE)] if spec.get("colorful")
                        else PALETTE[0]))
        parts.append('<text class="tick" x="%g" y="%g" text-anchor="end">%s</text>'
                     % (ml - 8, y + row_h / 2 + 3, html.escape(shown[i])))
        parts.append('<text class="val" x="%g" y="%g">%s</text>'
                     % (ml + bar_len + 6, y + row_h / 2 + 3, fmt_num(value)))
    svg = ('<svg viewBox="0 0 %d %d" role="img">%s</svg>'
           % (width, height, "".join(parts)))
    return svg, ""


def chart_line(spec, labels, series, area=False):
    width, height = 640, _chart_height(spec)
    ml, mr, mt, mb = 46, 14, 10, 26
    plot_w, plot_h = width - ml - mr, height - mt - mb
    vmax = max(max(s["values"]) for s in series)
    ticks = nice_ticks(vmax)
    top = ticks[-1]
    n = len(labels)

    def x_of(i):
        return ml + (plot_w / 2 if n == 1 else plot_w * i / (n - 1))

    def y_of(v):
        return mt + plot_h * (1 - v / top)

    parts = _axis_grid(ticks, ml, width - mr, y_of)
    step = _x_label_step(n)
    for i in range(0, n, step):
        if labels[i]:
            parts.append(
                '<text class="tick" x="%g" y="%g" text-anchor="middle">%s</text>'
                % (x_of(i), height - 8, html.escape(labels[i])))
    for k, s in enumerate(series):
        color = PALETTE[k % len(PALETTE)]
        points = " ".join("%g,%g" % (x_of(i), y_of(v))
                          for i, v in enumerate(s["values"]))
        if area:
            parts.append(
                '<path d="M%g,%g L%s L%g,%g Z" fill="%s" opacity="0.16"/>'
                % (x_of(0), y_of(0), points, x_of(n - 1), y_of(0), color))
        parts.append('<polyline points="%s" fill="none" stroke="%s" '
                     'stroke-width="2.5" stroke-linejoin="round"/>' % (points, color))
        if n <= 30:
            for i, v in enumerate(s["values"]):
                parts.append('<circle cx="%g" cy="%g" r="3" fill="%s"/>'
                             % (x_of(i), y_of(v), color))
    svg = ('<svg viewBox="0 0 %d %d" role="img">%s</svg>'
           % (width, height, "".join(parts)))
    legend = _legend([(s["name"], PALETTE[k % len(PALETTE)])
                      for k, s in enumerate(series)]) if len(series) > 1 else ""
    return svg, legend


def chart_pie(spec, labels, series, donut=False):
    values = series[0]["values"]
    total = sum(values)
    if total <= 0:
        raise ChartError("pie chart values sum to zero")
    size = 220
    cx = cy = size / 2
    r_outer = size / 2 - 4
    r_inner = r_outer * 0.62 if donut else 0
    parts = []
    nonzero = [(i, v) for i, v in enumerate(values) if v > 0]
    if len(nonzero) == 1:
        i = nonzero[0][0]
        color = PALETTE[i % len(PALETTE)]
        if donut:
            parts.append('<circle cx="%g" cy="%g" r="%g" fill="none" stroke="%s" '
                         'stroke-width="%g"/>'
                         % (cx, cy, (r_outer + r_inner) / 2, color, r_outer - r_inner))
        else:
            parts.append('<circle cx="%g" cy="%g" r="%g" fill="%s"/>'
                         % (cx, cy, r_outer, color))
    else:
        angle = -math.pi / 2
        for i, value in enumerate(values):
            if value <= 0:
                continue
            sweep = 2 * math.pi * value / total
            a0, a1 = angle, angle + sweep
            angle = a1
            large = 1 if sweep > math.pi else 0
            x0o, y0o = cx + r_outer * math.cos(a0), cy + r_outer * math.sin(a0)
            x1o, y1o = cx + r_outer * math.cos(a1), cy + r_outer * math.sin(a1)
            color = PALETTE[i % len(PALETTE)]
            if donut:
                x0i, y0i = cx + r_inner * math.cos(a1), cy + r_inner * math.sin(a1)
                x1i, y1i = cx + r_inner * math.cos(a0), cy + r_inner * math.sin(a0)
                path = ("M%g,%g A%g,%g 0 %d 1 %g,%g L%g,%g A%g,%g 0 %d 0 %g,%g Z"
                        % (x0o, y0o, r_outer, r_outer, large, x1o, y1o,
                           x0i, y0i, r_inner, r_inner, large, x1i, y1i))
            else:
                path = ("M%g,%g L%g,%g A%g,%g 0 %d 1 %g,%g Z"
                        % (cx, cy, x0o, y0o, r_outer, r_outer, large, x1o, y1o))
            parts.append('<path d="%s" fill="%s" stroke="var(--panel)" '
                         'stroke-width="1.5"/>' % (path, color))
    svg = ('<svg viewBox="0 0 %d %d" role="img" class="pie">%s</svg>'
           % (size, size, "".join(parts)))
    legend = _legend([
        ("%s — %s (%s%%)" % (labels[i] or "·", fmt_num(v),
                             fmt_num(round(100 * v / total, 1))),
         PALETTE[i % len(PALETTE)])
        for i, v in enumerate(values)])
    return svg, legend


CHART_TYPES = {
    "bar": chart_bar,
    "hbar": chart_hbar,
    "line": chart_line,
    "area": lambda spec, labels, series: chart_line(spec, labels, series, area=True),
    "pie": chart_pie,
    "donut": lambda spec, labels, series: chart_pie(spec, labels, series, donut=True),
}


def _load_chart_data(spec, ctx):
    """Fill labels/values/series from the CSV or JSON file named in "data"."""
    rel = str(spec["data"])
    if any(key in spec for key in ("labels", "values", "series")):
        raise ChartError('chart uses "data" — remove the inline '
                         'labels/values/series keys')
    path = Path(ctx.get("base_dir", ".")) / rel
    if not path.is_file():
        raise ChartError('data file "%s" not found' % rel)

    if path.suffix.lower() == ".json":
        try:
            loaded = json.loads(path.read_text(encoding="utf-8"))
        except json.JSONDecodeError as exc:
            raise ChartError('data file "%s": %s' % (rel, exc)) from exc
        if not isinstance(loaded, dict):
            raise ChartError('data file "%s" must be a JSON object with '
                             'labels and values/series' % rel)
        for key in ("labels", "values", "series", "name"):
            if key in loaded:
                spec[key] = loaded[key]
        return

    # CSV: header row, first column = labels, every other column = a series
    with path.open(newline="", encoding="utf-8-sig") as handle:
        rows = [row for row in csv.reader(handle)
                if any(cell.strip() for cell in row)]
    if len(rows) < 2 or len(rows[0]) < 2:
        raise ChartError('data file "%s" needs a header row plus data rows, '
                         'first column = labels' % rel)
    header = [cell.strip() for cell in rows[0]]
    spec["labels"] = [row[0].strip() for row in rows[1:]]
    columns = []
    for col in range(1, len(header)):
        values = []
        for row_no, row in enumerate(rows[1:], start=2):
            cell = row[col].strip() if col < len(row) else ""
            try:
                values.append(float(cell) if cell else 0.0)
            except ValueError:
                raise ChartError('data file "%s": %r (row %d, column "%s") '
                                 'is not a number' % (rel, cell, row_no,
                                                      header[col])) from None
        columns.append({"name": header[col], "values": values})
    if len(columns) == 1:
        spec["values"] = columns[0]["values"]
        spec.setdefault("name", columns[0]["name"])
    else:
        spec["series"] = columns


def render_chart(body, ctx):
    try:
        spec = json.loads("\n".join(body))
    except json.JSONDecodeError as exc:
        raise ChartError("invalid JSON in chart block: %s" % exc) from exc
    if not isinstance(spec, dict):
        raise ChartError("chart block must be a JSON object")
    if "data" in spec:
        _load_chart_data(spec, ctx)
    kind = str(spec.get("type", "bar")).lower()
    if kind not in CHART_TYPES:
        raise ChartError('unknown chart type "%s" (use %s)'
                         % (kind, ", ".join(sorted(CHART_TYPES))))
    labels, series = _series_of(spec)
    svg, legend = CHART_TYPES[kind](spec, labels, series)
    caption = ('<figcaption>%s</figcaption>' % render_inline(str(spec["title"]))
               if spec.get("title") else "")
    return ('<figure class="chart chart-%s">%s'
            '<div class="chart-body">%s%s</div></figure>'
            % (kind, caption, svg, legend))


# --------------------------------------------------------------------------
# Block-level markdown
# --------------------------------------------------------------------------

STAT_COLOR_ALIASES = {
    "green": "green", "good": "green", "pass": "green",
    "amber": "amber", "warn": "amber", "yellow": "amber",
    "red": "red", "bad": "red", "fail": "red",
    "blue": "blue", "info": "blue",
    "gray": "gray", "grey": "gray", "dim": "gray",
}


def render_stats(body):
    cells = []
    for line in body:
        if not line.strip():
            continue
        parts = [p.strip() for p in line.split("|")]
        num = parts[0]
        label = parts[1] if len(parts) > 1 else ""
        color = STAT_COLOR_ALIASES.get(parts[2].lower(), "") \
            if len(parts) > 2 and parts[2] else ""
        cells.append('<div class="stat%s"><div class="num">%s</div>'
                     '<div class="lab">%s</div></div>'
                     % ((" " + color) if color else "",
                        render_inline(num), render_inline(label)))
    return '<div class="stat-row">%s</div>' % "".join(cells)


def render_note(label, body_lines, extra_class=""):
    label_html = ('<div class="note-label">%s</div>' % render_inline(label)
                  if label else "")
    paragraphs = []
    current = []
    for line in body_lines + [""]:
        if line.strip():
            current.append(line.strip())
        elif current:
            paragraphs.append("<p>%s</p>" % render_inline(" ".join(current)))
            current = []
    return ('<div class="note%s">%s%s</div>'
            % (extra_class, label_html, "".join(paragraphs)))


def render_pills(body):
    pills = []
    for line in body:
        if not line.strip():
            continue
        text, _, href = (p.strip() for p in line.partition("|"))
        if href:
            pills.append('<a class="pill" href="%s">%s</a>'
                         % (html.escape(href, quote=True), render_inline(text)))
        else:
            pills.append('<span class="pill">%s</span>' % render_inline(text))
    return '<div class="row">%s</div>' % "".join(pills)


def render_cards(arg, body, ctx):
    cards = []
    title, content = None, []
    for line in body + ["### "]:
        if line.startswith("### "):
            if title is not None or content:
                cards.append((title, content))
            title, content = line[4:].strip(), []
        else:
            content.append(line)
    rendered = []
    for card_title, card_body in cards:
        title_html = "<h3>%s</h3>" % render_inline(card_title) if card_title else ""
        rendered.append('<div class="card">%s%s</div>'
                        % (title_html, render_blocks(card_body, ctx)))
    if arg and arg.strip() in ("2", "3"):
        cols = int(arg.strip())
    else:
        count = len(rendered)
        cols = 3 if count in (3, 6, 9) else 2
    return '<div class="grid cols-%d">%s</div>' % (cols, "".join(rendered))


def render_table(rows):
    def cells(row):
        row = row.strip()
        if row.startswith("|"):
            row = row[1:]
        if row.endswith("|"):
            row = row[:-1]
        return [c.strip() for c in row.split("|")]

    aligns = []
    for cell in cells(rows[1]):
        left, right = cell.startswith(":"), cell.endswith(":")
        aligns.append("center" if left and right else
                      "right" if right else "left")

    def render_row(row, tag):
        out = []
        for i, cell in enumerate(cells(row)):
            align = aligns[i] if i < len(aligns) else "left"
            style = ' style="text-align:%s"' % align if align != "left" else ""
            out.append("<%s%s>%s</%s>" % (tag, style, render_inline(cell), tag))
        return "<tr>%s</tr>" % "".join(out)

    head = render_row(rows[0], "th")
    body = "".join(render_row(r, "td") for r in rows[2:])
    return ("<table><thead>%s</thead><tbody>%s</tbody></table>" % (head, body))


def render_list(lines, start):
    ordered = bool(re.match(r"^\s*\d+[.)]\s", lines[start]))
    items = []  # (text, [subitems])
    i = start
    while i < len(lines):
        match = re.match(r"^(\s*)([-*+]|\d+[.)])\s+(.*)$", lines[i])
        if not match or not lines[i].strip():
            break
        indent, text = len(match.group(1)), match.group(3)
        if indent >= 2 and items:
            items[-1][1].append(text)
        else:
            items.append((text, []))
        i += 1
    tag = "ol" if ordered else "ul"
    out = []
    for text, children in items:
        if children:
            sub = "".join("<li>%s</li>" % render_inline(c) for c in children)
            out.append("<li>%s<ul>%s</ul></li>" % (render_inline(text), sub))
        else:
            out.append("<li>%s</li>" % render_inline(text))
    return "<%s>%s</%s>" % (tag, "".join(out), tag), i


_FENCE_RE = re.compile(r"^```(\S*)\s*(.*?)\s*$")
_LIST_RE = re.compile(r"^\s*([-*+]|\d+[.)])\s+")
_TABLE_SEP_RE = re.compile(r"^\|?[\s:|-]+\|[\s:|-]*$")


def _is_block_start(line):
    stripped = line.strip()
    return (not stripped
            or stripped.startswith("```")
            or stripped.startswith("#")
            or stripped.startswith(">")
            or stripped.startswith("|")
            or stripped.startswith("<")
            or bool(_LIST_RE.match(line))
            or bool(re.fullmatch(r"-{3,}", stripped)))


def render_fence(lang, arg, body, ctx):
    if lang == "chart":
        return render_chart(body, ctx)
    if lang == "stats":
        return render_stats(body)
    if lang == "note":
        return render_note(arg, body)
    if lang == "notes":
        if not ctx.get("show_notes"):
            return ""
        return render_note(arg or "Speaker notes", body, extra_class=" speaker")
    if lang == "cards":
        return render_cards(arg, body, ctx)
    if lang == "pills":
        return render_pills(body)
    if lang == "mermaid":
        ctx["mermaid"] = True
        return '<pre class="mermaid">%s</pre>' % html.escape("\n".join(body))
    css_class = ' class="language-%s"' % html.escape(lang) if lang else ""
    return "<pre><code%s>%s</code></pre>" % (css_class,
                                             html.escape("\n".join(body)))


def render_blocks(lines, ctx, intro_first=False):
    out = []
    i = 0
    saw_paragraph = False
    while i < len(lines):
        stripped = lines[i].strip()
        if not stripped:
            i += 1
            continue

        fence = _FENCE_RE.match(stripped)
        if fence:
            lang, arg = fence.group(1).lower(), fence.group(2)
            body = []
            depth = 0  # nested fences (with info strings) inside cards/notes
            i += 1
            while i < len(lines):
                inner = lines[i].strip()
                if inner.startswith("```"):
                    if inner == "```":
                        if depth == 0:
                            break
                        depth -= 1
                    else:
                        depth += 1
                body.append(lines[i])
                i += 1
            i += 1  # closing fence
            try:
                out.append(render_fence(lang, arg, body, ctx))
            except ChartError as exc:
                raise SystemExit("error: %s (in slide “%s”)"
                                 % (exc, ctx.get("slide", "?"))) from exc
            continue

        if stripped.startswith("### "):
            out.append("<h3>%s</h3>" % render_inline(stripped[4:]))
            i += 1
            continue

        if re.fullmatch(r"-{3,}", stripped):
            out.append("<hr>")
            i += 1
            continue

        if stripped.startswith(">"):
            quote = []
            while i < len(lines) and lines[i].strip().startswith(">"):
                quote.append(lines[i].strip().lstrip(">").strip())
                i += 1
            label = None
            if quote and re.fullmatch(r"\*\*[^*]+\*\*", quote[0]):
                label, quote = quote[0].strip("*"), quote[1:]
            out.append(render_note(label, quote))
            continue

        if (stripped.startswith("|") and i + 1 < len(lines)
                and _TABLE_SEP_RE.match(lines[i + 1].strip())):
            rows = []
            while i < len(lines) and lines[i].strip().startswith("|"):
                rows.append(lines[i].strip())
                i += 1
            out.append(render_table(rows))
            continue

        if _LIST_RE.match(lines[i]):
            block, i = render_list(lines, i)
            out.append(block)
            continue

        if stripped.startswith("<"):
            raw = []
            while i < len(lines) and lines[i].strip():
                raw.append(lines[i])
                i += 1
            out.append("\n".join(raw))
            continue

        # paragraph
        para = []
        while i < len(lines) and lines[i].strip() and not _is_block_start(lines[i]):
            para.append(lines[i].strip())
            i += 1
        css = ' class="intro"' if intro_first and not saw_paragraph else ""
        saw_paragraph = True
        out.append("<p%s>%s</p>" % (css, render_inline(" ".join(para))))
    return "\n".join(out)


# --------------------------------------------------------------------------
# Slides
# --------------------------------------------------------------------------

def split_slides(body):
    slides = []
    current = None
    fence_depth = 0
    for line in body.split("\n"):
        stripped = line.strip()
        if stripped.startswith("```"):
            if stripped == "```" and fence_depth > 0:
                fence_depth -= 1
            else:
                fence_depth += 1
        heading = None if fence_depth else re.match(r"^(#{1,2})\s+(.*)$", line)
        if heading:
            title = heading.group(2).strip()
            slide_id = None
            id_match = re.search(r"\{#([a-zA-Z0-9_-]+)\}\s*$", title)
            if id_match:
                slide_id = id_match.group(1)
                title = title[:id_match.start()].strip()
            current = {"level": len(heading.group(1)), "title": title,
                       "id": slide_id, "lines": []}
            slides.append(current)
        else:
            if current is None:
                if not stripped:
                    continue
                current = {"level": 2, "title": "", "id": None, "lines": []}
                slides.append(current)
            current["lines"].append(line)
    # assign unique ids
    used = set()
    for slide in slides:
        base = slide["id"] or slugify(slide["title"])
        candidate, n = base, 2
        while candidate in used:
            candidate = "%s-%d" % (base, n)
            n += 1
        slide["id"] = candidate
        used.add(candidate)
    return slides


# --------------------------------------------------------------------------
# Page template
# --------------------------------------------------------------------------

PAGE_CSS = """
  :root {
    --bg: %(bg)s;
    --panel: #161a22;
    --panel-2: #1d2230;
    --ink: #e8ecf1;
    --ink-dim: #aab2c0;
    --rule: #2a3142;
    --accent: %(accent)s;
    --accent-2: #6aa9ff;
    --good: #6fcf97;
    --warn: #ffd166;
    --bad: #ff7676;
    %(chart_dark)s
    --mono: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
  }
  @media (prefers-color-scheme: light) {
    :root {
      --bg: %(bg_light)s;
      --panel: #ffffff;
      --panel-2: #f3f4f8;
      --ink: #1c2024;
      --ink-dim: #5b6470;
      --rule: #e3e6ec;
      --accent: %(accent_light)s;
      --accent-2: #1f5fcb;
      --good: #1e9e5a;
      --warn: #b88600;
      --bad: #d64545;
      %(chart_light)s
    }
  }
  * { box-sizing: border-box; }
  html, body { margin: 0; padding: 0; background: var(--bg); color: var(--ink); }
  body {
    font: 16px/1.55 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
          "Helvetica Neue", Arial, sans-serif;
    -webkit-font-smoothing: antialiased;
  }
  .layout { display: grid; grid-template-columns: 240px 1fr; min-height: 100vh; }
  nav.toc {
    position: sticky; top: 0; align-self: start; max-height: 100vh; overflow: auto;
    border-right: 1px solid var(--rule); padding: 28px 20px 40px;
    background: var(--panel);
  }
  nav.toc h2 {
    font-size: 11px; letter-spacing: 0.12em; text-transform: uppercase;
    color: var(--ink-dim); margin: 0 0 14px;
  }
  nav.toc ol { list-style: none; margin: 0; padding: 0; counter-reset: step; }
  nav.toc ol li { counter-increment: step; margin: 4px 0; }
  nav.toc ol li a {
    display: block; padding: 6px 8px; border-radius: 6px;
    text-decoration: none; color: var(--ink); font-size: 13.5px;
  }
  nav.toc ol li a::before {
    content: counter(step, decimal-leading-zero);
    color: var(--ink-dim); font-family: var(--mono); font-size: 11px;
    margin-right: 10px;
  }
  nav.toc ol li a:hover { background: var(--panel-2); }
  main { padding: 0; min-width: 0; }
  section.slide {
    padding: 64px 72px;
    border-bottom: 1px solid var(--rule);
    min-height: 100vh;
  }
  section.slide.title {
    background: linear-gradient(135deg, var(--panel) 0%%, var(--panel-2) 100%%);
  }
  .eyebrow {
    font-size: 11px; letter-spacing: 0.18em; text-transform: uppercase;
    color: var(--accent); margin-bottom: 18px;
  }
  h1 { font-size: 42px; line-height: 1.15; margin: 0 0 16px; letter-spacing: -0.01em; }
  h1.hero { font-size: 56px; max-width: 18ch; }
  h2.slide-h { font-size: 30px; margin: 0 0 28px; letter-spacing: -0.01em; }
  h3 { font-size: 18px; margin: 28px 0 10px; color: var(--ink); }
  p, li { color: var(--ink); font-size: 16.5px; }
  p.intro { font-size: 17px; color: var(--ink); max-width: 70ch; }
  a { color: var(--accent-2); }
  hr { border: none; border-top: 1px solid var(--rule); margin: 26px 0; }
  img { max-width: 100%%; border-radius: 8px; }
  .grid { display: grid; gap: 20px; margin: 18px 0; }
  .grid.cols-2 { grid-template-columns: 1fr 1fr; }
  .grid.cols-3 { grid-template-columns: repeat(3, 1fr); }
  .card {
    background: var(--panel); border: 1px solid var(--rule); border-radius: 10px;
    padding: 20px 22px;
  }
  .card h3 { margin-top: 0; }
  table { width: 100%%; border-collapse: collapse; margin: 12px 0; font-size: 14.5px; }
  th, td {
    text-align: left; padding: 10px 12px;
    border-bottom: 1px solid var(--rule); vertical-align: top;
  }
  th { font-weight: 600; color: var(--ink-dim); font-size: 12.5px;
       text-transform: uppercase; letter-spacing: 0.06em; }
  code, kbd { font-family: var(--mono); font-size: 13.5px;
              background: var(--panel-2); padding: 1px 6px; border-radius: 4px; }
  pre {
    background: var(--panel-2); border: 1px solid var(--rule); border-radius: 8px;
    padding: 14px 16px; overflow: auto; font-family: var(--mono); font-size: 13px;
    line-height: 1.55;
  }
  pre code { background: none; padding: 0; font-size: inherit; }
  .badge {
    display: inline-block; font-family: var(--mono); font-size: 11.5px;
    padding: 2px 8px; border-radius: 999px; border: 1px solid var(--rule);
    background: var(--panel-2); color: var(--ink-dim);
    letter-spacing: 0.04em;
  }
  .badge.good   { color: var(--good);   border-color: color-mix(in srgb, var(--good) 35%%, transparent); }
  .badge.warn   { color: var(--warn);   border-color: color-mix(in srgb, var(--warn) 40%%, transparent); }
  .badge.bad    { color: var(--bad);    border-color: color-mix(in srgb, var(--bad) 35%%, transparent); }
  .badge.info   { color: var(--accent-2); border-color: color-mix(in srgb, var(--accent-2) 35%%, transparent); }
  .badge.accent { color: var(--accent); border-color: color-mix(in srgb, var(--accent) 35%%, transparent); }
  .badge.purple { color: var(--c4); border-color: color-mix(in srgb, var(--c4) 35%%, transparent); }
  .badge.teal   { color: var(--c7); border-color: color-mix(in srgb, var(--c7) 35%%, transparent); }
  .badge.dim    { color: var(--ink-dim); }
  .pill {
    display: inline-flex; align-items: center; gap: 6px;
    background: var(--panel-2); border: 1px solid var(--rule);
    border-radius: 999px; padding: 4px 10px; font-size: 12.5px;
    font-family: var(--mono); color: var(--ink-dim); text-decoration: none;
  }
  a.pill:hover { color: var(--ink); border-color: var(--accent); }
  .note {
    border-left: 3px solid var(--accent); padding: 14px 18px;
    background: var(--panel-2); border-radius: 0 8px 8px 0;
    margin: 18px 0; font-size: 15.5px;
  }
  .note p { margin: 6px 0; font-size: 15.5px; }
  .note .note-label {
    font-weight: 600; color: var(--accent);
    text-transform: uppercase; letter-spacing: 0.08em; font-size: 11.5px;
    margin-bottom: 6px;
  }
  .note.speaker {
    background: transparent; border: 1px dashed var(--rule);
    border-left: 3px solid var(--c4); border-radius: 0 8px 8px 0;
    color: var(--ink-dim);
  }
  .note.speaker .note-label { color: var(--c4); }
  .stat-row { display: flex; gap: 28px; flex-wrap: wrap; margin: 20px 0 6px; }
  .stat { background: var(--panel); border: 1px solid var(--rule);
          border-radius: 10px; padding: 14px 22px; min-width: 120px; }
  .stat .num { font-size: 32px; font-weight: 700; line-height: 1; }
  .stat .lab { font-size: 12px; color: var(--ink-dim);
               text-transform: uppercase; letter-spacing: 0.08em; margin-top: 6px; }
  .stat.green .num { color: var(--good); }
  .stat.amber .num { color: var(--warn); }
  .stat.red   .num { color: var(--bad); }
  .stat.blue  .num { color: var(--accent-2); }
  .stat.gray  .num { color: var(--ink-dim); }
  .row { display: flex; flex-wrap: wrap; gap: 8px; margin: 14px 0; }
  figure.chart { margin: 22px 0; }
  figure.chart figcaption {
    font-size: 13px; color: var(--ink-dim); font-family: var(--mono);
    text-transform: uppercase; letter-spacing: 0.08em; margin-bottom: 10px;
  }
  .chart-body { display: flex; align-items: center; gap: 26px; flex-wrap: wrap; }
  .chart svg { max-width: 100%%; height: auto; flex: 1 1 360px; min-width: 280px; }
  .chart svg.pie { flex: 0 0 200px; min-width: 180px; max-width: 220px; }
  .chart text { font-family: var(--mono); font-size: 11px; fill: var(--ink-dim); }
  .chart text.val { fill: var(--ink); font-size: 11.5px; }
  .chart line.grid { stroke: var(--rule); stroke-width: 1; }
  .legend { display: flex; flex-direction: column; gap: 8px; font-size: 13.5px; }
  .legend .key { display: inline-flex; align-items: center; gap: 8px; color: var(--ink); }
  .legend .key i { width: 12px; height: 12px; border-radius: 3px; flex: none; }
  .chart-bar .legend, .chart-line .legend, .chart-area .legend {
    flex-direction: row; gap: 18px; flex-basis: 100%%;
  }
  .footer {
    padding: 28px 72px; color: var(--ink-dim); font-size: 13px;
    border-top: 1px solid var(--rule);
  }
  @media (max-width: 900px) {
    .layout { grid-template-columns: 1fr; }
    nav.toc { position: static; max-height: none; border-right: none;
              border-bottom: 1px solid var(--rule); }
    section.slide { padding: 36px 28px; min-height: auto; }
    h1.hero { font-size: 38px; }
    .grid.cols-2, .grid.cols-3 { grid-template-columns: 1fr; }
  }
  @media print {
    nav.toc { display: none; }
    .layout { grid-template-columns: 1fr; }
    section.slide { page-break-after: always; min-height: auto; }
  }
"""

# Preset palettes. "chart" / "chart_light" are chart colors c2..c7 — c1 is
# always the accent. Explicit frontmatter keys (accent, background, …)
# override whatever the palette sets.
PALETTES = {
    "default": {
        "accent": "#ffb547", "accent_light": "#c2530a",
        "background": "#0f1115", "background_light": "#fbfbfd",
        "chart": ["#6aa9ff", "#6fcf97", "#c39bd3", "#ffd166", "#ff7676", "#8fd3c7"],
        "chart_light": ["#1f5fcb", "#1e9e5a", "#8e44ad", "#b88600", "#d64545", "#0f8a7a"],
    },
    "ocean": {
        "accent": "#45c4dd", "accent_light": "#0277bd",
        "background": "#0a1318", "background_light": "#f6fafc",
        "chart": ["#5d9cff", "#4fd6b8", "#8e9bff", "#ffd166", "#ff8aa1", "#9ad6e8"],
        "chart_light": ["#1d5fd6", "#0c8f6e", "#5460d6", "#b88600", "#c23d5d", "#0b7da0"],
    },
    "forest": {
        "accent": "#9ccc65", "accent_light": "#33691e",
        "background": "#0e130c", "background_light": "#fafbf7",
        "chart": ["#66bb6a", "#ffd54f", "#a1887f", "#4db6ac", "#dce775", "#ef9a9a"],
        "chart_light": ["#2e7d32", "#b88600", "#6d4c41", "#00796b", "#9e9d24", "#c62828"],
    },
    "mono": {
        "accent": "#e8e8e8", "accent_light": "#222222",
        "background": "#0c0c0d", "background_light": "#fcfcfc",
        "chart": ["#bdbdbd", "#9e9e9e", "#757575", "#d6d6d6", "#616161", "#8a8a8a"],
        "chart_light": ["#424242", "#757575", "#9e9e9e", "#212121", "#bdbdbd", "#616161"],
    },
    "crimson": {
        "accent": "#ff6b81", "accent_light": "#b3123d",
        "background": "#150a0e", "background_light": "#fdf8f9",
        "chart": ["#ff9e7d", "#f06292", "#ba68c8", "#ffd166", "#90a4ae", "#ef5350"],
        "chart_light": ["#d84315", "#ad1457", "#7b1fa2", "#b88600", "#546e7a", "#c62828"],
    },
}


def _chart_vars(colors):
    return " ".join("--c%d: %s;" % (i + 1, color)
                    for i, color in enumerate(colors))


DECK_CSS = """
  /* template: deck — full-screen snap-scrolling slides */
  body.tpl-deck { height: 100vh; overflow-y: auto; scroll-snap-type: y mandatory; }
  body.tpl-deck .layout { display: block; }
  body.tpl-deck nav.toc { display: none; }
  body.tpl-deck section.slide {
    height: 100vh; overflow: hidden; scroll-snap-align: start;
    display: flex; flex-direction: column; justify-content: center;
    padding: 48px 96px; position: relative;
  }
  body.tpl-deck section.slide > * { max-width: 1080px; }
  body.tpl-deck .footer { display: none; }
  body.tpl-deck section.slide::after {
    content: attr(data-num); position: absolute; right: 28px; bottom: 20px;
    font-family: var(--mono); font-size: 12px; color: var(--ink-dim);
  }
  @media (max-width: 900px) {
    body.tpl-deck section.slide { padding: 36px 28px; height: auto;
                                  min-height: 100vh; overflow: visible; }
  }
  @media print {
    body.tpl-deck { height: auto; overflow: visible; }
    body.tpl-deck section.slide { height: auto; overflow: visible; }
  }
"""

DOC_CSS = """
  /* template: doc — single-column document / report */
  body.tpl-doc .layout { display: block; max-width: 880px; margin: 0 auto; }
  body.tpl-doc nav.toc {
    position: static; max-height: none; overflow: visible;
    border: 1px solid var(--rule); border-radius: 10px;
    margin: 36px 28px 0; background: var(--panel);
  }
  body.tpl-doc section.slide { min-height: auto; padding: 44px 28px;
                               border-bottom: 1px solid var(--rule); }
  body.tpl-doc section.slide.title { border-radius: 10px; margin: 24px 28px;
                                     border: 1px solid var(--rule); }
  body.tpl-doc h1.hero { font-size: 40px; }
  body.tpl-doc .footer { border-top: none; text-align: center; }
"""

TEMPLATES = {
    "sidebar": "",      # the default walkthrough look: sticky TOC + sections
    "deck": DECK_CSS,   # full-screen slides, snap scrolling, slide counter
    "doc": DOC_CSS,     # single-column report, TOC box at the top
}

MERMAID_SNIPPET = """
<script type="module">
  import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";
  const dark = window.matchMedia("(prefers-color-scheme: dark)").matches;
  mermaid.initialize({ startOnLoad: true, theme: dark ? "dark" : "neutral" });
</script>
"""


def build_html(meta, slides, ctx, template=None):
    template = template or meta.get("template", "sidebar")
    if template not in TEMPLATES:
        raise SystemExit('error: unknown template "%s" (available: %s)'
                         % (template, ", ".join(sorted(TEMPLATES))))
    title = meta.get("title") or strip_markup(slides[0]["title"]) or "Presentation"
    toc_title = meta.get("toc_title", "Contents")
    palette_name = meta.get("palette", meta.get("theme", "default"))
    if palette_name not in PALETTES:
        raise SystemExit('error: unknown palette "%s" (available: %s)'
                         % (palette_name, ", ".join(sorted(PALETTES))))
    palette = PALETTES[palette_name]

    def css_value(key, default):
        # these land inside the <style> block — strip anything that could
        # terminate it or open a tag; all valid CSS color/gradient values pass
        return re.sub(r"[<>{}]", "", meta.get(key, default))

    accent = css_value("accent", palette["accent"])
    accent_light = css_value(
        "accent_light",
        accent if "accent" in meta else palette["accent_light"])
    background = css_value("background", palette["background"])
    background_light = css_value("background_light", palette["background_light"])

    toc_items = []
    sections = []
    for index, slide in enumerate(slides):
        ctx["slide"] = strip_markup(slide["title"]) or slide["id"]
        toc_items.append('<li><a href="#%s">%s</a></li>'
                         % (slide["id"],
                            html.escape(strip_markup(slide["title"]) or "Untitled")))
        classes = "slide title" if slide["level"] == 1 else "slide"
        if index == 0 and slide["level"] == 1:
            eyebrow = meta.get("eyebrow", "")
            heading = '<h1 class="hero">%s</h1>' % render_inline(slide["title"])
        else:
            eyebrow = "%02d" % (index + 1)
            if slide["level"] == 1:
                heading = "<h1>%s</h1>" % render_inline(slide["title"])
            else:
                heading = '<h2 class="slide-h">%s</h2>' % render_inline(slide["title"])
        if index == 0 and meta.get("subtitle"):
            heading += '\n<p class="intro">%s</p>' % render_inline(meta["subtitle"])
        eyebrow_html = '<div class="eyebrow">%s</div>' % render_inline(eyebrow) \
            if eyebrow else ""
        body = render_blocks(slide["lines"], ctx, intro_first=True)
        sections.append(
            '<section id="%s" class="%s" data-num="%d / %d">\n%s%s\n%s\n</section>'
            % (slide["id"], classes, index + 1, len(slides),
               eyebrow_html, heading, body))

    footer = meta.get("footer",
                      "Built with crossPresent · self-contained HTML · "
                      "prints one slide per page")
    mermaid = MERMAID_SNIPPET if ctx.get("mermaid") else ""

    css = (PAGE_CSS % {
        "accent": accent, "accent_light": accent_light,
        "bg": background, "bg_light": background_light,
        "chart_dark": _chart_vars([accent] + palette["chart"]),
        "chart_light": _chart_vars([accent_light] + palette["chart_light"]),
    } + TEMPLATES[template])
    return """<!doctype html>
<html lang="%(lang)s">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>%(title)s</title>
<style>%(css)s</style>
</head>
<body class="tpl-%(template)s">
<div class="layout">

<nav class="toc" aria-label="Table of contents">
  <h2>%(toc_title)s</h2>
  <ol>
%(toc)s
  </ol>
</nav>

<main>
%(sections)s
</main>
</div>

<div class="footer">%(footer)s</div>
%(mermaid)s</body>
</html>
""" % {
        "lang": meta.get("lang", "en"),
        "title": html.escape(title),
        "template": template,
        "css": css,
        "toc_title": html.escape(toc_title),
        "toc": "\n".join("    " + item for item in toc_items),
        "sections": "\n\n".join(sections),
        "footer": render_inline(footer),
        "mermaid": mermaid,
    }


# --------------------------------------------------------------------------
# Image embedding
# --------------------------------------------------------------------------

def embed_images(html_text, base_dir):
    def embed(match):
        src = match.group(1)
        if src.startswith(("http://", "https://", "data:")):
            return match.group(0)
        path = (base_dir / src).resolve()
        if not path.is_file():
            print("warning: --embed could not find image %s" % src, file=sys.stderr)
            return match.group(0)
        mime = mimetypes.guess_type(str(path))[0] or "application/octet-stream"
        data = base64.b64encode(path.read_bytes()).decode("ascii")
        return match.group(0).replace(src, "data:%s;base64,%s" % (mime, data))

    return re.sub(r'<img src="([^"]+)"', embed, html_text)


# --------------------------------------------------------------------------
# Scaffold
# --------------------------------------------------------------------------

SCAFFOLD = """---
title: %(name)s
subtitle: One sentence on what this deck covers and who it is for.
eyebrow: Project walkthrough
# templates: sidebar (TOC + sections) · deck (full-screen slides) · doc (report)
template: sidebar
# palettes: default · ocean · forest · mono · crimson
palette: default
# theming — uncomment to override the palette (dark / light pair):
# accent: "#ffb547"
# background: "#0f1115"
# background_light: "#fbfbfd"
footer: %(name)s · built with crossPresent
---

# %(name)s

```stats
12 | things done | green
3 | in progress | amber
1 | blocked | red
```

## The problem {#problem}

First paragraph of a slide is styled as the intro — use it to frame the
slide in one or two sentences.

- Bullet points work, with **bold**, *italic*, `code` and [links](https://example.com)
- Badges: [[DONE|good]] [[WIP|warn]] [[BLOCKED|bad]] [[v2.1|info]] [[NOTE]]
  - One level of nesting is supported

> **Heads up**
> Blockquotes become callout notes. Start the first line with a bold
> phrase to give the note a label.

```notes
Speaker notes live in a `notes` block. They are stripped from the
output unless you build (or serve) with --notes.
```

## Numbers, visualised

```chart
{
  "type": "bar",
  "title": "Requests per day",
  "labels": ["Mon", "Tue", "Wed", "Thu", "Fri"],
  "values": [120, 200, 150, 310, 260]
}
```

Chart types: `bar`, `hbar`, `line`, `area`, `pie`, `donut`.
Use `"series"` instead of `"values"` for multi-series lines and grouped bars.

## Tables and cards

| Step | What happens | Status |
|------|--------------|--------|
| Parse | Markdown in | [[done|good]] |
| Render | HTML out | [[done|good]] |
| Charts | Inline SVG | [[next|warn]] |

```cards
### Left card
Cards split on `###` headings inside a `cards` block.

### Right card
Pass a column count after the fence tag: ` ```cards 3 `.
```

# Thanks — that's the deck.

```pills
README | https://example.com
Repo | https://example.com
```
"""

# The bundled showcase deck for `crosspresent demo`. Kept byte-identical to
# examples/demo.md (a test enforces it) so the demo and the repo example never
# drift. cmd_demo materialises these into a temp dir and builds them, so the
# demo is self-contained and works from any directory after install.
DEMO = """\
---
title: crossPresent — Feature Tour
subtitle: Every block type the generator supports, in one deck. Open the source file side by side with this page — each slide shows what the Markdown looks like rendered.
eyebrow: crossPresent demo
footer: crossPresent feature tour · self-contained HTML, no JS, no external assets
---

# crossPresent — Feature Tour

```stats
1 | markdown file in | blue
1 | html file out | green
0 | dependencies | gray
6 | chart types | amber
```

The whole deck you are reading was generated from
`examples/demo.md` with one command:

```bash
crosspresent build examples/demo.md
```

## Text, badges and notes {#text}

The first paragraph of every slide is styled as an intro — slightly
larger, capped at a readable line length. Use it to frame the slide.

Regular paragraphs follow. Inline markup: **bold**, *italic*,
`inline code`, and [links](https://example.com). Badges are
double-bracket shorthand:

- `[[shipped|good]]` renders [[shipped|good]]
- `[[in review|warn]]` renders [[in review|warn]]
- `[[broken|bad]]` renders [[broken|bad]]
- `[[v2.1|info]]` [[API|accent]] [[design|purple]] [[infra|teal]] [[plain]]

> **Notes are blockquotes**
> Start the first line with a bold phrase and it becomes the note's
> label. Use these for the "here is the catch" moments — the thing
> you would say out loud while presenting the slide.

## Bar and grouped bar {#bars}

A chart is a fenced block tagged `chart` containing JSON. Single
`values` array gives you one series; `series` gives you groups and an
automatic legend.

```chart
{
  "type": "bar",
  "title": "Tests by category",
  "labels": ["Positive", "Negative", "Combos", "Schema", "Multihit", "HTTP", "Non-func", "Offline"],
  "values": [9, 12, 21, 3, 2, 3, 6, 4]
}
```

```chart
{
  "type": "bar",
  "title": "Pass / fail by run",
  "labels": ["Mon", "Tue", "Wed", "Thu", "Fri"],
  "series": [
    {"name": "passed", "values": [61, 62, 60, 63, 63]},
    {"name": "failed", "values": [4, 3, 5, 2, 1]}
  ]
}
```

## Horizontal bars {#hbar}

`hbar` suits long labels — categories read left to right instead of
being crushed under the axis. Add `"colorful": true` to cycle the
palette per bar.

```chart
{
  "type": "hbar",
  "title": "Where the suite spends its time",
  "labels": ["Live API round-trips", "Schema validation", "XML parsing", "Fixture setup", "Report generation"],
  "values": [8.2, 2.1, 1.4, 0.9, 0.4],
  "colorful": true
}
```

## Lines and areas {#lines}

`line` takes the same JSON as `bar`. Multi-series gets a legend; an
`area` chart is a line with the region under it filled.

```chart
{
  "type": "line",
  "title": "p95 latency by week (ms)",
  "labels": ["W1", "W2", "W3", "W4", "W5", "W6", "W7", "W8"],
  "series": [
    {"name": "resolve by DOI", "values": [420, 390, 410, 380, 360, 980, 400, 370]},
    {"name": "resolve by metadata", "values": [610, 580, 640, 600, 590, 1400, 620, 600]}
  ]
}
```

```chart
{
  "type": "area",
  "title": "Suite size over time",
  "labels": ["Jan", "Feb", "Mar", "Apr", "May", "Jun"],
  "values": [12, 19, 31, 44, 58, 67]
}
```

## Pie and donut {#pie}

`pie` and `donut` take one series. The legend carries values and
percentages, so the slices stay clean.

```chart
{
  "type": "donut",
  "title": "Test outcomes",
  "labels": ["passed", "xfail (documented findings)", "skipped"],
  "values": [63, 3, 1]
}
```

## Charts from data files {#data}

Instead of inline numbers, point a chart at a CSV (or JSON) file with
`"data"`. First row is the header, first column is the labels, every
other column becomes a series. The chart below comes straight from
[data/weekly.csv](data/weekly.csv) — regenerate the CSV in CI and the
deck stays current.

```chart
{
  "type": "bar",
  "title": "Outcomes by week — from data/weekly.csv",
  "data": "data/weekly.csv"
}
```

```notes
This block is a speaker note — it only appears when the deck is built
with --notes. Use it for the things you say, not the things you show.
```

## Stat tiles {#stats}

A `stats` block is one line per tile: `value | label | color`.
Colors: `green`, `amber`, `red`, `blue`, `gray` (or leave blank).

```stats
63 | passed | green
3 | xfail | amber
1 | skipped | gray
≈ 13 s | wall-clock | blue
```

## Tables {#tables}

Standard pipe tables, with alignment markers in the separator row.
Cells take the full inline syntax — badges included.

| ID | What it does | Status | Runtime |
|----|--------------|--------|--------:|
| [[TP-01|good]] | Default `id=doi:…` resolves | passing | 0.4 s |
| [[TN-03|warn]] | `title` alone should be rejected | xfail — Finding 2 | 0.3 s |
| [[S-03|bad]] | Unresolved envelope validates | skipped — Finding 7 | — |

## Cards {#cards}

A `cards` block splits on `###` headings into a responsive grid.
Column count is automatic (2 or 3) or forced with ` ```cards 3 `.

```cards 3
### Black-box only
Assert on what the API outputs — status, headers, body, timing.
Nothing about server internals.

### Offline / live split
Live tests skip unless `--run-live` is passed, so CI without network
access still has a gate that means something.

### One HTTP client
Every test goes through one client — base URL, retries, pacing.
Tests read as intent, not plumbing.
```

## Code and pills {#code}

Fenced code with any other tag renders as a code block:

```python
def resolve(doi: str) -> Response:
    return client.get(params={"id": f"doi:{doi}", "redirect": "false"})
```

A `pills` block makes a row of link chips — good for closing slides:

```pills
README | https://example.com/readme
Source | https://example.com/repo
Report | https://example.com/report
```

# That's every block.

Scaffold your own deck and start from a working file:

```bash
crosspresent new mydeck
crosspresent build mydeck.md --open
```

```pills
crossPresent README | ../README.md
Walkthrough example | walkthrough.html
```
"""

DEMO_DATA = """\
week,passed,failed
W1,58,6
W2,60,4
W3,61,3
W4,63,1
"""


# --------------------------------------------------------------------------
# CLI
# --------------------------------------------------------------------------

def _build_page(src, template=None, show_notes=False):
    """Read, parse and render one deck. Returns (page_html, slide_count, ctx)."""
    meta, body = parse_frontmatter(src.read_text(encoding="utf-8"))
    slides = split_slides(body)
    if not slides:
        raise SystemExit("error: no slides found — start one with '## Title'")
    ctx = {"base_dir": src.parent, "show_notes": show_notes}
    page = build_html(meta, slides, ctx, template=template)
    return page, len(slides), ctx


def _expand_sources(patterns):
    """Resolve build sources: expand any glob patterns, dedupe, sort.

    Literal paths pass through unchanged (existence is checked per-deck, so the
    single-source "not found" message is preserved). A glob matching nothing is
    an error naming the pattern.
    """
    seen = {}
    for pat in patterns:
        if any(ch in pat for ch in "*?["):
            matches = glob.glob(pat, recursive=True)
            if not matches:
                raise SystemExit('error: no files matched "%s"' % pat)
            for m in matches:
                seen[str(Path(m))] = Path(m)
        else:
            seen[str(Path(pat))] = Path(pat)
    return sorted(seen.values(), key=str)


def _output_path(src, output, output_dir):
    """Where one deck's HTML goes: explicit -o, else into --output-dir, else
    beside the source as <name>.html."""
    if output:
        return Path(output)
    if output_dir:
        return Path(output_dir) / (src.stem + ".html")
    return src.with_suffix(".html")


def _build_one(src, args):
    """Build a single deck and write it. Raises SystemExit on failure."""
    if not src.is_file():
        raise SystemExit("error: %s not found" % src)
    page, slide_count, ctx = _build_page(src, args.template, args.notes)
    if args.embed:
        page = embed_images(page, src.parent)
    out = _output_path(src, args.output, args.output_dir)
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(page, encoding="utf-8")
    print("wrote %s (%d slides%s)"
          % (out, slide_count, ", mermaid: CDN script included"
             if ctx.get("mermaid") else ""))
    if args.open:
        webbrowser.open(out.resolve().as_uri())


def cmd_build(args):
    sources = _expand_sources(args.source)
    if args.output and len(sources) > 1:
        raise SystemExit(
            "error: -o/--output takes a single source (got %d) — use "
            "-d/--output-dir to build several into a folder" % len(sources))
    multi = len(sources) > 1
    built = failed = 0
    for src in sources:
        try:
            _build_one(src, args)
            built += 1
        except SystemExit as exc:
            if not multi:
                raise                       # single source: behave exactly as before
            print("error: %s: %s" % (src, exc), file=sys.stderr)
            failed += 1
    if multi:
        print("built %d/%d%s" % (built, len(sources),
                                 " (%d failed)" % failed if failed else ""))
    if failed:
        raise SystemExit(1)


def _demo_project(dest):
    """Materialise the bundled showcase deck and its data file into `dest`.

    Returns the path to the deck. Writing the data file alongside keeps the
    demo self-contained, so `crosspresent demo` works from any directory.
    """
    dest = Path(dest)
    src = dest / "demo.md"
    src.write_text(DEMO, encoding="utf-8")
    data = dest / "data"
    data.mkdir(parents=True, exist_ok=True)
    (data / "weekly.csv").write_text(DEMO_DATA, encoding="utf-8")
    return src


def cmd_demo(args):
    workdir = Path(tempfile.mkdtemp(prefix="crosspresent-demo-"))
    src = _demo_project(workdir)
    page, slide_count, ctx = _build_page(src, args.template, args.notes)
    out = workdir / "demo.html"
    out.write_text(page, encoding="utf-8")
    print("built the demo deck (%d slides) → %s" % (slide_count, out))
    if not args.no_open:
        webbrowser.open(out.resolve().as_uri())


SERVE_ERROR_PAGE = """<!doctype html>
<html lang="en"><head><meta charset="utf-8"><title>build error</title>
<style>body{background:#0f1115;color:#e8ecf1;font:15px/1.6 ui-monospace,Menlo,monospace;
padding:40px}h1{color:#ff7676;font-size:18px}pre{white-space:pre-wrap;
background:#1d2230;padding:16px;border-radius:8px}</style></head>
<body><h1>build error — fix the source and save again</h1>
<pre>%s</pre></body></html>
"""


def _inject_live_reload(page, version):
    """Dev-server only: poll /__live__ and reload when the deck rebuilds."""
    script = ('<script>(function(){var v="%d";setInterval(function(){'
              'fetch("/__live__",{cache:"no-store"})'
              '.then(function(r){return r.text()})'
              '.then(function(t){if(t!==v)location.reload()})'
              '.catch(function(){})},700);})()</script>' % version)
    return page.replace("</body>", script + "\n</body>", 1)


def cmd_serve(args):
    src = Path(args.source).resolve()
    if not src.is_file():
        raise SystemExit("error: %s not found" % src)
    state = {"version": 0, "page": "", "signature": None}

    def signature():
        watched = [src]
        for pattern in ("*.csv", "*.json", "data/*.csv", "data/*.json"):
            watched.extend(src.parent.glob(pattern))
        return tuple((str(p), p.stat().st_mtime) for p in sorted(watched)
                     if p.exists())

    def rebuild():
        try:
            page, slide_count, _ = _build_page(src, args.template, args.notes)
            print("rebuilt %s (%d slides)" % (src.name, slide_count))
        except SystemExit as exc:
            page = SERVE_ERROR_PAGE % html.escape(str(exc))
            print(str(exc), file=sys.stderr)
        state["version"] += 1
        state["page"] = _inject_live_reload(page, state["version"])

    def watch():
        while True:
            time.sleep(0.5)
            current = signature()
            if current != state["signature"]:
                state["signature"] = current
                rebuild()

    state["signature"] = signature()
    rebuild()

    serve_dir = str(src.parent)

    class Handler(http.server.SimpleHTTPRequestHandler):
        def __init__(self, *handler_args, **handler_kwargs):
            super().__init__(*handler_args, directory=serve_dir,
                             **handler_kwargs)

        def _send(self, body, content_type):
            data = body.encode("utf-8")
            self.send_response(200)
            self.send_header("Content-Type", content_type)
            self.send_header("Content-Length", str(len(data)))
            self.send_header("Cache-Control", "no-store")
            self.end_headers()
            self.wfile.write(data)

        def do_GET(self):
            path = self.path.split("?")[0]
            if path in ("/", "/index.html", "/" + src.with_suffix(".html").name):
                self._send(state["page"], "text/html; charset=utf-8")
            elif path == "/__live__":
                self._send(str(state["version"]), "text/plain")
            else:
                super().do_GET()  # images and other assets next to the deck

        def log_message(self, *log_args):
            pass

    threading.Thread(target=watch, daemon=True).start()
    server = http.server.ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
    url = "http://127.0.0.1:%d/" % args.port
    print("serving %s at %s — edit and save to reload, Ctrl-C to stop"
          % (src.name, url))
    if not args.no_open:
        webbrowser.open(url)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nstopped")


def cmd_new(args):
    name = args.name
    path = Path(name if name.endswith(".md") else name + ".md")
    if path.exists() and not args.force:
        raise SystemExit("error: %s already exists (use --force to overwrite)" % path)
    deck_name = path.stem.replace("-", " ").replace("_", " ").title()
    path.write_text(SCAFFOLD % {"name": deck_name}, encoding="utf-8")
    prog = Path(sys.argv[0]).name
    runner = "python3 " + prog if prog.endswith(".py") else prog
    print("wrote %s — next: %s build %s" % (path, runner, path))


CLI_EPILOG = """\
examples:
  crosspresent demo                        see everything it can do (opens a browser)
  crosspresent new mydeck                  scaffold a starter deck
  crosspresent build mydeck.md --open      build mydeck.md -> mydeck.html, then open it
  crosspresent build decks/*.md -d public  build every deck into ./public
  crosspresent serve mydeck.md             live preview: save the file = auto-reload

authoring (full guide in the README):
  templates  sidebar (TOC + sections) · deck (full-screen slides) · doc (report)
  palettes   default · ocean · forest · mono · crimson
  blocks     ```chart  ```stats  ```note  ```cards  ```pills  ```mermaid  ```notes
  charts     bar · hbar · line · area · pie · donut — inline SVG, dark/light aware
  badges     [[shipped|good]]  ([good warn bad info accent purple teal dim])

Output is one self-contained HTML file: no dependencies, no JavaScript
(unless a deck uses a ```mermaid diagram). Print it from the browser for PDF.
Docs: https://github.com/OpenStruct/crosspresent
"""


def main(argv=None):
    parser = argparse.ArgumentParser(
        prog="crosspresent",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="Turn one Markdown file into a self-contained HTML "
                    "presentation — charts, stat tiles, tables, cards, callouts "
                    "and badges, with no dependencies and no JS in the output.",
        epilog=CLI_EPILOG)
    parser.add_argument("--version", action="version", version=VERSION)
    sub = parser.add_subparsers(dest="command", required=True)

    build = sub.add_parser("build", help="build deck.md into deck.html")
    build.add_argument("source", nargs="+",
                       help="markdown source file(s) or glob, e.g. deck.md or "
                            "decks/*.md")
    build.add_argument("-o", "--output",
                       help="output path (single source only; default: same "
                            "name .html)")
    build.add_argument("-d", "--output-dir",
                       help="write every deck's .html into this folder "
                            "(created if missing)")
    build.add_argument("-t", "--template", choices=sorted(TEMPLATES),
                       help="override the deck's template "
                            "(sidebar: TOC + scrolling sections, "
                            "deck: full-screen slides, doc: single-column report)")
    build.add_argument("--embed", action="store_true",
                       help="inline local images as data URIs")
    build.add_argument("--notes", action="store_true",
                       help="include speaker notes (```notes blocks) in the output")
    build.add_argument("--open", action="store_true",
                       help="open the result in a browser")
    build.set_defaults(func=cmd_build)

    demo = sub.add_parser(
        "demo", help="build the bundled showcase deck and open it (no files "
                     "needed — works anywhere)")
    demo.add_argument("-t", "--template", choices=sorted(TEMPLATES),
                      help="preview the demo in a different template")
    demo.add_argument("--notes", action="store_true",
                      help="include the demo's speaker notes")
    demo.add_argument("--no-open", action="store_true",
                      help="build but don't open the browser")
    demo.set_defaults(func=cmd_demo)

    serve = sub.add_parser(
        "serve", help="live-preview a deck: rebuild on save, auto-reload")
    serve.add_argument("source", help="markdown source file")
    serve.add_argument("-t", "--template", choices=sorted(TEMPLATES),
                       help="override the deck's template")
    serve.add_argument("--port", type=int, default=7350,
                       help="port to listen on (default 7350)")
    serve.add_argument("--notes", action="store_true",
                       help="include speaker notes in the preview")
    serve.add_argument("--no-open", action="store_true",
                       help="don't open the browser automatically")
    serve.set_defaults(func=cmd_serve)

    new = sub.add_parser("new", help="scaffold a starter deck")
    new.add_argument("name", help="deck name (mydeck or mydeck.md)")
    new.add_argument("--force", action="store_true", help="overwrite if it exists")
    new.set_defaults(func=cmd_new)

    args = parser.parse_args(argv)
    args.func(args)


if __name__ == "__main__":
    main()