from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path
from typing import Any

import pyarrow as pa
import pyarrow.parquet as pq

from perception_states import (
    LOCK_PATH,
    _load_episode,
    discover_robot_episodes,
    load_source_lock,
    normalize_episode,
)


def state_type() -> pa.DataType:
    return pa.struct(
        [
            ("robot_family", pa.string()),
            ("source_dataset", pa.string()),
            ("source_revision", pa.string()),
            ("source_episode_index", pa.int64()),
            ("fps", pa.float64()),
            ("num_frames", pa.int64()),
            ("frame_index", pa.list_(pa.int64())),
            ("timestamp_sec", pa.list_(pa.float64())),
            ("primary_channel", pa.string()),
            (
                "channels",
                pa.list_(
                    pa.struct(
                        [
                            ("name", pa.string()),
                            ("value_names", pa.list_(pa.string())),
                            ("values", pa.list_(pa.list_(pa.float64()))),
                        ]
                    )
                ),
            ),
        ]
    )


def collect_states(lock_path: Path, cache_dir: Path | None) -> dict[str, dict[str, Any]]:
    lock = load_source_lock(lock_path)
    states: dict[str, dict[str, Any]] = {}
    for episode in discover_robot_episodes(lock, cache_dir):
        table, feature_info = _load_episode(episode, cache_dir)
        row = normalize_episode(table, episode, feature_info)
        bench_id = row.pop("bench_id")
        states[bench_id] = row
    return states


def embed_perception_states(
    input_path: Path,
    output_path: Path,
    *,
    lock_path: Path = LOCK_PATH,
    cache_dir: Path | None = None,
) -> dict[str, Any]:
    if input_path.resolve() == output_path.resolve():
        raise ValueError("Input and output paths must differ")

    states = collect_states(lock_path, cache_dir)
    source = pq.ParquetFile(input_path)
    if "perception_state" in source.schema_arrow.names:
        raise ValueError("Input already contains perception_state")
    if source.metadata.num_rows != 100:
        raise ValueError(f"Expected 100 benchmark rows, found {source.metadata.num_rows}")

    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_schema = source.schema_arrow.append(pa.field("perception_state", state_type()))
    matched: set[str] = set()
    video_only: list[str] = []
    with pq.ParquetWriter(output_path, output_schema, compression="zstd") as writer:
        for batch in source.iter_batches(batch_size=1):
            table = pa.Table.from_batches([batch])
            bench_id = str(table["id"][0].as_py())
            state = states.get(bench_id)
            if state is None:
                video_only.append(bench_id)
            else:
                matched.add(bench_id)
            enriched = table.append_column(
                "perception_state", pa.array([state], type=state_type())
            )
            writer.write_table(enriched, row_group_size=1)

    missing = set(states) - matched
    if missing:
        output_path.unlink(missing_ok=True)
        raise ValueError(f"State IDs absent from benchmark: {sorted(missing)}")
    if len(matched) != 75 or len(video_only) != 25:
        output_path.unlink(missing_ok=True)
        raise ValueError(
            f"Expected 75 state rows and 25 video-only rows, got {len(matched)} and {len(video_only)}"
        )

    provenance = {
        "schema_version": 1,
        "artifact": output_path.name,
        "input_sha256": _sha256(input_path),
        "output_sha256": _sha256(output_path),
        "source_lock": lock_path.name,
        "source_lock_sha256": _sha256(lock_path),
        "rows": source.metadata.num_rows,
        "robot_state_rows": len(matched),
        "video_only_rows": len(video_only),
        "video_only_ids": video_only,
    }
    provenance_path = output_path.with_suffix(output_path.suffix + ".provenance.json")
    provenance_path.write_text(json.dumps(provenance, indent=2) + "\n", encoding="utf-8")
    return provenance


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


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Embed pinned robot proprioception into existing WGO-Bench rows."
    )
    parser.add_argument("input", type=Path)
    parser.add_argument("output", type=Path)
    parser.add_argument("--lock", type=Path, default=LOCK_PATH)
    parser.add_argument("--cache-dir", type=Path)
    args = parser.parse_args()
    result = embed_perception_states(
        args.input,
        args.output,
        lock_path=args.lock,
        cache_dir=args.cache_dir,
    )
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()