"""Document-level curation; no language-model inference or invented OCR corrections."""
from __future__ import annotations

from collections import defaultdict, deque
import hashlib
import json
from pathlib import Path
import re
from urllib.parse import urlparse

POLICY = Path(__file__).with_name("technical_mega_curation_policy.json")


def load_metadata(root: Path) -> dict[str, list[dict]]:
    paths = [root / "polish_cnc_technical_dynaword/provenance" / name for name in (
        "full_source_records.jsonl", "augmentation_bcpw_records.jsonl",
        "augmentation_zpe_records.jsonl", "augmentation_rock_records.jsonl",
    )]
    paths += [root / folder / "provenance/articles.jsonl" for folder in (
        "polish_industrial_maintenance_dynaword", "polish_automation_control_dynaword",
        "polish_engineering_new_dynaword",
    )]
    paths.append(root / "zpe_cnc_pl_dynaword/provenance/records.jsonl")
    paths += sorted((root / "polish_source_subset/data").glob("*/*.attribution.jsonl"))
    result: dict[str, list[dict]] = defaultdict(list)
    for path in paths:
        for line in path.read_text(encoding="utf-8-sig").splitlines():
            if line.strip():
                metadata = json.loads(line)
                if metadata not in result[metadata["id"]]:
                    result[metadata["id"]].append(metadata)
    return dict(result)


def group_keys(record: dict, metadata: list[dict]) -> list[str]:
    """Aliases join shared PDFs, book chapters and alternate source namespaces."""
    source, identity = record["source"], record["id"]
    keys = set()
    for item in metadata:
        if source.startswith("bibliotekanauki-"):
            article = str(item["article_id"])
            keys.add("bibliotekanauki:" + article)
        elif source == "wikibooks":
            keys.add("wikibooks:" + item["title"].split("/", 1)[0])
        elif source == "open_agh_chemistry_pl":
            keys.update("agh-book:" + str(book["book_id"]) for book in item["memberships"])
        elif source in ("rock_pollub_pl", "rock-pollub-open"):
            handle = item["handle"].removeprefix("https://hdl.handle.net/").strip("/")
            keys.add("rock-book:" + handle)
        elif source == "open_icm_pl":
            keys.add("icm-book:" + item["handle"].removeprefix("https://hdl.handle.net/").strip("/"))
        elif source == "bcpw-public-domain":
            keys.add("bcpw-book:" + " ".join(item["title"].split()).casefold())
        elif source == "wikisource-maszynisci-1873":
            keys.add("wikisource-book:maszynisci-1873")
        elif source == "zpe-cnc-pl":
            page = urlparse(item["url"]).path.rstrip("/").rsplit("/", 1)[-1]
            if not re.fullmatch(r"D[A-Za-z0-9]+", page):
                raise ValueError(f"Unreviewed ZPE page identity: {identity}: {page}")
            keys.add("zpe-page:" + page)
        else:
            raise ValueError(f"Unreviewed source family: {source}")
        for digest in (item.get("pdf_sha256"), item.get("payload_sha256"), (item.get("pdf") or {}).get("sha256")):
            if digest:
                if not re.fullmatch(r"[0-9a-f]{64}", digest):
                    raise ValueError(f"Invalid PDF checksum: {identity}")
                keys.add("pdf:" + digest)
    if not keys:
        raise ValueError(f"Missing document/book attribution: {identity}")
    return sorted(keys)


def exclusion_reasons(record: dict, metadata: list[dict], policy: dict) -> list[str]:
    source = record["source"]
    reasons = set()
    if source == "wikibooks":
        for item in metadata:
            book = item["title"].split("/", 1)[0]
            decision = policy["wikibooks_books"][book]  # Unknown books require review.
            if not decision["include"]:
                reasons.add("outside_selected_book_scope")
    if source == "open_icm_pl" and record["id"] not in policy["open_icm_include_ids"]:
        reasons.add("outside_selected_book_scope")
    if source in ("bcpw-public-domain", "wikisource-maszynisci-1873"):
        reasons.add("historical_technical_archive_not_current_training")
    if source.startswith("bibliotekanauki-"):
        for item in metadata:
            reviewed = policy["reviewed_damaged_articles"].get(str(item["article_id"]))
            if reviewed:
                if item["pdf_sha256"] != reviewed["pdf_sha256"]:
                    raise ValueError("Reviewed damaged PDF changed; a new review is required")
                reasons.add("verified_unreliable_pdf_text_layout")
    return sorted(reasons)


def assign_groups(records: list[dict], metadata: dict[str, list[dict]], policy: dict) -> None:
    parents: dict[str, str] = {}

    def find(key: str) -> str:
        parents.setdefault(key, key)
        root = key
        while parents[root] != root:
            root = parents[root]
        while parents[key] != key:
            next_key = parents[key]
            parents[key] = root
            key = next_key
        return root

    for record in records:
        identities = [record, *record.get("_aliases", [])]
        keys = sorted({key for identity in identities for key in group_keys(identity, metadata[identity["id"]])})
        root = find(keys[0])
        for key in keys[1:]:
            other = find(key)
            if other != root:
                low, high = sorted((root, other))
                parents[high] = low
                root = low
        record["_group_keys"] = keys
        record["_exclusion_reasons"] = sorted({
            reason for identity in identities
            for reason in exclusion_reasons(identity, metadata[identity["id"]], policy)
        })
    group_reasons: dict[str, set[str]] = defaultdict(set)
    for record in records:
        record["_group_id"] = find(record["_group_keys"][0])
        group_reasons[record["_group_id"]].update(record["_exclusion_reasons"])
    for record in records:
        record["_exclusion_reasons"] = sorted(group_reasons[record["_group_id"]])
        record["_split"] = "quarantine" if record["_exclusion_reasons"] else split_for(record["_group_id"])


def split_for(group: str) -> str:
    # Preserve the original article-ID split algorithm for unaliased Biblioteka articles.
    seed = group.removeprefix("bibliotekanauki:") if group.startswith("bibliotekanauki:") else group
    bucket = int(hashlib.sha256(seed.encode("utf-8")).hexdigest()[:8], 16) % 100
    return "test" if bucket < 5 else "valid" if bucket < 10 else "train"


def balanced_samples(records: list[dict], limit: int = 32) -> list[dict]:
    """Round robin across source families; distinct books/documents first."""
    buckets: dict[str, list[dict]] = defaultdict(list)
    for record in sorted(records, key=lambda row: hashlib.sha256(row["id"].encode()).hexdigest()):
        buckets[record["source"]].append(record)
    queues = {}
    for source, rows in sorted(buckets.items()):
        seen = set()
        first, rest = [], []
        for row in rows:
            (rest if row["_group_id"] in seen else first).append(row)
            seen.add(row["_group_id"])
        queues[source] = deque(first + rest)
    sample = []
    while len(sample) < limit and any(queues.values()):
        for queue in queues.values():
            if queue and len(sample) < limit:
                sample.append(queue.popleft())
    return sample