#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
build_site.py - generate the static Threat Register site.

Outputs:
  site/index.html
  site/threats/T-001.html ... T-069.html

Inputs:
  evidence_threats/register.json
      Existing enriched register. Remains authoritative for threat data,
      repositories, mitigation research, applicable source types and gaps.

  evidence-v3/threat_correlations.json
      New correlation output. Authoritative for CVE, paper, signal, incident and assessment correlations,
      including accepted and review states.

Usage:
  python3 build_site.py
  python3 build_site.py site
  python3 build_site.py site --register evidence_threats/register.json \
      --correlations evidence-v3/threat_correlations.json

Design principle:
  The Threat Register remains central. The index shows compact evidence counts.
  Each evidence indicator links to the External Evidence section on the existing
  T-xxx detail page. Rejected correlations are not rendered.
"""

from __future__ import annotations

import argparse
import html
import json
import re
import sys
from pathlib import Path
from typing import Any, Iterable
from site_navigation import navigation as site_navigation


DEFAULT_REGISTER = Path("data/threats_register.json")
DEFAULT_CORRELATIONS = Path("evidence/threat_correlations.json")
DEFAULT_OUTPUT = Path("site")
DEFAULT_R155_ROOT = Path("regulatory/r155")
DEFAULT_R155_MAPPINGS = Path("regulatory/r155/r155_threat_mappings.json")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Build the static Threat Register website with correlated evidence."
    )
    parser.add_argument(
        "output_dir",
        nargs="?",
        type=Path,
        default=DEFAULT_OUTPUT,
        help="Output directory (default: site)",
    )
    parser.add_argument(
        "--register",
        type=Path,
        default=DEFAULT_REGISTER,
        help="Existing enriched register JSON",
    )
    parser.add_argument(
        "--correlations",
        type=Path,
        default=DEFAULT_CORRELATIONS,
        help="Correlation JSON produced by correlate_evidence.py",
    )
    parser.add_argument("--r155-root", type=Path, default=DEFAULT_R155_ROOT, help="UN R155 regulatory data directory")
    parser.add_argument("--r155-mappings", type=Path, default=DEFAULT_R155_MAPPINGS, help="Promoted UN R155 review baseline mapping JSON")
    parser.add_argument(
        "--accepted-limit",
        type=int,
        default=30,
        help="Maximum accepted correlations rendered per threat (default: 30)",
    )
    parser.add_argument(
        "--review-limit",
        type=int,
        default=30,
        help="Maximum review correlations rendered per threat (default: 30)",
    )
    args = parser.parse_args()

    if args.accepted_limit < 1:
        parser.error("--accepted-limit must be at least 1")
    if args.review_limit < 1:
        parser.error("--review-limit must be at least 1")

    return args


def e(value: Any) -> str:
    return html.escape(str(value if value is not None else ""), quote=True)


def public_source(value: Any) -> str:
    """Neutralise workshop organisation names in public HTML only."""
    source = str(value or "").strip()
    if source.casefold().startswith("workshop"):
        return "Risk assessment workshop"
    return source


def safe_url(value: Any) -> str:
    """Return a safe external URL.

    Correlation output should already contain plain URLs, but this also accepts
    old HTML-anchor fields by extracting the first http(s) URL.
    """
    raw = html.unescape(str(value or "")).strip()
    match = re.search(r"https?://[^\s\"'<>]+", raw, re.I)
    if not match:
        return ""
    return match.group(0).rstrip(".,);]")


def slug_class(risk: Any) -> str:
    return {
        "critical": "critical",
        "high": "high",
        "moderate": "moderate",
        "medium": "moderate",
        "low": "low",
    }.get(str(risk or "").lower(), "unrated")


def load_json(path: Path) -> dict[str, Any]:
    if not path.exists():
        raise FileNotFoundError(f"Input file not found: {path}")
    try:
        with path.open("r", encoding="utf-8") as handle:
            data = json.load(handle)
    except json.JSONDecodeError as exc:
        raise ValueError(
            f"Invalid JSON in {path}: line {exc.lineno}, column {exc.colno}: {exc.msg}"
        ) from exc
    if not isinstance(data, dict):
        raise ValueError(f"Expected a JSON object in {path}")
    return data


STRENGTH_CLASS = {
    "Strong": "ev-strong",
    "Moderate": "ev-moderate",
    "Weak": "ev-weak",
    "None": "ev-none",
    "n/a": "ev-na",
    "Mitigations only": "ev-mit",
}


CSS = r"""
:root {
  --bg:#eef1f5; --surface:#fff; --surface-alt:#f7f9fb; --surface-hover:#f1f5f8;
  --ink:#1b2430; --muted:#5d6b7c; --line:#d5dce5; --accent:#1f4e79;
  --critical:#b3261e; --high:#d9692a; --medium:#c9a227; --low:#5b8c85; --unrated:#7a8696;
  --ev-strong:#2f6f4f; --ev-moderate:#3f7cac; --ev-weak:#8a7a3a; --ev-none:#8c4a4a;
  --ev-na:#7a8696; --ev-mit:#5a5aa0;
  --gA:#b3261e; --gB:#d9692a; --gC:#3f7cac; --gD:#7a8696;
  --accepted:#2f7d59; --review:#b37a20; --cve:#167da8; --paper:#6655b7; --signal:#b04f86; --incident:#b55832; --assessment:#3d7b72; --narrative:#7b5b3d; --repo:#526b7d;
}
@media (prefers-color-scheme: dark) {
  :root {
    --bg:#12171e; --surface:#1a212b; --surface-alt:#151c25; --surface-hover:#202a36;
    --ink:#e6ebf1; --muted:#93a1b3; --line:#2c3644; --accent:#7db4e6;
    --critical:#ef6a60; --high:#f0924f; --medium:#dcbc4a; --low:#7fb3aa; --unrated:#93a1b3;
    --ev-strong:#4f9b76; --ev-moderate:#6ba3d1; --ev-weak:#b8a65a; --ev-none:#c07878;
    --ev-na:#93a1b3; --ev-mit:#8f8fd4;
    --gA:#ef6a60; --gB:#f0924f; --gC:#6ba3d1; --gD:#93a1b3;
    --accepted:#58c493; --review:#e0a74d; --cve:#63bee4; --paper:#a99bf4; --signal:#e58bc2; --incident:#e98c68; --assessment:#73c1b3; --narrative:#c7a27e; --repo:#91a7b7;
  }
}
.site-header {
  display:flex;
  align-items:center;
  justify-content:space-between;
  gap:24px;
  min-height:68px;
  padding:12px 28px;
  background:var(--surface);
  border-bottom:1px solid var(--line);
}

.site-nav {
  display:flex;
  flex-wrap:wrap;
  justify-content:flex-start;
  gap:4px;
}

.site-nav-link {
  color:var(--muted);
  padding:7px 10px;
  border-radius:5px;
  font-size:.84rem;
  font-weight:600;
  text-decoration:none;
}

.site-nav-link:hover {
  color:var(--ink);
  background:var(--surface-alt);
  text-decoration:none;
}

.site-nav-link.active {
  color:var(--accent);
  background:color-mix(
    in srgb,
    var(--accent) 12%,
    transparent
  );
}

.site-brand {
  margin-left:auto;
  color:var(--ink);
  font-weight:700;
  white-space:nowrap;
  text-decoration:none;
}

.site-brand:hover {
  text-decoration:none;
}

@media (max-width:900px) {
  .site-header {
    align-items:flex-start;
    flex-direction:column-reverse;
  }

  .site-brand {
    margin-left:0;
  }
}
* { box-sizing:border-box; }
html { scroll-behavior:smooth; }
body {
  background:var(--bg);
  color:var(--ink);
  font:16px/1.5 "Segoe UI",system-ui,sans-serif;
  margin:0;
  padding:0;
}

main {
  max-width:1200px;
  margin:auto;
  padding:24px;
}

h1,h2,h3 { margin-top:0; }
a { color:var(--accent); text-decoration:none; }
a:hover { text-decoration:underline; }
.sub { color:var(--muted); }
.hero,.card { background:var(--surface); border:1px solid var(--line); border-radius:6px; padding:20px; margin-bottom:20px; }
.hero { padding:24px; margin-bottom:24px; }
.grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(170px,1fr)); gap:16px; margin-bottom:20px; }
.metric { background:var(--bg); border:1px solid var(--line); border-radius:6px; padding:16px; }
.metric .value { font-size:2rem; font-weight:700; }
.metric .label { color:var(--muted); }
table { width:100%; border-collapse:collapse; }
th,td { text-align:left; padding:10px 12px; border-bottom:1px solid var(--line); vertical-align:top; }
th { color:var(--muted); font-weight:600; }
.badge { display:inline-block; padding:4px 10px; border-radius:4px; color:#fff; font-size:.85rem; font-weight:600; white-space:nowrap; }
.critical { background:var(--critical); }.high { background:var(--high); }.medium,.moderate { background:var(--medium); }
.low { background:var(--low); }.unrated { background:var(--unrated); }
.ev-strong { background:var(--ev-strong); }.ev-moderate { background:var(--ev-moderate); }.ev-weak { background:var(--ev-weak); }
.ev-none { background:var(--ev-none); }.ev-na { background:var(--ev-na); }.ev-mit { background:var(--ev-mit); }
.grade { display:inline-block; min-width:20px; text-align:center; border-radius:3px; color:#fff; font-size:.75rem; font-weight:700; margin-right:6px; }
.gA { background:var(--gA); }.gB { background:var(--gB); }.gC { background:var(--gC); }.gD { background:var(--gD); }
.pill { display:inline-block; background:var(--bg); border:1px solid var(--line); border-radius:10px; padding:0 9px; margin:2px 4px 2px 0; font-size:.8rem; }
.pill.gap { border-color:var(--medium); }
.muted { color:var(--muted); font-size:.9rem; }.small { font-size:.85rem; }
pre { white-space:pre-wrap; overflow-wrap:break-word; }
.footer { margin-top:30px; color:var(--muted); }
.filters { display:flex; flex-wrap:wrap; gap:12px; margin-bottom:14px; }
.filters input,.filters select { background:var(--bg); color:var(--ink); border:1px solid var(--line); border-radius:4px; padding:7px 10px; font:inherit; }
.filters input { min-width:260px; }
dl { display:grid; grid-template-columns:200px 1fr; gap:6px 16px; margin:0; }
dt { color:var(--muted); } dd { margin:0; }
.nav { display:flex; justify-content:space-between; margin:18px 0; }
.ev-item { padding:10px 0; border-bottom:1px solid var(--line); }.ev-item:last-child { border-bottom:0; }
.hyp { color:var(--muted); font-style:italic; }

/* Register evidence indicator */
.register-evidence { display:inline-flex; flex-direction:column; align-items:flex-start; min-width:116px; padding:7px 9px; border:1px solid var(--line); border-radius:6px; background:var(--surface-alt); color:inherit; text-decoration:none; }
.register-evidence:hover { border-color:var(--accent); background:var(--surface-hover); text-decoration:none; }
.register-evidence-total { color:var(--accepted); font-size:1rem; font-weight:700; line-height:1.2; }
.register-evidence-types { margin-top:2px; color:var(--muted); font-size:.72rem; }
.register-evidence-review { margin-top:2px; color:var(--review); font-size:.72rem; }
.register-evidence-review-types { margin-top:1px; color:var(--muted); font-size:.68rem; }
.register-evidence.empty .register-evidence-total { color:var(--muted); }

/* Evidence detail section */
.evidence-panel { scroll-margin-top:20px; }
.evidence-heading { display:flex; justify-content:space-between; align-items:flex-start; gap:20px; margin-bottom:16px; }
.section-kicker { margin:0 0 4px; color:var(--accent); font-size:.68rem; font-weight:700; letter-spacing:.1em; text-transform:uppercase; }
.evidence-heading h2 { margin-bottom:4px; }
.evidence-threat-reference { padding:5px 9px; border:1px solid var(--line); border-radius:5px; background:var(--surface-alt); color:var(--accent); font-family:monospace; font-size:.75rem; font-weight:700; }
.evidence-summary { display:grid; grid-template-columns:repeat(auto-fit,minmax(145px,1fr)); gap:10px; }
.evidence-stat { padding:13px 15px; background:var(--surface-alt); border:1px solid var(--line); border-radius:6px; }
.evidence-stat.cve { border-left:3px solid var(--cve); }
.evidence-stat.paper { border-left:3px solid var(--paper); }
.evidence-stat.signal { border-left:3px solid var(--signal); }
.evidence-stat.incident { border-left:3px solid var(--incident); }
.evidence-stat.assessment { border-left:3px solid var(--assessment); }
.evidence-stat.narrative { border-left:3px solid var(--narrative); }
.evidence-stat.repo { border-left:3px solid var(--repo); }
.evidence-stat.review { border-left:3px solid var(--review); }
.evidence-stat-value { color:var(--ink); font-size:1.35rem; font-weight:700; line-height:1; }
.evidence-stat-label { margin-top:5px; color:var(--muted); font-size:.72rem; }
.evidence-disclaimer { margin:14px 0 0; }
.evidence-empty { padding:20px; background:var(--surface-alt); border:1px solid var(--line); border-radius:6px; text-align:center; }

/* Correlation cards */
.correlation-list { display:flex; flex-direction:column; gap:9px; }
.correlation-item { border:1px solid var(--line); border-left:3px solid var(--accepted); border-radius:6px; background:var(--surface-alt); overflow:hidden; }
.correlation-item[data-status="review"] { border-left-color:var(--review); }
.correlation-item-header { display:flex; justify-content:space-between; align-items:center; gap:12px; padding:9px 12px; border-bottom:1px solid var(--line); }
.evidence-badges { display:flex; flex-wrap:wrap; gap:5px; }
.evidence-badge { display:inline-flex; align-items:center; padding:2px 6px; border-radius:4px; font-size:.62rem; font-weight:700; letter-spacing:.04em; text-transform:uppercase; }
.type-cve { color:var(--cve); background:color-mix(in srgb,var(--cve) 9%,transparent); border:1px solid color-mix(in srgb,var(--cve) 24%,transparent); }
.type-paper { color:var(--paper); background:color-mix(in srgb,var(--paper) 9%,transparent); border:1px solid color-mix(in srgb,var(--paper) 24%,transparent); }
.type-signal { color:var(--signal); background:color-mix(in srgb,var(--signal) 9%,transparent); border:1px solid color-mix(in srgb,var(--signal) 24%,transparent); }
.type-incident { color:var(--incident); background:color-mix(in srgb,var(--incident) 9%,transparent); border:1px solid color-mix(in srgb,var(--incident) 24%,transparent); }
.type-assessment { color:var(--assessment); background:color-mix(in srgb,var(--assessment) 9%,transparent); border:1px solid color-mix(in srgb,var(--assessment) 24%,transparent); }
.type-narrative { color:var(--narrative); background:color-mix(in srgb,var(--narrative) 9%,transparent); border:1px solid color-mix(in srgb,var(--narrative) 24%,transparent); }
.status-accepted { color:var(--accepted); background:color-mix(in srgb,var(--accepted) 9%,transparent); border:1px solid color-mix(in srgb,var(--accepted) 24%,transparent); }
.status-review { color:var(--review); background:color-mix(in srgb,var(--review) 9%,transparent); border:1px solid color-mix(in srgb,var(--review) 24%,transparent); }
.correlation-score { display:flex; align-items:baseline; gap:6px; }
.correlation-score span { color:var(--muted); font-size:.62rem; letter-spacing:.04em; text-transform:uppercase; }
.correlation-score strong { color:var(--accent); font-family:monospace; font-size:.88rem; }
.correlation-item[data-status="review"] .correlation-score strong { color:var(--review); }
.correlation-item-body { padding:12px; }
.correlation-item-body h3 { margin:0 0 6px; font-size:.94rem; line-height:1.4; }
.correlation-item-body p { margin:0; }
.evidence-tags { display:flex; flex-wrap:wrap; gap:5px; margin-top:9px; }
.evidence-tag { padding:2px 6px; border:1px solid var(--line); border-radius:10px; color:var(--muted); background:var(--bg); font-size:.65rem; }
.correlation-details { margin-top:10px; border-top:1px solid var(--line); padding-top:8px; }
.correlation-details summary { color:var(--muted); font-size:.72rem; cursor:pointer; }
.correlation-details dl { margin-top:8px; grid-template-columns:150px 1fr; font-size:.75rem; }
.score-grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(115px,1fr)); gap:6px; margin-top:9px; }
.score-cell { padding:6px 8px; border-radius:4px; background:var(--bg); }
.score-cell span { display:block; color:var(--muted); font-size:.62rem; }
.score-cell strong { display:block; margin-top:2px; color:var(--accent); font-family:monospace; font-size:.72rem; }
.correlation-item-footer { display:flex; justify-content:space-between; align-items:center; gap:12px; padding:7px 12px; border-top:1px solid var(--line); }
.evidence-link { font-size:.74rem; font-weight:600; }
.section-toolbar { display:flex; flex-wrap:wrap; align-items:center; justify-content:space-between; gap:10px; margin-bottom:12px; }
.section-count { color:var(--muted); font-size:.78rem; }

@media (max-width:800px) {
  .evidence-summary { grid-template-columns:repeat(2,minmax(0,1fr)); }
}
@media (max-width:700px) {
  dl { grid-template-columns:1fr; }
  .evidence-heading,.correlation-item-header,.correlation-item-footer { align-items:flex-start; flex-direction:column; }
  .evidence-summary { grid-template-columns:1fr; }
  table { display:block; overflow-x:auto; }
}
/* UN R155 production traceability */
.hero{display:flex;flex-wrap:wrap;align-items:flex-start;gap:6px}
.hero .sub,.hero h1{flex:0 0 100%}
.hero .badge,.hero .register-evidence{flex:0 0 auto}
.r155-regulatory-link{margin-left:auto;display:inline-flex;align-items:center;padding:6px 10px;border:1px solid var(--line);border-radius:6px;background:var(--surface-alt);color:var(--accent);font-size:.78rem;font-weight:700;text-decoration:none}
.r155-regulatory-link:hover{background:var(--surface-hover);text-decoration:none}
.r155-panel{border-top:4px solid #325d88;scroll-margin-top:20px}
.r155-heading{display:flex;justify-content:space-between;gap:16px}
.r155-status,.r155-kind,.r155-ref{display:inline-block;padding:3px 7px;border:1px solid var(--line);border-radius:5px;font-size:.68rem}
.r155-status.review{color:var(--review);border-color:var(--review)}
.r155-subheading{margin:18px 0 8px;padding-bottom:8px;border-bottom:1px solid var(--line)}
.r155-requirements,.r155-mappings{display:grid;gap:10px}
.r155-requirement,.r155-mapping{padding:13px 14px;border:1px solid var(--line);border-left:4px solid #4f6f8f;border-radius:6px;background:var(--surface-alt)}
.r155-mapping{border-left-color:#325d88}
.r155-requirement-head,.r155-mapping-head{display:flex;gap:8px;align-items:center;flex-wrap:wrap}
.r155-node-line{display:flex;gap:7px;flex-wrap:wrap;margin:7px 0}
.r155-terms{display:flex;gap:5px;flex-wrap:wrap}
.r155-term{padding:2px 6px;border:1px solid var(--line);border-radius:10px;color:var(--muted);font-size:.65rem}
.r155-summary{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:8px;margin:10px 0}
.r155-summary>div{padding:10px;border:1px solid var(--line);border-radius:6px;background:var(--surface-alt)}
.r155-summary strong,.r155-summary span{display:block}
.r155-summary span{font-size:.7rem;color:var(--muted)}
.r155-empty{padding:15px;border:1px solid var(--line);border-radius:6px;background:var(--surface-alt)}
.r155-baseline{margin:16px 0;padding:14px 16px;border:1px solid var(--line);border-left:4px solid #2f7d59;border-radius:6px;background:var(--surface-alt)}
.r155-baseline-badge{padding:4px 8px;border-radius:5px;background:#2f7d59;color:#fff;font-size:.7rem;font-weight:800}
.r155-mitigation{padding:8px 0;border-bottom:1px solid var(--line)}

"""


HEAD = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{title}</title>
<style>{css}</style>
</head>
<body>
{navigation}
<main>
"""

TAIL = """
</main>
</body>
</html>
"""


def strength_label(threat: dict[str, Any]) -> str:
    strength = threat.get("strength", "None")
    counts = threat.get("counts", {})
    if strength == "None" and counts.get("mitigation", 0):
        return "Mitigations only"
    return strength


def correlation_for(correlations: dict[str, Any], threat_id: str) -> dict[str, Any]:
    result = correlations.get("threats", {}).get(threat_id, {})
    return result if isinstance(result, dict) else {}


def repository_items(threat: dict[str, Any]) -> list[dict[str, Any]]:
    evidence = threat.get("evidence", {})
    items = evidence.get("repo", []) if isinstance(evidence, dict) else []
    return [item for item in items if isinstance(item, dict)]


def evidence_statistics(threat: dict[str, Any], correlation: dict[str, Any]) -> dict[str, int]:
    stats = correlation.get("statistics", {})
    if not isinstance(stats, dict):
        stats = {}

    raw_items = correlation.get("evidence", [])
    if not isinstance(raw_items, list):
        raw_items = []

    accepted_items = [
        item for item in raw_items
        if isinstance(item, dict) and str(item.get("status", "")).lower() == "accepted"
    ]
    review_items = [
        item for item in raw_items
        if isinstance(item, dict) and str(item.get("status", "")).lower() == "review"
    ]

    def count(items: list[dict[str, Any]], evidence_type: str) -> int:
        return sum(
            1 for item in items
            if str(item.get("evidence_type", "")).lower() == evidence_type
        )

    accepted_cves = int(stats.get("cves", count(accepted_items, "cve")) or 0)
    accepted_papers = int(stats.get("papers", count(accepted_items, "paper")) or 0)
    accepted_signals = int(stats.get("signals", count(accepted_items, "signal")) or 0)
    accepted_incidents = int(stats.get("incidents", count(accepted_items, "incident")) or 0)
    accepted_assessments = int(stats.get("assessments", count(accepted_items, "assessment")) or 0)
    accepted_narratives = int(stats.get("narratives", count(accepted_items, "narrative")) or 0)

    calculated_total = (
        accepted_cves
        + accepted_papers
        + accepted_signals
        + accepted_incidents
        + accepted_assessments
        + accepted_narratives
    )
    accepted_total = max(
        int(stats.get("accepted", calculated_total) or 0),
        calculated_total,
    )
    review_total = max(
        int(stats.get("review", len(review_items)) or 0),
        len(review_items),
    )

    return {
        "accepted_cves": accepted_cves,
        "accepted_papers": accepted_papers,
        "accepted_signals": accepted_signals,
        "accepted_incidents": accepted_incidents,
        "accepted_assessments": accepted_assessments,
        "accepted_narratives": accepted_narratives,
        "accepted_total": accepted_total,
        "review_cves": count(review_items, "cve"),
        "review_papers": count(review_items, "paper"),
        "review_signals": count(review_items, "signal"),
        "review_incidents": count(review_items, "incident"),
        "review_assessments": count(review_items, "assessment"),
        "review_narratives": count(review_items, "narrative"),
        "review_total": review_total,
        "repositories": len(repository_items(threat)),
    }

def evidence_group(threat: dict[str, Any], correlation: dict[str, Any]) -> str:
    if strength_label(threat) == "n/a":
        return "na"
    stats = evidence_statistics(threat, correlation)
    if stats["accepted_total"] or stats["repositories"]:
        return "has"
    if stats["review_total"]:
        return "review"
    return "gap"


def evidence_cell(
    threat: dict[str, Any],
    correlation: dict[str, Any],
    detail_page: bool = False,
) -> str:
    if strength_label(threat) == "n/a":
        return (
            '<span class="badge ev-na">n/a</span> '
            '<span class="muted small">organisational</span>'
        )

    stats = evidence_statistics(threat, correlation)

    accepted = stats["accepted_total"]
    reviews = stats["review_total"]
    repos = stats["repositories"]

    if not accepted and not reviews and not repos:
        return (
            '<span class="register-evidence empty">'
            '<span class="register-evidence-total">—</span>'
            '<span class="register-evidence-types">No correlated evidence</span>'
            '</span>'
        )

    accepted_parts: list[str] = []

    accepted_specs = [
        ("accepted_cves", "CVE", "CVEs"),
        ("accepted_papers", "paper", "papers"),
        ("accepted_signals", "signal", "signals"),
        ("accepted_incidents", "incident", "incidents"),
        ("accepted_assessments", "assessment", "assessments"),
        ("accepted_narratives", "narrative", "narratives"),
    ]

    for key, singular, plural in accepted_specs:
        count = stats[key]
        if count:
            accepted_parts.append(
                f"{count} {singular if count == 1 else plural}"
            )

    if repos:
        accepted_parts.append(
            f"{repos} {'repo' if repos == 1 else 'repos'}"
        )

    review_parts: list[str] = []

    review_specs = [
        ("review_cves", "CVE", "CVEs"),
        ("review_papers", "paper", "papers"),
        ("review_signals", "signal", "signals"),
        ("review_incidents", "incident", "incidents"),
        ("review_assessments", "assessment", "assessments"),
        ("review_narratives", "narrative", "narratives"),
    ]

    for key, singular, plural in review_specs:
        count = stats[key]
        if count:
            review_parts.append(
                f"{count} {singular if count == 1 else plural}"
            )

    primary = (
        str(accepted)
        if accepted
        else (str(repos) if repos else "Review")
    )

    types_text = (
        " · ".join(accepted_parts)
        if accepted_parts
        else "Review candidates available"
    )

    review_html = (
        f'<span class="register-evidence-review">'
        f'{reviews} review candidate'
        f'{"s" if reviews != 1 else ""}'
        f'</span>'
        if reviews
        else ""
    )

    review_types_html = (
        f'<span class="register-evidence-review-types">'
        f'{" · ".join(e(part) for part in review_parts)}'
        f'</span>'
        if review_parts
        else ""
    )

    href = (
        "#evidence"
        if detail_page
        else f'threats/{e(threat["id"])}.html#evidence'
    )

    return (
        f'<a class="register-evidence" href="{href}">'
        f'<span class="register-evidence-total">{e(primary)}</span>'
        f'<span class="register-evidence-types">{e(types_text)}</span>'
        f'{review_html}'
        f'{review_types_html}'
        '</a>'
    )


def build_index(
    data: dict[str, Any],
    threats: list[dict[str, Any]],
    correlations: dict[str, Any],
) -> str:
    risk_counts = {
        risk: sum(1 for threat in threats if slug_class(threat.get("risk")) == risk)
        for risk in ("critical", "high", "moderate", "low")
    }
    with_evidence = sum(
        1 for threat in threats
        if evidence_group(threat, correlation_for(correlations, threat["id"])) == "has"
    )
    review_only = sum(
        1 for threat in threats
        if evidence_group(threat, correlation_for(correlations, threat["id"])) == "review"
    )
    organisational = sum(1 for threat in threats if strength_label(threat) == "n/a")
    evidence_gaps = sum(
        1 for threat in threats
        if evidence_group(threat, correlation_for(correlations, threat["id"])) == "gap"
    )
    categories = sorted({threat.get("category", "") for threat in threats if threat.get("category")})

    output = [HEAD.format(title="Threat Register", css=CSS, navigation=site_navigation("Threat Register"))]
    output.append(
        '<div class="hero"><h1>Threat Register</h1>'
        '<p class="sub">Evidence-based Automotive Cybersecurity Threat Register</p></div>'
    )
    output.append('<div class="grid">')
    metrics = [
        (len(threats), "Threats"),
        (risk_counts["critical"], "Critical"),
        (risk_counts["high"], "High"),
        (risk_counts["moderate"], "Moderate"),
        (risk_counts["low"], "Low"),
        (with_evidence, "With accepted evidence"),
        (review_only, "Review candidates only"),
        (evidence_gaps, "Evidence gaps"),
        (organisational, "Organisational (n/a)"),
    ]
    for value, label in metrics:
        output.append(
            f'<div class="metric"><div class="value">{value}</div>'
            f'<div class="label">{e(label)}</div></div>'
        )
    output.append('</div>')

    output.append('<div class="card"><h2>All Threats</h2>')
    output.append(
        '<div class="filters">'
        '<input type="search" id="q" placeholder="Search threats, categories, tags ...">'
        '<select id="risk"><option value="">All risk levels</option>'
        '<option>critical</option><option>high</option><option>moderate</option><option>low</option></select>'
        '<select id="cat"><option value="">All categories</option>'
        + "".join(f'<option>{e(category)}</option>' for category in categories)
        + '</select>'
        '<select id="ev"><option value="">All evidence</option>'
        '<option value="has">Accepted evidence</option>'
        '<option value="review">Review candidates only</option>'
        '<option value="gap">Evidence gap</option>'
        '<option value="na">Organisational (n/a)</option></select>'
        '</div>'
    )
    output.append(
        '<table><thead><tr><th>ID</th><th>Threat</th><th>Category</th>'
        '<th>Risk</th><th>Evidence</th></tr></thead><tbody id="rows">'
    )

    for threat in threats:
        correlation = correlation_for(correlations, threat["id"])
        group = evidence_group(threat, correlation)
        haystack = " ".join([
            str(threat.get("id", "")),
            str(threat.get("title", "")),
            str(threat.get("description", "")),
            str(threat.get("category", "")),
            " ".join(threat.get("tags", [])),
        ]).lower()


        output.append(
            f'<tr data-href="threats/{e(threat["id"])}.html" tabindex="0" '
            f'data-hay="{e(haystack)}" '
            f'data-risk="{slug_class(threat.get("risk"))}" '
            f'data-cat="{e(threat.get("category", ""))}" '
            f'data-ev="{e(group)}">'
            f'<td><a href="threats/{e(threat["id"])}.html">{e(threat["id"])}</a></td>'
            f'<td>{e(threat.get("title", ""))}</td>'
            f'<td>{e(threat.get("category", ""))}</td>'
            f'<td><span class="badge {slug_class(threat.get("risk"))}">'
            f'{e(threat.get("risk", "Not rated"))}</span></td>'
            f'<td>{evidence_cell(threat, correlation)}</td></tr>'
        )


    output.append('</tbody></table><p class="muted" id="count"></p></div>')

    correlation_time = str(correlations.get("generated_at", ""))[:16].replace("T", " ")
    source_workbook = data.get("source_workbook", "workbook")
    output.append(
        f'<div class="footer">Generated automatically from Threat Register dataset'
        f' · correlations generated {e(correlation_time)}'
        f' · source: {e(source_workbook)}</div>'
    )

    output.append(r"""<script>
const rows=[...document.querySelectorAll("#rows tr")];
const f={q:document.getElementById("q"),risk:document.getElementById("risk"),cat:document.getElementById("cat"),ev:document.getElementById("ev")};
function apply(){
  const q=f.q.value.trim().toLowerCase().split(/\s+/).filter(Boolean);let n=0;
  rows.forEach(r=>{
    const ok=q.every(w=>r.dataset.hay.includes(w))&&(!f.risk.value||r.dataset.risk===f.risk.value)&&
      (!f.cat.value||r.dataset.cat===f.cat.value)&&(!f.ev.value||r.dataset.ev===f.ev.value);
    r.style.display=ok?"":"none";if(ok)n++;
  });
  document.getElementById("count").textContent="Showing "+n+" of "+rows.length+" threats";
}
Object.values(f).forEach(x=>x.addEventListener("input",apply));
apply();

rows.forEach(r=>{
  r.style.cursor="pointer";

  r.addEventListener("click",e=>{
    if(e.target.closest("a, button, input, select, summary")) return;
    window.location.href=r.dataset.href;
  });

  r.addEventListener("keydown",e=>{
    if(e.key==="Enter"){
      window.location.href=r.dataset.href;
    }
  });
});
</script>""")



    output.append(TAIL)
    return "".join(output)


def link(url: Any, text: Any) -> str:
    safe = safe_url(url)
    return (
        f'<a href="{e(safe)}" target="_blank" rel="noopener noreferrer">{e(text)}</a>'
        if safe else e(text)
    )


def via(item: dict[str, Any]) -> str:
    return "".join(
        f'<span class="pill">{e(value)}</span>'
        for value in item.get("match_via", [])
    )


def ev_repo(item: dict[str, Any]) -> str:
    metadata = " · ".join(
        value for value in [
            f'{item.get("severity", "")} ({item.get("score")})' if item.get("severity") else "",
            item.get("role", ""),
            f'{item.get("stars", 0)} stars',
            f'last push {item.get("date", "")}' if item.get("date") else "",
            "mitigation / defensive" if item.get("kind") == "mitigation" else "public tooling",
        ] if value
    )
    llm_html = ""
    if item.get("llm"):
        llm = item["llm"]
        vulnerabilities = "; ".join(llm.get("vulnerabilities", [])[:3])
        llm_html = (
            '<div class="hyp small"><span class="grade gD">D</span>'
            f'Earlier LLM analysis ({e(llm.get("basis"))}: {e(llm.get("score"))}) '
            f'- hypothesis, not evidence: {e(vulnerabilities)}</div>'
        )
    return (
        '<div class="ev-item"><span class="grade gC">C</span>'
        f'{link(item.get("url"), item.get("title", "Repository"))}'
        f'<div class="muted small">{e(metadata)}</div>'
        f'<div class="small">{e(item.get("summary", ""))}</div>'
        f'<div class="small muted">matched via {via(item)}</div>{llm_html}</div>'
    )


def correlation_items(
    correlation: dict[str, Any],
    status: str | None = None,
    evidence_type: str | None = None,
) -> list[dict[str, Any]]:
    raw_items = correlation.get("evidence", [])
    if not isinstance(raw_items, list):
        return []

    result: list[dict[str, Any]] = []
    for item in raw_items:
        if not isinstance(item, dict):
            continue
        if status and item.get("status") != status:
            continue
        if evidence_type and item.get("evidence_type") != evidence_type:
            continue
        result.append(item)

    return sorted(
        result,
        key=lambda item: float(item.get("relevance_score", 0) or 0),
        reverse=True,
    )


def unique_tags(item: dict[str, Any], limit: int = 10) -> list[str]:
    result: list[str] = []
    seen: set[str] = set()
    features = item.get("matched_features", {})
    if isinstance(features, dict):
        for values in features.values():
            if not isinstance(values, list):
                continue
            for value in values:
                text = str(value).strip()
                key = text.casefold()
                if text and key not in seen:
                    result.append(text)
                    seen.add(key)
    for value in item.get("matched_terms", []):
        text = str(value).strip()
        key = text.casefold()
        if text and key not in seen:
            result.append(text)
            seen.add(key)
        if len(result) >= limit:
            break
    return result[:limit]


def render_score_breakdown(item: dict[str, Any]) -> str:
    breakdown = item.get("score_breakdown", {})
    if not isinstance(breakdown, dict) or not breakdown:
        return ""

    preferred = [
        ("lexical", "Lexical"),
        ("features", "Features"),
        ("assets", "Assets"),
        ("protocols", "Protocols"),
        ("attack_vectors", "Attack vectors"),
        ("impacts", "Impacts"),
        ("rule_bonus", "Rule contribution"),
        ("context_penalty", "Context penalty"),
        ("generic_penalty", "Generic penalty"),
        ("final", "Final score"),
    ]
    cells: list[str] = []
    for key, label in preferred:
        if key not in breakdown:
            continue
        try:
            display = f'{float(breakdown[key]):.2f}'
        except (TypeError, ValueError):
            display = str(breakdown[key])
        cells.append(
            f'<div class="score-cell"><span>{e(label)}</span><strong>{e(display)}</strong></div>'
        )
    return f'<div class="score-grid">{"".join(cells)}</div>' if cells else ""


def render_correlation_item(item: dict[str, Any]) -> str:
    evidence_type = str(item.get("evidence_type", "evidence")).strip().lower()
    status = str(item.get("status", "review")).strip().lower()
    evidence_id = str(item.get("evidence_id", ""))
    title = str(item.get("title") or evidence_id or "Untitled evidence")
    url = safe_url(item.get("url"))

    try:
        score = float(item.get("relevance_score", 0) or 0)
    except (TypeError, ValueError):
        score = 0.0

    type_config = {
        "cve": ("CVE", "View CVE"),
        "paper": ("Research", "View paper"),
        "signal": ("Signal", "View signal"),
        "incident": ("Incident", "View incident"),
        "assessment": ("Assessment", "View assessment"),
        "narrative": ("Narrative", "View source"),
    }
    type_label, action_label = type_config.get(
        evidence_type,
        (evidence_type.replace("_", " ").title() or "Evidence", "View source"),
    )

    external_link = (
        f'<a class="evidence-link" href="{e(url)}" target="_blank" '
        f'rel="noopener noreferrer">{e(action_label)} →</a>'
        if url else ""
    )

    tags_html = "".join(
        f'<span class="evidence-tag">{e(tag)}</span>'
        for tag in unique_tags(item)
    )
    rules = item.get("rules_fired", [])
    rules_text = ", ".join(str(value) for value in rules) if rules else "-"
    matched_axes = item.get("matched_axes", [])
    axes_text = ", ".join(str(value) for value in matched_axes) if matched_axes else "-"

    return f"""
<article class="correlation-item" data-type="{e(evidence_type)}" data-status="{e(status)}">
  <div class="correlation-item-header">
    <div class="evidence-badges">
      <span class="evidence-badge type-{e(evidence_type)}">{e(type_label)}</span>
      <span class="evidence-badge status-{e(status)}">{e(status)}</span>
    </div>
    <div class="correlation-score"><span>Correlation</span><strong>{score:.2f}</strong></div>
  </div>
  <div class="correlation-item-body">
    <h3>{e(title)}</h3>
    <p class="small">{e(item.get("explanation", ""))}</p>
    <div class="evidence-tags">{tags_html}</div>
    <details class="correlation-details">
      <summary>Technical correlation details</summary>
      <dl>
        <dt>Evidence identifier</dt><dd>{e(evidence_id or "-")}</dd>
        <dt>Evidence type</dt><dd>{e(type_label)}</dd>
        <dt>Evidence strength</dt><dd>{e(item.get("evidence_strength", "-") or "-")}</dd>
        <dt>Confidence</dt><dd>{e(item.get("confidence", "-") or "-")}</dd>
        <dt>Matched axes</dt><dd>{e(axes_text)}</dd>
        <dt>Rules fired</dt><dd>{e(rules_text)}</dd>
      </dl>
      {render_score_breakdown(item)}
    </details>
  </div>
  <div class="correlation-item-footer">
    <span class="muted small">{e(type_label)}</span>
    {external_link}
  </div>
</article>
"""

def render_evidence_summary(threat: dict[str, Any], correlation: dict[str, Any]) -> str:
    stats = evidence_statistics(threat, correlation)

    review_breakdown = []
    for key, label in [
        ("review_cves", "CVEs"),
        ("review_papers", "papers"),
        ("review_signals", "signals"),
        ("review_incidents", "incidents"),
        ("review_assessments", "assessments"),
        ("review_narratives", "narratives"),
    ]:
        if stats[key]:
            review_breakdown.append(f"{stats[key]} {label}")
    review_detail = " · ".join(review_breakdown) or "No review candidates"

    if strength_label(threat) == "n/a":
        body = (
            '<div class="evidence-empty"><strong>Organisational or governance threat</strong>'
            '<p>CVEs, papers, signals, incidents, assessments and public repositories do not '
            'by themselves prove this threat. Relevant support may also come from audits, '
            'regulatory analysis or organisational assessments.</p></div>'
        )
    elif not any(stats.values()):
        body = (
            '<div class="evidence-empty"><strong>No external evidence currently identified</strong>'
            '<p>No CVEs, papers, signals, incidents, assessments or repositories currently meet '
            'the configured correlation criteria. Absence of matched evidence does not demonstrate '
            'absence of the threat.</p></div>'
        )
    else:
        body = f"""
<div class="evidence-summary">
  <div class="evidence-stat cve"><div class="evidence-stat-value">{stats['accepted_cves']}</div><div class="evidence-stat-label">Accepted CVEs</div></div>
  <div class="evidence-stat paper"><div class="evidence-stat-value">{stats['accepted_papers']}</div><div class="evidence-stat-label">Accepted Papers</div></div>
  <div class="evidence-stat signal"><div class="evidence-stat-value">{stats['accepted_signals']}</div><div class="evidence-stat-label">Accepted Signals</div></div>
  <div class="evidence-stat incident"><div class="evidence-stat-value">{stats['accepted_incidents']}</div><div class="evidence-stat-label">Accepted Incidents</div></div>
  <div class="evidence-stat assessment"><div class="evidence-stat-value">{stats['accepted_assessments']}</div><div class="evidence-stat-label">Accepted Assessments</div></div>
  <div class="evidence-stat narrative"><div class="evidence-stat-value">{stats['accepted_narratives']}</div><div class="evidence-stat-label">Accepted Narratives</div></div>
  <div class="evidence-stat repo"><div class="evidence-stat-value">{stats['repositories']}</div><div class="evidence-stat-label">Repositories</div></div>
  <div class="evidence-stat review"><div class="evidence-stat-value">{stats['review_total']}</div><div class="evidence-stat-label">Review Candidates<br>{e(review_detail)}</div></div>
</div>
<p class="muted small evidence-disclaimer">Evidence strength describes the quality or authority of the source. Correlation status describes the automated relationship with this specific threat. Review status does not mean that the source itself is weak.</p>
"""

    return f"""
<div class="card evidence-panel" id="evidence">
  <div class="evidence-heading">
    <div>
      <p class="section-kicker">External Evidence</p>
      <h2>Evidence supporting this threat</h2>
      <p class="muted small">CVEs, academic research, strategic signals, real-world incidents and authoritative assessments from the correlation pipeline, plus public repositories from the existing evidence pipeline.</p>
    </div>
    <span class="evidence-threat-reference">{e(threat['id'])}</span>
  </div>
  {body}
</div>
"""

def diverse_correlation_selection(
    items: list[dict[str, Any]],
    limit: int,
) -> list[dict[str, Any]]:
    """
    Select correlation evidence while preserving evidence-type diversity.

    Selection strategy:
    1. Items are assumed to be sorted by relevance_score descending.
    2. Reserve the highest-scoring item for every available evidence_type.
    3. Fill the remaining positions with the highest-scoring remaining items.
    4. Return the final selection sorted by relevance_score descending.
    """

    if limit <= 0 or not items:
        return []

    if len(items) <= limit:
        return items

    selected: list[dict[str, Any]] = []
    selected_ids: set[int] = set()
    seen_types: set[str] = set()

    # First pass: preserve at least one item for every evidence type.
    for item in items:
        evidence_type = str(
            item.get("evidence_type") or "evidence"
        ).strip().lower()

        if evidence_type in seen_types:
            continue

        selected.append(item)
        selected_ids.add(id(item))
        seen_types.add(evidence_type)

        if len(selected) >= limit:
            break

    # Second pass: fill remaining slots using the original relevance ranking.
    if len(selected) < limit:
        for item in items:
            if id(item) in selected_ids:
                continue

            selected.append(item)
            selected_ids.add(id(item))

            if len(selected) >= limit:
                break

    # Keep presentation ordered by relevance rather than by evidence type.
    return sorted(
        selected,
        key=lambda item: float(
            item.get("relevance_score", 0) or 0
        ),
        reverse=True,
    )




def render_correlation_section(
    correlation: dict[str, Any],
    status: str,
    heading: str,
    limit: int,
) -> str:
    items = correlation_items(correlation, status=status)
    if not items:
        return ""

    visible = diverse_correlation_selection(
        items,
        limit,
    )

    note = (
        f'<span class="section-count">Showing {len(visible)} of {len(items)}</span>'
        if len(items) > limit else f'<span class="section-count">{len(items)} items</span>'
    )
    return (
        '<div class="card">'
        f'<div class="section-toolbar"><h2>{e(heading)}</h2>{note}</div>'
        '<div class="correlation-list">'
        + "".join(render_correlation_item(item) for item in visible)
        + '</div></div>'
    )


def render_repositories(threat: dict[str, Any]) -> str:
    items = repository_items(threat)
    if not items:
        return ""
    counts = threat.get("counts", {})
    total = int(counts.get("tooling", 0) or 0) + int(counts.get("mitigation", 0) or 0)
    more = (
        f' <span class="muted">(top {len(items)} of {total})</span>'
        if total > len(items) else ""
    )
    return (
        f'<div class="card"><h2>GitHub repositories{more}</h2>'
        + "".join(ev_repo(item) for item in items)
        + '</div>'
    )


RDW_BASELINE = {
    "T-058": ("4.3.1", "Vehicle-related backend servers", "direct"),
    "T-059": ("4.3.2", "Vehicle communication channels", "direct"),
    "T-060": ("4.3.3", "Vehicle update procedures and UN R156", "direct"),
    "T-061": ("4.3.4", "Unintended human actions and staff privilege abuse", "direct"),
    "T-062": ("4.3.5", "External connectivity and connections", "direct"),
    "T-063": ("4.3.6", "Vehicle data and code as attack targets", "direct"),
    "T-064": ("4.3.7", "Exploitable vulnerabilities and insufficient protection", "direct"),
    "T-065": ("Cross-cutting", "Identity, cryptographic keys and trust services", "cross-cutting"),
    "T-066": ("Cross-cutting", "Perception, localization and automated-driving inputs", "cross-cutting"),
    "T-067": ("Cross-cutting", "Fleet, dispatch, teleoperation and mobility-control platforms", "cross-cutting"),
    "T-068": ("Cross-cutting", "Connected road and traffic-management infrastructure", "cross-cutting"),
    "T-069": ("Cross-cutting", "Shared dependency / single point of failure", "cross-cutting"),
}

def r155_node_title(node: dict[str, Any]) -> str:
    return str(node.get("label") or node.get("title") or node.get("description") or "")

def render_r155_requirement(relation: dict[str, Any]) -> str:
    refs = " / ".join(str(x) for x in relation.get("references", []) if x) or "-"
    layer = str(relation.get("layer") or "requirement").replace("_", " ")
    status = str(relation.get("status") or "review").lower()
    return (
        f'<article class="r155-requirement"><div class="r155-requirement-head">'
        f'<span class="r155-status {e(status)}">{e(status)}</span><span class="r155-kind">{e(layer)}</span></div>'
        f'<h3>{e(relation.get("title") or "R155 requirement relation")}</h3>'
        f'<p class="small"><strong>R155 references:</strong> {e(refs)}</p>'
        f'<p class="muted small">{e(relation.get("rationale") or "Analytical requirement-level relation; expert review required.")}</p></article>'
    )

def render_r155_mapping(mapping: dict[str, Any], nodes: dict[str, dict[str, Any]]) -> str:
    node_id = str(mapping.get("regulatory_node_id") or "")
    node = nodes.get(node_id, {})
    status = str(mapping.get("status") or "review").lower()
    try:
        score = f'{float(mapping.get("score", 0)):.2f}'
    except (TypeError, ValueError):
        score = "-"
    terms = "".join(f'<span class="r155-term">{e(term)}</span>' for term in mapping.get("matched_terms", []))
    mids: list[str] = []
    for mid in list(mapping.get("mitigation_nodes") or []) + list(node.get("related_mitigations") or []):
        if mid in nodes and mid not in mids:
            mids.append(mid)
    mitigations = "".join(
        f'<div class="r155-mitigation"><span class="r155-ref">{e(nodes[mid].get("part", "-"))} / {e(nodes[mid].get("table", "-"))} / {e(nodes[mid].get("reference", "-"))}</span> {e(r155_node_title(nodes[mid]))}</div>'
        for mid in mids
    ) or '<p class="muted small">No corresponding mitigation node recorded.</p>'
    return (
        f'<article class="r155-mapping"><div class="r155-mapping-head">'
        f'<span class="r155-status {e(status)}">{e(status)}</span><span class="r155-kind">Annex 5</span>'
        f'<span class="muted small">score {e(score)}</span></div>'
        f'<div class="r155-node-line"><span class="r155-ref">Part {e(node.get("part", "-"))} / Table {e(node.get("table", "-"))} / Ref {e(node.get("reference", "-"))}</span></div>'
        f'<h3>{e(r155_node_title(node))}</h3>'
        f'<p class="small"><strong>NCRC rationale:</strong> {e(mapping.get("rationale") or "-")}</p>'
        f'<div class="r155-terms">{terms}</div><details><summary>Corresponding mitigations ({len(mids)})</summary>{mitigations}</details></article>'
    )

def render_r155_section(threat_id: str, mappings: list[dict[str, Any]], relations: list[dict[str, Any]], nodes: dict[str, dict[str, Any]]) -> str:
    baseline = ""
    if threat_id in RDW_BASELINE:
        coverage, title, relation = RDW_BASELINE[threat_id]
        baseline = (f'<div class="r155-baseline"><span class="r155-baseline-badge">RDW BASELINE</span>'
                    f'<p class="small"><strong>R155 coverage:</strong> {e(coverage)} / {e(title)}</p>'
                    f'<p class="muted small">Protected high-level baseline / {e(relation)}.</p></div>')
    req = "".join(render_r155_requirement(x) for x in relations)
    req_html = f'<div class="r155-requirements">{req}</div>' if req else '<div class="r155-empty">No main-text R155 requirement relation was generated for this threat.</div>'
    body = "".join(render_r155_mapping(x, nodes) for x in mappings)
    if not body:
        body = '<div class="r155-empty"><strong>No Annex 5 mapping candidates</strong><p>No candidate relationship between this threat and the current Annex 5 mapping set was generated.</p></div>'
    review_count = sum(1 for x in mappings if str(x.get("status") or "review") == "review")
    return (
        f'<section class="card r155-panel" id="r155"><div class="r155-heading"><div>'
        f'<p class="section-kicker">Regulatory traceability</p><h2>UN Regulation No. 155</h2>'
        f'<p class="muted small">NCRC review-baseline mapping of {e(threat_id)} to UN R155 requirements and Annex 5. Analytical traceability only, not a determination of compliance, non-compliance or legal effect.</p></div></div>'
        f'{baseline}<div class="r155-subheading"><strong>R155 REQUIREMENT RELEVANCE</strong><p class="muted small">Main-text R155 CSMS, vehicle-type and type-approval relations. Expert review required.</p></div>{req_html}'
        f'<div class="r155-subheading"><strong>ANNEX 5 ANALYTICAL CANDIDATES</strong><p class="muted small">Analytical candidate relationships from the promoted review baseline.</p></div>'
        f'<div class="r155-summary"><div><strong>{len(mappings)}</strong><span>Mappings</span></div><div><strong>{review_count}</strong><span>Review</span></div></div>'
        f'<div class="r155-mappings">{body}</div></section>'
    )

def build_threat(
    threat: dict[str, Any],
    previous_id: str | None,
    next_id: str | None,
    data: dict[str, Any],
    correlation: dict[str, Any],
    correlations: dict[str, Any],
    r155_mappings: list[dict[str, Any]],
    r155_relations: list[dict[str, Any]],
    r155_nodes: dict[str, dict[str, Any]],
    accepted_limit: int,
    review_limit: int,
) -> str:
    output = [HEAD.format(title=f'{threat["id"]} - {threat.get("title", "")}', css=CSS, navigation=site_navigation("Threat Register", "../"))]
    output.append('<p><a href="../index.html">← Threat Register</a></p>')
    output.append(
        f'<div class="hero">'
        f'<p class="sub">{e(threat["id"])} · {e(threat.get("category", ""))}</p>'
        f'<h1>{e(threat.get("title", ""))}</h1>'
        + (
            f'<p class="muted">{e(threat.get("title_nl"))}</p>'
            if threat.get("title_nl")
            else ""
        )
        + (
            f'<p class="muted small">'
            f'Note: {e(threat.get("title_note"))}</p>'
            if threat.get("title_note")
            else ""
        )
        + (
            f'<span class="badge {slug_class(threat.get("risk"))}">'
            f'Risk: {e(threat.get("risk", "Not rated"))}</span> '
        )
        + evidence_cell(
            threat,
            correlation,
            detail_page=True,
        )
        + '<a class="r155-regulatory-link" href="#r155">Regulatory</a>'
        + '</div>'
    )

    if threat.get("description"):
        output.append(
            '<div class="card threat-description">'
            '<p class="section-kicker">Threat analysis</p>'
            '<h2>Analysis / Description</h2>'
            f'<p>{e(threat.get("description"))}</p>'
            '</div>'
        )

    rows = [
        ("Primary domain", threat.get("primary_domain")),
        ("Secondary domains", "; ".join(threat.get("secondary_domains", []))),
        ("Affects", ", ".join(threat.get("affects", []))),
        (
            "Impact",
            f'{threat.get("impact", "")} (score {threat.get("impact_score", "")})'
            if threat.get("impact") else "",
        ),
        (
            "Probability",
            f'{threat.get("probability", "")} (score {threat.get("likelihood_score", "")})'
            if threat.get("probability") else "",
        ),
        ("Priority", threat.get("priority")),
        ("Tags", "; ".join(threat.get("tags", []))),
        ("Source", public_source(threat.get("source"))),
    ]
    output.append(
        '<div class="card"><h2>Assessment</h2><dl>'
        + "".join(f'<dt>{e(key)}</dt><dd>{e(value)}</dd>' for key, value in rows if value)
        + '</dl></div>'
    )

    for title, key in [
        ("Impact rationale", "impact_rationale"),
        ("Likelihood rationale", "likelihood_rationale"),
        ("Risk rationale", "risk_rationale"),
        ("Domain rationale", "domain_rationale"),
    ]:
        if threat.get(key):
            output.append(f'<div class="card"><h3>{e(title)}</h3><p>{e(threat[key])}</p></div>')

    additional_comments = str(
        threat.get("additional_comments") or ""
    ).strip()
    risk_rationale = str(
        threat.get("risk_rationale") or ""
    ).strip()

    if additional_comments and additional_comments != risk_rationale:
        output.append(
            '<div class="card">'
            '<h3>Additional comments</h3>'
            f'<p>{e(additional_comments)}</p>'
            '</div>'
        )

    # The Threat Register remains central: evidence is presented on the same page.
    output.append(render_evidence_summary(threat, correlation))
    output.append(
        render_correlation_section(
            correlation,
            status="accepted",
            heading="Accepted External Evidence",
            limit=accepted_limit,
        )
    )
    output.append(
        render_correlation_section(
            correlation,
            status="review",
            heading="Evidence Requiring Review",
            limit=review_limit,
        )
    )
    output.append(render_repositories(threat))

    gaps = threat.get("gaps", [])
    applicable_types = threat.get("applicable_types", [])
    if strength_label(threat) != "n/a" and (gaps or applicable_types):
        gap_html = (
            "".join(f'<span class="pill gap">{e(gap)}</span>' for gap in gaps)
            if gaps else '<span class="muted small">No evidence gaps for the configured source types.</span>'
        )
        output.append(
            '<div class="card"><h2>Evidence Coverage</h2>'
            f'<p>{gap_html}</p>'
            f'<p class="muted small">Relevant source types: {e(", ".join(applicable_types) or "-")}</p>'
            '</div>'
        )

    output.append(
        '<div class="card"><details><summary>How evidence was matched to this threat</summary>'
        f'<p class="small">Technical surfaces: {e(", ".join(threat.get("surfaces", [])) or "-")}<br>'
        f'Terms: {e(", ".join(threat.get("terms", [])) or "-")}<br>'
        'CVE, paper, signal, incident, assessment and narrative correlations are generated by correlate_evidence.py. '
        'Repository mappings remain sourced from the existing evidence pipeline.</p></details></div>'
    )

    output.append(render_r155_section(threat["id"], r155_mappings, r155_relations, r155_nodes))
    output.append(
        '<div class="nav"><span>'
        + (f'<a href="{e(previous_id)}.html">← {e(previous_id)}</a>' if previous_id else "")
        + '</span><span>'
        + (f'<a href="{e(next_id)}.html">{e(next_id)} →</a>' if next_id else "")
        + '</span></div>'
    )

    correlation_time = str(correlations.get("generated_at", ""))[:16].replace("T", " ")
    output.append(f'<div class="footer">Correlations generated {e(correlation_time)}</div>')
    output.append(TAIL)
    return "".join(output)


def main() -> int:
    args = parse_args()
    try:
        data = load_json(args.register)
        correlations = load_json(args.correlations)
        r155_mapping_data = load_json(args.r155_mappings)
        r155_annex = load_json(args.r155_root / "annex5.json")
        r155_nodes = {str(x["id"]): x for x in r155_annex.get("nodes", []) if isinstance(x, dict) and x.get("id")}
        r155_by_threat: dict[str, list[dict[str, Any]]] = {}
        for item in r155_mapping_data.get("mappings", []):
            if isinstance(item, dict):
                r155_by_threat.setdefault(str(item.get("threat_id") or ""), []).append(item)
        r155_relations_by_threat: dict[str, list[dict[str, Any]]] = {}
        for item in r155_mapping_data.get("regulatory_relations", []):
            if isinstance(item, dict):
                r155_relations_by_threat.setdefault(str(item.get("threat_id") or ""), []).append(item)

        raw_threats = data.get("threats", [])
        if not isinstance(raw_threats, list):
            raise ValueError(f"Expected 'threats' list in {args.register}")

        threats = sorted(
            [threat for threat in raw_threats if isinstance(threat, dict) and threat.get("id")],
            key=lambda threat: threat["id"],
        )
        if not threats:
            raise ValueError(f"No threats found in {args.register}")

        output_dir: Path = args.output_dir
        threat_dir = output_dir / "threats"
        threat_dir.mkdir(parents=True, exist_ok=True)

        (output_dir / "index.html").write_text(
            build_index(data, threats, correlations),
            encoding="utf-8",
        )

        ids = [threat["id"] for threat in threats]
        for number, threat in enumerate(threats):
            previous_id = ids[number - 1] if number else None
            next_id = ids[number + 1] if number + 1 < len(ids) else None
            correlation = correlation_for(correlations, threat["id"])
            page = build_threat(
                threat=threat,
                previous_id=previous_id,
                next_id=next_id,
                data=data,
                correlation=correlation,
                correlations=correlations,
                r155_mappings=r155_by_threat.get(threat["id"], []),
                r155_relations=r155_relations_by_threat.get(threat["id"], []),
                r155_nodes=r155_nodes,
                accepted_limit=args.accepted_limit,
                review_limit=args.review_limit,
            )
            (threat_dir / f'{threat["id"]}.html').write_text(page, encoding="utf-8")

        print(
            f"Wrote {output_dir}/index.html and {len(threats)} pages "
            f"in {threat_dir}/"
        )
        print(f"Register: {args.register}")
        print(f"Correlations: {args.correlations}")
        print(f"R155 mappings: {args.r155_mappings}")
        return 0

    except (FileNotFoundError, ValueError, OSError) as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        return 2


if __name__ == "__main__":
    sys.exit(main())
