"""Server-side preparation of the model-independent EVI core v2 data.

This command intentionally stops after building the local release and training
inputs.  It never uploads to Hugging Face and never launches a GPU training
run.  The checked-in server runbook continues from its output.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import shutil
import subprocess
import sys
import tarfile
import urllib.error
import urllib.request
import zipfile
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from pathlib import Path, PurePosixPath
from typing import IO, Any

import yaml

from ..atomic_io import atomic_write_json
from ..paths import repo_root

_CHUNK_BYTES = 8 * 1024 * 1024
_PROGRESS_BYTES = 256 * 1024 * 1024


class ServerPreparationError(RuntimeError):
    """The server cannot safely complete the registered preparation plan."""


@dataclass(frozen=True)
class ServerLayout:
    root: Path
    downloads: Path
    raw: Path
    tools: Path
    plotqa_release: Path
    release: Path
    training_inputs: Path
    gqa_image_cache: Path
    clevr_dataset_gen: Path
    blender_root: Path


def _mapping(value: Any, label: str) -> Mapping[str, Any]:
    if not isinstance(value, Mapping):
        raise ServerPreparationError(f"{label} must be a mapping")
    return value


def _load_json(path: Path) -> dict[str, Any]:
    try:
        value = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        raise ServerPreparationError(f"cannot read {path}: {exc}") from exc
    return dict(_mapping(value, str(path)))


def _load_yaml(path: Path) -> dict[str, Any]:
    try:
        value = yaml.safe_load(path.read_text(encoding="utf-8"))
    except (OSError, yaml.YAMLError) as exc:
        raise ServerPreparationError(f"cannot read {path}: {exc}") from exc
    return dict(_mapping(value, str(path)))


def _git_head(root: Path) -> str:
    completed = _run(
        ["git", "rev-parse", "HEAD"],
        cwd=root,
        capture=True,
    )
    revision = completed.stdout.strip()
    if len(revision) != 40 or any(char not in "0123456789abcdef" for char in revision):
        raise ServerPreparationError(f"repository HEAD is not a full Git revision: {revision!r}")
    return revision


def _verify_clean_master(root: Path, expected_commit: str) -> None:
    if _git_head(root) != expected_commit:
        raise ServerPreparationError("--code-commit differs from the current repository HEAD")
    branch = _run(
        ["git", "branch", "--show-current"],
        cwd=root,
        capture=True,
    ).stdout.strip()
    if branch != "master":
        raise ServerPreparationError(f"server preparation requires master, found {branch!r}")
    dirty = _run(
        ["git", "status", "--porcelain"],
        cwd=root,
        capture=True,
    ).stdout.strip()
    if dirty:
        raise ServerPreparationError("server preparation requires a clean Git checkout")


def _layout(workspace: Path, published: Mapping[str, Any], code_commit: str) -> ServerLayout:
    extracted = _mapping(published["extracted_artifacts"], "extracted_artifacts")
    release_relative = _safe_relative_path(
        str(extracted["release_directory"]),
        label="PlotQA seed release_directory",
    )
    return ServerLayout(
        root=workspace,
        downloads=workspace / "downloads",
        raw=workspace / "raw",
        tools=workspace / "tools",
        plotqa_release=workspace / "plotqa-seed" / release_relative,
        release=workspace / "releases" / f"evi-core-v2-{code_commit[:12]}",
        training_inputs=workspace / "training-inputs" / f"evi-core-v2-{code_commit[:12]}",
        gqa_image_cache=workspace / "cache" / "gqa-selected-images",
        clevr_dataset_gen=workspace / "tools" / "clevr-dataset-gen",
        blender_root=workspace / "tools" / "blender-2.79b",
    )


def _safe_relative_path(value: str, *, label: str) -> Path:
    path = PurePosixPath(value)
    if path.is_absolute() or not path.parts or any(part in {"", ".", ".."} for part in path.parts):
        raise ServerPreparationError(f"{label} is not a safe relative path: {value!r}")
    return Path(*path.parts)


def _assert_workspace_outside_repo(workspace: Path, root: Path) -> None:
    resolved = workspace.resolve()
    repository = root.resolve()
    try:
        resolved.relative_to(repository)
    except ValueError:
        return
    raise ServerPreparationError(
        f"data workspace must be outside the Git checkout so data cannot be committed: {resolved}"
    )


def _run(
    command: Sequence[str],
    *,
    cwd: Path | None = None,
    env: Mapping[str, str] | None = None,
    capture: bool = False,
) -> subprocess.CompletedProcess[str]:
    try:
        completed = subprocess.run(
            list(command),
            cwd=cwd,
            env=dict(env) if env is not None else None,
            check=False,
            text=True,
            capture_output=capture,
        )
    except OSError as exc:
        raise ServerPreparationError(f"cannot run {command[0]}: {exc}") from exc
    if completed.returncode != 0:
        details = (completed.stderr or completed.stdout or "").strip()
        if len(details) > 2000:
            details = details[-2000:]
        raise ServerPreparationError(
            f"command failed ({completed.returncode}): {' '.join(command)}"
            + (f"\n{details}" if details else "")
        )
    return completed


def _sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        while chunk := handle.read(_CHUNK_BYTES):
            digest.update(chunk)
    return digest.hexdigest()


def _verify_download(
    path: Path,
    *,
    expected_bytes: int,
    expected_sha256: str,
    label: str,
) -> None:
    if not path.is_file():
        raise ServerPreparationError(f"{label} is missing: {path}")
    actual_bytes = path.stat().st_size
    if actual_bytes != expected_bytes:
        raise ServerPreparationError(
            f"{label} byte count differs: {actual_bytes} != {expected_bytes}"
        )
    actual_sha256 = _sha256(path)
    if actual_sha256 != expected_sha256:
        raise ServerPreparationError(
            f"{label} download checksum differs: {actual_sha256} != {expected_sha256}"
        )


def _download(
    *,
    url: str,
    destination: Path,
    expected_bytes: int,
    expected_sha256: str,
    label: str,
) -> Path:
    if destination.is_file():
        _verify_download(
            destination,
            expected_bytes=expected_bytes,
            expected_sha256=expected_sha256,
            label=label,
        )
        print(f"[prepare] reuse {label}: {destination}", file=sys.stderr, flush=True)
        return destination
    destination.parent.mkdir(parents=True, exist_ok=True)
    partial = destination.with_name(destination.name + ".part")
    request = urllib.request.Request(
        url,
        headers={"User-Agent": "explicit-learning-server-prepare/1"},
    )
    written = 0
    next_progress = _PROGRESS_BYTES
    try:
        with urllib.request.urlopen(request, timeout=120) as response, partial.open("wb") as output:
            while chunk := response.read(_CHUNK_BYTES):
                output.write(chunk)
                written += len(chunk)
                if written >= next_progress:
                    print(
                        f"[prepare] {label}: {written / (1024**3):.2f} GiB",
                        file=sys.stderr,
                        flush=True,
                    )
                    next_progress += _PROGRESS_BYTES
        os.replace(partial, destination)
    except (OSError, urllib.error.URLError) as exc:
        partial.unlink(missing_ok=True)
        raise ServerPreparationError(f"cannot download {label}: {exc}") from exc
    _verify_download(
        destination,
        expected_bytes=expected_bytes,
        expected_sha256=expected_sha256,
        label=label,
    )
    return destination


def _download_plotqa_seed(
    *,
    published: Mapping[str, Any],
    destination_root: Path,
) -> Path:
    repository = _mapping(published["dataset_repository"], "dataset_repository")
    bundle = _mapping(published["bundle"], "bundle")
    relative = _safe_relative_path(str(bundle["path_in_repo"]), label="HF bundle path")
    destination_root.mkdir(parents=True, exist_ok=True)
    try:
        from huggingface_hub import hf_hub_download
    except ImportError as exc:
        raise ServerPreparationError(
            "huggingface-hub is required; install requirements/data.in"
        ) from exc
    try:
        downloaded = Path(
            hf_hub_download(
                repo_id=str(repository["repo_id"]),
                repo_type="dataset",
                filename=relative.as_posix(),
                revision=str(repository["revision"]),
                token=os.environ.get("HF_TOKEN"),
                local_dir=destination_root,
            )
        )
    except Exception as exc:
        raise ServerPreparationError(f"cannot download private PlotQA seed: {exc}") from exc
    _verify_download(
        downloaded,
        expected_bytes=int(bundle["bytes"]),
        expected_sha256=str(bundle["sha256"]),
        label="private PlotQA seed bundle",
    )
    return downloaded


def _write_stream_atomic(source: IO[bytes], destination: Path) -> None:
    destination.parent.mkdir(parents=True, exist_ok=True)
    partial = destination.with_name(destination.name + ".part")
    try:
        with partial.open("wb") as output:
            shutil.copyfileobj(source, output, length=_CHUNK_BYTES)
        os.replace(partial, destination)
    except OSError:
        partial.unlink(missing_ok=True)
        raise


def _extract_zip_members(
    archive: Path,
    destination: Path,
    members: Mapping[str, str],
) -> None:
    destination.mkdir(parents=True, exist_ok=True)
    try:
        with zipfile.ZipFile(archive) as source:
            available = set(source.namelist())
            missing = sorted(set(members) - available)
            if missing:
                raise ServerPreparationError(
                    f"{archive.name} is missing required members: {missing}"
                )
            for member_name, output_name in members.items():
                target = destination / _safe_relative_path(output_name, label="ZIP output path")
                info = source.getinfo(member_name)
                if target.is_file() and target.stat().st_size == info.file_size:
                    continue
                with source.open(info) as handle:
                    _write_stream_atomic(handle, target)
    except (OSError, zipfile.BadZipFile) as exc:
        raise ServerPreparationError(f"cannot extract {archive}: {exc}") from exc


def _extract_tar_prefix(archive: Path, destination: Path, prefix: str) -> None:
    safe_prefix = PurePosixPath(prefix)
    if safe_prefix.is_absolute() or ".." in safe_prefix.parts:
        raise ServerPreparationError(f"unsafe TAR prefix: {prefix!r}")
    found = False
    try:
        with tarfile.open(archive, mode="r:*") as source:
            for member in source:
                member_path = PurePosixPath(member.name)
                if member_path == safe_prefix:
                    relative = PurePosixPath(".")
                else:
                    try:
                        relative = member_path.relative_to(safe_prefix)
                    except ValueError:
                        continue
                found = True
                target = destination / Path(*relative.parts)
                if member.isdir():
                    target.mkdir(parents=True, exist_ok=True)
                    continue
                if not member.isfile():
                    raise ServerPreparationError(
                        f"unsupported link/device in PlotQA seed archive: {member.name}"
                    )
                handle = source.extractfile(member)
                if handle is None:
                    raise ServerPreparationError(f"cannot read TAR member: {member.name}")
                with handle:
                    _write_stream_atomic(handle, target)
    except (OSError, tarfile.TarError) as exc:
        raise ServerPreparationError(f"cannot extract {archive}: {exc}") from exc
    if not found:
        raise ServerPreparationError(f"PlotQA seed archive has no {prefix!r} subtree")


def _extract_tar_all(archive: Path, destination: Path) -> None:
    try:
        with tarfile.open(archive, mode="r:*") as source:
            for member in source:
                relative = _safe_relative_path(member.name, label="TAR member")
                target = destination / relative
                if member.isdir():
                    target.mkdir(parents=True, exist_ok=True)
                    continue
                if not member.isfile():
                    raise ServerPreparationError(
                        f"unsupported link/device in tool archive: {member.name}"
                    )
                if target.is_file() and target.stat().st_size == member.size:
                    continue
                handle = source.extractfile(member)
                if handle is None:
                    raise ServerPreparationError(f"cannot read TAR member: {member.name}")
                with handle:
                    _write_stream_atomic(handle, target)
    except (OSError, tarfile.TarError) as exc:
        raise ServerPreparationError(f"cannot extract {archive}: {exc}") from exc


def _prepare_repository(
    *,
    destination: Path,
    url: str,
    revision: str,
) -> None:
    if (destination / ".git").is_dir():
        head = _git_head(destination)
        if head == revision:
            return
        _run(["git", "fetch", "--depth", "1", "origin", revision], cwd=destination)
        _run(["git", "checkout", "--detach", revision], cwd=destination)
    elif destination.exists():
        raise ServerPreparationError(
            f"official CLEVR tool path exists but is not a Git checkout: {destination}"
        )
    else:
        destination.parent.mkdir(parents=True, exist_ok=True)
        _run(["git", "clone", "--no-checkout", url, str(destination)])
        _run(["git", "checkout", "--detach", revision], cwd=destination)
    if _git_head(destination) != revision:
        raise ServerPreparationError("official CLEVR generator did not resolve to pinned revision")


def _blender_environment(runtime_library_dir: Path | None) -> dict[str, str]:
    environment = dict(os.environ)
    if runtime_library_dir is not None:
        current = environment.get("LD_LIBRARY_PATH")
        environment["LD_LIBRARY_PATH"] = (
            f"{runtime_library_dir}{os.pathsep}{current}" if current else str(runtime_library_dir)
        )
    return environment


def _check_blender(executable: Path, runtime_library_dir: Path | None) -> None:
    if not executable.is_file():
        raise ServerPreparationError(f"Blender executable is missing: {executable}")
    try:
        completed = subprocess.run(
            [str(executable), "--version"],
            env=_blender_environment(runtime_library_dir),
            check=False,
            text=True,
            capture_output=True,
            timeout=30,
        )
    except (OSError, subprocess.TimeoutExpired) as exc:
        raise ServerPreparationError(f"cannot execute Blender 2.79b: {exc}") from exc
    if completed.returncode != 0:
        details = (completed.stderr or completed.stdout or "").strip()[-2000:]
        raise ServerPreparationError(
            "Blender 2.79b runtime check failed. Install libglu1-mesa or pass "
            f"--blender-runtime-library-dir. Details: {details}"
        )


def _validate_existing_training_inputs(path: Path) -> bool:
    manifest_path = path / "manifest.json"
    if not manifest_path.is_file():
        return False
    manifest = _load_json(manifest_path)
    expected = {
        "kind": "certified_model_independent_training_inputs",
        "trained": False,
        "group_count": 12000,
        "view_count": 46000,
        "comparison_slot_count": 46000,
        "full_only_raw_rows": 12000,
        "full_plus_intervention_raw_rows": 46000,
        "admission_mode": "structural_no_content_hash_replay",
        "reasoning_vlm_calls": 0,
        "per_example_human_decisions": 0,
    }
    if any(manifest.get(key) != value for key, value in expected.items()):
        return False
    return all(
        (path / name).is_file()
        for name in (
            "comparison-slots.jsonl",
            "full-only.raw.jsonl",
            "full-plus-intervention.raw.jsonl",
        )
    )


def _plan(
    *,
    layout: ServerLayout,
    published: Mapping[str, Any],
    resources: Mapping[str, Any],
    code_commit: str,
) -> dict[str, Any]:
    repository = _mapping(published["dataset_repository"], "dataset_repository")
    gqa = _mapping(_mapping(resources["structured_sources"], "structured_sources")["gqa"], "gqa")
    clevr = _mapping(
        _mapping(resources["structured_sources"], "structured_sources")["clevr"],
        "clevr",
    )
    return {
        "contract": "server_prepare_evi_core_v2",
        "code_commit": code_commit,
        "workspace": str(layout.root),
        "inputs": {
            "plotqa_seed": {
                "repo_id": repository["repo_id"],
                "revision": repository["revision"],
                "groups": 4000,
            },
            "gqa": {
                "revision": gqa["revision"],
                "groups": 6000,
            },
            "clevr": {
                "revision": clevr["revision"],
                "groups": 5000,
                "renderer": "official Blender 2.79b Cycles",
            },
        },
        "outputs": {
            "release": str(layout.release),
            "training_inputs": str(layout.training_inputs),
            "train_groups": 12000,
            "validation_groups": 2000,
            "certified_eval_groups": 1000,
            "views": 58000,
            "training_slots": 46000,
        },
        "reasoning_vlm_calls": 0,
        "per_example_human_decisions": 0,
        "content_hash_replay_required": False,
        "hf_upload_performed": False,
    }


def prepare_server_data(args: argparse.Namespace) -> dict[str, Any]:
    root = repo_root()
    workspace = args.workspace.resolve()
    _assert_workspace_outside_repo(workspace, root)
    resources = _load_yaml(root / "configs" / "resources.yaml")
    published = _load_json(root / "configs" / "published_release.json")
    code_commit = args.code_commit or _git_head(root)
    layout = _layout(workspace, published, code_commit)
    plan = _plan(
        layout=layout,
        published=published,
        resources=resources,
        code_commit=code_commit,
    )
    if args.dry_run:
        return plan
    _verify_clean_master(root, code_commit)

    layout.root.mkdir(parents=True, exist_ok=True)
    structured = _mapping(resources["structured_sources"], "structured_sources")
    gqa = _mapping(structured["gqa"], "structured_sources.gqa")
    gqa_archives = _mapping(gqa["source_archives"], "gqa.source_archives")
    clevr = _mapping(structured["clevr"], "structured_sources.clevr")
    clevr_archive = _mapping(clevr["no_images_archive"], "clevr.no_images_archive")
    renderer = _mapping(clevr["official_renderer"], "clevr.official_renderer")
    repositories = _mapping(resources["repositories"], "repositories")
    generator = _mapping(
        repositories[str(renderer["repository"])],
        "repositories.clevr_dataset_gen",
    )

    print("[prepare] download/extract pinned PlotQA seed", file=sys.stderr, flush=True)
    plotqa_archive = _download_plotqa_seed(
        published=published,
        destination_root=layout.downloads / "plotqa-seed",
    )
    if not (layout.plotqa_release / "manifest.json").is_file():
        release_prefix = str(
            _mapping(published["extracted_artifacts"], "extracted_artifacts")["release_directory"]
        )
        _extract_tar_prefix(
            plotqa_archive,
            layout.plotqa_release,
            release_prefix,
        )

    print("[prepare] download/extract official GQA annotations", file=sys.stderr, flush=True)
    gqa_question_spec = _mapping(gqa_archives["questions"], "GQA questions archive")
    gqa_scene_spec = _mapping(gqa_archives["scene_graphs"], "GQA scene archive")
    gqa_questions = _download(
        url=str(gqa_question_spec["url"]),
        destination=layout.downloads / "gqa" / str(gqa_question_spec["filename"]),
        expected_bytes=int(gqa_question_spec["bytes"]),
        expected_sha256=str(gqa_question_spec["sha256"]),
        label="GQA 1.2 questions",
    )
    gqa_scenes = _download(
        url=str(gqa_scene_spec["url"]),
        destination=layout.downloads / "gqa" / str(gqa_scene_spec["filename"]),
        expected_bytes=int(gqa_scene_spec["bytes"]),
        expected_sha256=str(gqa_scene_spec["sha256"]),
        label="GQA 1.2 scene graphs",
    )
    gqa_root = layout.raw / "gqa"
    _extract_zip_members(
        gqa_questions,
        gqa_root,
        {
            "train_balanced_questions.json": "train_balanced_questions.json",
            "val_balanced_questions.json": "val_balanced_questions.json",
            "readme.txt": "questions-readme.txt",
        },
    )
    _extract_zip_members(
        gqa_scenes,
        gqa_root,
        {
            "train_sceneGraphs.json": "train_sceneGraphs.json",
            "val_sceneGraphs.json": "val_sceneGraphs.json",
            "readme.txt": "scene-graphs-readme.txt",
        },
    )

    print("[prepare] download/extract official CLEVR annotations", file=sys.stderr, flush=True)
    clevr_zip = _download(
        url=str(clevr_archive["url"]),
        destination=layout.downloads / "clevr" / str(clevr_archive["filename"]),
        expected_bytes=int(clevr_archive["bytes"]),
        expected_sha256=str(clevr_archive["sha256"]),
        label="CLEVR v1 no-images annotations",
    )
    clevr_root = layout.raw / "clevr" / "CLEVR_v1.0"
    _extract_zip_members(
        clevr_zip,
        clevr_root,
        {
            "CLEVR_v1.0/questions/CLEVR_train_questions.json": (
                "questions/CLEVR_train_questions.json"
            ),
            "CLEVR_v1.0/questions/CLEVR_val_questions.json": ("questions/CLEVR_val_questions.json"),
            "CLEVR_v1.0/scenes/CLEVR_train_scenes.json": ("scenes/CLEVR_train_scenes.json"),
            "CLEVR_v1.0/scenes/CLEVR_val_scenes.json": "scenes/CLEVR_val_scenes.json",
            "CLEVR_v1.0/LICENSE.txt": "LICENSE.txt",
        },
    )

    print("[prepare] install pinned official CLEVR renderer", file=sys.stderr, flush=True)
    _prepare_repository(
        destination=layout.clevr_dataset_gen,
        url=str(generator["url"]),
        revision=str(generator["revision"]),
    )
    blender_archive = _download(
        url=str(renderer["blender_url"]),
        destination=layout.downloads / "clevr" / str(renderer["blender_archive"]),
        expected_bytes=int(renderer["blender_archive_bytes"]),
        expected_sha256=str(renderer["blender_archive_sha256"]),
        label="Blender 2.79b Linux archive",
    )
    blender_executable = layout.blender_root / "blender"
    if not blender_executable.is_file():
        _extract_tar_all(blender_archive, layout.tools)
    runtime_library_dir = (
        args.blender_runtime_library_dir.resolve()
        if args.blender_runtime_library_dir is not None
        else layout.blender_root / "lib"
    )
    _check_blender(blender_executable, runtime_library_dir)

    if layout.release.exists():
        _run(
            [
                sys.executable,
                "-m",
                "explicit_learning.cli.data",
                "validate-evi-core-release",
                "--release",
                str(layout.release),
            ],
            cwd=root,
        )
        print(f"[prepare] reuse validated release: {layout.release}", file=sys.stderr)
    else:
        print("[prepare] build PlotQA+GQA+CLEVR EVI core release", file=sys.stderr, flush=True)
        _run(
            [
                sys.executable,
                "-m",
                "explicit_learning.cli.data",
                "build-evi-core-release",
                "--plotqa-release",
                str(layout.plotqa_release),
                "--gqa-train-questions",
                str(gqa_root / "train_balanced_questions.json"),
                "--gqa-train-scene-graphs",
                str(gqa_root / "train_sceneGraphs.json"),
                "--gqa-val-questions",
                str(gqa_root / "val_balanced_questions.json"),
                "--gqa-val-scene-graphs",
                str(gqa_root / "val_sceneGraphs.json"),
                "--gqa-image-cache",
                str(layout.gqa_image_cache),
                "--clevr-train-questions",
                str(clevr_root / "questions" / "CLEVR_train_questions.json"),
                "--clevr-train-scenes",
                str(clevr_root / "scenes" / "CLEVR_train_scenes.json"),
                "--clevr-val-questions",
                str(clevr_root / "questions" / "CLEVR_val_questions.json"),
                "--clevr-val-scenes",
                str(clevr_root / "scenes" / "CLEVR_val_scenes.json"),
                "--clevr-blender-executable",
                str(blender_executable),
                "--clevr-dataset-gen-root",
                str(layout.clevr_dataset_gen),
                "--clevr-blender-runtime-library-dir",
                str(runtime_library_dir),
                "--output",
                str(layout.release),
                "--release-config",
                str(root / "configs" / "release.evi-core-v2.json"),
                "--code-commit",
                code_commit,
                "--workers",
                str(args.workers),
                "--download-workers",
                str(args.download_workers),
            ],
            cwd=root,
        )
        _run(
            [
                sys.executable,
                "-m",
                "explicit_learning.cli.data",
                "validate-evi-core-release",
                "--release",
                str(layout.release),
            ],
            cwd=root,
        )

    if layout.training_inputs.exists():
        if not _validate_existing_training_inputs(layout.training_inputs):
            raise ServerPreparationError(
                f"existing training-input directory is incomplete: {layout.training_inputs}"
            )
        print(
            f"[prepare] reuse validated training inputs: {layout.training_inputs}",
            file=sys.stderr,
        )
    else:
        print("[prepare] build 46K registered training slots", file=sys.stderr, flush=True)
        _run(
            [
                sys.executable,
                "-m",
                "explicit_learning.cli.train",
                "build-training-inputs",
                "--dataset",
                str(layout.release / "train" / "groups.jsonl"),
                "--asset-root",
                str(layout.release),
                "--release-manifest",
                str(layout.release / "manifest.json"),
                "--output-dir",
                str(layout.training_inputs),
                "--code-commit",
                code_commit,
                "--max-slots",
                "46000",
                "--workers",
                str(args.workers),
            ],
            cwd=root,
        )
    if not _validate_existing_training_inputs(layout.training_inputs):
        raise ServerPreparationError("final training-input validation failed")

    completed = {
        **plan,
        "status": "ready_for_model_dependent_server_steps",
        "release_manifest": str(layout.release / "manifest.json"),
        "training_inputs_manifest": str(layout.training_inputs / "manifest.json"),
    }
    atomic_write_json(layout.root / "server-preparation-summary.json", completed)
    return completed


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="explicit-prepare",
        description=(
            "Download the PlotQA seed and official GQA/CLEVR sources, build the local "
            "EVI core v2 release with official Blender, and create training inputs. "
            "No Hugging Face upload is performed."
        ),
    )
    parser.add_argument("--workspace", type=Path, required=True)
    parser.add_argument("--code-commit")
    parser.add_argument("--workers", type=int, default=8)
    parser.add_argument("--download-workers", type=int, default=24)
    parser.add_argument("--blender-runtime-library-dir", type=Path)
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Print the immutable plan without network, files, rendering, or training.",
    )
    return parser


def main(argv: list[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    if args.workers < 1 or args.download_workers < 1:
        print("explicit-prepare: worker counts must be positive", file=sys.stderr)
        return 2
    if args.code_commit is not None and (
        len(args.code_commit) != 40
        or any(char not in "0123456789abcdef" for char in args.code_commit)
    ):
        print("explicit-prepare: --code-commit must be a full lowercase 40-hex", file=sys.stderr)
        return 2
    try:
        result = prepare_server_data(args)
    except ServerPreparationError as exc:
        print(f"explicit-prepare: {exc}", file=sys.stderr)
        return 1
    print(json.dumps(result, sort_keys=True))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())