#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Build site/github.html from github/github.json and threat correlations.

This generator does not read legacy repository evidence from register.json.
"""
from __future__ import annotations

import argparse
import html
import json
import re
import sys
from collections import defaultdict
from pathlib import Path
from typing import Any
from site_navigation import navigation as site_navigation

DEFAULT_GITHUB = Path("github/github.json")
DEFAULT_CORRELATIONS = Path("evidence/threat_correlations.json")
DEFAULT_OUTPUT = Path("site/github.html")



def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Build the GitHub repository overview page.")
    parser.add_argument("--github", type=Path, default=DEFAULT_GITHUB)
    parser.add_argument("--correlations", type=Path, default=DEFAULT_CORRELATIONS)
    parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
    return parser.parse_args()


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


def load_json(path: Path) -> dict[str, Any]:
    if not path.exists():
        raise FileNotFoundError(f"Input file not found: {path}")
    with path.open("r", encoding="utf-8") as handle:
        try:
            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


def safe_int(value: Any) -> int:
    try:
        return int(value)
    except (TypeError, ValueError):
        return 0


def safe_float(value: Any) -> float:
    try:
        return float(value)
    except (TypeError, ValueError):
        return 0.0


def text(value: Any) -> str:
    return re.sub(r"\s+", " ", str(value or "")).strip()


def listify(value: Any) -> list[str]:
    if isinstance(value, list):
        return [text(item) for item in value if text(item)]
    if isinstance(value, str) and value.strip():
        return [part.strip() for part in re.split(r"[;,]", value) if part.strip()]
    return []


def repository_id(record: dict[str, Any]) -> str:
    return text(
        record.get("id")
        or (f"github:{record.get('full_name')}" if record.get("full_name") else "")
        or record.get("url")
    )


def build_correlation_index(correlations: dict[str, Any]) -> dict[str, list[dict[str, Any]]]:
    result: dict[str, list[dict[str, Any]]] = defaultdict(list)
    threats = correlations.get("threats", {})
    if not isinstance(threats, dict):
        return result
    for threat_id, threat in threats.items():
        if not isinstance(threat, dict):
            continue
        threat_title = text(threat.get("title"))
        evidence = threat.get("evidence", [])
        if not isinstance(evidence, list):
            continue
        for item in evidence:
            if not isinstance(item, dict):
                continue
            if text(item.get("evidence_type")).lower() != "repository":
                continue
            evidence_id = text(item.get("evidence_id")).casefold()
            if not evidence_id:
                continue
            result[evidence_id].append({
                "threat_id": threat_id,
                "threat_title": threat_title,
                "status": text(item.get("status")).lower(),
                "score": safe_float(item.get("relevance_score")),
                "confidence": text(item.get("confidence")),
            })
    for values in result.values():
        values.sort(key=lambda item: item["score"], reverse=True)
    return result


def repository_matches(
    record: dict[str, Any],
    index: dict[str, list[dict[str, Any]]],
) -> list[dict[str, Any]]:
    candidates = [repository_id(record)]
    full_name = text(record.get("full_name"))
    if full_name:
        candidates.extend([full_name, f"github:{full_name}"])
    candidates.append(text(record.get("url")))
    seen: set[tuple[str, str]] = set()
    matches: list[dict[str, Any]] = []
    for candidate in candidates:
        for item in index.get(candidate.casefold(), []):
            key = (item["threat_id"], item["status"])
            if key not in seen:
                matches.append(item)
                seen.add(key)
    return sorted(matches, key=lambda item: item["score"], reverse=True)


def nav() -> str:
    return site_navigation("GitHub")

CSS = r"""
:root{--bg:#eef1f5;--surface:#fff;--surface-alt:#f7f9fb;--surface-hover:#f1f5f8;--ink:#1b2430;--muted:#5d6b7c;--line:#d5dce5;--accent:#1f4e79;--accepted:#2f7d59;--review:#b37a20;--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;--accepted:#58c493;--review:#e0a74d;--repo:#91a7b7}}
*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);font:16px/1.5 "Segoe UI",system-ui,sans-serif}a{color:var(--accent);text-decoration:none}a:hover{text-decoration:underline}.site-header{position:sticky;top:0;z-index:100;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-brand{color:var(--ink);font-weight:700;white-space:nowrap}.site-brand:hover{text-decoration:none}.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}.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)}main{max-width:1240px;margin:auto;padding:26px 24px 44px}.hero,.card{background:var(--surface);border:1px solid var(--line);border-radius:7px;padding:22px;margin-bottom:20px}h1,h2,h3{margin-top:0}.hero h1{margin-bottom:6px}.sub,.muted{color:var(--muted)}.small{font-size:.82rem}.metric-row{display:flex;flex-wrap:wrap;gap:8px;margin-bottom:20px}.metric{display:flex;align-items:baseline;gap:7px;padding:9px 12px;background:var(--surface);border:1px solid var(--line);border-radius:6px}.metric strong{font-size:1.15rem}.metric span{color:var(--muted);font-size:.78rem}.filters{display:grid;grid-template-columns:minmax(260px,1fr) repeat(3,minmax(145px,auto));gap:10px;margin-bottom:16px}.filters input,.filters select{width:100%;background:var(--bg);color:var(--ink);border:1px solid var(--line);border-radius:5px;padding:8px 10px;font:inherit}.toolbar{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:14px}.toolbar h2{margin:0}.count{color:var(--muted);font-size:.8rem}.repository-list{display:grid;grid-template-columns:repeat(auto-fit,minmax(340px,1fr));gap:12px}.repository{display:flex;flex-direction:column;min-width:0;background:var(--surface-alt);border:1px solid var(--line);border-left:3px solid var(--repo);border-radius:6px;padding:15px}.repository:hover{background:var(--surface-hover)}.repository-head{display:flex;justify-content:space-between;gap:12px}.repository h3{margin:0 0 5px;font-size:1rem;overflow-wrap:anywhere}.level{display:inline-flex;align-items:center;height:24px;padding:2px 7px;border:1px solid var(--line);border-radius:10px;color:var(--repo);font-size:.65rem;font-weight:700;text-transform:uppercase}.description{margin:8px 0 10px;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:5;line-clamp:5;overflow:hidden}.metadata,.tags,.matches{display:flex;flex-wrap:wrap;gap:5px}.metadata{margin-top:auto;color:var(--muted);font-size:.72rem}.tag{padding:2px 7px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--muted);font-size:.66rem}.matches{margin-top:11px;padding-top:10px;border-top:1px solid var(--line)}.match{display:inline-flex;gap:5px;padding:3px 7px;border:1px solid var(--line);border-radius:5px;font-size:.69rem}.match.accepted{color:var(--accepted)}.match.review{color:var(--review)}.footer{margin-top:28px;color:var(--muted);font-size:.82rem}
@media(max-width:900px){.site-header{position:static;align-items:flex-start;flex-direction:column}.site-nav{justify-content:flex-start}.filters{grid-template-columns:1fr 1fr}}@media(max-width:650px){.site-header{padding:12px 16px}main{padding:18px 12px 34px}.filters{grid-template-columns:1fr}.repository-list{grid-template-columns:1fr}.repository-head,.toolbar{align-items:flex-start;flex-direction:column}}
"""


def build_page(github_data: dict[str, Any], correlations: dict[str, Any]) -> str:
    records = github_data.get("repositories", [])
    if not isinstance(records, list):
        raise ValueError("GitHub input must contain a repositories list")
    repositories = [record for record in records if isinstance(record, dict)]
    correlation_index = build_correlation_index(correlations)

    enriched = []
    languages: set[str] = set()
    accepted_repositories = 0
    review_repositories = 0
    for record in repositories:
        matches = repository_matches(record, correlation_index)
        accepted = [item for item in matches if item["status"] == "accepted"]
        review = [item for item in matches if item["status"] == "review"]
        if accepted:
            accepted_repositories += 1
        if review:
            review_repositories += 1
        language = text(record.get("language")) or "Unknown"
        languages.add(language)
        enriched.append((record, matches, accepted, review))

    enriched.sort(
        key=lambda value: (
            bool(value[2]),
            safe_float((value[0].get("relevance") or {}).get("score") if isinstance(value[0].get("relevance"), dict) else 0),
            safe_int(value[0].get("stars")),
            text(value[0].get("full_name")).lower(),
        ),
        reverse=True,
    )

    direct = sum(
        text((record.get("relevance") or {}).get("level") if isinstance(record.get("relevance"), dict) else "").lower() == "direct"
        for record in repositories
    )
    strong = sum(
        text((record.get("relevance") or {}).get("level") if isinstance(record.get("relevance"), dict) else "").lower() == "strong"
        for record in repositories
    )

    output = [
        '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">',
        '<meta name="viewport" content="width=device-width,initial-scale=1">',
        '<title>GitHub Repositories</title><style>', CSS, '</style></head><body>', nav(), '<main>',
        '<section class="hero"><h1>GitHub Repositories</h1>',
        '<p class="sub">Technical tooling, implementations, proof-of-concept research and defensive projects relevant to automotive cybersecurity. Threat mappings are generated by the correlation pipeline.</p></section>',
        '<section class="metric-row">',
    ]
    for value, label in [
        (len(repositories), "Repositories"),
        (direct, "Direct relevance"),
        (strong, "Strong relevance"),
        (accepted_repositories, "With accepted mapping"),
        (review_repositories, "With review mapping"),
    ]:
        output.append(f'<div class="metric"><strong>{value}</strong><span>{e(label)}</span></div>')
    output.extend([
        '</section><section class="card">',
        '<div class="toolbar"><h2>Repository evidence</h2><span class="count" id="count"></span></div>',
        '<div class="filters">',
        '<input type="search" id="q" placeholder="Search repository, description, topics ...">',
        '<select id="level"><option value="">All relevance levels</option><option value="direct">Direct</option><option value="strong">Strong</option></select>',
        '<select id="language"><option value="">All languages</option>',
        ''.join(f'<option value="{e(language)}">{e(language)}</option>' for language in sorted(languages, key=str.casefold)),
        '</select><select id="mapping"><option value="">All mappings</option><option value="accepted">Accepted</option><option value="review">Review</option><option value="unmatched">Unmatched</option></select>',
        '</div><div class="repository-list" id="repositories">',
    ])

    for record, matches, accepted, review in enriched:
        relevance = record.get("relevance") if isinstance(record.get("relevance"), dict) else {}
        level = text(relevance.get("level")).lower() or "unknown"
        relevance_score = safe_float(relevance.get("score"))
        language = text(record.get("language")) or "Unknown"
        full_name = text(record.get("full_name") or record.get("name") or repository_id(record))
        url = text(record.get("url"))
        description = text(record.get("description"))
        topics = listify(record.get("topics"))
        classification = record.get("classification") if isinstance(record.get("classification"), dict) else {}
        topic_values = topics + listify(classification.get("automotive_term_hits")) + listify(classification.get("security_term_hits"))
        unique_topics = []
        seen_topics = set()
        for topic in topic_values:
            key = topic.casefold()
            if key not in seen_topics:
                unique_topics.append(topic)
                seen_topics.add(key)
        mapping = "accepted" if accepted else ("review" if review else "unmatched")
        haystack = " ".join([full_name, description, language, level, " ".join(unique_topics)]).lower()
        title = f'<a href="{e(url)}" target="_blank" rel="noopener noreferrer">{e(full_name)}</a>' if url else e(full_name)
        tags = ''.join(f'<span class="tag">{e(topic)}</span>' for topic in unique_topics[:10])
        match_html = []
        for match in matches[:8]:
            href = f'threats/{match["threat_id"]}.html#evidence'
            match_html.append(
                f'<a class="match {e(match["status"])}" href="{e(href)}" title="{e(match["threat_title"])}">'
                f'{e(match["threat_id"])} · {match["score"]:.2f}</a>'
            )
        if not match_html:
            match_html.append('<span class="muted small">No threat mapping above the review threshold</span>')
        output.append(
            f'<article class="repository" data-hay="{e(haystack)}" data-level="{e(level)}" '
            f'data-language="{e(language)}" data-mapping="{e(mapping)}">'
            '<div class="repository-head"><div>'
            f'<h3>{title}</h3><span class="muted small">{e(text(record.get("owner")))}</span>'
            f'</div><span class="level">{e(level)} · {relevance_score:.2f}</span></div>'
            f'<p class="description">{e(description or "No repository description available.")}</p>'
            f'<div class="tags">{tags}</div>'
            '<div class="metadata">'
            f'<span>{e(language)}</span><span>★ {safe_int(record.get("stars"))}</span>'
            f'<span>Forks {safe_int(record.get("forks"))}</span>'
            f'<span>{"Archived" if record.get("archived") else "Active"}</span>'
            '</div><div class="matches">' + ''.join(match_html) + '</div></article>'
        )

    generated = text(github_data.get("generated_at"))[:16].replace("T", " ")
    output.extend([
        '</div></section>',
        f'<footer class="footer">GitHub evidence generated {e(generated)} · source: {e(github_data.get("source_input", "github/github.json"))}</footer>',
        r'''<script>
const cards=[...document.querySelectorAll(".repository")];
const controls={q:document.getElementById("q"),level:document.getElementById("level"),language:document.getElementById("language"),mapping:document.getElementById("mapping")};
function apply(){const terms=controls.q.value.trim().toLowerCase().split(/\s+/).filter(Boolean);let visible=0;cards.forEach(card=>{const show=terms.every(term=>card.dataset.hay.includes(term))&&(!controls.level.value||card.dataset.level===controls.level.value)&&(!controls.language.value||card.dataset.language===controls.language.value)&&(!controls.mapping.value||card.dataset.mapping===controls.mapping.value);card.style.display=show?"":"none";if(show)visible++;});document.getElementById("count").textContent="Showing "+visible+" of "+cards.length+" repositories";}
Object.values(controls).forEach(control=>control.addEventListener("input",apply));apply();
</script>''',
        '</main></body></html>',
    ])
    return ''.join(output)


def main() -> int:
    args = parse_args()
    try:
        github_data = load_json(args.github)
        correlations = load_json(args.correlations)
        page = build_page(github_data, correlations)
        args.output.parent.mkdir(parents=True, exist_ok=True)
        args.output.write_text(page, encoding="utf-8")
        repositories = github_data.get("repositories", [])
        count = len(repositories) if isinstance(repositories, list) else 0
        print(f"Wrote {args.output} with {count} repositories")
        return 0
    except (FileNotFoundError, ValueError, OSError) as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        return 2


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