from __future__ import annotations

import argparse
import csv
import io
import json
import os
import re
import shutil
import subprocess
import sys
import urllib.request
import zipfile
from collections import defaultdict
from datetime import date
from difflib import SequenceMatcher
from pathlib import Path, PurePosixPath
from typing import Any

import pyarrow as pa
import pyarrow.parquet as pq

from common import (
    Archive,
    TexEntry,
    archive_stem_title,
    brace_balance,
    canonical_json,
    clean_tex_label,
    content_size_category,
    extract_braced_command,
    extract_document_body,
    find_secret_patterns,
    find_unsafe_tex_references,
    make_chunks,
    mime_type_for,
    normalize_title,
    sha256_bytes,
    sha256_file,
    write_text_lf,
)


DEFAULT_CATALOG_URL = "https://kadubon.github.io/github.io/research-catalog.json"
REPO_ID = "kadubon/paper-tex-corpus"
VERSION = "1.0.0"
SENTINEL = ".paper-tex-corpus-build"


PAPERS_SCHEMA = pa.schema(
    [
        ("paper_id", pa.string()),
        ("doi", pa.string()),
        ("title", pa.string()),
        ("authors", pa.list_(pa.string())),
        ("date_published", pa.string()),
        ("abstract", pa.string()),
        ("keywords", pa.list_(pa.string())),
        ("language", pa.string()),
        ("genre", pa.string()),
        ("canonical_url", pa.string()),
        ("works_url", pa.string()),
        ("tex_source", pa.large_string()),
        ("archive_path", pa.string()),
        ("archive_sha256", pa.string()),
        ("tex_entry", pa.string()),
        ("tex_sha256", pa.string()),
        ("source_archive_paths", pa.list_(pa.string())),
        ("source_archive_sha256s", pa.list_(pa.string())),
        ("source_tex_entries", pa.list_(pa.string())),
        ("source_tex_sha256s", pa.list_(pa.string())),
        ("mapping_status", pa.string()),
        ("content_status", pa.string()),
        ("quality_flags", pa.list_(pa.string())),
    ]
)

ARCHIVE_ONLY_SCHEMA = pa.schema(
    [
        ("record_id", pa.string()),
        ("title", pa.string()),
        ("authors", pa.list_(pa.string())),
        ("date_raw", pa.string()),
        ("language", pa.string()),
        ("tex_source", pa.large_string()),
        ("archive_path", pa.string()),
        ("archive_sha256", pa.string()),
        ("tex_entry", pa.string()),
        ("tex_sha256", pa.string()),
        ("mapping_status", pa.string()),
        ("candidate_dois", pa.list_(pa.string())),
        ("content_status", pa.string()),
        ("duplicate_of_archive", pa.string()),
        ("quality_flags", pa.list_(pa.string())),
    ]
)

CHUNKS_SCHEMA = pa.schema(
    [
        ("chunk_id", pa.string()),
        ("paper_id", pa.string()),
        ("doi", pa.string()),
        ("title", pa.string()),
        ("partition", pa.string()),
        ("source_id", pa.string()),
        ("source_archive_path", pa.string()),
        ("tex_entry", pa.string()),
        ("section_path", pa.list_(pa.string())),
        ("section_title", pa.string()),
        ("chunk_index", pa.int32()),
        ("char_start", pa.int64()),
        ("char_end", pa.int64()),
        ("chunk_tex", pa.large_string()),
        ("chunk_text", pa.large_string()),
        ("char_count", pa.int32()),
        ("quality_flags", pa.list_(pa.string())),
    ]
)

ENTRY_SCHEMA = pa.struct(
    [
        ("path", pa.string()),
        ("size", pa.int64()),
        ("compressed_size", pa.int64()),
        ("crc32", pa.string()),
        ("sha256", pa.string()),
        ("media_type", pa.string()),
        ("is_tex", pa.bool_()),
    ]
)

ARCHIVES_SCHEMA = pa.schema(
    [
        ("archive_id", pa.string()),
        ("archive_path", pa.string()),
        ("archive_filename", pa.string()),
        ("archive_size", pa.int64()),
        ("archive_sha256", pa.string()),
        ("mapped_dois", pa.list_(pa.string())),
        ("candidate_dois", pa.list_(pa.string())),
        ("mapping_status", pa.string()),
        ("mapping_method", pa.string()),
        ("mapping_score", pa.float64()),
        ("content_status", pa.string()),
        ("primary_tex_entry", pa.string()),
        ("primary_tex_sha256", pa.string()),
        ("duplicate_of_archive", pa.string()),
        ("entries", pa.list_(ENTRY_SCHEMA)),
        ("quality_flags", pa.list_(pa.string())),
    ]
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Build the Hugging Face-optimized K. Takahashi TeX corpus."
    )
    parser.add_argument("--source", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    catalog = parser.add_mutually_exclusive_group()
    catalog.add_argument("--catalog-file", type=Path)
    catalog.add_argument("--catalog-url", default=DEFAULT_CATALOG_URL)
    parser.add_argument(
        "--manual-mappings",
        type=Path,
        default=Path(__file__).resolve().parents[1]
        / "config"
        / "manual_mappings.json",
    )
    return parser.parse_args()


def ensure_safe_workspace(source: Path, output: Path) -> tuple[Path, Path]:
    source = source.resolve()
    output = output.resolve()
    if not source.is_dir():
        raise SystemExit(f"Source directory does not exist: {source}")
    if output == source or output in source.parents or source in output.parents:
        raise SystemExit("Source and output must be separate, non-nested directories.")
    output.mkdir(parents=True, exist_ok=True)
    sentinel = output / SENTINEL
    if not sentinel.exists():
        if any(output.iterdir()):
            raise SystemExit(
                f"Refusing to build into non-empty directory without {SENTINEL}: {output}"
            )
        write_text_lf(sentinel, "This sentinel marks a generated paper-tex-corpus workspace.\n")
    for generated in ("data", "raw"):
        target = output / generated
        if target.exists():
            shutil.rmtree(target)
    for generated_file in (
        "metadata/research-catalog.json",
        "metadata/catalog-crosswalk.csv",
        "metadata/source-state.json",
        "checksums.sha256",
        "build-report.json",
        "README.md",
        "LICENSE",
        "CITATION.cff",
    ):
        target = output / generated_file
        if target.exists():
            target.unlink()
    return source, output


def git_output(source: Path, *args: str) -> str:
    result = subprocess.run(
        ["git", "-C", str(source), *args],
        check=True,
        text=True,
        encoding="utf-8",
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    return result.stdout.strip()


def source_state(source: Path) -> dict[str, Any]:
    status = git_output(source, "status", "--porcelain")
    if status:
        raise SystemExit("Source repository is dirty; refusing a non-reproducible build.")
    return {
        "source_repository": git_output(source, "remote", "get-url", "origin"),
        "source_commit": git_output(source, "rev-parse", "HEAD"),
        "source_commit_date": git_output(
            source, "show", "-s", "--format=%cI", "HEAD"
        ),
        "source_branch": git_output(source, "branch", "--show-current"),
    }


def load_catalog(args: argparse.Namespace) -> tuple[dict[str, Any], str]:
    if args.catalog_file:
        raw = args.catalog_file.read_bytes()
        origin = str(args.catalog_file.resolve())
    else:
        with urllib.request.urlopen(args.catalog_url, timeout=60) as response:
            raw = response.read()
        origin = args.catalog_url
    catalog = json.loads(raw.decode("utf-8"))
    if catalog.get("record_count") != len(catalog.get("records", [])):
        raise SystemExit("Catalog record_count does not match records length.")
    return catalog, origin


def tex_entry_from_bytes(
    path: str,
    raw: bytes,
    compressed_size: int,
    crc: int,
) -> TexEntry:
    flags: list[str] = []
    try:
        text = raw.decode("utf-8")
    except UnicodeDecodeError:
        text = raw.decode("utf-8", errors="replace")
        flags.append("utf8_decode_replacement")
    title_raw = extract_braced_command(text, "title")
    author_raw = extract_braced_command(text, "author")
    date_raw = extract_braced_command(text, "date")
    stripped = text.strip()
    if len(stripped) <= 2 or not re.search(r"\\begin\s*\{document\}", text):
        content_status = "invalid_source"
    else:
        content_status = "valid"
    if not title_raw:
        flags.append("missing_title_command")
    if not author_raw:
        flags.append("missing_author_command")
    if not re.search(r"\\begin\s*\{abstract\}", text):
        flags.append("missing_abstract_environment")
    balance = brace_balance(text)
    if balance:
        flags.append(f"brace_imbalance:{balance}")
    if re.search(r"\\(?:immediate\s*)?\\write18", text):
        flags.append("shell_escape_command")
    unsafe_references = find_unsafe_tex_references(text)
    if unsafe_references:
        flags.append("unsafe_external_path_reference")
    secret_hits = find_secret_patterns(text)
    if secret_hits:
        flags.extend(f"secret_pattern:{name}" for name in secret_hits)
    return TexEntry(
        path=path,
        size=len(raw),
        compressed_size=compressed_size,
        crc32=f"{crc:08x}",
        sha256=sha256_bytes(raw),
        text=text,
        title_raw=title_raw,
        title_clean=clean_tex_label(title_raw),
        author_raw=author_raw,
        author_clean=clean_tex_label(author_raw),
        date_raw=clean_tex_label(date_raw),
        doi_candidates=sorted(
            {
                match.group(0).rstrip(".,;)")
                for match in DOI_RE.finditer(text)
            }
        ),
        content_status=content_status,
        quality_flags=sorted(set(flags)),
    )


DOI_RE = re.compile(r"10\.\d{4,9}/[-._;()/:A-Z0-9]+", re.IGNORECASE)


def choose_primary_tex(filename: str, tex_entries: list[TexEntry]) -> int | None:
    if not tex_entries:
        return None
    stem_norm = normalize_title(archive_stem_title(filename))
    ranked: list[tuple[float, int, int]] = []
    for index, entry in enumerate(tex_entries):
        title_norm = normalize_title(entry.title_clean or Path(entry.path).stem)
        title_score = SequenceMatcher(None, stem_norm, title_norm).ratio()
        path_score = SequenceMatcher(
            None, stem_norm, normalize_title(Path(entry.path).stem)
        ).ratio()
        validity = 1 if entry.content_status == "valid" else 0
        ranked.append((validity * 10 + max(title_score, path_score), entry.size, index))
    return max(ranked)[2]


def scan_archives(source: Path, output: Path) -> list[Archive]:
    archives: list[Archive] = []
    raw_dir = output / "raw"
    raw_dir.mkdir(parents=True, exist_ok=True)
    for source_zip in sorted(source.glob("*.zip"), key=lambda item: item.name.lower()):
        destination = raw_dir / source_zip.name
        shutil.copyfile(source_zip, destination)
        archive_hash = sha256_file(source_zip)
        if sha256_file(destination) != archive_hash:
            raise SystemExit(f"Raw copy hash mismatch: {source_zip.name}")
        entries: list[dict[str, Any]] = []
        tex_entries: list[TexEntry] = []
        archive_flags: list[str] = []
        try:
            with zipfile.ZipFile(source_zip) as archive:
                bad_member = archive.testzip()
                if bad_member:
                    raise SystemExit(
                        f"CRC failure in {source_zip.name}: {bad_member}"
                    )
                for info in archive.infolist():
                    member = PurePosixPath(info.filename.replace("\\", "/"))
                    if (
                        member.is_absolute()
                        or ".." in member.parts
                        or re.match(r"^[A-Za-z]:", info.filename)
                    ):
                        raise SystemExit(
                            f"Unsafe ZIP member path in {source_zip.name}: {info.filename}"
                        )
                    if info.is_dir():
                        continue
                    raw = archive.read(info)
                    entry = {
                        "path": info.filename,
                        "size": len(raw),
                        "compressed_size": info.compress_size,
                        "crc32": f"{info.CRC:08x}",
                        "sha256": sha256_bytes(raw),
                        "media_type": mime_type_for(info.filename),
                        "is_tex": Path(info.filename).suffix.lower() == ".tex",
                    }
                    entries.append(entry)
                    if entry["is_tex"]:
                        tex_entries.append(
                            tex_entry_from_bytes(
                                info.filename,
                                raw,
                                info.compress_size,
                                info.CRC,
                            )
                        )
        except zipfile.BadZipFile as error:
            raise SystemExit(f"Broken ZIP {source_zip.name}: {error}") from error
        primary_index = choose_primary_tex(source_zip.name, tex_entries)
        if len(tex_entries) > 1:
            archive_flags.append("multiple_tex_entries")
        if not tex_entries:
            archive_flags.append("missing_tex_entry")
        if any(
            flag.startswith("secret_pattern:")
            for tex in tex_entries
            for flag in tex.quality_flags
        ):
            raise SystemExit(f"Secret-like pattern found in {source_zip.name}")
        archives.append(
            Archive(
                filename=source_zip.name,
                source_path=source_zip,
                raw_path=f"raw/{source_zip.name}",
                size=source_zip.stat().st_size,
                sha256=archive_hash,
                entries=entries,
                tex_entries=tex_entries,
                primary_tex_index=primary_index,
                quality_flags=sorted(set(archive_flags)),
            )
        )
    return archives


def title_candidates(archive: Archive) -> list[str]:
    values = [archive_stem_title(archive.filename)]
    if archive.primary_tex:
        values.extend(
            [
                archive.primary_tex.title_clean,
                clean_tex_label(Path(archive.primary_tex.path).stem),
            ]
        )
    return [value for value in values if normalize_title(value)]


def title_score(archive: Archive, catalog_title: str) -> float:
    target = normalize_title(catalog_title)
    scores: list[float] = []
    for candidate in title_candidates(archive):
        value = normalize_title(candidate)
        score = SequenceMatcher(None, value, target).ratio()
        if (
            min(len(value), len(target)) >= 20
            and (value in target or target in value)
        ):
            length_ratio = min(len(value), len(target)) / max(len(value), len(target))
            score = max(score, min(1.0, length_ratio + 0.12))
        scores.append(score)
    return max(scores, default=0.0)


def apply_mappings(
    archives: list[Archive],
    papers: list[dict[str, Any]],
    manual_path: Path,
) -> None:
    by_doi = {paper["doi"].lower(): paper for paper in papers}
    mapping_config = json.loads(manual_path.read_text(encoding="utf-8"))
    manual = mapping_config["mappings"]
    forced_archive_only = mapping_config.get("archive_only", {})
    for archive in archives:
        if archive.filename not in forced_archive_only:
            continue
        decision = forced_archive_only[archive.filename]
        archive.mapping_method = "explicit_archive_only"
        archive.mapping_status = "archive_only"
        archive.mapping_score = 0.0
        external_doi = (decision.get("external_doi") or "").lower()
        archive.quality_flags.append(
            f"external_record_not_in_catalog:{external_doi}"
            if external_doi
            else "no_verified_external_record"
        )
        archive.quality_flags = sorted(set(archive.quality_flags))
    for archive in archives:
        if archive.filename not in manual:
            continue
        dois = [doi.lower() for doi in manual[archive.filename]]
        missing = [doi for doi in dois if doi not in by_doi]
        if missing:
            raise SystemExit(
                f"Manual mapping references missing catalog DOI(s): {missing}"
            )
        archive.mapped_dois = dois
        archive.mapping_method = "manual_evidence"
        archive.mapping_score = max(
            title_score(archive, by_doi[doi]["title"]) for doi in dois
        )
        archive.mapping_status = "matched"

    normalized_title_to_dois: dict[str, list[str]] = defaultdict(list)
    for paper in papers:
        normalized_title_to_dois[normalize_title(paper["title"])].append(
            paper["doi"].lower()
        )

    for archive in archives:
        if (
            archive.mapped_dois
            or archive.mapping_method == "explicit_archive_only"
            or not archive.primary_tex
        ):
            continue
        candidate_norms = {
            normalize_title(candidate) for candidate in title_candidates(archive)
        }
        exact_dois = sorted(
            {
                doi
                for norm in candidate_norms
                for doi in normalized_title_to_dois.get(norm, [])
            }
        )
        if len(exact_dois) == 1:
            archive.mapped_dois = exact_dois
            archive.mapping_method = "exact_normalized_title"
            archive.mapping_score = 1.0
            archive.mapping_status = "matched"
            continue

        body_front = archive.primary_tex.text
        bibliography = re.search(
            r"\\begin\s*\{thebibliography\}|\\bibliography\s*\{",
            body_front,
        )
        if bibliography:
            body_front = body_front[: bibliography.start()]
        body_front = body_front[:40_000]
        front_dois = {
            match.group(0).rstrip(".,;)").lower()
            for match in DOI_RE.finditer(body_front)
        }
        intersection = sorted(front_dois.intersection(by_doi))
        if len(intersection) == 1:
            doi = intersection[0]
            score = title_score(archive, by_doi[doi]["title"])
            if score >= 0.92:
                archive.mapped_dois = [doi]
                archive.mapping_method = "doi_in_source"
                archive.mapping_score = score
                archive.mapping_status = "matched"
                continue

        scores = sorted(
            (
                (title_score(archive, paper["title"]), paper["doi"].lower())
                for paper in papers
            ),
            reverse=True,
        )
        best_score, best_doi = scores[0]
        second_score = scores[1][0]
        archive.mapping_score = best_score
        archive.candidate_dois = [best_doi]
        if best_score >= 0.84 and best_score - second_score >= 0.06:
            archive.mapped_dois = [best_doi]
            archive.mapping_method = "strong_unique_title"
            archive.mapping_status = "matched"
        elif best_score >= 0.70:
            archive.mapping_method = "ambiguous_title_candidate"
            archive.mapping_status = "ambiguous"
        else:
            archive.mapping_method = "unresolved"
            archive.mapping_status = "archive_only"

    duplicate_groups: dict[str, list[Archive]] = defaultdict(list)
    for archive in archives:
        if archive.primary_tex:
            duplicate_groups[archive.primary_tex.sha256].append(archive)
    for group in duplicate_groups.values():
        if len(group) < 2:
            continue
        representative = sorted(
            group,
            key=lambda archive: (
                0 if archive.mapped_dois else 1,
                1 if re.search(r"\(\d+\)\.zip$", archive.filename) else 0,
                archive.filename.lower(),
            ),
        )[0]
        for duplicate in group:
            if duplicate is representative:
                continue
            duplicate.duplicate_of_archive = representative.raw_path
            if not duplicate.mapped_dois and representative.mapped_dois:
                duplicate.mapped_dois = list(representative.mapped_dois)
                duplicate.mapping_method = "exact_content_duplicate"
                duplicate.mapping_score = representative.mapping_score
                duplicate.mapping_status = "matched"


def author_list(author_clean: str) -> list[str]:
    if not author_clean:
        return []
    if "takahashi" in author_clean.lower():
        return ["K. Takahashi"]
    return [author_clean]


def build_rows(
    archives: list[Archive],
    papers: list[dict[str, Any]],
) -> tuple[
    list[dict[str, Any]],
    list[dict[str, Any]],
    list[dict[str, Any]],
    list[dict[str, Any]],
]:
    archives_by_doi: dict[str, list[Archive]] = defaultdict(list)
    ambiguous_by_doi: dict[str, list[Archive]] = defaultdict(list)
    for archive in archives:
        for doi in archive.mapped_dois:
            archives_by_doi[doi].append(archive)
        if archive.mapping_status == "ambiguous":
            for doi in archive.candidate_dois:
                ambiguous_by_doi[doi].append(archive)

    paper_rows: list[dict[str, Any]] = []
    catalog_by_doi = {paper["doi"].lower(): paper for paper in papers}
    for paper in papers:
        doi = paper["doi"].lower()
        sources = sorted(
            archives_by_doi.get(doi, []),
            key=lambda archive: (
                1 if archive.content_status != "valid" else 0,
                1 if archive.duplicate_of_archive else 0,
                1 if re.search(r"\(\d+\)\.zip$", archive.filename) else 0,
                -archive.mapping_score,
                archive.filename.lower(),
            ),
        )
        usable = [
            archive
            for archive in sources
            if archive.primary_tex
            and archive.primary_tex.content_status == "valid"
            and not archive.duplicate_of_archive
        ]
        primary = usable[0] if usable else (sources[0] if sources else None)
        primary_tex = primary.primary_tex if primary else None
        flags = {
            flag
            for source in sources
            for flag in [
                *source.quality_flags,
                *(source.primary_tex.quality_flags if source.primary_tex else []),
            ]
        }
        if len(usable) > 1:
            flags.add("multiple_source_manuscripts")
        if not sources:
            flags.add("metadata_only")
        if not sources and ambiguous_by_doi.get(doi):
            mapping_status = "ambiguous"
            flags.add("ambiguous_source_candidate")
        elif not sources:
            mapping_status = "metadata_only"
        elif len(usable) > 1:
            mapping_status = "multi_source"
        else:
            mapping_status = primary.mapping_method
        if not sources:
            content_status = "metadata_only"
        elif usable:
            content_status = "valid"
        else:
            content_status = "invalid_source"
        paper_rows.append(
            {
                "paper_id": doi,
                "doi": doi,
                "title": paper["title"],
                "authors": list(paper.get("authors") or []),
                "date_published": paper.get("date_published") or "",
                "abstract": paper.get("abstract") or "",
                "keywords": list(paper.get("keywords") or []),
                "language": paper.get("language") or "en",
                "genre": paper.get("genre") or "",
                "canonical_url": paper.get("canonical_url")
                or paper.get("doi_url")
                or "",
                "works_url": paper.get("local_record_url") or paper.get("id") or "",
                "tex_source": primary_tex.text if primary_tex else "",
                "archive_path": primary.raw_path if primary else "",
                "archive_sha256": primary.sha256 if primary else "",
                "tex_entry": primary_tex.path if primary_tex else "",
                "tex_sha256": primary_tex.sha256 if primary_tex else "",
                "source_archive_paths": [source.raw_path for source in sources],
                "source_archive_sha256s": [source.sha256 for source in sources],
                "source_tex_entries": [
                    source.primary_tex.path if source.primary_tex else ""
                    for source in sources
                ],
                "source_tex_sha256s": [
                    source.primary_tex.sha256 if source.primary_tex else ""
                    for source in sources
                ],
                "mapping_status": mapping_status,
                "content_status": content_status,
                "quality_flags": sorted(flags),
            }
        )

    archive_only_rows: list[dict[str, Any]] = []
    for archive in archives:
        if archive.mapped_dois:
            continue
        tex = archive.primary_tex
        flags = set(archive.quality_flags)
        if tex:
            flags.update(tex.quality_flags)
        archive_only_rows.append(
            {
                "record_id": f"archive:{archive.sha256}",
                "title": (
                    tex.title_clean
                    if tex and tex.title_clean
                    else archive_stem_title(archive.filename)
                ),
                "authors": author_list(tex.author_clean if tex else ""),
                "date_raw": tex.date_raw if tex else "",
                "language": "en",
                "tex_source": tex.text if tex else "",
                "archive_path": archive.raw_path,
                "archive_sha256": archive.sha256,
                "tex_entry": tex.path if tex else "",
                "tex_sha256": tex.sha256 if tex else "",
                "mapping_status": archive.mapping_status,
                "candidate_dois": archive.candidate_dois,
                "content_status": archive.content_status,
                "duplicate_of_archive": archive.duplicate_of_archive,
                "quality_flags": sorted(flags),
            }
        )

    chunk_rows: list[dict[str, Any]] = []
    seen_tex_hashes: set[str] = set()
    for archive in archives:
        tex = archive.primary_tex
        if (
            tex is None
            or tex.content_status != "valid"
            or tex.sha256 in seen_tex_hashes
        ):
            continue
        seen_tex_hashes.add(tex.sha256)
        doi = archive.mapped_dois[0] if archive.mapped_dois else ""
        if doi:
            paper = catalog_by_doi[doi]
            paper_id = doi
            title = paper["title"]
            partition = "papers"
        else:
            paper_id = f"archive:{archive.sha256}"
            title = tex.title_clean or archive_stem_title(archive.filename)
            partition = "archive_only"
        body = extract_document_body(tex.text)
        for index, chunk in enumerate(make_chunks(body)):
            chunk_hash = sha256_bytes(
                (
                    tex.sha256
                    + "\0"
                    + str(index)
                    + "\0"
                    + chunk["chunk_tex"]
                ).encode("utf-8")
            )
            flags = sorted(
                set(archive.quality_flags)
                | set(tex.quality_flags)
                | set(chunk["quality_flags"])
            )
            chunk_rows.append(
                {
                    "chunk_id": f"chunk:{chunk_hash}",
                    "paper_id": paper_id,
                    "doi": doi,
                    "title": title,
                    "partition": partition,
                    "source_id": f"sha256:{tex.sha256}",
                    "source_archive_path": archive.raw_path,
                    "tex_entry": tex.path,
                    "section_path": chunk["section_path"],
                    "section_title": chunk["section_title"],
                    "chunk_index": index,
                    "char_start": chunk["char_start"],
                    "char_end": chunk["char_end"],
                    "chunk_tex": chunk["chunk_tex"],
                    "chunk_text": chunk["chunk_text"],
                    "char_count": len(chunk["chunk_tex"]),
                    "quality_flags": flags,
                }
            )

    archive_rows: list[dict[str, Any]] = []
    for archive in archives:
        primary = archive.primary_tex
        flags = set(archive.quality_flags)
        if primary:
            flags.update(primary.quality_flags)
        archive_rows.append(
            {
                "archive_id": f"sha256:{archive.sha256}",
                "archive_path": archive.raw_path,
                "archive_filename": archive.filename,
                "archive_size": archive.size,
                "archive_sha256": archive.sha256,
                "mapped_dois": archive.mapped_dois,
                "candidate_dois": archive.candidate_dois,
                "mapping_status": archive.mapping_status,
                "mapping_method": archive.mapping_method,
                "mapping_score": archive.mapping_score,
                "content_status": archive.content_status,
                "primary_tex_entry": primary.path if primary else "",
                "primary_tex_sha256": primary.sha256 if primary else "",
                "duplicate_of_archive": archive.duplicate_of_archive,
                "entries": archive.entries,
                "quality_flags": sorted(flags),
            }
        )
    return paper_rows, archive_only_rows, chunk_rows, archive_rows


def write_parquet(
    output: Path,
    config: str,
    rows: list[dict[str, Any]],
    schema: pa.Schema,
    row_group_size: int,
) -> Path:
    target = output / "data" / config / "train-00000-of-00001.parquet"
    target.parent.mkdir(parents=True, exist_ok=True)
    table = pa.Table.from_pylist(rows, schema=schema)
    pq.write_table(
        table,
        target,
        compression="zstd",
        compression_level=9,
        use_dictionary=True,
        row_group_size=row_group_size,
        write_page_index=True,
        data_page_version="2.0",
        version="2.6",
    )
    return target


def write_crosswalk(output: Path, archives: list[Archive]) -> None:
    target = output / "metadata" / "catalog-crosswalk.csv"
    target.parent.mkdir(parents=True, exist_ok=True)
    buffer = io.StringIO(newline="")
    writer = csv.DictWriter(
        buffer,
        fieldnames=[
            "archive_filename",
            "archive_sha256",
            "mapped_dois",
            "candidate_dois",
            "mapping_status",
            "mapping_method",
            "mapping_score",
            "content_status",
            "primary_tex_entry",
            "primary_tex_sha256",
            "duplicate_of_archive",
            "quality_flags",
        ],
        lineterminator="\n",
    )
    writer.writeheader()
    for archive in archives:
        primary = archive.primary_tex
        flags = sorted(
            set(archive.quality_flags)
            | set(primary.quality_flags if primary else [])
        )
        writer.writerow(
            {
                "archive_filename": archive.filename,
                "archive_sha256": archive.sha256,
                "mapped_dois": "|".join(archive.mapped_dois),
                "candidate_dois": "|".join(archive.candidate_dois),
                "mapping_status": archive.mapping_status,
                "mapping_method": archive.mapping_method,
                "mapping_score": f"{archive.mapping_score:.6f}",
                "content_status": archive.content_status,
                "primary_tex_entry": primary.path if primary else "",
                "primary_tex_sha256": primary.sha256 if primary else "",
                "duplicate_of_archive": archive.duplicate_of_archive,
                "quality_flags": "|".join(flags),
            }
        )
    write_text_lf(target, buffer.getvalue())


def license_text() -> str:
    return """Creative Commons Attribution 4.0 International (CC BY 4.0)
SPDX-License-Identifier: CC-BY-4.0

This work is licensed under the Creative Commons Attribution 4.0 International License.

To view a copy of this license, visit:
https://creativecommons.org/licenses/by/4.0/
or:
https://creativecommons.org/licenses/by/4.0/legalcode

NO WARRANTY; LIMITATION OF LIABILITY.
This material is provided "as is", without warranty of any kind. The author shall not
be liable for any damages or other liability arising from, out of, or in connection
with the material or the use or other dealings in the material.
"""


def citation_text(source_date: str) -> str:
    release_date = source_date[:10]
    year = release_date[:4]
    return f"""cff-version: 1.2.0
message: "If you use this dataset, please cite the corpus and the individual paper DOI(s)."
title: "K. Takahashi Paper TeX Corpus"
type: dataset
authors:
  - family-names: "Takahashi"
    given-names: "K."
    orcid: "https://orcid.org/0009-0004-4273-3365"
version: "{VERSION}"
date-released: "{release_date}"
license: CC-BY-4.0
repository-code: "https://huggingface.co/datasets/{REPO_ID}"
url: "https://huggingface.co/datasets/{REPO_ID}"
preferred-citation:
  type: dataset
  authors:
    - family-names: "Takahashi"
      given-names: "K."
      orcid: "https://orcid.org/0009-0004-4273-3365"
  title: "K. Takahashi Paper TeX Corpus"
  year: {year}
  version: "{VERSION}"
  url: "https://huggingface.co/datasets/{REPO_ID}"
"""


def readme_text(report: dict[str, Any]) -> str:
    counts = report["counts"]
    size_category = content_size_category(
        counts["papers"]
        + counts["archive_only"]
        + counts["chunks"]
        + counts["archives"]
    )
    return f"""---
pretty_name: "K. Takahashi Paper TeX Corpus"
short_description: "A provenance-rich TeX corpus of K. Takahashi's research papers, with DOI metadata, section-aware RAG chunks, original ZIP archives, and checksums."
license: cc-by-4.0
language:
- en
task_categories:
- text-retrieval
- document-question-answering
- text-generation
tags:
- latex
- tex
- scientific-papers
- research-corpus
- mathematics
- artificial-intelligence
- rag
- provenance
- reproducible-research
size_categories:
- {size_category}
configs:
- config_name: papers
  default: true
  data_files:
  - split: train
    path: data/papers/train-*.parquet
- config_name: archive_only
  data_files:
  - split: train
    path: data/archive_only/train-*.parquet
- config_name: chunks
  data_files:
  - split: train
    path: data/chunks/train-*.parquet
- config_name: archives
  data_files:
  - split: train
    path: data/archives/train-*.parquet
---

# K. Takahashi Paper TeX Corpus

This dataset publishes K. Takahashi's TeX research corpus in four complementary views:
canonical DOI records, uncatalogued archive records, section-aware retrieval chunks, and
an inventory of the original source ZIPs. The unmodified ZIP files are available under
`raw/`, while all viewer-facing data is provided directly as Parquet.

## What this dataset is for

The purpose of this dataset is to make a collection of scholarly TeX sources usable as a
**searchable, citable, and auditable research corpus**. A directory of ZIP files preserves
the manuscripts, but it is difficult to search across papers, connect a passage to its DOI,
or determine which file and version produced a result. This dataset adds those missing
layers without replacing the original sources:

- a **bibliographic layer** links each catalogued work to its DOI, title, abstract,
  publication date, keywords, and canonical URL;
- a **source layer** preserves the full TeX text and byte-identical source ZIP so that a
  result can be inspected in its original context;
- a **retrieval layer** supplies section-aware chunks that retain TeX mathematics and
  avoid splitting structural environments where possible; and
- a **provenance layer** records checksums, archive members, mappings, duplicate
  relationships, and quality flags so that downstream results can be traced and rebuilt.

The intended outcome is not merely easier downloading. It is a reproducible path from
**finding a relevant passage**, to **identifying the paper and DOI**, to **checking the
underlying TeX source and archive**. This is useful when answers, search results, or corpus
statistics need evidence that can be followed back to a specific scholarly document.

## Research content overview

The papers form a connected, theory-oriented research program on how autonomous and
self-modifying intelligent systems can remain viable, interpretable, governable, and
physically grounded when no infallible external evaluator is available. The corpus asks
how claims about intelligence, safety, autonomy, value, persistence, or improvement can
be stated in operational terms and checked using finite observations, explicit
assumptions, resource constraints, and reproducible evidence.

Major, overlapping research strands include:

- **Self-organizing and self-improving intelligence.** Early and continuing papers study
  computational autopoiesis, active inference, collective adaptive intelligence,
  teleogenesis, and architectures that can revise their own models or organization while
  preserving specified viability or value constraints.
- **Observable-only and "no-meta" assurance.** A large part of the corpus examines agents
  that cannot rely on a trusted meta-judge. It develops audit gates, proof- or
  evidence-carrying claims, typed contracts, replayable records, provenance rules,
  fail-closed controls, and institutional mechanisms for deciding what can be supported
  from observable data.
- **Persistence, semantics, observation, and memory.** Papers analyze how identity,
  meaning, values, and predictive organization behave under coarse-graining,
  self-modification, finite context, partial logging, ontology drift, and non-Markovian
  memory. Related work studies semantic phase transitions and limits on stable
  representation.
- **Physical and thermodynamic constraints.** The research treats computation and agency
  as processes embedded in open physical systems. Topics include free-energy and
  entropy-production principles, exergy and resource accounting, energy-memory-compute
  trade-offs, stochastic thermodynamics, and physically explicit boundaries and ledgers.
- **Mathematical structures for comparison and dynamics.** The corpus uses category
  theory, information geometry, optimal transport and Hellinger--Kantorovich/Bures
  geometry, gradient flows, dynamical systems, control theory, information theory, and
  causal inference to compare models and describe change across scales.
- **AI systems, scaling, and multi-agent operation.** Applied theoretical papers address
  LLM routing, inference reuse, memory telemetry, long-running agents, training
  bottlenecks, silent data corruption, compute and I/O limits, multi-agent coordination,
  and the conditions under which distributed inference or verification is beneficial.
- **Governance, welfare, and human--AI coexistence.** Other papers connect the technical
  framework to rights, consent, non-coercive assistance, public claim certification,
  institutional accountability, work and welfare, benevolent propagation, and
  human--AI or organizational systems.

Across the collection, the emphasis shifts from broad architectures and axiomatic
proposals for self-organizing intelligence toward increasingly operational frameworks
based on measurable interfaces, causal identification, uncertainty sets, runtime
monitoring, physical accounting, and machine-checkable certificates. This is a thematic
guide, not a claim that every paper uses all of these concepts or that the proposed
theories have been empirically validated. The authoritative description of each work is
its catalog title, abstract, keywords, and linked DOI record.

## Dataset snapshot

| Item | Count |
|---|---:|
| Canonical scholarly records (`papers`) | {counts["papers"]} |
| Uncatalogued or unresolved records (`archive_only`) | {counts["archive_only"]} |
| Retrieval chunks (`chunks`) | {counts["chunks"]} |
| Original ZIP archives (`archives`) | {counts["archives"]} |
| TeX entries inside ZIPs | {counts["tex_entries"]} |
| Non-TeX auxiliary entries | {counts["auxiliary_entries"]} |
| Invalid primary TeX sources | {counts["invalid_sources"]} |
| Exact duplicate primary TeX archives | {counts["duplicate_archives"]} |

Source snapshot:

- TeX archive commit: `{report["source"]["source_commit"]}`
- Research catalog state: `{report["catalog"]["source_state_date"]}`
- Dataset release: `v{VERSION}`

## Which config should I start with?

All configs have one `train` split representing the complete corpus; `train` does not mean
that the records have been assigned to a machine-learning training partition.

| If you want to... | Start with | What one row represents |
|---|---|---|
| browse papers, join metadata by DOI, or retrieve a complete manuscript | `papers` | one canonical catalog record |
| build search, RAG, ranking, or embedding experiments | `chunks` | one section-aware TeX/text fragment |
| verify files, hashes, members, mappings, or preservation state | `archives` | one original ZIP archive |
| include older, supplementary, derivative, or unresolved sources | `archive_only` | one non-catalogued source record |

For most document-level analysis, begin with `papers`. For retrieval systems, begin with
`chunks` and use its paper/document identifier and DOI fields to join back to `papers`.
Use `archives` when exact source provenance matters. Add `archive_only` only when coverage
beyond the current publication catalog is required.

## Configs

### `papers` (default)

One row per canonical scholarly DOI in the machine-readable publication catalog. Catalog
metadata is authoritative. Source fields are empty when no TeX source can be established
without guessing. A DOI can point to multiple component source manuscripts; the primary
source is kept in the singular fields and every source is listed in the `source_*` arrays.

### `archive_only`

ZIPs that are not safely attributable to a current catalog DOI. These include older
versions, supplements, derivative manuscripts, and unresolved title candidates. No DOI
is inferred for these rows.

### `chunks`

Deterministic, section-aware chunks built from unique valid primary TeX sources. Chunking
targets about 4,000 characters, allows up to 6,000 characters, and reuses up to 400
characters of complete trailing blocks. The pipeline does not split equation, theorem,
proof, or verbatim environments. `char_start` and `char_end` refer to the comment-stripped
document body. Both the original TeX fragment and a conservative readable projection are
included.

### `archives`

One row per original ZIP. It records SHA-256 checksums, member metadata, DOI mappings,
duplicate relationships, and quality flags. The `raw/*.zip` files are byte-for-byte copies
of the source backup.

## Quick use

```python
from datasets import load_dataset

papers = load_dataset("{REPO_ID}", "papers", split="train")
chunks = load_dataset("{REPO_ID}", "chunks", split="train")

print(papers[0]["title"], papers[0]["doi"])
print(chunks[0]["section_title"], chunks[0]["chunk_text"][:500])
```

DuckDB can query the Parquet files directly:

```sql
SELECT doi, title, mapping_status
FROM read_parquet(
  'https://huggingface.co/datasets/{REPO_ID}/resolve/main/data/papers/train-00000-of-00001.parquet'
)
LIMIT 10;
```

## Provenance and mapping

Bibliographic metadata comes from the publication index and its
[`research-catalog.json`](https://kadubon.github.io/github.io/research-catalog.json).
Mappings use, in order, explicit evidence recorded in `config/manual_mappings.json`, a
unique DOI in the manuscript front matter, exact normalized titles, or a strong unique
title match. Similarity-only candidates below the acceptance threshold remain
`ambiguous` or `archive_only`. The complete decision record is
`metadata/catalog-crosswalk.csv`.

`metadata/source-state.json`, `build-report.json`, and `checksums.sha256` make the release
auditable. `scripts/build_dataset.py` regenerates all Parquet files and raw copies;
`scripts/validate_dataset.py` performs structural, checksum, security-pattern,
cross-config, PyArrow, DuckDB, and optional 🤗 Datasets checks. `CITATION.cff` provides
machine-readable corpus citation metadata.

## Practical use cases

### Citation-grounded search and RAG

Index `chunk_text` for readable retrieval or `chunk_tex` when exact TeX syntax matters.
After retrieval, carry the DOI, paper/document identifier, section path, and position into
the application response. A user or evaluator can then open the corresponding `papers`
row, inspect the complete `tex_source`, and follow `canonical_url` to the publication.
This structure supports citation-grounded systems, but the dataset does not itself verify
that a generated answer is entailed by a retrieved chunk.

### Math- and TeX-aware retrieval research

The corpus retains equations in TeX instead of replacing them with MathML or a normalized
formula language. It can therefore support experiments on tokenization, lexical and
semantic retrieval, reranking, chunking, or representation learning for documents in
which mathematical notation and document structure are important. Results may depend on
author-specific macros and conservative TeX-to-text conversion, so comparisons should
report the fields and preprocessing used.

### Corpus analysis and reproducible preprocessing

The `papers` view supports document-level analyses using publication metadata and complete
source text. The `chunks` view supports passage-level analyses while preserving section
context. Because source and generated artifacts have SHA-256 identifiers and the build
scripts are included, researchers can describe an input snapshot precisely and compare
alternative extraction, parsing, deduplication, or chunking pipelines.

### Archival and provenance work

The `archives` config and `raw/` directory can be used to check whether a derived record
matches an original package, inspect auxiliary files, study source-package composition,
or reconstruct the corpus. Invalid, duplicated, multi-manuscript, ambiguous, and
catalogue-external cases are represented explicitly rather than removed, which allows
users to define and report their own inclusion policy.

### Training and tool development

Under CC BY 4.0 attribution, the corpus can be used as input for model pretraining,
fine-tuning, parser development, LaTeX tooling, or other preprocessing research. Users
should create their own task-specific splits and evaluation criteria, prevent unintended
train/test overlap caused by related or duplicate manuscripts, and retain paper-level
attribution where outputs expose source content.

## What this dataset does not provide

- It is not an evaluation benchmark, answer key, or set of verified ground-truth answers.
- It does not certify the scientific correctness, novelty, or current validity of a paper.
- It does not include embeddings, a vector database, a retrieval service, or a trained
  model.
- It does not normalize equations or convert them to MathML.
- It does not guarantee that general-purpose TeX parsers can expand every author macro.
- It does not define a train/validation/test split; each config's `train` split is the
  complete released view.

## Limitations

- Inclusion does not certify the scientific correctness of a manuscript.
- TeX-to-text conversion is conservative and may retain formatting commands.
- No MathML conversion or equation normalization is included in v1.
- A small number of source packages are invalid, duplicated, multi-manuscript, or not
  attributable to a current DOI; these states are explicit rather than silently repaired.
- Public author contact information and ORCID values present in the source are retained.
- The corpus records source provenance, not whether any particular writing tool or
  assistance process was used.

## License and citation

The dataset and included source materials are released under
[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). Attribute K. Takahashi,
cite this dataset, and cite each paper's DOI when using individual works.

Suggested BibTeX:

```bibtex
@dataset{{takahashi_paper_tex_corpus_{report["catalog"]["source_state_date"][:4]},
  author    = {{Takahashi, K.}},
  title     = {{K. Takahashi Paper TeX Corpus}},
  year      = {{{report["catalog"]["source_state_date"][:4]}}},
  version   = {{{VERSION}}},
  publisher = {{Hugging Face}},
  url       = {{https://huggingface.co/datasets/{REPO_ID}}}
}}
```

Canonical publication records and paper-specific citation links are available at
<https://kadubon.github.io/github.io/works.html>.
"""


def write_checksums(output: Path) -> None:
    excluded_parts = {".git", ".venv", "__pycache__", ".pytest_cache"}
    excluded_names = {
        "checksums.sha256",
        "publish-report.json",
        SENTINEL,
    }
    rows: list[str] = []
    for path in sorted(
        (item for item in output.rglob("*") if item.is_file()),
        key=lambda item: item.relative_to(output).as_posix(),
    ):
        relative = path.relative_to(output)
        if any(part in excluded_parts for part in relative.parts):
            continue
        if relative.name in excluded_names:
            continue
        rows.append(f"{sha256_file(path)}  {relative.as_posix()}")
    write_text_lf(output / "checksums.sha256", "\n".join(rows) + "\n")


def main() -> None:
    args = parse_args()
    source, output = ensure_safe_workspace(args.source, args.output)
    state = source_state(source)
    catalog, catalog_origin = load_catalog(args)
    scholarly = [
        record
        for record in catalog["records"]
        if record.get("record_type") == "scholarly_article"
    ]
    if len(scholarly) != 227:
        raise SystemExit(
            f"Expected 227 scholarly records, found {len(scholarly)}."
        )
    archives = scan_archives(source, output)
    if len(archives) != 250:
        raise SystemExit(f"Expected 250 ZIP archives, found {len(archives)}.")
    apply_mappings(archives, scholarly, args.manual_mappings.resolve())
    paper_rows, archive_only_rows, chunk_rows, archive_rows = build_rows(
        archives, scholarly
    )

    write_parquet(output, "papers", paper_rows, PAPERS_SCHEMA, row_group_size=8)
    write_parquet(
        output,
        "archive_only",
        archive_only_rows,
        ARCHIVE_ONLY_SCHEMA,
        row_group_size=16,
    )
    write_parquet(output, "chunks", chunk_rows, CHUNKS_SCHEMA, row_group_size=128)
    write_parquet(
        output, "archives", archive_rows, ARCHIVES_SCHEMA, row_group_size=32
    )

    metadata_dir = output / "metadata"
    metadata_dir.mkdir(parents=True, exist_ok=True)
    write_text_lf(
        metadata_dir / "research-catalog.json",
        canonical_json(catalog),
    )
    write_crosswalk(output, archives)
    source_record = {
        **state,
        "catalog_origin": catalog_origin,
        "catalog_sha256": sha256_bytes(
            canonical_json(catalog).encode("utf-8")
        ),
        "catalog_source_state_date": catalog.get("source_state_date"),
        "build_version": VERSION,
    }
    write_text_lf(
        metadata_dir / "source-state.json",
        canonical_json(source_record),
    )

    tex_entries = [tex for archive in archives for tex in archive.tex_entries]
    tex_hash_counts: dict[str, int] = defaultdict(int)
    for tex in tex_entries:
        tex_hash_counts[tex.sha256] += 1
    auxiliary_entries = [
        entry
        for archive in archives
        for entry in archive.entries
        if not entry["is_tex"]
    ]
    report = {
        "schema_version": "1.0",
        "dataset_id": REPO_ID,
        "version": VERSION,
        "generated_at": (
            f"{catalog.get('source_state_date')}T00:00:00+09:00"
            if catalog.get("source_state_date")
            else state["source_commit_date"]
        ),
        "source": state,
        "catalog": {
            "origin": catalog_origin,
            "source_state_date": catalog.get("source_state_date"),
            "record_count": len(catalog["records"]),
            "scholarly_record_count": len(scholarly),
            "sha256": source_record["catalog_sha256"],
        },
        "counts": {
            "papers": len(paper_rows),
            "archive_only": len(archive_only_rows),
            "chunks": len(chunk_rows),
            "archives": len(archive_rows),
            "tex_entries": len(tex_entries),
            "auxiliary_entries": len(auxiliary_entries),
            "invalid_sources": sum(
                archive.content_status == "invalid_source" for archive in archives
            ),
            "duplicate_archives": sum(
                bool(archive.duplicate_of_archive) for archive in archives
            ),
            "duplicate_tex_groups": sum(
                count > 1 for count in tex_hash_counts.values()
            ),
            "matched_archives": sum(
                bool(archive.mapped_dois) for archive in archives
            ),
            "ambiguous_archives": sum(
                archive.mapping_status == "ambiguous" for archive in archives
            ),
            "metadata_only_papers": sum(
                row["content_status"] == "metadata_only" for row in paper_rows
            ),
        },
        "bytes": {
            "raw_zip_total": sum(archive.size for archive in archives),
            "tex_uncompressed_total": sum(tex.size for tex in tex_entries),
        },
        "mapping_methods": {
            method: sum(archive.mapping_method == method for archive in archives)
            for method in sorted({archive.mapping_method for archive in archives})
        },
        "quality": {
            "secret_pattern_hits": 0,
            "unsafe_zip_paths": 0,
            "broken_zip_archives": 0,
            "utf8_replacement_entries": sum(
                "utf8_decode_replacement" in tex.quality_flags
                for tex in tex_entries
            ),
        },
    }
    write_text_lf(output / "build-report.json", canonical_json(report))
    write_text_lf(output / "LICENSE", license_text())
    write_text_lf(
        output / "CITATION.cff",
        citation_text(
            catalog.get("source_state_date")
            or state["source_commit_date"]
            or date.today().isoformat()
        ),
    )
    write_text_lf(output / "README.md", readme_text(report))
    write_checksums(output)
    print(canonical_json(report), end="")


if __name__ == "__main__":
    main()