"""Verify delivered mega-corpus content, split isolation, attribution and native packs."""
from __future__ import annotations

import argparse
from collections import Counter
import hashlib
import json
from pathlib import Path

import numpy as np
import pyarrow.parquet as pq
import tiktoken
from tokenizers import Tokenizer

from pack_cnc_slayer import sha256 as file_sha256
from technical_corpus_curation import assign_groups
from validate_cnc_dynaword import SCHEMA, SPLITS, validate as validate_format


def digest(text: str) -> str:
    return hashlib.sha256(text.encode("utf-8")).hexdigest()


def verify(root: Path, baseline: Path | None = None) -> dict:
    result = {"format_validation": validate_format(root)}
    manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8"))
    provenance_rows = [json.loads(line) for line in (root / "provenance/records.jsonl").read_text(encoding="utf-8").splitlines()]
    provenance = {item["id"]: item for item in provenance_rows}
    if len(provenance) != len(provenance_rows):
        raise ValueError("Duplicate provenance identity")
    metadata_rows = [json.loads(line) for line in (root / "provenance/source_metadata.jsonl").read_text(encoding="utf-8").splitlines()]
    metadata = {item["id"]: item["metadata"] for item in metadata_rows}
    if len(metadata) != len(metadata_rows):
        raise ValueError("Duplicate source metadata identity")
    policy = json.loads((root / "processing/technical_mega_curation_policy.json").read_text(encoding="utf-8"))
    all_rows, seen_ids, seen_texts, seen_groups, seen_aliases = [], set(), set(), {}, {}
    source_counts, rows_by_split = {}, {}
    cl100k = tiktoken.get_encoding("cl100k_base")
    for split, relative in {**SPLITS, "quarantine": "quarantine/records.parquet"}.items():
        table = pq.read_table(root / relative)
        if table.column_names != SCHEMA:
            raise ValueError(f"Schema mismatch: {relative}")
        rows = table.to_pylist()
        rows_by_split[split] = rows
        source_counts[split] = dict(sorted(Counter(row["source"] for row in rows).items()))
        for row in rows:
            identity, text = row["id"], row["text"]
            normalized = digest(" ".join(text.split()).casefold())
            if identity in seen_ids or normalized in seen_texts:
                raise ValueError(f"Duplicate identity/content: {identity}")
            seen_ids.add(identity)
            seen_texts.add(normalized)
            proof = provenance[identity]
            if proof["split"] != split or proof["raw_text_sha256"] != digest(text) or proof["text_sha256"] != normalized:
                raise ValueError(f"Text or split differs from provenance: {identity}")
            for field in ("source", "license", "author", "created", "token_count"):
                if proof[field] != row[field]:
                    raise ValueError(f"Attribution/content mismatch: {identity}: {field}")
            for alias in (proof["group_id"], *proof["group_aliases"]):
                if alias in seen_aliases and seen_aliases[alias] != split:
                    raise ValueError(f"Document/book alias crosses splits: {alias}")
                seen_aliases[alias] = split
            group = proof["group_id"]
            seen_groups[group] = split
            if (split == "quarantine") != bool(proof["exclusion_reasons"]):
                raise ValueError(f"Exclusion reason/split mismatch: {identity}")
            if split == "quarantine" and row["token_count"] != len(cl100k.encode_ordinary(text)):
                raise ValueError(f"Quarantine proxy token mismatch: {identity}")
            row["_aliases"] = proof["duplicate_input_identities"]
            all_rows.append(row)
        expected = manifest["quarantine"] if split == "quarantine" else manifest["splits"][split]
        if len(rows) != expected["documents"] or sum(row["token_count"] for row in rows) != expected["tokens"]:
            raise ValueError(f"Partition count mismatch: {split}")
        if source_counts[split] != expected["sources"]:
            raise ValueError(f"Source count mismatch: {split}")
        if len({provenance[row["id"]]["group_id"] for row in rows}) != expected["document_groups"]:
            raise ValueError(f"Document group count mismatch: {split}")
        if split != "quarantine":
            samples = [json.loads(line) for line in (root / f"samples/{split}.jsonl").read_text(encoding="utf-8").splitlines()]
            lookup = {row["id"]: {field: row[field] for field in SCHEMA} for row in rows}
            if len({row["id"] for row in samples}) != len(samples):
                raise ValueError(f"Duplicate sample: {split}")
            if any(lookup.get(row["id"]) != row for row in samples):
                raise ValueError(f"Sample not in its split: {split}")
            if len(source_counts[split]) <= 32 and {row["source"] for row in samples} != set(source_counts[split]):
                raise ValueError(f"Samples omit available source families: {split}")
    if seen_ids != set(provenance):
        raise ValueError("Orphan or missing provenance")
    assign_groups(all_rows, metadata, policy)
    for row in all_rows:
        proof = provenance[row["id"]]
        if row["_group_id"] != proof["group_id"] or row["_split"] != proof["split"] or row["_exclusion_reasons"] != proof["exclusion_reasons"] or row["_group_keys"] != proof["group_aliases"]:
            raise ValueError(f"Recomputed curation/group assignment differs: {row['id']}")
    conservation = manifest["conservation"]
    retained = sum(len(rows_by_split[split]) for split in SPLITS)
    if len(all_rows) != conservation["records"] or retained != manifest["documents"] or len(rows_by_split["quarantine"]) != conservation["quarantined_records"] or retained != conservation["retained_records"]:
        raise ValueError("Record conservation mismatch")
    if sum(row["token_count"] for split in SPLITS for row in rows_by_split[split]) != manifest["tokens"]:
        raise ValueError("Active corpus token total mismatch")
    if baseline:
        originals = [row for path in sorted((baseline / "data").glob("*.parquet")) for row in pq.read_table(path).to_pylist()]
        fingerprints = lambda rows: {row["id"]: tuple(row[field] for field in SCHEMA) for row in rows}
        if len(originals) != len(all_rows) or fingerprints(originals) != fingerprints(all_rows):
            raise ValueError("Original records were lost, added or modified")
    packed = json.loads((root / "slayer_v6/manifest.json").read_text(encoding="utf-8"))
    tokenizer_file = root / "slayer_v6/tokenizer.json"
    if file_sha256(tokenizer_file) != packed["tokenizer_sha256"]:
        raise ValueError("Tokenizer checksum mismatch")
    tokenizer = Tokenizer.from_file(str(tokenizer_file))
    if tokenizer.token_to_id("<|endoftext|>") != 0 or tokenizer.get_vocab_size() != packed["vocab_size"] or packed["eos_id"] != 0 or packed["version"] != manifest["version"]:
        raise ValueError("Tokenizer or pack version mismatch")
    native_counts = {}
    for split in SPLITS:
        folder = root / "slayer_v6" / split
        token_file, index_file = folder / f"{split}.bin", folder / "docs.idx"
        expected = packed["splits"][split]
        if file_sha256(token_file) != expected["bin_sha256"] or file_sha256(index_file) != expected["idx_sha256"]:
            raise ValueError(f"Pack checksum mismatch: {split}")
        tokens = np.fromfile(token_file, dtype="<u2")
        offsets = np.fromfile(index_file, dtype="<u8")
        rows = rows_by_split[split]
        if len(offsets) != len(rows) or len(rows) != expected["documents"] or len(tokens) != expected["tokens_including_eos"]:
            raise ValueError(f"Pack length mismatch: {split}")
        if len(offsets) and (offsets[0] == 0 or np.any(offsets[1:] <= offsets[:-1]) or offsets[-1] != len(tokens)):
            raise ValueError(f"Non-monotonic or incomplete document offsets: {split}")
        if len(tokens) and int(tokens.max()) >= packed["vocab_size"]:
            raise ValueError(f"Invalid vocabulary token: {split}")
        start = 0
        for row, end in zip(rows, offsets):
            end = int(end)
            if tokens[end - 1] != 0:
                raise ValueError(f"Missing EOS: {row['id']}")
            encoded = np.asarray(tokenizer.encode(row["text"]).ids, dtype="<u2")
            if not np.array_equal(encoded, tokens[start:end - 1]):
                raise ValueError(f"Packed tokens differ from exact reencoding: {row['id']}")
            start = end
        native_counts[split] = {"documents": len(rows), "tokens_including_eos": len(tokens), "exact_reencoded_documents": len(rows)}
    artifact_paths = sorted(path for path in root.rglob("*") if path.is_file() and path.name != "validation_report.json" and ".cache" not in path.parts)
    result.update({
        "version": manifest["version"], "base_hub_revision": manifest["base_hub_revision"],
        "records_accounted_for": len(all_rows), "retained_records": retained,
        "quarantined_records": len(rows_by_split["quarantine"]),
        "cross_split_group_aliases": 0, "exact_duplicate_texts": 0,
        "baseline_all_eight_columns_preserved": baseline is not None,
        "all_proxy_token_counts_verified": True,
        "native_tokenizer_sha256": packed["tokenizer_sha256"], "native_packs": native_counts,
        "sources_by_split": source_counts,
        "artifacts": {str(path.relative_to(root)).replace("\\", "/"): file_sha256(path) for path in artifact_paths},
    })
    return result


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--root", type=Path, required=True)
    parser.add_argument("--baseline", type=Path)
    args = parser.parse_args()
    result = verify(args.root, args.baseline)
    (args.root / "provenance/validation_report.json").write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(json.dumps({key: value for key, value in result.items() if key not in ("artifacts", "sources_by_split")}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()