#!/usr/bin/env python3
"""Materialize selected GLB files from a mounted source tree."""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import shutil
from pathlib import Path
from typing import Any, Iterator

def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open('rb') as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
            digest.update(chunk)
    return digest.hexdigest()

def iter_records(manifest: Path) -> Iterator[dict[str, Any]]:
    with manifest.open('r', encoding='utf-8') as handle:
        for line_no, line in enumerate(handle, 1):
            if not line.strip():
                continue
            try:
                record = json.loads(line)
            except json.JSONDecodeError as exc:
                raise RuntimeError(f'{manifest}:{line_no}: invalid JSON: {exc}') from exc
            yield record

def resolve_source(source_root: Path, relative_path: str) -> Path:
    relative = Path(relative_path)
    if relative.is_absolute() or '..' in relative.parts:
        raise RuntimeError(f'unsafe manifest path: {relative_path}')
    candidates = [source_root / relative]
    if relative.parts and relative.parts[0] == 'meshes':
        candidates.append(source_root / Path(*relative.parts[1:]))
    for candidate in candidates:
        if candidate.is_file():
            return candidate
    raise FileNotFoundError(f'source mesh not found for {relative_path}')

def materialize_record(record: dict[str, Any], source_root: Path, output_root: Path, verify_only: bool) -> tuple[int, int]:
    group_key = record.get('group_key')
    stages = record.get('stages')
    if not isinstance(group_key, str) or not isinstance(stages, list):
        raise RuntimeError('manifest record is missing group_key or stages')
    copied = 0
    for stage in stages:
        mesh = stage.get('mesh') if isinstance(stage, dict) else None
        if not isinstance(mesh, dict):
            raise RuntimeError(f'missing mesh metadata for {group_key}')
        relative_path = mesh.get('path')
        expected = mesh.get('sha256')
        if not isinstance(relative_path, str) or not isinstance(expected, str):
            raise RuntimeError(f'invalid mesh metadata for {group_key}')
        source = resolve_source(source_root, relative_path)
        actual = sha256_file(source)
        if actual != expected:
            raise RuntimeError(f'checksum mismatch for {relative_path}: expected {expected}, got {actual}')
        if not verify_only:
            destination = output_root / relative_path
            destination.parent.mkdir(parents=True, exist_ok=True)
            temporary = destination.with_name(destination.name + '.partial')
            with source.open('rb') as src, temporary.open('wb') as dst:
                shutil.copyfileobj(src, dst, length=1024 * 1024)
            os.replace(temporary, destination)
        copied += 1
    return 1, copied

def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--manifest', type=Path, required=True, help='Sanitized EVA01-Edit three-stage JSONL manifest')
    parser.add_argument('--source-root', type=Path, required=True, help='Mounted source mesh root or its parent dataset root')
    parser.add_argument('--output-root', type=Path, default=Path('.'), help='Output dataset root')
    parser.add_argument('--group-key', action='append', help='Materialize only this group; may be repeated')
    parser.add_argument('--max-groups', type=int, help='Stop after this many selected groups')
    parser.add_argument('--verify-only', action='store_true', help='Verify source existence and checksums without copying')
    args = parser.parse_args()
    if args.max_groups is not None and args.max_groups < 1:
        parser.error('--max-groups must be positive')
    selected = set(args.group_key or [])
    groups, meshes = 0, 0
    for record in iter_records(args.manifest):
        group_key = record.get('group_key')
        if selected and group_key not in selected:
            continue
        if args.max_groups is not None and groups >= args.max_groups:
            break
        group_count, mesh_count = materialize_record(record, args.source_root, args.output_root, args.verify_only)
        groups += group_count
        meshes += mesh_count
    if selected and groups != len(selected):
        missing = sorted(selected - {r.get('group_key') for r in iter_records(args.manifest)})
        raise RuntimeError(f'requested group(s) were not found: {missing}')
    print(json.dumps({'groups': groups, 'mesh_files': meshes, 'verify_only': args.verify_only}, indent=2))

if __name__ == '__main__':
    main()