#!/usr/bin/env python3
"""Create the deterministic, minimal PixCell core-v1 source bundle.

This maintainer-only command is the one-time bridge from the original audited
source banks to the standalone public factory.  The produced bundle contains
only files consumed by ``build_release.py``:

* accepted-only manifests and audit reports;
* executable per-card generator programs;
* exact model and target images;
* explicit factor/parameter specifications; and
* calibration, topology, and admission evidence used by the release gate.

Historical proposals, rejected candidates, GDS intermediates, caches, and
private benchmark material are intentionally excluded.
"""

from __future__ import annotations

import argparse
import gzip
import hashlib
import io
import json
import tarfile
from pathlib import Path
from typing import Any

from _shared import LEVELS, ReleaseError, read_json, sha256_file, write_json


CORE_NAME = "core-v1"
EXPECTED_RELEASE_DIGEST = (
    "e1c509dca337ce485efcb2b35101a052e06b12331b63a2f21a36c93b3682ea89"
)
SOURCE_COMMIT = "2ab0e551fc75c2ad7087ef88ecad2b5de279704b"
BANK_NAMES = {
    "l0": "pool_v8_l0_bank",
    "l1": "pool_v8_l1_bank",
    "l2": "pool_v8_l2_bank",
    "l3": "pool_v8_l3_full120",
    "l4": "pool_v8_l4_core108",
}
EXPECTED_LEVELS = {
    "l0": {
        "rows": 177,
        "source_digest": (
            "495b2c8f4864199213a888a5f8323db08525c76213552f919e901e386784ea76"
        ),
    },
    "l1": {
        "rows": 215,
        "source_digest": (
            "30765ca9366965807b65e321a7492afe6d2f8e7ae0c9fbc3a629e4641a771bc1"
        ),
    },
    "l2": {
        "rows": 118,
        "source_digest": (
            "05737221cfc0aeb3ef08efc64504d3db031530f5cef1496a48b0239ad23d6b46"
        ),
    },
    "l3": {
        "rows": 120,
        "source_digest": (
            "aa696edde9a6bc5ee0c5275d9a7f05eed2a1bc56c600791ebb5c51a3d4953fc6"
        ),
    },
    "l4": {
        "rows": 108,
        "source_digest": (
            "8db07b0730b3864a3f864abf08eb5fcf94c144ffcea5d3224590560d429c836f"
        ),
    },
}
OPTIONAL_SIDECARS = (
    "parameters.json",
    "topology_contract.json",
    "factor_assignment.json",
    "candidate_evidence.json",
)
ARCHIVE_PAYLOAD = Path | bytes
PRIVATE_MANIFEST_KEYS = frozenset(
    {
        "proposal_workspace",
        "source_root",
        "repository_root",
    }
)


def _sha256_bytes(payload: bytes) -> str:
    return hashlib.sha256(payload).hexdigest()


def _payload_bytes(value: ARCHIVE_PAYLOAD) -> bytes:
    return value if isinstance(value, bytes) else value.read_bytes()


def _payload_size(value: ARCHIVE_PAYLOAD) -> int:
    return len(value) if isinstance(value, bytes) else value.stat().st_size


def _sanitized_manifest_bytes(value: Any) -> bytes:
    """Remove unused private workspace pointers from a public source capsule."""

    def clean(item: Any) -> Any:
        if isinstance(item, dict):
            return {
                str(key): clean(child)
                for key, child in item.items()
                if str(key) not in PRIVATE_MANIFEST_KEYS
            }
        if isinstance(item, list):
            return [clean(child) for child in item]
        return item

    return (
        json.dumps(
            clean(value),
            indent=2,
            sort_keys=True,
            ensure_ascii=True,
            allow_nan=False,
        )
        + "\n"
    ).encode("utf-8")


def _inside(root: Path, relative: str, *, label: str) -> Path:
    candidate = (root / relative).resolve()
    try:
        candidate.relative_to(root.resolve())
    except ValueError as exc:
        raise ReleaseError(f"{label} escapes source bank: {relative}") from exc
    if not candidate.is_file():
        raise ReleaseError(f"{label} does not exist: {relative}")
    return candidate


def _record_files(
    bank: Path,
    record: dict[str, Any],
) -> dict[str, Path]:
    card_relative = record.get("path")
    if not isinstance(card_relative, str):
        raise ReleaseError(f"{record.get('candidate_id')}: missing card path")
    card_dir = (bank / card_relative).resolve()
    try:
        card_dir.relative_to(bank.resolve())
    except ValueError as exc:
        raise ReleaseError(f"card path escapes bank: {card_relative}") from exc
    if not card_dir.is_dir():
        raise ReleaseError(f"missing card directory: {card_relative}")

    files = {
        "program": _inside(
            bank,
            str(record.get("program_path") or f"{card_relative}/ground_truth.py"),
            label="program",
        ),
        "model_view": _inside(
            bank,
            str(record.get("model_view_path") or f"{card_relative}/model_view.png"),
            label="model view",
        ),
        "target": _inside(
            bank,
            f"{card_relative}/device_bw.png",
            label="target",
        ),
        "calibration": _inside(
            bank,
            f"{card_relative}/calibration.json",
            label="calibration",
        ),
    }
    for filename in OPTIONAL_SIDECARS:
        path = card_dir / filename
        if path.is_file():
            files[filename.removesuffix(".json")] = path
    if not isinstance(record.get("footprint_um"), list):
        path = card_dir / "footprint.json"
        if path.is_file():
            files["footprint"] = path
    return files


def _public_role(record: dict[str, Any]) -> str:
    role = str(record.get("variation_role") or record.get("public_role") or "semantic")
    return "semantic" if role == "semantic_base" else role


def _first(record: dict[str, Any], *keys: str) -> str:
    for key in keys:
        value = record.get(key)
        if value:
            return str(value)
    return ""


def _family(level: str, record: dict[str, Any]) -> str:
    return (
        _first(record, "family", "composition_family")
        or {
            "l0": "Primitive catalog",
            "l1": "Primitive operations",
            "l2": "Composed operations",
            "l3": "Hierarchical representations",
            "l4": "Photonic components",
        }[level]
    )


def collect_source(
    source_root: Path,
) -> tuple[dict[str, ARCHIVE_PAYLOAD], dict[str, Any], dict[str, Any]]:
    """Return archive payload paths, source inventory metadata, and grammar map."""

    tasks_root = source_root / "rl" / "tasks"
    if not tasks_root.is_dir():
        raise ReleaseError(f"source root has no rl/tasks directory: {source_root}")

    payload: dict[str, ARCHIVE_PAYLOAD] = {}
    grammar_rows: list[dict[str, Any]] = []
    level_summaries: dict[str, Any] = {}
    curriculum_order = 0

    for level in LEVELS:
        bank_name = BANK_NAMES[level]
        bank = tasks_root / bank_name
        manifest_path = bank / "manifest.json"
        audit_path = bank / "audit_report.json"
        if not manifest_path.is_file() or not audit_path.is_file():
            raise ReleaseError(f"{level}: incomplete source bank at {bank}")
        manifest = read_json(manifest_path)
        audit = read_json(audit_path)
        records = manifest.get("records")
        if not isinstance(records, list):
            raise ReleaseError(f"{level}: manifest has no records")
        expected = EXPECTED_LEVELS[level]
        if len(records) != expected["rows"]:
            raise ReleaseError(
                f"{level}: row count {len(records)} != {expected['rows']}"
            )
        source_digest = manifest.get("dataset_digest_sha256")
        if source_digest != expected["source_digest"]:
            raise ReleaseError(f"{level}: source digest drift")
        if audit.get("dataset_digest_sha256") != source_digest:
            raise ReleaseError(f"{level}: manifest/audit digest mismatch")
        if "accepted_only" not in str(manifest.get("status", "")):
            raise ReleaseError(f"{level}: source bank is not accepted-only")

        prefix = Path("rl") / "tasks" / bank_name
        payload[(prefix / "manifest.json").as_posix()] = _sanitized_manifest_bytes(
            manifest
        )
        payload[(prefix / "audit_report.json").as_posix()] = audit_path
        role_counts: dict[str, int] = {}

        for record in records:
            files = _record_files(bank, record)
            for path in files.values():
                relative = path.relative_to(bank)
                payload[(prefix / relative).as_posix()] = path

            card_id = _first(record, "card_id", "candidate_id", "task_id")
            grammar_id = str(record.get("grammar_id") or card_id)
            role = _public_role(record)
            role_counts[role] = role_counts.get(role, 0) + 1
            factor_path = files.get("factor_assignment")
            parameter_path = files.get("parameters")
            grammar_rows.append(
                {
                    "id": card_id,
                    "level": level.upper(),
                    "curriculum_order": curriculum_order,
                    "concept_id": _first(
                        record,
                        "concept_id",
                        "operation_id",
                        "composition_id",
                        "identity_id",
                        "motif_id",
                        "card_id",
                        "candidate_id",
                    ),
                    "grammar_id": grammar_id,
                    "leakage_group_id": str(
                        record.get("leakage_group_id") or grammar_id
                    ),
                    "variation_role": role,
                    "family": _family(level, record),
                    "label": _first(
                        record,
                        "label",
                        "identity_label",
                        "composition_label",
                        "operation_label",
                        "concept_label",
                        "mode_label",
                    ),
                    "generator_program": (
                        prefix / files["program"].relative_to(bank)
                    ).as_posix(),
                    "factor_assignment": (
                        read_json(factor_path) if factor_path is not None else {}
                    ),
                    "parameters": (
                        read_json(parameter_path) if parameter_path is not None else {}
                    ),
                    "deterministic_seed": None,
                }
            )
            curriculum_order += 1

        level_summaries[level] = {
            "bank_name": bank_name,
            "row_count": len(records),
            "source_dataset_digest_sha256": source_digest,
            "generator_version": str(manifest.get("generator_version") or ""),
            "role_counts": dict(sorted(role_counts.items())),
        }

    inventory_entries = []
    for relative, source in sorted(payload.items()):
        source_bytes = _payload_bytes(source)
        inventory_entries.append(
            {
                "path": relative,
                "bytes": len(source_bytes),
                "sha256": _sha256_bytes(source_bytes),
            }
        )
    source_manifest = {
        "schema_version": "pixcell-core-source-v1",
        "core_name": CORE_NAME,
        "source_commit": SOURCE_COMMIT,
        "randomness": {
            "mode": "none",
            "seed": None,
            "explanation": (
                "core-v1 is an explicit deterministic enumeration; every factor "
                "assignment and executable generator program is frozen."
            ),
        },
        "bank_names": BANK_NAMES,
        "levels": level_summaries,
        "file_count": len(inventory_entries),
        "payload_bytes": sum(entry["bytes"] for entry in inventory_entries),
        "files": inventory_entries,
    }
    grammar_catalog = {
        "schema_version": "pixcell-grammar-catalog-v1",
        "core_name": CORE_NAME,
        "row_count": len(grammar_rows),
        "representation_count": len({row["grammar_id"] for row in grammar_rows}),
        "randomness": "none",
        "rows": grammar_rows,
    }
    return payload, source_manifest, grammar_catalog


def _tar_info(name: str, size: int) -> tarfile.TarInfo:
    info = tarfile.TarInfo(name=name)
    info.size = size
    info.mode = 0o644
    info.uid = 0
    info.gid = 0
    info.uname = ""
    info.gname = ""
    info.mtime = 0
    info.pax_headers = {}
    return info


def write_deterministic_archive(
    output_path: Path,
    payload: dict[str, ARCHIVE_PAYLOAD],
    source_manifest: dict[str, Any],
) -> None:
    output_path.parent.mkdir(parents=True, exist_ok=True)
    internal_manifest = (
        json.dumps(
            source_manifest,
            indent=2,
            sort_keys=True,
            ensure_ascii=True,
            allow_nan=False,
        )
        + "\n"
    ).encode("utf-8")
    with output_path.open("wb") as raw:
        with gzip.GzipFile(
            filename="",
            mode="wb",
            fileobj=raw,
            compresslevel=9,
            mtime=0,
        ) as compressed:
            with tarfile.open(
                mode="w",
                fileobj=compressed,
                format=tarfile.PAX_FORMAT,
            ) as archive:
                for relative, source in sorted(payload.items()):
                    info = _tar_info(relative, _payload_size(source))
                    if isinstance(source, bytes):
                        archive.addfile(info, io.BytesIO(source))
                    else:
                        with source.open("rb") as handle:
                            archive.addfile(info, handle)
                info = _tar_info("source_manifest.json", len(internal_manifest))
                archive.addfile(info, io.BytesIO(internal_manifest))


def pack_core_v1(
    source_root: Path,
    dataset_root: Path,
) -> dict[str, Any]:
    dataset_root = dataset_root.expanduser().resolve()
    source_root = source_root.expanduser().resolve()
    catalog = read_json(dataset_root / "metadata" / "catalog.json")
    if catalog.get("release_digest_sha256") != EXPECTED_RELEASE_DIGEST:
        raise ReleaseError("public release digest is not the frozen core-v1 digest")
    if catalog.get("total_rows") != 738:
        raise ReleaseError("public release row count is not 738")

    payload, source_manifest, grammar_catalog = collect_source(source_root)
    core_root = dataset_root / "factory" / CORE_NAME
    archive_path = core_root / "source.tar.gz"
    write_deterministic_archive(archive_path, payload, source_manifest)
    write_json(core_root / "source_manifest.json", source_manifest)
    write_json(core_root / "grammar_catalog.json", grammar_catalog)

    archive_sha = sha256_file(archive_path)
    admission_policy_path = dataset_root / "factory" / "admission_policy.json"
    if not admission_policy_path.is_file():
        raise ReleaseError("factory/admission_policy.json is missing")
    reproducibility_report_path = (
        dataset_root / "factory" / CORE_NAME / "reproducibility_report.json"
    )
    if not reproducibility_report_path.is_file():
        raise ReleaseError("core-v1 reproducibility report is missing")
    reference_paths = [
        *(f"data/{level}/train-00000-of-00001.parquet" for level in LEVELS),
        "galleries/all.png",
        *(f"galleries/{level}.png" for level in LEVELS),
        "metadata/catalog.json",
        "metadata/audit_report.json",
        *(f"metadata/source_reports/{level}.json" for level in LEVELS),
    ]
    reference_artifacts = {
        relative: sha256_file(dataset_root / relative) for relative in reference_paths
    }
    freeze = {
        "schema_version": "pixcell-core-freeze-v1",
        "core_name": CORE_NAME,
        "release_digest_sha256": EXPECTED_RELEASE_DIGEST,
        "row_count": 738,
        "representation_count": 547,
        "accepted_only": True,
        "source_commit": SOURCE_COMMIT,
        "levels": {
            level: {
                "row_count": EXPECTED_LEVELS[level]["rows"],
                "source_dataset_digest_sha256": EXPECTED_LEVELS[level]["source_digest"],
            }
            for level in LEVELS
        },
        "source_bundle": {
            "path": "factory/core-v1/source.tar.gz",
            "sha256": archive_sha,
            "bytes": archive_path.stat().st_size,
            "inventory_path": "factory/core-v1/source_manifest.json",
            "file_count": source_manifest["file_count"],
            "uncompressed_payload_bytes": source_manifest["payload_bytes"],
        },
        "grammar_catalog": {
            "path": "factory/core-v1/grammar_catalog.json",
            "sha256": sha256_file(core_root / "grammar_catalog.json"),
            "row_count": grammar_catalog["row_count"],
            "representation_count": grammar_catalog["representation_count"],
        },
        "admission_policy": {
            "path": "factory/admission_policy.json",
            "sha256": sha256_file(admission_policy_path),
        },
        "reproducibility_report": {
            "path": "factory/core-v1/reproducibility_report.json",
            "sha256": sha256_file(reproducibility_report_path),
        },
        "determinism": {
            "randomness": "none",
            "seed": None,
            "archive_metadata_normalized": True,
            "expected_logical_digest_is_mandatory": True,
            "reference_artifacts_are_platform_specific": True,
        },
        "reference_artifacts": reference_artifacts,
        "build_command": "python scripts/build_all.py",
        "validation_command": ("python scripts/validate_release.py --execute-programs"),
    }
    write_json(core_root / "freeze.json", freeze)
    return freeze


def _parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--source",
        type=Path,
        required=True,
        help="Working tree containing the five audited source banks.",
    )
    parser.add_argument(
        "--dataset-root",
        type=Path,
        default=Path(__file__).resolve().parents[1],
        help="Dataset package root (default: parent of scripts/).",
    )
    return parser


def main() -> None:
    args = _parser().parse_args()
    freeze = pack_core_v1(args.source, args.dataset_root)
    bundle = freeze["source_bundle"]
    print(
        f"packed {freeze['row_count']} rows into {bundle['file_count']} source "
        f"files; archive sha256 {bundle['sha256']}"
    )


if __name__ == "__main__":
    main()