#!/usr/bin/env python3
"""Collect CI job/step timings from the GitHub API and generate an HTML diff report.

In CI, the script reads GITHUB_TOKEN, GITHUB_REPOSITORY, GITHUB_RUN_ID, and
GITHUB_SHA from the environment to collect timings via the REST API.

If a baseline JSON file (ci-timings-baseline.json by default) exists, the
report includes a diff with per-job and per-step deltas, plus a gantt chart
overlaying current vs baseline bars.

Usage:
    # Collect from API (CI mode):
    python scripts/ci/timings_report.py

    # Regenerate HTML from saved JSON (testing):
    python scripts/ci/timings_report.py --from-json ci-timings.json
"""

from __future__ import annotations

import argparse
import glob
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime
from html import escape

API_BASE = "https://api.github.com"

# Retry policy for GitHub API calls. The repo-scoped GITHUB_TOKEN shares a
# rate-limit budget across every concurrent workflow run; when several PRs
# run CI at once, this report job (which makes dozens of paginated calls)
# regularly hits 403 rate-limit responses. Those are transient — retry with
# backoff, honoring Retry-After / X-RateLimit-Reset when present.
_RETRY_STATUSES = {403, 429, 500, 502, 503, 504}
_MAX_ATTEMPTS = 5
_MAX_RETRY_WAIT_S = 120.0


class TimingsUnavailable(Exception):
    """GitHub API data could not be collected (rate limit, outage, ...).

    This is a REPORT job — never a reason to fail the PR's checks. main()
    catches this and exits 0 with a degraded summary.
    """


def _retry_wait_s(headers, attempt: int) -> float:
    """Seconds to wait before the next attempt, honoring server hints."""
    retry_after = (headers.get("Retry-After") or "").strip() if headers else ""
    if retry_after.isdigit():
        return min(float(retry_after), _MAX_RETRY_WAIT_S)
    reset = (headers.get("X-RateLimit-Reset") or "").strip() if headers else ""
    remaining = (headers.get("X-RateLimit-Remaining") or "").strip() if headers else ""
    if remaining == "0" and reset.isdigit():
        return min(max(float(reset) - time.time(), 1.0), _MAX_RETRY_WAIT_S)
    return min(2.0 ** attempt * 2.0, _MAX_RETRY_WAIT_S)  # 4s, 8s, 16s, 32s


def _urlopen_with_retry(req: urllib.request.Request):
    """urlopen with backoff on rate-limit/transient statuses.

    Returns (parsed_json, link_header). Raises TimingsUnavailable when
    attempts are exhausted — callers treat that as "no report this run",
    not a job failure.
    """
    last_err: Exception | None = None
    for attempt in range(1, _MAX_ATTEMPTS + 1):
        try:
            with urllib.request.urlopen(req) as resp:
                return json.loads(resp.read()), resp.headers.get("Link", "")
        except urllib.error.HTTPError as e:
            last_err = e
            if e.code not in _RETRY_STATUSES or attempt == _MAX_ATTEMPTS:
                break
            wait = _retry_wait_s(e.headers, attempt)
            print(f"GitHub API {e.code} on {req.full_url} — "
                  f"retry {attempt}/{_MAX_ATTEMPTS - 1} in {wait:.0f}s",
                  file=sys.stderr)
            time.sleep(wait)
        except urllib.error.URLError as e:
            last_err = e
            if attempt == _MAX_ATTEMPTS:
                break
            wait = _retry_wait_s(None, attempt)
            print(f"GitHub API connection error on {req.full_url} ({e.reason}) — "
                  f"retry {attempt}/{_MAX_ATTEMPTS - 1} in {wait:.0f}s",
                  file=sys.stderr)
            time.sleep(wait)
    raise TimingsUnavailable(
        f"GitHub API unavailable after {_MAX_ATTEMPTS} attempts: {last_err}"
    )


# ---------------------------------------------------------------------------
# GitHub API helpers
# ---------------------------------------------------------------------------

def api_get(path: str, token: str, params: dict | None = None,
            list_key: str | None = None) -> list | dict:
    """Authenticated GitHub API GET with automatic pagination.

    For list endpoints, pass list_key to extract items from the paginated
    wrapper response (e.g. list_key='jobs' for {'total_count': N, 'jobs': [...]}).
    When list_key is omitted, a non-list response is returned as-is (single object).

    Transient failures (403 rate limit, 429, 5xx, connection errors) are
    retried with backoff; exhausted retries raise TimingsUnavailable.
    """
    url = f"{API_BASE}{path}"
    if params:
        url += "?" + urllib.parse.urlencode(params)

    results: list = []
    while url:
        req = urllib.request.Request(url, headers={
            "Authorization": f"Bearer {token}",
            "Accept": "application/vnd.github+json",
            "X-GitHub-Api-Version": "2022-11-28",
            "User-Agent": "ci-timings-report",
        })
        data, link_header = _urlopen_with_retry(req)

        if list_key:
            results.extend(data.get(list_key, []))
        elif isinstance(data, list):
            results.extend(data)
        else:
            return data

        next_url = None
        for part in link_header.split(","):
            part = part.strip()
            if 'rel="next"' in part:
                next_url = part[part.find("<") + 1:part.find(">")]
                break
        url = next_url

    return results


def parse_ts(ts: str | None) -> datetime | None:
    if not ts:
        return None
    return datetime.fromisoformat(ts.replace("Z", "+00:00"))


def dur_s(started: str | None, completed: str | None) -> float | None:
    s = parse_ts(started)
    e = parse_ts(completed)
    if not s or not e:
        return None
    return (e - s).total_seconds()


def is_skipped(job: dict) -> bool:
    """A job is 'skipped' when GitHub didn't actually run it.

    Skipped jobs have conclusion == 'skipped' and typically have null or
    equal started_at/completed_at timestamps, yielding duration_s of None
    or 0. They should be excluded from delta comparisons, gantt bars,
    regression tables, and aggregate stats (wall/compute).
    """
    return job.get("conclusion") == "skipped"


# ---------------------------------------------------------------------------
# Timings collection
# ---------------------------------------------------------------------------

def _normalize_job(raw: dict) -> dict:
    steps = []
    for step in (raw.get("steps") or []):
        steps.append({
            "name": step.get("name", ""),
            "number": step.get("number", 0),
            "status": step.get("status", ""),
            "conclusion": step.get("conclusion", ""),
            "started_at": step.get("started_at"),
            "completed_at": step.get("completed_at"),
            "duration_s": dur_s(step.get("started_at"), step.get("completed_at")),
        })
    return {
        "name": raw.get("name", "unknown"),
        "workflow_name": raw.get("_workflow_name", ""),
        "job_id": raw.get("id"),
        "status": raw.get("status", ""),
        "conclusion": raw.get("conclusion", ""),
        "started_at": raw.get("started_at"),
        "completed_at": raw.get("completed_at"),
        "duration_s": dur_s(raw.get("started_at"), raw.get("completed_at")),
        "html_url": raw.get("html_url", ""),
        "steps": steps,
    }


def _annotate_wait_times(jobs: list[dict]) -> None:
    """Annotate each job with ``wait_s`` — how long it sat idle before starting.

    Wait time = ``started_at - max(completed_at of all jobs that finished
    before this job started)``. Jobs with no predecessor (e.g. ``detect``)
    get ``wait_s = 0``. Skipped jobs get ``wait_s = None``.

    This is a timestamp heuristic, not a workflow-YAML dependency parse: it
    infers dependencies from temporal ordering rather than ``needs:``
    declarations. It's accurate for pipeline-shaped CI where the critical
    path is linear at each stage (detect → parallel lanes → gate → report).
    """
    for j in jobs:
        if is_skipped(j):
            j["wait_s"] = None
            continue
        started = parse_ts(j.get("started_at"))
        if started is None:
            j["wait_s"] = None
            continue
        latest_dep_end: datetime | None = None
        for other in jobs:
            if other is j or is_skipped(other):
                continue
            other_end = parse_ts(other.get("completed_at"))
            if other_end is None or other_end > started:
                continue
            if latest_dep_end is None or other_end > latest_dep_end:
                latest_dep_end = other_end
        j["wait_s"] = (started - latest_dep_end).total_seconds() if latest_dep_end else 0.0


def collect_timings(token: str, repo: str, run_id: str, head_sha: str) -> dict:
    """Collect job/step timings from the GitHub API.

    1. Get orchestrator run's direct jobs (detect, all-checks-pass, etc.).
       Skip workflow-call placeholder jobs (step name starts with
       "Run ./.github/workflows/").
    2. Find sub-workflow runs via head_sha + event=workflow_call.
    3. Get each sub-workflow run's jobs with full step timing.
    """
    owner, repo_name = repo.split("/")

    # Orchestrator run info
    run_info = api_get(f"/repos/{owner}/{repo_name}/actions/runs/{run_id}", token)
    created_at = run_info.get("created_at", "")

    # Orchestrator direct jobs
    orch_jobs = api_get(f"/repos/{owner}/{repo_name}/actions/runs/{run_id}/jobs",
                        token, list_key="jobs")

    direct = []
    for job in orch_jobs:
        steps = job.get("steps") or []
        if any(s.get("name", "").startswith("Run ./.github/workflows/") for s in steps):
            continue  # workflow-call placeholder
        if job.get("status") in ("in_progress", "queued"):
            continue  # skip self / unfinished
        direct.append(job)

    # Sub-workflow runs
    sub_runs = api_get(f"/repos/{owner}/{repo_name}/actions/runs", token, params={
        "head_sha": head_sha,
        "event": "workflow_call",
        "per_page": 100,
    }, list_key="workflow_runs")
    sub_runs = [r for r in sub_runs if r.get("created_at", "") >= created_at]

    sub_jobs_raw = []
    for sr in sub_runs:
        sr_id = sr["id"]
        sr_name = sr.get("name", "")
        sr_jobs = api_get(f"/repos/{owner}/{repo_name}/actions/runs/{sr_id}/jobs",
                          token, list_key="jobs")
        for j in sr_jobs:
            j["_workflow_name"] = sr_name
            j["_workflow_run_id"] = sr_id
            sub_jobs_raw.append(j)

    # Normalize + sort
    all_jobs = [_normalize_job(j) for j in direct + sub_jobs_raw]
    all_jobs = [j for j in all_jobs if j["status"] not in ("in_progress", "queued")]
    all_jobs.sort(key=lambda j: j.get("started_at") or "")
    _annotate_wait_times(all_jobs)

    return {
        "run_id": run_id,
        "head_sha": head_sha,
        "created_at": created_at,
        "jobs": all_jobs,
    }


# ---------------------------------------------------------------------------
# Formatting helpers
# ---------------------------------------------------------------------------

def fmt_dur(seconds: float | None) -> str:
    if seconds is None:
        return "—"
    if seconds < 60:
        return f"{seconds:.1f}s"
    m = int(seconds // 60)
    s = seconds % 60
    if s == 0:
        return f"{m}m"
    return f"{m}m{s:.0f}s"


def fmt_delta(current: float | None, baseline: float | None) -> tuple[str, str]:
    """Return (text, css_class) for a delta."""
    if current is None or baseline is None:
        return ("—", "neutral")
    delta = current - baseline
    if baseline == 0:
        pct_str = "new" if delta > 0 else "0%"
    else:
        pct = (delta / baseline) * 100
        pct_str = f"{pct:+.1f}%"
    if abs(delta) < 1.0:
        cls = "neutral"
    elif delta > 0:
        cls = "slower"
    else:
        cls = "faster"
    sign = "+" if delta >= 0 else ""
    return (f"{sign}{delta:.1f}s ({pct_str})", cls)


def nice_ticks(max_seconds: float, num_ticks: int = 8) -> list[int]:
    if max_seconds <= 0:
        return [0]
    raw = max_seconds / num_ticks
    for nice in [5, 10, 15, 30, 60, 120, 180, 300, 600, 900, 1800, 3600, 7200]:
        if nice >= raw:
            step = nice
            break
    else:
        step = max(int(raw), 3600)
    return list(range(0, int(max_seconds) + step + 1, step))


def fmt_tick(seconds: int) -> str:
    if seconds < 60:
        return f"{seconds}s"
    m, s = divmod(seconds, 60)
    if s == 0:
        return f"{m}m"
    return f"{m}m{s}s"


# ---------------------------------------------------------------------------
# Stats computation
# ---------------------------------------------------------------------------

def compute_stats(timings: dict, baseline: dict | None = None) -> dict:
    jobs_all = timings.get("jobs", [])
    jobs = [j for j in jobs_all if not is_skipped(j)]
    bl_jobs_all = (baseline or {}).get("jobs", [])
    bl_jobs = [j for j in bl_jobs_all if not is_skipped(j)]
    bl_map = {j["name"]: j for j in bl_jobs}

    # Wall time (skipped jobs have no real timestamps)
    starts = [s for s in (parse_ts(j.get("started_at")) for j in jobs) if s is not None]
    ends = [e for e in (parse_ts(j.get("completed_at")) for j in jobs) if e is not None]
    wall = (max(ends) - min(starts)).total_seconds() if starts and ends else 0
    compute = sum(j.get("duration_s") or 0 for j in jobs)

    # Baseline wall/compute
    bl_wall = None
    bl_compute = None
    if baseline:
        bl_starts = [s for s in (parse_ts(j.get("started_at")) for j in bl_jobs) if s is not None]
        bl_ends = [e for e in (parse_ts(j.get("completed_at")) for j in bl_jobs) if e is not None]
        if bl_starts and bl_ends:
            bl_wall = (max(bl_ends) - min(bl_starts)).total_seconds()
        bl_compute = sum(j.get("duration_s") or 0 for j in bl_jobs)

    # Per-job deltas (skipped excluded)
    faster = 0
    slower = 0
    unchanged = 0
    no_baseline = 0
    for j in jobs:
        bl = bl_map.get(j["name"])
        if not bl:
            no_baseline += 1
            continue
        cur_d = j.get("duration_s") or 0
        bl_d = bl.get("duration_s") or 0
        if abs(cur_d - bl_d) < 1.0:
            unchanged += 1
        elif cur_d > bl_d:
            slower += 1
        else:
            faster += 1

    skipped = sum(1 for j in jobs_all if is_skipped(j))
    bl_skipped = sum(1 for j in bl_jobs_all if is_skipped(j))
    total_wait = sum(j.get("wait_s") or 0 for j in jobs)
    bl_total_wait = sum(j.get("wait_s") or 0 for j in bl_jobs)

    return {
        "wall": wall,
        "compute": compute,
        "bl_wall": bl_wall,
        "bl_compute": bl_compute,
        "faster": faster,
        "slower": slower,
        "unchanged": unchanged,
        "no_baseline": no_baseline,
        "skipped": skipped,
        "bl_skipped": bl_skipped,
        "total_wait": total_wait,
        "bl_total_wait": bl_total_wait,
        "total_jobs": len(jobs_all),
    }


# ---------------------------------------------------------------------------
# Resource profile loading + bottleneck analysis
# ---------------------------------------------------------------------------

def load_resource_profiles(directory: str) -> dict[str, dict]:
    """Load all resource-profile-*/resource-profile.json artifacts.

    Returns {label: profile_dict}. Labels are derived from the artifact
    directory name (resource-profile-<label> → <label>).
    """
    profiles: dict[str, dict] = {}
    if not directory or not os.path.isdir(directory):
        return profiles

    for path in glob.glob(os.path.join(directory, "**", "resource-profile.json"), recursive=True):
        try:
            with open(path, encoding="utf-8") as f:
                profile = json.load(f)
        except (json.JSONDecodeError, OSError):
            continue
        label = profile.get("label") or os.path.basename(os.path.dirname(path))
        profiles[label] = profile

    return profiles


def classify_bottleneck(timings: dict, profiles: dict[str, dict]) -> str:
    """Return a one-line bottleneck classification.

    Examines wall time, compute time, wait time, and resource profiles
    to identify the dominant constraint.

    Possible verdicts:
      - "CPU-bound: <job> at <pct>% CPU for <dur>"
      - "Memory-bound: <job> peaked at <mb> MB"
      - "Disk IO-bound: <job> at <ops>/s for <dur>"
      - "Wait-bound: <wait>s idle waiting for dependencies"
      - "Evenly distributed: no single bottleneck"
      - "Insufficient data: <reason>"
    """
    stats = compute_stats(timings, None)
    jobs = [j for j in timings.get("jobs", []) if not is_skipped(j)]

    if not jobs:
        return "Insufficient data: no jobs in timings"

    # --- Wait-bound: if total wait > 50% of wall time ---
    wall = stats["wall"]
    total_wait = stats["total_wait"]
    if wall > 0 and total_wait > 0:
        wait_pct = total_wait / wall * 100
        if wait_pct > 50:
            return (f"Wait-bound: {fmt_dur(total_wait)} idle "
                    f"({wait_pct:.0f}% of {fmt_dur(wall)} wall) waiting for dependencies")

    # --- Resource-bound: check profiles for CPU/mem/disk extremes ---
    if profiles:
        cpu_hotspot = None
        mem_hotspot = None
        disk_hotspot = None
        max_cpu = 0.0
        max_mem_frac = 0.0
        max_disk_ops = 0.0

        for label, p in profiles.items():
            cpu_info = p.get("cpu", {})
            mem_info = p.get("memory", {})
            disk_info = p.get("disk", {})

            cpu_avg = cpu_info.get("avg_usage_pct", 0)
            cpu_peak = cpu_info.get("peak_usage_pct", 0)
            if cpu_avg > max_cpu:
                max_cpu = cpu_avg
                cpu_hotspot = (label, cpu_avg, cpu_peak, p.get("duration_s", 0))

            # Memory is USED MB. Compare against the machine's total when the
            # profile carries it; otherwise fall back to an absolute floor.
            mem_peak = mem_info.get("peak_mb", 0)
            mem_total = mem_info.get("total_mb", 0)
            mem_frac = (mem_peak / mem_total) if mem_total > 0 else (mem_peak / 16000.0)
            if mem_frac > max_mem_frac:
                max_mem_frac = mem_frac
                mem_hotspot = (label, mem_peak, mem_total)

            disk_ops = disk_info.get("avg_ops_per_s", 0)
            disk_mb = disk_info.get("total_mb", 0)
            if disk_ops > max_disk_ops:
                max_disk_ops = disk_ops
                disk_hotspot = (label, disk_ops, disk_mb, p.get("duration_s", 0))

        # Classify: pick the most extreme dimension.
        # Each candidate's sort key is normalized to roughly 0-100 so the
        # dimensions are comparable:
        #   CPU   — avg usage pct (bound when > 80)
        #   Disk  — avg completed IOs/s / 10 (bound when > 500 ops/s)
        #   Mem   — peak used as pct of total (bound when > 85%)

        candidates = []
        if cpu_hotspot and cpu_hotspot[1] > 80:
            candidates.append((
                cpu_hotspot[1],  # sort key
                f"CPU-bound: {cpu_hotspot[0]} at {cpu_hotspot[1]:.0f}% avg CPU "
                f"(peak {cpu_hotspot[2]:.0f}%) for {fmt_dur(cpu_hotspot[3])}"
            ))
        if disk_hotspot and disk_hotspot[1] > 500:
            candidates.append((
                disk_hotspot[1] / 10,
                f"Disk IO-bound: {disk_hotspot[0]} at {disk_hotspot[1]:.0f} ops/s "
                f"({disk_hotspot[2]:.0f} MB total) for {fmt_dur(disk_hotspot[3])}"
            ))
        if mem_hotspot and max_mem_frac > 0.85:
            total_note = f" of {mem_hotspot[2]:.0f} MB" if mem_hotspot[2] else ""
            candidates.append((
                max_mem_frac * 100,
                f"Memory-bound: {mem_hotspot[0]} peaked at "
                f"{mem_hotspot[1]:.0f} MB used{total_note}"
            ))

        if candidates:
            candidates.sort(reverse=True)
            return candidates[0][1]

    # --- No resource profiles, but check wall vs compute ---
    compute = stats["compute"]
    if wall > 0 and compute > 0:
        parallelism = compute / wall
        if parallelism < 1.2 and len(jobs) > 2:
            # Low parallelism ratio means jobs are serial
            slowest = max(jobs, key=lambda j: j.get("duration_s") or 0)
            slow_dur = slowest.get("duration_s") or 0
            slow_pct = slow_dur / wall * 100 if wall > 0 else 0
            if slow_pct > 40:
                return (f"Serial bottleneck: {slowest['name']} takes "
                        f"{fmt_dur(slow_dur)} ({slow_pct:.0f}% of wall)")

    # --- Fallback: the single slowest job ---
    slowest = max(jobs, key=lambda j: j.get("duration_s") or 0)
    slow_dur = slowest.get("duration_s") or 0
    if slow_dur > 0 and wall > 0:
        slow_pct = slow_dur / wall * 100
        if slow_pct > 40 and len(jobs) > 1:
            return (f"Dominated by {slowest['name']}: "
                    f"{fmt_dur(slow_dur)} ({slow_pct:.0f}% of wall)")

    return "Evenly distributed: no single bottleneck"


# ---------------------------------------------------------------------------
# HTML generation
# ---------------------------------------------------------------------------

CSS = """
* { box-sizing: border-box; margin: 0; padding: 0; }
body {
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
  background: #0d1117; color: #e6edf3; line-height: 1.5; padding: 24px;
}
h1 { font-size: 24px; border-bottom: 1px solid #30363d; padding-bottom: 12px; margin-bottom: 8px; }
.meta { color: #8b949e; font-size: 13px; margin-bottom: 24px; }
h2 { font-size: 18px; margin: 32px 0 12px; }

/* Stats cards */
.stats { display: flex; gap: 12px; flex-wrap: wrap; margin-bottom: 24px; }
.stat-card {
  background: #161b22; border: 1px solid #30363d; border-radius: 8px;
  padding: 14px 18px; min-width: 140px;
}
.stat-label { font-size: 12px; color: #8b949e; text-transform: uppercase; letter-spacing: 0.5px; }
.stat-value { font-size: 22px; font-weight: 600; margin: 4px 0; }
.stat-delta { font-size: 13px; }
.faster { color: #3fb950; }
.slower { color: #f85149; }
.neutral { color: #8b949e; }

/* Gantt */
.gantt-wrap { overflow-x: auto; }
.gantt { min-width: 700px; }
.gantt-row { display: flex; align-items: center; height: 28px; }
.gantt-label {
  width: 220px; padding-right: 12px; text-align: right;
  font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
}
.gantt-track { flex: 1; position: relative; height: 100%; border-left: 1px solid #21262d; }
.gantt-bar {
  position: absolute; height: 18px; border-radius: 3px;
  display: flex; align-items: center; justify-content: center;
  font-size: 10px; color: transparent; overflow: hidden;
  transition: color 0.15s;
}
.gantt-bar:hover { color: #fff; z-index: 10; }
.gantt-bar.current { background: #1f6feb; top: 5px; z-index: 2; }
.gantt-bar.wait {
  background: repeating-linear-gradient(
    45deg, #30363d, #30363d 3px, transparent 3px, transparent 6px
  );
  top: 5px; z-index: 1; opacity: 0.6;
}
.gantt-bar.baseline {
  background: transparent; border: 1px dashed #8b949e; top: 2px; height: 24px; z-index: 1;
}
.gantt-axis { display: flex; height: 20px; position: relative; border-top: 1px solid #30363d; margin-top: 4px; }
.gantt-tick { position: absolute; font-size: 10px; color: #8b949e; transform: translateX(-50%); top: 4px; }
.gantt-tick::before { content: ''; position: absolute; top: -4px; left: 50%; width: 1px; height: 4px; background: #30363d; }
.legend { display: flex; gap: 16px; margin-top: 8px; font-size: 12px; color: #8b949e; }
.legend-swatch { display: inline-block; width: 16px; height: 10px; border-radius: 2px; margin-right: 4px; vertical-align: middle; }

/* Tables */
table { border-collapse: collapse; width: 100%; font-size: 13px; margin-bottom: 16px; }
th, td { border: 1px solid #30363d; padding: 6px 10px; text-align: left; }
th { background: #161b22; font-weight: 600; position: sticky; top: 0; }
tr:hover td { background: #161b22; }
.num { text-align: right; font-variant-numeric: tabular-nums; }
.job-name { font-weight: 500; }

/* Step details */
details { margin-bottom: 8px; background: #161b22; border: 1px solid #30363d; border-radius: 6px; }
summary { padding: 8px 12px; cursor: pointer; font-weight: 500; font-size: 14px; user-select: none; }
summary:hover { background: #21262d; }
details[open] summary { border-bottom: 1px solid #30363d; }
details table { border: none; margin: 0; }
details td, details th { font-size: 12px; }

/* Worst regressions */
.regressions { margin-bottom: 24px; }
.regressions table { font-size: 13px; }
.tag {
  display: inline-block; padding: 1px 6px; border-radius: 3px; font-size: 11px; font-weight: 500;
}
.tag.slow { background: rgba(248,81,73,0.15); color: #f85149; }
.tag.fast { background: rgba(63,185,80,0.15); color: #3fb950; }
"""


def _gantt_bars(timings: dict, baseline: dict | None) -> str:
    """Render the gantt chart HTML.

    Both current and baseline timelines are normalized to start at t=0
    (relative to each run's earliest job start). The axis scale spans
    0..max_end across both runs so bars are directly comparable.
    """
    jobs = [j for j in timings.get("jobs", [])
            if j.get("started_at") and j.get("completed_at") and not is_skipped(j)]
    bl_map = {j["name"]: j for j in (baseline or {}).get("jobs", [])}

    # Current run: relative offsets from earliest start
    cur_starts = [s for s in (parse_ts(j.get("started_at")) for j in jobs) if s is not None]
    cur_ends = [e for e in (parse_ts(j.get("completed_at")) for j in jobs) if e is not None]
    if not cur_starts or not cur_ends:
        return '<p style="color:#8b949e">No timing data available.</p>'
    cur_t0 = min(cur_starts)
    cur_max = (max(cur_ends) - cur_t0).total_seconds()

    # Baseline run: max duration (for axis scale only — bars are aligned
    # to the current job's start, not to the baseline timeline)
    bl_max_dur = 0.0
    for bl_j in bl_map.values():
        if is_skipped(bl_j):
            continue
        s = parse_ts(bl_j.get("started_at"))
        e = parse_ts(bl_j.get("completed_at"))
        if s is not None and e is not None:
            bl_max_dur = max(bl_max_dur, (e - s).total_seconds())

    total_s = max(cur_max, bl_max_dur)
    if total_s <= 0:
        total_s = 1

    rows = []
    for j in jobs:
        s = parse_ts(j.get("started_at"))
        e = parse_ts(j.get("completed_at"))
        if s is None or e is None:
            continue
        left = (s - cur_t0).total_seconds() / total_s * 100
        width = max((e - s).total_seconds() / total_s * 100, 0.5)  # min 0.5% for visibility
        dur = j.get("duration_s") or 0

        bl = bl_map.get(j["name"])
        bl_bar = ""
        if bl and not is_skipped(bl):
            bl_s = parse_ts(bl.get("started_at"))
            bl_e = parse_ts(bl.get("completed_at"))
            if bl_s is not None and bl_e is not None:
                # Align baseline bar to the current job's start so the
                # two durations are directly comparable — the baseline's
                # own wait/position is irrelevant for a duration diff.
                bl_left = left
                bl_width = max((bl_e - bl_s).total_seconds() / total_s * 100, 0.5)
                bl_dur = bl.get("duration_s") or 0
                bl_bar = (
                    f'<div class="gantt-bar baseline" '
                    f'style="left:{bl_left:.2f}%;width:{bl_width:.2f}%" '
                    f'title="baseline: {fmt_dur(bl_dur)}"></div>'
                )

        name_display = escape(j["name"])
        if j.get("workflow_name"):
            name_display = f'{escape(j["workflow_name"])} / {escape(j["name"])}'

        delta_info = ""
        if bl and not is_skipped(bl) and bl.get("duration_s") is not None:
            d_text, d_cls = fmt_delta(dur, bl.get("duration_s"))
            delta_info = f' — {d_text}'

        # Wait bar: shows idle time before the job started running
        wait_bar = ""
        wait_s = j.get("wait_s")
        if wait_s and wait_s >= 1.0:
            wait_left = (s - cur_t0).total_seconds() - wait_s
            wait_left_pct = max(wait_left / total_s * 100, 0)
            wait_width_pct = max(wait_s / total_s * 100, 0.3)
            wait_bar = (
                f'<div class="gantt-bar wait" '
                f'style="left:{wait_left_pct:.2f}%;width:{wait_width_pct:.2f}%" '
                f'title="{escape(j["name"])} — waited: {fmt_dur(wait_s)}"></div>'
            )

        rows.append(
            f'<div class="gantt-row">'
            f'<div class="gantt-label" title="{escape(j["name"])}">{name_display}</div>'
            f'<div class="gantt-track">'
            f'{bl_bar}'
            f'{wait_bar}'
            f'<div class="gantt-bar current" '
            f'style="left:{left:.2f}%;width:{width:.2f}%" '
            f'title="{escape(j["name"])}: {fmt_dur(dur)}{delta_info}"></div>'
            f'</div></div>'
        )

    # Axis
    ticks = nice_ticks(total_s)
    tick_html = "".join(
        f'<span class="gantt-tick" style="left:{(t / total_s * 100):.1f}%">{fmt_tick(t)}</span>'
        for t in ticks
    )
    axis = f'<div class="gantt-axis"><div class="gantt-track">{tick_html}</div></div>'

    legend = (
        '<div class="legend">'
        '<span><span class="legend-swatch" style="background:#1f6feb"></span>Current</span>'
        '<span><span class="legend-swatch" style="background:repeating-linear-gradient(45deg,#30363d,#30363d 3px,transparent 3px,transparent 6px);opacity:0.6"></span>Wait</span>'
    )
    if baseline:
        legend += '<span><span class="legend-swatch" style="border:1px dashed #8b949e"></span>Baseline (main)</span>'
    legend += '</div>'

    return f'<div class="gantt-wrap"><div class="gantt">{"".join(rows)}{axis}</div></div>{legend}'


def _stats_cards(stats: dict) -> str:
    wall_text = fmt_dur(stats["wall"])
    wall_delta = ""
    if stats["bl_wall"] is not None:
        d, cls = fmt_delta(stats["wall"], stats["bl_wall"])
        wall_delta = f'<span class="stat-delta {cls}">{d}</span>'

    compute_text = fmt_dur(stats["compute"])
    compute_delta = ""
    if stats["bl_compute"] is not None:
        d, cls = fmt_delta(stats["compute"], stats["bl_compute"])
        compute_delta = f'<span class="stat-delta {cls}">{d}</span>'

    cards = [
        f'<div class="stat-card"><span class="stat-label">Wall Time</span>'
        f'<div class="stat-value">{wall_text}</div>{wall_delta}</div>',
        f'<div class="stat-card"><span class="stat-label">Total Compute</span>'
        f'<div class="stat-value">{compute_text}</div>{compute_delta}</div>',
        f'<div class="stat-card"><span class="stat-label">Jobs Faster</span>'
        f'<div class="stat-value faster">{stats["faster"]}</div></div>',
        f'<div class="stat-card"><span class="stat-label">Jobs Slower</span>'
        f'<div class="stat-value slower">{stats["slower"]}</div></div>',
        f'<div class="stat-card"><span class="stat-label">Unchanged</span>'
        f'<div class="stat-value neutral">{stats["unchanged"]}</div></div>',
        f'<div class="stat-card"><span class="stat-label">Skipped</span>'
        f'<div class="stat-value neutral">{stats["skipped"]}</div></div>',
        f'<div class="stat-card"><span class="stat-label">No Baseline</span>'
        f'<div class="stat-value neutral">{stats["no_baseline"]}</div></div>',
    ]
    return f'<div class="stats">{"".join(cards)}</div>'


def _job_table(timings: dict, baseline: dict | None) -> str:
    bl_map = {j["name"]: j for j in (baseline or {}).get("jobs", [])}
    rows = []
    for j in timings.get("jobs", []):
        name = escape(j["name"])
        if j.get("workflow_name"):
            name = f'{escape(j["workflow_name"])} / {escape(j["name"])}'

        concl = j.get("conclusion", "")
        concl_icon = {"success": "✓", "failure": "✗", "skipped": "⊘"}.get(concl, "?")
        concl_cls = {"success": "faster", "failure": "slower", "skipped": "neutral"}.get(concl, "neutral")

        if is_skipped(j):
            rows.append(
                f'<tr>'
                f'<td class="job-name">{name}</td>'
                f'<td class="num neutral">skipped</td>'
                f'<td class="num neutral">—</td>'
                f'<td class="num neutral">—</td>'
                f'<td class="num neutral">—</td>'
                f'<td class="num neutral">—</td>'
                f'<td class="{concl_cls}" style="text-align:center">{concl_icon}</td>'
                f'</tr>'
            )
            continue

        dur = j.get("duration_s")
        wait = j.get("wait_s")
        bl = bl_map.get(j["name"])
        bl_dur = bl.get("duration_s") if bl and not is_skipped(bl) else None
        bl_wait = bl.get("wait_s") if bl and not is_skipped(bl) else None
        delta_text, delta_cls = fmt_delta(dur, bl_dur)
        wait_delta_text, wait_delta_cls = fmt_delta(wait, bl_wait)

        rows.append(
            f'<tr>'
            f'<td class="job-name">{name}</td>'
            f'<td class="num">{fmt_dur(dur)}</td>'
            f'<td class="num">{fmt_dur(wait)}</td>'
            f'<td class="num">{fmt_dur(bl_dur)}</td>'
            f'<td class="num {delta_cls}">{delta_text}</td>'
            f'<td class="num {wait_delta_cls}">{wait_delta_text}</td>'
            f'<td class="{concl_cls}" style="text-align:center">{concl_icon}</td>'
            f'</tr>'
        )

    return (
        '<table><thead><tr>'
        '<th>Job</th><th class="num">Run</th><th class="num">Wait</th>'
        '<th class="num">Baseline</th><th class="num">Δ Run</th>'
        '<th class="num">Δ Wait</th><th>Status</th>'
        '</tr></thead><tbody>' + "".join(rows) + '</tbody></table>'
    )


def _step_details(timings: dict, baseline: dict | None) -> str:
    bl_map = {j["name"]: j for j in (baseline or {}).get("jobs", [])}
    blocks = []
    for j in timings.get("jobs", []):
        if not j.get("steps"):
            continue
        if is_skipped(j):
            continue
        bl = bl_map.get(j["name"], {})
        bl_steps = {s["name"]: s for s in bl.get("steps", [])}

        dur = j.get("duration_s") or 0
        wait = j.get("wait_s")
        bl_dur = bl.get("duration_s") if bl and not is_skipped(bl) else None
        delta_text, delta_cls = fmt_delta(dur, bl_dur)

        summary_text = f'{escape(j["name"])} — {fmt_dur(dur)}'
        if wait is not None and wait >= 1.0:
            summary_text += f' <span class="neutral">(wait {fmt_dur(wait)})</span>'
        if bl_dur is not None:
            summary_text += f' <span class="{delta_cls}">({delta_text})</span>'

        step_rows = []
        for s in j["steps"]:
            s_dur = s.get("duration_s")
            bl_s = bl_steps.get(s["name"])
            bl_s_dur = bl_s.get("duration_s") if bl_s else None
            s_delta, s_cls = fmt_delta(s_dur, bl_s_dur)

            step_rows.append(
                f'<tr>'
                f'<td>{escape(s["name"])}</td>'
                f'<td class="num">{fmt_dur(s_dur)}</td>'
                f'<td class="num">{fmt_dur(bl_s_dur)}</td>'
                f'<td class="num {s_cls}">{s_delta}</td>'
                f'</tr>'
            )

        blocks.append(
            f'<details><summary>{summary_text}</summary>'
            f'<table><thead><tr>'
            '<th>Step</th><th class="num">Current</th><th class="num">Baseline</th>'
            '<th class="num">Delta</th>'
            f'</tr></thead><tbody>{"".join(step_rows)}</tbody></table>'
            f'</details>'
        )

    return "".join(blocks) if blocks else '<p style="color:#8b949e">No step data available.</p>'


def _regressions(timings: dict, baseline: dict | None) -> str:
    """Show top 10 biggest absolute regressions/improvements across all steps."""
    if not baseline:
        return ""
    bl_map = {j["name"]: j for j in baseline.get("jobs", [])}

    deltas = []  # (abs_delta, job_name, step_name, current, baseline, is_slower)
    for j in timings.get("jobs", []):
        if is_skipped(j):
            continue
        bl = bl_map.get(j["name"])
        if not bl or is_skipped(bl):
            continue
        bl_steps = {s["name"]: s for s in bl.get("steps", [])}
        for s in j.get("steps", []):
            bl_s = bl_steps.get(s["name"])
            if not bl_s:
                continue
            cur = s.get("duration_s") or 0
            bl_d = bl_s.get("duration_s") or 0
            diff = cur - bl_d
            if abs(diff) < 1.0:
                continue
            deltas.append((abs(diff), diff, j["name"], s["name"], cur, bl_d))

    deltas.sort(key=lambda x: x[0], reverse=True)
    top = deltas[:10]
    if not top:
        return ""

    rows = []
    for _, diff, job, step, cur, bl_d in top:
        cls = "slower" if diff > 0 else "faster"
        tag = f'<span class="tag {"slow" if diff > 0 else "fast"}">{"+" if diff > 0 else ""}{diff:.1f}s</span>'
        rows.append(
            f'<tr>'
            f'<td class="job-name">{escape(job)}</td>'
            f'<td>{escape(step)}</td>'
            f'<td class="num">{fmt_dur(cur)}</td>'
            f'<td class="num">{fmt_dur(bl_d)}</td>'
            f'<td>{tag}</td>'
            f'</tr>'
        )

    return (
        '<div class="regressions">'
        '<table><thead><tr>'
        '<th>Job</th><th>Step</th><th class="num">Current</th><th class="num">Baseline</th>'
        '<th>Delta</th>'
        '</tr></thead><tbody>' + "".join(rows) + '</tbody></table>'
        '</div>'
    )


def _resource_table(profiles: dict[str, dict]) -> str:
    """Render per-job resource usage as an HTML table."""
    if not profiles:
        return ""

    rows = []
    for label in sorted(profiles):
        p = profiles[label]
        cpu = p.get("cpu", {})
        mem = p.get("memory", {})
        disk = p.get("disk", {})

        rows.append(
            f'<tr>'
            f'<td class="job-name">{escape(label)}</td>'
            f'<td class="num">{fmt_dur(p.get("duration_s"))}</td>'
            f'<td class="num">{cpu.get("avg_usage_pct", 0):.0f}%</td>'
            f'<td class="num">{cpu.get("peak_usage_pct", 0):.0f}%</td>'
            f'<td class="num">{mem.get("avg_mb", 0):.0f}</td>'
            f'<td class="num">{mem.get("peak_mb", 0):.0f}</td>'
            f'<td class="num">{disk.get("total_mb", 0):.0f}</td>'
            f'<td class="num">{disk.get("avg_ops_per_s", 0):.0f}</td>'
            f'</tr>'
        )

    return (
        '<table><thead><tr>'
        '<th>Job</th><th class="num">Duration</th>'
        '<th class="num">CPU avg</th><th class="num">CPU peak</th>'
        '<th class="num">Mem avg (MB)</th><th class="num">Mem peak (MB)</th>'
        '<th class="num">Disk (MB)</th><th class="num">Disk ops/s</th>'
        '</tr></thead><tbody>' + "".join(rows) + '</tbody></table>'
    )


def _bottleneck_box(timings: dict, profiles: dict[str, dict]) -> str:
    """Render the bottleneck analysis as a callout box."""
    verdict = classify_bottleneck(timings, profiles)
    return (
        f'<div style="background:#161b22;border:1px solid #30363d;'
        f'border-radius:8px;padding:16px;margin-bottom:24px">'
        f'<div style="font-size:12px;color:#8b949e;text-transform:uppercase;'
        f'letter-spacing:0.5px;margin-bottom:4px">Bottleneck Analysis</div>'
        f'<div style="font-size:16px;font-weight:500">{escape(verdict)}</div>'
        f'</div>'
    )


def generate_html(timings: dict, baseline: dict | None = None,
                  profiles: dict[str, dict] | None = None) -> str:
    stats = compute_stats(timings, baseline)

    sha_short = (timings.get("head_sha") or "")[:7]
    run_id = timings.get("run_id", "?")
    created = timings.get("created_at", "")

    bl_info = ""
    if baseline:
        bl_sha = (baseline.get("head_sha") or "")[:7]
        bl_info = f' | Baseline: <code>{bl_sha}</code> (main)'

    html = (
        f'<!DOCTYPE html>\n<html lang="en">\n<head>\n'
        f'<meta charset="utf-8">\n'
        f'<meta name="viewport" content="width=device-width, initial-scale=1">\n'
        f'<title>CI Timing Report — {sha_short}</title>\n'
        f'<style>{CSS}</style>\n'
        f'</head>\n<body>\n'
        f'<h1>CI Timing Report</h1>\n'
        f'<div class="meta">Run <code>{escape(run_id)}</code> | SHA <code>{sha_short}</code>'
        f' | Generated {escape(created)}{bl_info}</div>\n'
    )

    html += '<h2>Global Stats</h2>\n'
    html += _stats_cards(stats)

    html += _bottleneck_box(timings, profiles or {})

    if profiles:
        html += '<h2>Resource Usage</h2>\n'
        html += _resource_table(profiles)

    if baseline:
        html += '<h2>Top Regressions & Improvements</h2>\n'
        html += _regressions(timings, baseline)

    html += '<h2>Gantt Chart</h2>\n'
    html += _gantt_bars(timings, baseline)

    html += '<h2>Per-Job Comparison</h2>\n'
    html += _job_table(timings, baseline)

    html += '<h2>Step Details</h2>\n'
    html += _step_details(timings, baseline)

    html += '</body>\n</html>\n'
    return html


# ---------------------------------------------------------------------------
# Markdown summary for $GITHUB_STEP_SUMMARY
# ---------------------------------------------------------------------------

def generate_summary(timings: dict, baseline: dict | None = None,
                     profiles: dict[str, dict] | None = None) -> str:
    stats = compute_stats(timings, baseline)
    bl_map = {j["name"]: j for j in (baseline or {}).get("jobs", [])}

    lines = ["## CI Timing Summary\n"]

    # Bottleneck analysis
    bottleneck = classify_bottleneck(timings, profiles or {})
    lines.append(f"**Bottleneck:** {bottleneck}")
    lines.append("")

    # Global stats table
    lines.append("| Metric | Current | Baseline | Delta |")
    lines.append("|--------|---------|----------|-------|")

    wall_d = ""
    if stats["bl_wall"] is not None:
        d, _ = fmt_delta(stats["wall"], stats["bl_wall"])
        wall_d = d
    lines.append(f"| Wall time | {fmt_dur(stats['wall'])} | {fmt_dur(stats['bl_wall'])} | {wall_d} |")

    compute_d = ""
    if stats["bl_compute"] is not None:
        d, _ = fmt_delta(stats["compute"], stats["bl_compute"])
        compute_d = d
    lines.append(f"| Total compute | {fmt_dur(stats['compute'])} | {fmt_dur(stats['bl_compute'])} | {compute_d} |")

    wait_d = ""
    if stats["bl_total_wait"] is not None:
        d, _ = fmt_delta(stats["total_wait"], stats["bl_total_wait"])
        wait_d = d
    lines.append(f"| Total wait | {fmt_dur(stats['total_wait'])} | {fmt_dur(stats['bl_total_wait'])} | {wait_d} |")

    lines.append(f"| Jobs faster | {stats['faster']} | — | — |")
    lines.append(f"| Jobs slower | {stats['slower']} | — | — |")
    lines.append(f"| Jobs unchanged | {stats['unchanged']} | — | — |")
    lines.append(f"| Jobs skipped | {stats['skipped']} | {stats['bl_skipped']} | — |")
    lines.append(f"| Jobs without baseline | {stats['no_baseline']} | — | — |")
    lines.append("")

    return "\n".join(lines)


# ---------------------------------------------------------------------------
# Review status JSON for the unified PR comment
# ---------------------------------------------------------------------------

# Wall-time regressions above this fraction of baseline are "warning" severity.
_TIMINGS_WARN_PCT = 0.25


def generate_review_status(
    timings: dict, baseline: dict | None, report_url: str | None = None,
    profiles: dict[str, dict] | None = None
) -> list[dict]:
    """Produce a review_status JSON array for the CI timings review section.

    Returns a list with one ``{source, results: [...]}`` entry. The
    result kind is ``"debug"`` or ``"warning"`` (timings is never error —
    it's an observability job). *summary* is a single short line suitable
    for the PR comment. *detail* has the per-job deltas as a markdown
    fragment.
    """
    stats = compute_stats(timings, baseline)
    bottleneck = classify_bottleneck(timings, profiles or {})

    if baseline is None:
        severity = "debug"
        summary = f"Wall time {fmt_dur(stats['wall'])} (no baseline yet)."
    else:
        wall = stats["wall"]
        bl_wall = stats["bl_wall"] or 0
        if bl_wall > 0:
            pct = (wall - bl_wall) / bl_wall * 100
            wall_str = f"Wall time {fmt_dur(wall)} vs {fmt_dur(bl_wall)} ({pct:+.1f}%)."
            if pct > _TIMINGS_WARN_PCT * 100:
                severity = "warning"
            else:
                severity = "debug"
        else:
            wall_str = f"Wall time {fmt_dur(wall)}."
            severity = "debug"

        if stats["slower"]:
            wall_str += f" {stats['slower']} job(s) slower,"
        if stats["faster"]:
            wall_str += f" {stats['faster']} faster,"
        if stats["unchanged"]:
            wall_str += f" {stats['unchanged']} unchanged."
        summary = wall_str

    summary += f" Bottleneck: {bottleneck}"

    # Per-job delta detail (top 5 by absolute change)
    detail_lines: list[str] = []
    if baseline:
        bl_map = {j["name"]: j for j in baseline.get("jobs", [])}
        deltas: list[tuple[float, str, str]] = []
        for j in timings.get("jobs", []):
            if is_skipped(j):
                continue
            bl = bl_map.get(j["name"])
            if not bl or is_skipped(bl):
                continue
            cur = j.get("duration_s") or 0
            bl_d = bl.get("duration_s") or 0
            diff = cur - bl_d
            if abs(diff) < 1.0:
                continue
            deltas.append((abs(diff), j["name"], f"{diff:+.1f}s"))
        deltas.sort(reverse=True)
        for _, name, delta_str in deltas[:5]:
            detail_lines.append(f"- {name}: {delta_str}")

    result: dict = {
        "kind": severity,
        "title": "CI timings",
        "summary": summary,
        "detail": "\n".join(detail_lines),
    }
    if report_url:
        result["link"] = report_url
        result["link_label"] = "View report"

    return [{"source": "ci timing", "results": [result]}]


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def expect_env(var: str) -> str:
    val = os.environ.get(var)
    if not val:
        raise ValueError(f"missing environment variable {var}")
    return val

def main():
    parser = argparse.ArgumentParser(description="Collect CI timings and generate HTML report")
    parser.add_argument("--from-json", help="Read timings from JSON instead of API")
    parser.add_argument("--baseline", default="ci-timings-baseline.json",
                        help="Baseline JSON path (default: ci-timings-baseline.json)")
    parser.add_argument("--output", default="ci-timings-report.html",
                        help="HTML output path (default: ci-timings-report.html)")
    parser.add_argument("--json-out", default="ci-timings.json",
                        help="JSON output path (default: ci-timings.json)")
    parser.add_argument("--summary-out", default="ci-timings-summary.md",
                        help="Markdown summary output path (default: ci-timings-summary.md)")
    parser.add_argument("--review-status-out", default="",
                        help="If set, write a review-status JSON for the unified PR comment.")
    parser.add_argument("--review-status-only", action="store_true",
                        help="Write review status from existing timings without regenerating the report.")
    parser.add_argument("--profiles-dir", default="",
                        help="Directory of downloaded resource-profile-* artifacts.")
    args = parser.parse_args()

    # Load resource profiles (available in both API and --from-json modes)
    profiles = load_resource_profiles(args.profiles_dir) if args.profiles_dir else {}

    # Collect or load timings
    if args.from_json:
        with open(args.from_json, encoding="utf-8") as f:
            timings = json.load(f)
    else:
        repo = expect_env("GITHUB_REPOSITORY")
        run_id = expect_env("GITHUB_RUN_ID")
        head_sha = expect_env("GITHUB_SHA")
        try:
            # A missing token (e.g. an empty PAT on a fork PR, where repo
            # secrets are unavailable) is a degraded run, not a hard error:
            # route it through the same soft-fail path so this advisory job
            # never reddens the PR.
            token = os.environ.get("GITHUB_TOKEN")
            if not token:
                raise TimingsUnavailable("GITHUB_TOKEN is empty")
            timings = collect_timings(token, repo, run_id, head_sha)
        except TimingsUnavailable as e:
            # Observability job: a missing report must never redden the PR.
            # Emit a degraded summary + placeholder artifact and exit 0.
            msg = f"CI timing data unavailable this run: {e}"
            print(msg, file=sys.stderr)
            with open(args.summary_out, "a", encoding="utf-8") as f:
                f.write(f"\n> ⚠️ {msg}\n")
            with open(args.output, "w", encoding="utf-8") as f:
                f.write(f"<html><body><p>{escape(msg)}</p></body></html>\n")
            # No JSON on purpose: an empty timings file must never be cached
            # as the main baseline.
            sys.exit(0)

    # Save JSON
    with open(args.json_out, "w", encoding="utf-8") as f:
        json.dump(timings, f, indent=2)
    print(f"Saved timings to {args.json_out} ({len(timings.get('jobs', []))} jobs)")

    # Load baseline
    baseline = None
    if os.path.exists(args.baseline):
        with open(args.baseline, encoding="utf-8") as f:
            baseline = json.load(f)
        print(f"Loaded baseline from {args.baseline}")
    else:
        print(f"No baseline file at {args.baseline} — generating current-only report")

    if args.review_status_only:
        if not args.review_status_out:
            parser.error("--review-status-only requires --review-status-out")
        report_url = os.environ.get("CI_TIMINGS_REPORT_URL", "")
        statuses = generate_review_status(timings, baseline, report_url, profiles)
        with open(args.review_status_out, "w", encoding="utf-8") as f:
            f.write(f"review_status={json.dumps(statuses)}\n")
        print(f"Wrote review status to {args.review_status_out}")
        return

    # Generate HTML
    html = generate_html(timings, baseline, profiles)
    with open(args.output, "w", encoding="utf-8") as f:
        f.write(html)
    print(f"Generated HTML report: {args.output}")

    # Write summary
    summary = generate_summary(timings, baseline, profiles)
    with open(args.summary_out, "a", encoding="utf-8") as f:
        f.write(summary)
        print(f"Wrote summary to {args.summary_out}")

    # Write review status for the unified PR comment.
    # The output goes to GITHUB_OUTPUT (or a file with the same key=value
    # format) so the ci-timings job can expose it as a workflow_call output.
    if args.review_status_out:
        report_url = os.environ.get("CI_TIMINGS_REPORT_URL", "")
        statuses = generate_review_status(timings, baseline, report_url, profiles)
        json_str = json.dumps(statuses)
        with open(args.review_status_out, "a", encoding="utf-8") as f:
            f.write(f"review_status={json_str}\n")
        print(f"Wrote review status to {args.review_status_out}")


if __name__ == "__main__":
    main()