#!/usr/bin/env python3
"""Validate a publication checkout without access to its original sources."""

from __future__ import annotations

import hashlib
import json
import re
import unittest
from copy import deepcopy
from collections import Counter
from html.parser import HTMLParser
from html import unescape
from pathlib import Path
from urllib.parse import unquote, urlsplit
from unittest.mock import patch

from editorial import narrative_copy, reconstruction_reductions
from site_builder_interactive import academic_page


ROOT = Path(__file__).resolve().parents[1]
PAGES = ("index.html", "en.html", "zh.html")
TITLE = "AWSM: Agentic World Simulation and Mapping — Phygital AI"
CANONICAL_ROOT = "https://phygital-ai.github.io/agentic-world-simulation-and-mapping/"
VIDEO = "assets/embodied-demo/four-robots-214924-156s-phone.mp4"
POSTER = "assets/embodied-demo/navigation-214924-poster.png"
HEX_SHA256 = re.compile(r"^[0-9a-f]{64}$")


def load_json(relative_path: str) -> dict:
    return json.loads((ROOT / relative_path).read_text(encoding="utf-8"))


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


class Document(HTMLParser):
    def __init__(self, path: Path) -> None:
        super().__init__(convert_charrefs=True)
        self.path = path
        self.ids: list[str] = []
        self.references: list[tuple[str, str, str]] = []
        self.canonicals: list[str] = []
        self.titles: list[str] = []
        self.videos: list[dict] = []
        self._video: dict | None = None
        self.section_text: dict[str, list[str]] = {}
        self._title_depth = 0
        self._sections: list[str] = []
        self.feed(path.read_text(encoding="utf-8"))

    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        attributes = dict(attrs)
        element_id = attributes.get("id")
        if element_id is not None:
            self.ids.append(element_id)
        if tag == "section":
            self._sections.append(element_id or "")
            if element_id:
                self.section_text.setdefault(element_id, [])
        if tag == "title":
            self._title_depth += 1
        for attribute in ("href", "src"):
            value = attributes.get(attribute)
            if value:
                self.references.append((tag, attribute, value))
        rel = (attributes.get("rel") or "").split()
        if tag == "link" and "canonical" in rel:
            self.canonicals.append(attributes.get("href") or "")
        if tag == "video":
            self._video = {
                "attributes": attributes,
                "section": self._sections[-1] if self._sections else "",
                "sources": [],
            }
            self.videos.append(self._video)
        elif tag == "source" and self._video is not None and attributes.get("src"):
            self._video["sources"].append(attributes["src"])

    def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        self.handle_starttag(tag, attrs)

    def handle_endtag(self, tag: str) -> None:
        if tag == "title":
            self._title_depth -= 1
        if tag == "video":
            self._video = None
        if tag == "section" and self._sections:
            self._sections.pop()

    def handle_data(self, data: str) -> None:
        if self._title_depth:
            self.titles.append(data)
        for section_id in self._sections:
            if section_id:
                self.section_text[section_id].append(data)

    @property
    def title(self) -> str:
        return " ".join("".join(self.titles).split())

    def text_for(self, section_id: str) -> str:
        return " ".join("".join(self.section_text.get(section_id, [])).split())


class PublicationValidation(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        cls.contract = load_json("data/source_contract.json")
        cls.manifest = load_json("evidence/publication_manifest.json")
        cls.demo = load_json("data/embodied_demo.json")
        cls.documents = {name: Document(ROOT / name) for name in PAGES}

    def assert_hashed_file(self, relative_path: str, expected_sha: str, expected_bytes=None) -> None:
        self.assertIsInstance(relative_path, str)
        self.assertTrue(relative_path, "empty published path")
        self.assertRegex(expected_sha, HEX_SHA256)
        path = ROOT / relative_path
        self.assertTrue(path.is_file(), f"missing file: {relative_path}")
        self.assertEqual(sha256(path), expected_sha, relative_path)
        if expected_bytes is not None:
            self.assertEqual(path.stat().st_size, expected_bytes, relative_path)

    def test_source_contract_published_hashes(self) -> None:
        records = list(self.contract["figures"].values())
        for model in self.contract["models"].values():
            records.extend(model.values())
        records.extend(self.contract["vendor"].values())
        records.append(self.contract["gt_asset"])
        for record in records:
            self.assert_hashed_file(record["published"], record["sha256"], record.get("bytes"))

    def test_tables_and_figures_exist_in_both_languages(self) -> None:
        required = {f"table-{number}" for number in (1, 2, 3, 6, 7)}
        required |= {f"figure-{number}" for number in range(1, 6)}
        self.assertEqual([row["number"] for row in self.contract["tables"]], list(range(1, 8)))
        for name, document in self.documents.items():
            self.assertTrue(required <= set(document.ids), f"{name}: missing {sorted(required - set(document.ids))}")
            self.assertFalse({"table-4", "table-5"} & set(document.ids), f"{name}: removed appearance tables returned")

    def test_editorial_preserves_experiment_copy(self) -> None:
        protected = (
            "intro2", "method1", "method2", "workflow", "finding1_title", "finding1", "finding2_title", "finding2",
            "finding3_title", "discussion1_title", "discussion1",
            "discussion2_title", "discussion2", "discussion3_title", "discussion3",
            "metric1", "metric1_label", "metric2", "metric2_label", "metric3", "metric3_label",
        )

        def check_copy(copy, english):
            original = deepcopy(copy)
            narrative_copy(copy, english)
            for key in protected:
                self.assertEqual(copy[key], original[key], f"{english}: {key}")
            self.assertEqual(copy["limits"][:len(original["limits"])], original["limits"])
            self.assertEqual(len(copy["contributions"]), 3)

        with patch("site_builder_interactive.narrative_copy", side_effect=check_copy):
            academic_page(True)
            academic_page(False)

    def test_narrative_roles_and_scope(self) -> None:
        sections = ["results", "motivation", "workflow", "more-results", "embodied-demo", "related-work", "limitations", "citation", "references"]
        for name, document in self.documents.items():
            self.assertEqual([element for element in document.ids if element in sections], sections)
            markup = (ROOT / name).read_text(encoding="utf-8")
            toc = re.search(r'<aside class="toc">(.*?)</aside>', markup, re.S).group(1)
            self.assertEqual(re.findall(r'href="#([^"]+)"', toc), sections)
            chinese = name == "zh.html"
            results = document.text_for("results")
            self.assertTrue(results.startswith("01 / OVERVIEW"))
            self.assertNotIn("01 / RESULTS", markup)
            self.assertIn('<a href="#results">' + ("概览" if chinese else "Overview") + '</a>', toc)
            self.assertIn('<a href="#more-results">' + ("结果与分析" if chinese else "Results & analysis") + '</a>', toc)
            self.assertTrue(document.text_for("more-results").startswith("04 / RESULTS AND ANALYSIS"))
            self.assertIn("大模型智能体" if chinese else "large-model agents", results)
            self.assertIn("agentic", results.lower())
            self.assertIn("NVIDIA Isaac Sim", results)
            self.assertNotIn("No universal winner", results)
            self.assertNotIn("PSNR, SSIM, and LPIPS disagree", results)
            self.assertLess(markup.index('id="figure-2"'), markup.index('id="figure-3"'))
            self.assertLess(markup.index('id="figure-3"'), markup.index('id="figure-4"'))
            for suffix in ("?lang=en", "shake?lang=en"):
                self.assertIn(f'href="https://office-cafe-vipe.hiwtishere.chatgpt.site/{suffix}"', markup)
            self.assertIn("可复用的仿真就绪" if chinese else "reusable simulation-ready", results)
            self.assertIn("控制器承担另一种角色" if chinese else "controllers have a separate role", document.text_for("workflow"))
            self.assertIn("而非学习得到的动力学预测模型" if chinese else "not a learned dynamics predictor", document.text_for("motivation"))
            self.assertIn("特定场景的仿真集成" if chinese else "scene-specific simulation integration", document.text_for("related-work"))

    def test_ids_links_and_anchors(self) -> None:
        for name, document in self.documents.items():
            duplicates = sorted(item for item, count in Counter(document.ids).items() if count > 1)
            self.assertFalse(duplicates, f"{name}: duplicate ids {duplicates}")
            for _tag, _attribute, reference in document.references:
                parsed = urlsplit(reference)
                if parsed.scheme or parsed.netloc or reference.startswith("//"):
                    continue
                if any(marker in reference for marker in ("{{", "}}", "${")):
                    continue
                if parsed.path:
                    relative = Path(unquote(parsed.path.lstrip("/")))
                    target = (ROOT / relative) if parsed.path.startswith("/") else (document.path.parent / relative)
                    target = target.resolve()
                    self.assertTrue(target.is_relative_to(ROOT), f"{name}: path escapes publication: {reference}")
                    self.assertTrue(target.exists(), f"{name}: broken local reference: {reference}")
                else:
                    target = document.path
                if parsed.fragment:
                    self.assertEqual(target.suffix.lower(), ".html", f"{name}: fragment targets non-HTML: {reference}")
                    target_document = self.documents.get(target.name) or Document(target)
                    self.assertIn(unquote(parsed.fragment), target_document.ids, f"{name}: broken anchor: {reference}")

    def test_manifest_files_match_bytes_and_hashes(self) -> None:
        seen: set[str] = set()
        for record in self.manifest["files"]:
            relative_path = record["path"]
            self.assertNotIn(relative_path, seen, f"duplicate manifest path: {relative_path}")
            seen.add(relative_path)
            self.assert_hashed_file(relative_path, record["sha256"], record["bytes"])

    def test_sha256sums_matches_manifest_and_files(self) -> None:
        sums: dict[str, str] = {}
        for line_number, line in enumerate((ROOT / "evidence/SHA256SUMS").read_text(encoding="utf-8").splitlines(), 1):
            match = re.fullmatch(r"([0-9a-f]{64})  (.+)", line)
            self.assertIsNotNone(match, f"SHA256SUMS:{line_number}: invalid line")
            expected_sha, relative_path = match.groups()
            self.assertNotIn(relative_path, sums, f"SHA256SUMS duplicate: {relative_path}")
            sums[relative_path] = expected_sha
            self.assert_hashed_file(relative_path, expected_sha)
        manifest_sums = {record["path"]: record["sha256"] for record in self.manifest["files"]}
        manifest_path = "evidence/publication_manifest.json"
        expected_sums = dict(manifest_sums)
        expected_sums[manifest_path] = sha256(ROOT / manifest_path)
        self.assertEqual(sums, expected_sums)

    def test_embodied_demo_metadata_and_media(self) -> None:
        media = self.demo["media"]
        self.assertEqual(media["video"], VIDEO)
        self.assertEqual(media["poster"], POSTER)
        self.assertIsInstance(media["duration_s"], (int, float))
        self.assertGreater(media["duration_s"], 0)
        self.assertIsInstance(self.demo["run_id"], str)
        self.assertTrue(self.demo["run_id"].strip())
        self.assertEqual(self.demo["audit"]["status"], "FAILED")
        self.assertEqual(self.demo["navigation"]["localization"], "simulator_pose")
        self.assertEqual(self.demo["navigation"]["route"], "predefined")
        self.assert_hashed_file(media["video"], media["sha256"], media["bytes"])
        self.assertEqual(media["duration_s"], 156.0)
        self.assertEqual(media["frame_count"], 4680)
        self.assertEqual(self.demo["run_id"], "sceneweft-walljourney-20260930-214924")
        self.assert_hashed_file(media["poster"], media["poster_sha256"])
        self.assert_hashed_file(media["hd"]["video"], media["hd"]["sha256"], media["hd"]["bytes"])
        self.assert_hashed_file(media["map"]["image"], media["map"]["sha256"], media["map"]["bytes"])
        self.assertEqual(self.demo["audit"]["measured_terminal_hold_s"], 7.994999821297824)
        audit = load_json("evidence/embodied-demo-audit.json")
        self.assertEqual(audit["run_id"], self.demo["run_id"])
        self.assertEqual([check["check"] for check in audit["failed_checks"]], ["measured_terminal_health_and_formation_hold"])
        delivery = load_json("evidence/embodied-demo-delivery.json")
        self.assertEqual(delivery["run_id"], self.demo["run_id"])
        for binding in delivery["asset_bindings"]:
            self.assert_hashed_file(binding["published"], binding["sha256"])

    def test_embodied_demo_markup_and_bilingual_copy(self) -> None:
        navigation_terms = {
            "index.html": ("navigation", "simulation"),
            "en.html": ("navigation", "simulation"),
            "zh.html": ("导航", "仿真"),
        }
        for name, document in self.documents.items():
            self.assertIn("embodied-demo", document.ids, f"{name}: missing embodied-demo section")
            matching_videos = [
                video for video in document.videos
                if video["section"] == "embodied-demo" and video["sources"] == [VIDEO]
            ]
            self.assertEqual(len(matching_videos), 1, f"{name}: expected one embodied demo video")
            self.assertEqual(
                sum(VIDEO in video["sources"] for video in document.videos),
                1,
                f"{name}: demo source must belong to exactly one video",
            )
            video = matching_videos[0]["attributes"]
            self.assertNotIn("src", video)
            self.assertEqual(video.get("poster"), POSTER)
            self.assertIn(video.get("preload", "metadata").lower(), {"none", "metadata"})
            self.assertIn("controls", video)
            self.assertIn("playsinline", video)
            self.assertNotIn("autoplay", video)
            section_text = document.text_for("embodied-demo").lower()
            for term in navigation_terms[name]:
                self.assertIn(term, section_text, f"{name}: embodied demo must state {term!r}")
            self.assertIn("20260930-214924", section_text)
            self.assertIn("2:36", section_text)
            self.assertNotIn("235.2", section_text)
            self.assertIn("demo-route-map", document.ids)

    def test_title_and_language_specific_canonical(self) -> None:
        expected = {
            "index.html": CANONICAL_ROOT,
            "en.html": CANONICAL_ROOT,
            "zh.html": CANONICAL_ROOT + "zh.html",
        }
        for name, document in self.documents.items():
            self.assertEqual(document.title, "AWSM：智能体世界仿真与建图 — Phygital AI" if name == "zh.html" else TITLE)
            self.assertEqual(document.canonicals, [expected[name]])
            markup = (ROOT / name).read_text(encoding="utf-8")
            self.assertIn('<html lang="zh-CN">' if name == "zh.html" else '<html lang="en">', markup)
            self.assertIn(f'hreflang="zh-CN" href="{CANONICAL_ROOT}zh.html"', markup)
            self.assertIn(f'hreflang="en" href="{CANONICAL_ROOT}"', markup)
            self.assertIn(f'hreflang="x-default" href="{CANONICAL_ROOT}"', markup)
            self.assertIn('<a href="zh.html"', markup)
            self.assertIn('<a href="index.html"', markup)
        self.assertEqual((ROOT / "index.html").read_bytes(), (ROOT / "en.html").read_bytes())

    def test_awsm_header(self) -> None:
        for name in PAGES:
            markup = (ROOT / name).read_text(encoding="utf-8")
            header = markup.split('<header>', 1)[1].split('</header>', 1)[0]
            chinese = name == "zh.html"
            title_name = '智能体世界仿真与建图' if chinese else 'Agentic World Simulation and Mapping'
            self.assertIn(f'<p class="title-name">{title_name}</p>', header)
            self.assertIn(f'<h1 aria-label="AWSM: {title_name}">AWSM</h1>', header)
            self.assertLess(header.index('class="title-name"'), header.index('class="title-lockup"'))
            subtitle = '把真实空间，变成虚实融合智能体可以使用的世界。' if chinese else 'From real spaces to worlds phygital agents can use.'
            lead = re.search(r'<p class="lead">(.*?)</p>', header).group(1)
            self.assertEqual(re.sub(r'<[^>]+>', '', lead), subtitle)
            emphasis = '虚实融合智能体可以使用的世界。' if chinese else 'worlds phygital agents can use.'
            self.assertIn(f'<strong class="tagline-emphasis">{emphasis}</strong>', lead)
            self.assertIn(f'<meta name="description" content="{subtitle}">', markup)
            self.assertNotIn('class="brand-tagline"', header)
            pronunciation = '读作 “awesome”' if chinese else 'pronounced “awesome”'
            self.assertIn(f'<p class="pronunciation">{pronunciation}</p>', header)
            brand_note = 'Phygital = physical（物理）+ digital（数字），即虚实融合。' if chinese else 'Phygital = physical + digital.'
            self.assertIn(f'<p class="brand-note">{brand_note}</p>', header)
            self.assertNotIn(')Phygital', header)
            self.assertNotIn('class="eyebrow"', header)
            self.assertNotIn('class="meta"', header)
            self.assertIn('@misc{awsm_2026,', markup)
            self.assertIn('title        = {{AWSM}: Agentic World Simulation and Mapping}', markup)
            self.assertNotIn('@misc{agentic_world_2026,', markup)
            self.assertIn('<time datetime="2026-10-01">', header)
            self.assertIn('2026年10月1日' if chinese else 'October 1, 2026', header)

    def test_viewer_sources_and_concurrent_work(self) -> None:
        from site_builder_interactive import SCENE_JS
        self.assertEqual((ROOT / "scene-compare.js").read_text().strip(), SCENE_JS.strip())
        manifest = json.loads((ROOT / "data/scene_comparison.json").read_text())
        self.assertGreater(manifest["camera"]["position"][1], 20)
        self.assertNotIn("mirror", manifest["display_cutaway"]["keep_name_pattern"])
        for name in PAGES:
            markup = (ROOT / name).read_text(encoding="utf-8")
            for asset in ("app.js", "scene-compare.js", "office-models.js"):
                self.assertIn(f'src="{asset}?v={sha256(ROOT / asset)[:12]}"', markup)
            self.assertIn('同期工作 AHa-3D' if name == 'zh.html' else 'Concurrent work AHa-3D', markup)
            self.assertIn('剖切视图' if name == 'zh.html' else 'Toggle Cutaway', markup)

    def test_editorial_stylesheet_cache_version(self) -> None:
        expected = f'editorial.css?v={sha256(ROOT / "editorial.css")[:12]}'
        for name in PAGES:
            markup = (ROOT / name).read_text(encoding="utf-8")
            self.assertIn(f'<link rel="stylesheet" href="{expected}">', markup)
            self.assertNotIn('href="editorial.css"', markup)

    def test_downloadable_citation(self) -> None:
        citation = (ROOT / "data/awsm.bib").read_text(encoding="utf-8")
        self.assertIn('author       = {{Phygital AI}}', citation)
        self.assertIn(f'url          = {{{CANONICAL_ROOT}}}', citation)
        for name in PAGES:
            markup = (ROOT / name).read_text(encoding="utf-8")
            rendered = re.search(r'<pre class="citation-block"><code>(.*?)</code></pre>', markup, re.S).group(1)
            self.assertEqual(unescape(rendered), citation.rstrip())
            self.assertIn('href="data/awsm.bib" download="awsm.bib"', markup)

    def test_revision_presentation_and_review_scope(self) -> None:
        for name in PAGES:
            markup = (ROOT / name).read_text()
            nav = re.search(r'<nav>(.*?)</nav>', markup, re.S).group(1)
            self.assertIn('href="https://github.com/wentingw/AWSM"', nav)
            self.assertIn('GitHub ↗', nav)
            self.assertNotIn('DATA ↗', nav)
            self.assertEqual(re.findall(r'<figure[^>]*id="figure-(\d+)"', markup), list('12345'))
            for number in range(1, 6):
                self.assertEqual(markup.count(f'Figure {number}.'), 1)
            self.assertIn('<figure id="figure-2"><img loading="lazy" src="assets/fixed_five_view_comparison_m1_m4.jpg"', markup)
            self.assertIn('class="scene-comparison" id="figure-3"', markup)
            self.assertIn('class="fixed-comparison" id="figure-4"', markup)
            self.assertIn('class="hero" id="overview-video"', markup)
            self.assertNotIn('figure-1-caption', markup)
            self.assertNotIn('AWSM: from real spaces to worlds phygital agents can use.', markup)
            for phrase in ('7.994999821', 'unresolved audit failures', 'did not pass every task-audit', 'We discuss it as a parallel effort', '前置工作', '未通过的审计项', '尚未通过全部任务审计', '源运行报告飞行任务'):
                self.assertNotIn(phrase, markup)
            self.assertIn('让机器人前往前台，并在那里排成一列。' if name=='zh.html' else 'Send the robots to the reception desk and have them line up there.', markup)
            self.assertIn('已完成人工审阅' if name=='zh.html' else 'manually reviewed', markup)
            self.assertIn('不改变其原始判定' if name=='zh.html' else 'does not revise their recorded verdicts', markup)
            self.assertEqual(markup.count('data-office-external='), 2)
            self.assertIn('并非外站页面截图' if name=='zh.html' else 'not screenshots of the external website', markup)
        self.assertEqual(self.demo['audit']['status'], 'FAILED')

    def test_tldr_reductions_and_task_scope(self) -> None:
        surface, depth = reconstruction_reductions()
        self.assertAlmostEqual(surface, 80.95096, places=3)
        self.assertAlmostEqual(depth, 53.77076, places=3)
        for name, document in self.documents.items():
            markup = (ROOT / name).read_text()
            chinese = name == 'zh.html'
            summary = re.search(r'<aside class="tldr"><strong>TL;DR</strong><p>(.*?)</p>', markup).group(1)
            for term in ('IMU', 'M1', 'M4', '81%', '54%'):
                self.assertIn(term, summary)
            self.assertIn('真值位姿条件' if chinese else 'GT-pose-conditioned', summary)
            self.assertIn('预设路线' if chinese else 'predefined routes', summary)
            self.assertIn('180 个评估视角' if chinese else '180 evaluation views', document.text_for('results'))
            self.assertEqual(markup.count('class="metric-reduction"'), 2)
            self.assertNotIn('180 度', document.text_for('results'))
            self.assertIn('相对降低约 81%' if chinese else '≈81% relative reduction', markup)
            self.assertIn('相对降低约 54%' if chinese else '≈54% relative reduction', markup)


if __name__ == "__main__":
    unittest.main(verbosity=2)