"""Compute all scores and write the results site."""
from __future__ import annotations

import datetime as dt
import html
import json
import shutil
from pathlib import Path

import numpy as np

from .loading import load_challenges, load_submissions
from .metrics import compute_metric, metric_names
from .reference import collect_order, select_reference
from .wav import read_wav, resolve_output


def score_challenge(challenge: dict, submissions: list[dict], out_audio: Path | None = None) -> dict:
    """Load every output for one challenge, compute pairwise errors, choose the reference, and return a results dict."""
    spec = challenge["output"]
    names = metric_names(challenge)
    primary = challenge["metrics"]["primary"]

    signals: dict[str, np.ndarray] = {}
    rows: dict[str, dict] = {}
    for sub in submissions:
        for sol in sub["solutions"]:
            key = f"{sub['submission_id']}/{sol['solution_id']}"
            p = resolve_output(sol["output"], sub["_path"].parent)
            signals[key] = read_wav(p, spec)
            audio_rel = None
            if out_audio is not None:
                dest = out_audio / sub["submission_id"] / f"{sol['solution_id']}.wav"
                dest.parent.mkdir(parents=True, exist_ok=True)
                shutil.copyfile(p, dest)
                audio_rel = f"audio/{sub['submission_id']}/{sol['solution_id']}.wav"
            rows[key] = {
                "key": key,
                "submission_id": sub["submission_id"],
                "solution_id": sol["solution_id"],
                "submitter": sub["submitter"]["name"],
                "date": sub.get("date"),
                "method": sol.get("method"),
                "parameters": sol.get("parameters"),
                "timing_seconds": sol.get("timing_seconds"),
                "hardware": sol.get("hardware"),
                "code_url": sol.get("code_url") or sub.get("code_url"),
                "viz_url": sol.get("viz_url") or sub.get("viz_url"),
                "more_accurate_than": [f"{sub['submission_id']}/{w}" for w in sol.get("more_accurate_than", [])],
                "notes": sol.get("notes"),
                "audio": audio_rel,
                "peak": float(np.max(np.abs(signals[key]))),
            }

    keys = list(signals)
    pairwise = {name: {a: {} for a in keys} for name in names}
    for name in names:
        params = challenge["metrics"][name]
        for a in keys:
            for r in keys:
                pairwise[name][a][r] = 0.0 if a == r else compute_metric(name, signals[a], signals[r], params)

    info = collect_order(submissions)
    explicit = challenge.get("reference_solution")
    if explicit is not None and explicit not in keys:
        raise KeyError(f"reference_solution {explicit!r} is not among the solutions")
    selection = select_reference(info, pairwise[primary], explicit)
    ref = selection["reference"]
    for key, row in rows.items():
        row["errors"] = {name: pairwise[name][key][ref] for name in names} if ref else {}
        row["is_reference"] = key == ref

    # Check every asserted pair against the chosen reference, for the report.
    violations = []
    if ref:
        for worse, better, _sid in info.pairs:
            for name in names:
                if not pairwise[name][better][ref] < pairwise[name][worse][ref]:
                    violations.append({"metric": name, "worse": worse, "better": better})

    ordered = sorted(rows.values(), key=lambda r: (r["errors"].get(primary, float("inf")), r["key"]))
    return {
        "challenge_id": challenge["challenge_id"],
        "title": challenge.get("title"),
        "generated": dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds"),
        "metrics": names,
        "primary_metric": primary,
        "reference": ref,
        "reference_selection": selection,
        "order_violations_vs_reference": violations,
        "solutions": ordered,
        "pairwise": pairwise,
        "submissions": [
            {k: v for k, v in sub.items() if not k.startswith("_") and k != "solutions"} for sub in submissions
        ],
    }


# ---------------------------------------------------------------- HTML

_CSS = """
:root { --fg: #1b1b1b; --bg: #ffffff; --muted: #666; --line: #ddd; --accent: #2a6db0; --ref: #e8f4e8; }
@media (prefers-color-scheme: dark) { :root { --fg: #e6e6e6; --bg: #151515; --muted: #999; --line: #333; --accent: #7ab3e8; --ref: #1f3320; } }
body { font-family: system-ui, sans-serif; color: var(--fg); background: var(--bg); margin: 0; padding: 16px; line-height: 1.45; }
main { max-width: 1200px; margin: 0 auto; }
a { color: var(--accent); }
table { border-collapse: collapse; width: 100%; font-size: 0.92em; }
th, td { border-bottom: 1px solid var(--line); padding: 6px 8px; text-align: left; vertical-align: top; }
th { position: sticky; top: 0; background: var(--bg); }
td.num { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
tr.ref { background: var(--ref); }
.muted { color: var(--muted); }
.wrap { overflow-x: auto; }
audio { width: 180px; height: 28px; }
details { margin: 1em 0; }
code { font-size: 0.9em; }
"""


def _fmt(x, digits=4):
    if x is None:
        return ""
    if isinstance(x, float):
        if x == 0:
            return "0"
        return f"{x:.{digits}g}"
    return html.escape(str(x))


def _link(url, text):
    if not url:
        return ""
    return f'<a href="{html.escape(url)}">{html.escape(text)}</a>'


def render_challenge_page(res: dict, challenge: dict, links: dict) -> str:
    names = res["metrics"]
    primary = res["primary_metric"]
    head = "".join(
        f"<th>{html.escape(n)}{' (primary)' if n == primary else ''}</th>" for n in names
    )
    body = []
    for r in res["solutions"]:
        errs = "".join(f'<td class="num">{_fmt(r["errors"].get(n))}</td>' for n in names)
        params = html.escape(json.dumps(r["parameters"])) if r["parameters"] else ""
        mat = ", ".join(html.escape(k.split("/", 1)[1]) for k in r["more_accurate_than"])
        audio = f'<audio controls preload="none" src="{html.escape(r["audio"])}"></audio>' if r["audio"] else ""
        linkbits = " ".join(x for x in [_link(r["code_url"], "code"), _link(r["viz_url"], "viz"), _link(r["audio"], "wav")] if x)
        body.append(
            f'<tr class="{"ref" if r["is_reference"] else ""}">'
            f'<td>{html.escape(r["submission_id"])}<br><span class="muted">{html.escape(r["submitter"])}</span></td>'
            f'<td>{html.escape(r["solution_id"])}{" <b>(reference)</b>" if r["is_reference"] else ""}</td>'
            f'<td>{html.escape(r["method"] or "")}<br><span class="muted"><code>{params}</code></span></td>'
            f"{errs}"
            f'<td class="num">{_fmt(r["timing_seconds"], 3)}</td>'
            f'<td>{html.escape(r["hardware"] or "")}</td>'
            f'<td class="muted">{mat}</td>'
            f"<td>{audio}<br>{linkbits}</td>"
            "</tr>"
        )
    sel = res["reference_selection"]
    cand_rows = "".join(
        f"<tr><td>{html.escape(c['candidate'])}</td><td class='num'>{c['pairs_preserved']}/{c['pairs_total']}</td>"
        f"<td class='num'>{_fmt(c['mean_error_to_other_candidates'])}</td>"
        f"<td>{html.escape(', '.join(f'{w} vs {b}' for w, b in c['violated_pairs']))}</td></tr>"
        for c in sel.get("candidates", [])
    )
    viol = res["order_violations_vs_reference"]
    viol_html = (
        "<p>All asserted accuracy orderings are preserved by both metrics under the chosen reference.</p>"
        if not viol
        else "<ul>" + "".join(
            f"<li>{html.escape(v['metric'])}: {html.escape(v['better'])} asserted more accurate than {html.escape(v['worse'])}, but its error is not smaller</li>"
            for v in viol
        ) + "</ul>"
    )
    pair_tables = []
    keys = [r["key"] for r in res["solutions"]]
    for n in names:
        hdr = "".join(f"<th>{html.escape(k)}</th>" for k in keys)
        rws = "".join(
            f"<tr><th>{html.escape(a)}</th>" + "".join(f"<td class='num'>{_fmt(res['pairwise'][n][a][b], 3)}</td>" for b in keys) + "</tr>"
            for a in keys
        )
        pair_tables.append(f"<h4>{html.escape(n)}</h4><div class='wrap'><table><tr><th></th>{hdr}</tr>{rws}</table></div>")
    spec_link = links.get("spec")
    return f"""<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
<title>{html.escape(res["challenge_id"])} results</title><style>{_CSS}</style></head>
<body><main>
<p><a href="../">All challenges</a></p>
<h1>{html.escape(res["challenge_id"])}</h1>
<p>{html.escape(res.get("title") or "")}. {"<a href='" + html.escape(spec_link) + "'>Challenge specification</a>. " if spec_link else ""}<a href="results.json">results.json</a>. Generated {html.escape(res["generated"])}.</p>
<p>Errors are relative to the reference solution <b>{html.escape(res["reference"] or "none")}</b>, chosen by rule <i>{html.escape(sel["rule"])}</i>. Rows are sorted by the primary metric.</p>
<div class="wrap"><table>
<tr><th>Submission</th><th>Solution</th><th>Method</th>{head}<th>Time (s)</th><th>Hardware</th><th>Claimed more accurate than</th><th>Output</th></tr>
{"".join(body)}
</table></div>
<details><summary>Reference selection</summary>
<p>Candidates are the maximal elements of each submission's asserted order. The score is the number of asserted pairs from other submissions whose order is preserved by the primary error to this candidate. Ties are broken by the mean primary error to the other candidates.</p>
<div class="wrap"><table><tr><th>Candidate</th><th>Pairs preserved</th><th>Mean error to other candidates</th><th>Violated pairs</th></tr>{cand_rows}</table></div>
<h4>Order check against the chosen reference</h4>{viol_html}
</details>
<details><summary>Pairwise errors (row vs column as reference)</summary>{"".join(pair_tables)}</details>
</main></body></html>
"""


def render_index(results: list[dict], links: dict) -> str:
    items = "".join(
        f'<li><a href="{html.escape(r["challenge_id"])}/">{html.escape(r["challenge_id"])}</a>: {html.escape(r.get("title") or "")} '
        f'<span class="muted">({len(r["solutions"])} solutions, reference {html.escape(r["reference"] or "none")})</span></li>'
        for r in results
    )
    repo = links.get("challenge_repo")
    sols = links.get("solutions_repo")
    return f"""<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
<title>Challenge results</title><style>{_CSS}</style></head>
<body><main>
<h1>Challenge results</h1>
<p>{"Specifications: <a href='" + html.escape(repo) + "'>" + html.escape(repo) + "</a>. " if repo else ""}{"Solutions: <a href='" + html.escape(sols) + "'>" + html.escape(sols) + "</a>." if sols else ""}</p>
<ul>{items}</ul>
</main></body></html>
"""


def build(challenges_dir: Path, solutions_dir: Path, out: Path, challenge_repo_url: str | None = None, solutions_repo_url: str | None = None) -> list[dict]:
    challenges = load_challenges(challenges_dir)
    submissions = load_submissions(solutions_dir)
    out.mkdir(parents=True, exist_ok=True)
    results = []
    for cid, ch in challenges.items():
        subs = [s for s in submissions if s["challenge_id"] == cid]
        cdir = out / cid
        cdir.mkdir(parents=True, exist_ok=True)
        res = score_challenge(ch, subs, cdir / "audio") if subs else {
            "challenge_id": cid, "title": ch.get("title"), "generated": dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds"),
            "metrics": metric_names(ch), "primary_metric": ch["metrics"]["primary"], "reference": None,
            "reference_selection": {"rule": "none", "candidates": []}, "order_violations_vs_reference": [], "solutions": [], "pairwise": {}, "submissions": [],
        }
        with open(cdir / "results.json", "w") as f:
            json.dump(res, f, indent=1)
        links = {"spec": f"{challenge_repo_url}/blob/main/challenges/{cid}/README.md" if challenge_repo_url else None}
        (cdir / "index.html").write_text(render_challenge_page(res, ch, links))
        results.append(res)
    (out / "index.html").write_text(render_index(results, {"challenge_repo": challenge_repo_url, "solutions_repo": solutions_repo_url}))
    return results