#!/usr/bin/env python3
"""
Generate the figures embedded in the dataset card.

    python make_charts.py                       # summary-derived figures only
    python make_charts.py --parquet data/train-00000-of-00001.parquet

Writes theme-neutral SVG into assets/. No matplotlib: the output is plain,
diffable SVG with a transparent background, so it reads on both the light and
dark Hugging Face themes and stays reviewable in git.

Figures 01-03 need only summary.json. Figures 04-06 need the parquet.
Re-run after every release so the card can never describe stale data.
"""

from __future__ import annotations

import argparse
import json
from collections import Counter, defaultdict
from pathlib import Path

# ---------------------------------------------------------------- palette ---
INK = "#8b95a5"        # labels — legible on white and on #0f172a
MUTED = "#9aa3b2"      # secondary text
GRID = "#8b95a566"     # axis rules, translucent
AGENT = "#6366f1"
HUMAN = "#b4bcca"
ASSISTED = "#6366f1"
AUTONOMOUS = "#f59e0b"
PATTERN_COLORS = {
    "none": "#b4bcca",
    "individual": "#f59e0b",
    "team": "#34a0a4",
    "org-wide": "#6366f1",
}
FONT = "system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif"
MONO = "ui-monospace, SFMono-Regular, Menlo, monospace"


def esc(s: str) -> str:
    return (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))


def text(x, y, s, size=12, fill=INK, anchor="start", weight="400", font=FONT):
    return (f'<text x="{x:.1f}" y="{y:.1f}" font-family="{font}" '
            f'font-size="{size}" fill="{fill}" text-anchor="{anchor}" '
            f'font-weight="{weight}">{esc(s)}</text>')


def rect(x, y, w, h, fill, rx=2, opacity=1.0):
    if w <= 0:
        return ""
    return (f'<rect x="{x:.1f}" y="{y:.1f}" width="{w:.1f}" height="{h:.1f}" '
            f'rx="{rx}" fill="{fill}" opacity="{opacity}"/>')


def svg(width, height, body) -> str:
    return (f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" '
            f'height="{height}" viewBox="0 0 {width} {height}" '
            f'role="img">\n{body}\n</svg>\n')


def write(out_dir: Path, name: str, content: str) -> None:
    path = out_dir / name
    path.write_text(content)
    print(f"  wrote {path}  ({len(content):,} bytes)")


# --------------------------------------------------- 01 · ecosystem spread ---
def fig_ecosystems(summary: dict, out: Path, min_n: int = 10) -> None:
    rows = [e for e in summary["ecosystems"] if e["n"] >= min_n]
    rows.sort(key=lambda e: e["median"], reverse=True)

    left, right, top = 132, 58, 62
    row_h, gap = 30, 8
    plot_w = 760 - left - right
    height = top + len(rows) * (row_h + gap) + 46
    scale = max(e["mean"] for e in rows) * 1.06

    b = [text(0, 22, "Agent-share floor by ecosystem", 15, INK, weight="600"),
         text(0, 40, f"median vs mean, n \u2265 {min_n} \u00b7 the gap is the skew",
              11.5, MUTED)]

    # legend
    b.append(rect(left + plot_w - 150, 30, 9, 9, AGENT))
    b.append(text(left + plot_w - 136, 39, "median", 11, MUTED))
    b.append(rect(left + plot_w - 78, 30, 9, 9, AGENT, opacity=0.32))
    b.append(text(left + plot_w - 64, 39, "mean", 11, MUTED))

    for i, e in enumerate(rows):
        y = top + i * (row_h + gap)
        b.append(text(left - 12, y + 13, e["ecosystem"], 12, INK, "end", "500"))
        b.append(text(left - 12, y + 26, f'n={e["n"]}', 10, MUTED, "end"))
        b.append(rect(left, y + 15, plot_w * e["mean"] / scale, 11,
                      AGENT, opacity=0.28))
        b.append(rect(left, y + 1, plot_w * e["median"] / scale, 12, AGENT))
        b.append(text(left + plot_w * e["mean"] / scale + 8, y + 17,
                      f'{e["median"]:.1f} / {e["mean"]:.1f}%', 10.5, MUTED,
                      font=MONO))

    axis_y = top + len(rows) * (row_h + gap) + 6
    b.append(f'<line x1="{left}" y1="{axis_y}" x2="{left + plot_w}" '
             f'y2="{axis_y}" stroke="{GRID}" stroke-width="1"/>')
    for tick in range(0, int(scale) + 1, 5):
        x = left + plot_w * tick / scale
        b.append(f'<line x1="{x:.1f}" y1="{axis_y}" x2="{x:.1f}" '
                 f'y2="{axis_y + 4}" stroke="{GRID}" stroke-width="1"/>')
        b.append(text(x, axis_y + 17, f"{tick}%", 10, MUTED, "middle"))

    write(out, "01-ecosystems.svg", svg(760, height, "\n".join(b)))


# ------------------------------------------------- 02 · adoption patterns ---
def fig_patterns(summary: dict, out: Path) -> None:
    counts = summary["summary"]["patternCounts"]
    order = ["none", "individual", "team", "org-wide"]
    total = sum(counts.values())
    blurb = {"none": "no signature observed",
             "individual": "one person's workflow",
             "team": "a small group",
             "org-wide": "broad adoption"}

    width, bar_y, bar_h, pad = 760, 74, 46, 3
    b = [text(0, 22, "How adoption is distributed", 15, INK, weight="600"),
         text(0, 40, f"{total} repositories, classified by how concentrated "
                     "agent commits are across contributors", 11.5, MUTED)]

    x = 0.0
    for key in order:
        w = width * counts[key] / total - pad
        b.append(rect(x, bar_y, w, bar_h, PATTERN_COLORS[key], rx=3))
        if w > 58:
            b.append(text(x + 11, bar_y + 21, str(counts[key]), 15, "#ffffff",
                          weight="600", font=MONO))
            b.append(text(x + 11, bar_y + 36, key, 11, "#ffffffcc"))
        x += w + pad

    y = bar_y + bar_h + 30
    for i, key in enumerate(order):
        cx = (i % 2) * 380
        cy = y + (i // 2) * 22
        b.append(rect(cx, cy - 9, 9, 9, PATTERN_COLORS[key]))
        b.append(text(cx + 15, cy, f"{key} \u2014 {blurb[key]}", 11.5, MUTED))
        b.append(text(cx + 330, cy, f"{counts[key] / total * 100:.0f}%", 11.5,
                      INK, "end", font=MONO))

    note = (f'Among individual repositories the median top contributor accounts '
            f'for {summary["summary"]["individualMedianTopShare"]}% of all agent commits.')
    b.append(text(0, y + 62, note, 11.5, MUTED))
    write(out, "02-adoption-patterns.svg", svg(width, y + 76, "\n".join(b)))


# --------------------------------------------- 03 · composition of commits ---
def fig_composition(summary: dict, out: Path) -> None:
    s = summary["summary"]
    assisted, autonomous = s["assistedSharePct"], s["autonomousSharePct"]
    unsigned = 100 - assisted - autonomous
    width, bar_y, bar_h = 760, 92, 40

    b = [text(0, 22, "Where the 8.5% floor comes from", 15, INK, weight="600"),
         text(0, 40, f'{s["totalCommits"]:,} considered commits \u00b7 merges and '
                     "CI/dependency bots already excluded", 11.5, MUTED)]

    x = 0.0
    for share, colour, label in ((assisted, ASSISTED, "assisted"),
                                 (autonomous, AUTONOMOUS, "autonomous"),
                                 (unsigned, HUMAN, "no signature")):
        w = width * share / 100
        b.append(rect(x, bar_y, max(w - 2, 2), bar_h, colour, rx=3))
        x += w

    b.append(f'<line x1="0" y1="{bar_y - 10}" x2="{width * (assisted + autonomous) / 100:.1f}" '
             f'y2="{bar_y - 10}" stroke="{AGENT}" stroke-width="1.5"/>')
    b.append(text(width * (assisted + autonomous) / 100 + 10, bar_y - 6,
                  f'{s["aggregateSharePct"]}% floor', 12, INK, weight="600",
                  font=MONO))

    rows = [("assisted", ASSISTED, assisted,
             "a developer's identity authored the commit; the agent signed it"),
            ("autonomous", AUTONOMOUS, autonomous,
             "a bot identity is the author \u2014 no human in the loop"),
            ("no signature", HUMAN, unsigned,
             "manual commits, and any assistance the metadata cannot see")]
    y = bar_y + bar_h + 34
    for label, colour, share, blurb in rows:
        b.append(rect(0, y - 10, 10, 10, colour))
        b.append(text(18, y, label, 12, INK, weight="500"))
        b.append(text(120, y, f"{share:.1f}%", 12, INK, font=MONO))
        b.append(text(180, y, blurb, 11.5, MUTED))
        y += 24

    b.append(text(0, y + 14, f'{s["assistedOfAgentPct"]}% of matched commits still '
                             "have a human author. The floor is not a measure of "
                             "autonomous AI.", 11.5, MUTED))
    write(out, "03-commit-composition.svg", svg(width, y + 28, "\n".join(b)))


# ------------------------------------------------- 04 · floor distribution ---
def fig_distribution(df, out: Path) -> None:
    edges = [0, 0.001, 1, 2.5, 5, 10, 20, 35, 50, 75, 100.01]
    labels = ["0%", "0\u20131", "1\u20132.5", "2.5\u20135", "5\u201310",
              "10\u201320", "20\u201335", "35\u201350", "50\u201375", "75\u2013100"]
    vals = df.agent_share_pct_floor.tolist()
    counts = [sum(1 for v in vals if lo <= v < hi)
              for lo, hi in zip(edges, edges[1:])]

    width, left, top, bar_w, gap = 760, 44, 66, 60, 12
    plot_h, base = 190, 66 + 190
    scale = max(counts) * 1.12

    b = [text(0, 22, "Distribution of repository floors", 15, INK, weight="600"),
         text(0, 40, f"{len(vals)} repositories \u00b7 heavily right-skewed; "
                     "the median is not the mean", 11.5, MUTED)]

    for i, (c, lab) in enumerate(zip(counts, labels)):
        x = left + i * (bar_w + gap)
        h = plot_h * c / scale
        colour = HUMAN if i == 0 else AGENT
        b.append(rect(x, base - h, bar_w, h, colour, rx=3))
        b.append(text(x + bar_w / 2, base - h - 8, str(c), 11.5, INK, "middle",
                      font=MONO))
        b.append(text(x + bar_w / 2, base + 17, lab, 10.5, MUTED, "middle"))

    b.append(f'<line x1="{left - 8}" y1="{base}" '
             f'x2="{left + len(counts) * (bar_w + gap)}" y2="{base}" '
             f'stroke="{GRID}" stroke-width="1"/>')
    b.append(text(left + len(counts) * (bar_w + gap) / 2, base + 40,
                  "agent-share floor", 11, MUTED, "middle"))
    write(out, "04-floor-distribution.svg", svg(width, base + 54, "\n".join(b)))


# ----------------------------------------------------- 05 · adoption curve ---
def fig_timeline(df, out: Path) -> None:
    agent, total = Counter(), Counter()
    for raw in df.timeline_json:
        for m in json.loads(raw):
            agent[m["month"]] += m.get("agent", 0)
            total[m["month"]] += m.get("total", 0)
    months = sorted(total)
    pcts = [agent[m] / total[m] * 100 if total[m] else 0 for m in months]

    width, left, right, top, plot_h = 760, 44, 24, 70, 200
    plot_w = width - left - right
    base = top + plot_h
    scale = max(max(pcts) * 1.2, 5)
    step = plot_w / max(len(months) - 1, 1)

    b = [text(0, 22, "Signed share by month", 15, INK, weight="600"),
         text(0, 40, "pooled across all repositories \u2014 commit-weighted, "
                     "not an average of percentages", 11.5, MUTED)]

    for frac in (0, 0.5, 1):
        y = base - plot_h * frac
        b.append(f'<line x1="{left}" y1="{y:.1f}" x2="{left + plot_w}" '
                 f'y2="{y:.1f}" stroke="{GRID}" stroke-width="1"/>')
        b.append(text(left - 10, y + 4, f"{scale * frac:.0f}%", 10, MUTED, "end"))

    pts = [(left + i * step, base - plot_h * p / scale)
           for i, p in enumerate(pcts)]
    area = (f'M{pts[0][0]:.1f},{base} '
            + " ".join(f"L{x:.1f},{y:.1f}" for x, y in pts)
            + f" L{pts[-1][0]:.1f},{base} Z")
    b.append(f'<path d="{area}" fill="{AGENT}" opacity="0.14"/>')
    b.append('<path d="' + " ".join(
        ("M" if i == 0 else "L") + f"{x:.1f},{y:.1f}"
        for i, (x, y) in enumerate(pts))
        + f'" fill="none" stroke="{AGENT}" stroke-width="2.2" '
          'stroke-linejoin="round"/>')

    for (x, y), m, p in zip(pts, months, pcts):
        b.append(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="3.2" fill="{AGENT}"/>')
        b.append(text(x, y - 11, f"{p:.1f}", 10, INK, "middle", font=MONO))
        b.append(text(x, base + 18, m[5:] + "/" + m[2:4], 10, MUTED, "middle"))

    write(out, "05-monthly-curve.svg", svg(width, base + 40, "\n".join(b)))


# ------------------------------------------------ 06 · share vs. spread ---
def fig_concentration(df, out: Path) -> None:
    d = df[(~df.low_activity) & (df.agent_attributed_commits > 0)]
    width, left, top, plot_w, plot_h = 760, 52, 72, 640, 250
    base = top + plot_h

    b = [text(0, 22, "A share means nothing without its spread", 15, INK,
              weight="600"),
         text(0, 40, f"{len(d)} repositories with \u2265100 considered commits "
                     "and at least one signed commit", 11.5, MUTED)]

    for frac in (0, 0.25, 0.5, 0.75, 1):
        y = base - plot_h * frac
        b.append(f'<line x1="{left}" y1="{y:.1f}" x2="{left + plot_w}" '
                 f'y2="{y:.1f}" stroke="{GRID}" stroke-width="1"/>')
        b.append(text(left - 10, y + 4, f"{frac * 100:.0f}%", 10, MUTED, "end"))

    xmax = max(d.agent_share_pct_floor.max(), 10)
    for row in d.itertuples():
        x = left + plot_w * row.agent_share_pct_floor / xmax
        y = base - plot_h * row.top_author_share_of_agent_commits / 100
        r = 2.4 + min((row.commits_considered / 2000) ** 0.5 * 3.2, 7)
        b.append(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="{r:.1f}" '
                 f'fill="{PATTERN_COLORS.get(row.adoption_pattern, HUMAN)}" '
                 f'opacity="0.62"/>')

    for tick in range(0, int(xmax) + 1, 10):
        x = left + plot_w * tick / xmax
        b.append(text(x, base + 18, f"{tick}%", 10, MUTED, "middle"))
    b.append(text(left + plot_w / 2, base + 38, "agent-share floor \u2192",
                  11, MUTED, "middle"))
    b.append(f'<text x="14" y="{top + plot_h / 2:.0f}" font-family="{FONT}" '
             f'font-size="11" fill="{MUTED}" text-anchor="middle" '
             f'transform="rotate(-90 14 {top + plot_h / 2:.0f})">'
             'top contributor\u2019s share of agent commits</text>')

    for i, (key, colour) in enumerate(
            [(k, PATTERN_COLORS[k]) for k in ("individual", "team", "org-wide")]):
        cx = left + plot_w - 250 + i * 88
        b.append(f'<circle cx="{cx}" cy="{top - 22}" r="4.5" fill="{colour}" '
                 'opacity="0.75"/>')
        b.append(text(cx + 10, top - 18, key, 11, MUTED))

    b.append(text(0, base + 60, "Bubble area is commits considered. Two "
                                "repositories with the same share sit at "
                                "opposite ends of this axis.", 11.5, MUTED))
    write(out, "06-share-vs-concentration.svg", svg(width, base + 74, "\n".join(b)))


# ------------------------------------------------------------------- main ---
def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--summary", default="summary.json")
    ap.add_argument("--parquet", default="data/train-00000-of-00001.parquet")
    ap.add_argument("--out", default="assets")
    args = ap.parse_args()

    out = Path(args.out)
    out.mkdir(parents=True, exist_ok=True)
    summary = json.loads(Path(args.summary).read_text())

    print("summary-derived figures")
    fig_ecosystems(summary, out)
    fig_patterns(summary, out)
    fig_composition(summary, out)

    parquet = Path(args.parquet)
    if not parquet.exists():
        print(f"\n{parquet} not found \u2014 skipping figures 04-06.")
        print("Run again from the dataset root to generate the full set.")
        return 0

    import pandas as pd  # imported late so 01-03 need no dependencies
    df = pd.read_parquet(parquet)
    print(f"\nparquet figures ({len(df)} rows)")
    fig_distribution(df, out)
    fig_timeline(df, out)
    fig_concentration(df, out)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())