#!/usr/bin/env python3
"""Materialize the exact SPARC VQA subset used by the released models."""

from __future__ import annotations

import argparse
import collections
import json
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq


VACANT_TASK_TYPES = {"vacant_goal", "vacant_start"}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("input", type=Path, help="Raw SPARC VQA Parquet file")
    parser.add_argument("output", type=Path, help="Filtered output Parquet file")
    parser.add_argument("--quality-threshold", type=float, default=0.97)
    parser.add_argument("--max-per-object", type=int, default=700)
    parser.add_argument("--blocked-vacant-location", action="append")
    return parser.parse_args()


def trajectory_key(source: str | None, row_metadata: dict) -> str:
    return "::".join(
        (
            source or "",
            str(row_metadata.get("trajectory_name") or ""),
            str(row_metadata.get("subtask_index") or ""),
        )
    )


def object_name(row_metadata: dict) -> str:
    task_object = row_metadata.get("task_obj_info") or {}
    if isinstance(task_object, dict):
        value = task_object.get("object") or row_metadata.get("object_phrase") or ""
    else:
        value = row_metadata.get("object_phrase") or ""
    return str(value).strip().lower() or "<unknown>"


def vacant_location(row_metadata: dict, task_type: str) -> str:
    location_key = "target_location" if task_type == "vacant_goal" else "start_location"
    task_object = row_metadata.get("task_obj_info") or {}
    if isinstance(task_object, dict):
        return str(task_object.get(location_key) or "")
    return ""


def is_blocked_vacant(row_metadata: dict, task_type: str, blocked_keywords: list[str]) -> bool:
    if task_type not in VACANT_TASK_TYPES:
        return False
    location = vacant_location(row_metadata, task_type).lower()
    return any(keyword in location for keyword in blocked_keywords)


def main() -> None:
    args = parse_args()
    blocked_keywords = [keyword.lower() for keyword in (args.blocked_vacant_location or ["gripper"])]
    parquet = pq.ParquetFile(args.input)
    candidates: list[tuple[float, int, int, str, dict, str]] = []

    for row_group_index in range(parquet.metadata.num_row_groups):
        table = parquet.read_row_group(row_group_index, columns=["metadata", "source", "task_type"])
        metadata_column = table["metadata"].to_pylist()
        source_column = table["source"].to_pylist()
        task_type_column = table["task_type"].to_pylist()
        for row_index, (metadata_string, source, task_type) in enumerate(
            zip(metadata_column, source_column, task_type_column)
        ):
            row_metadata = json.loads(metadata_string or "{}")
            selected_score = float(row_metadata.get("selected_start_score") or 0.0)
            if selected_score >= args.quality_threshold:
                candidates.append(
                    (selected_score, row_group_index, row_index, source, row_metadata, task_type)
                )
        print(
            f"Scanned row group {row_group_index + 1}/{parquet.metadata.num_row_groups}; "
            f"{len(candidates):,} examples pass the score threshold",
            flush=True,
        )

    candidates.sort(key=lambda candidate: candidate[0], reverse=True)

    kept_trajectories: set[str] = set()
    object_counts: collections.Counter[str] = collections.Counter()
    for _, _, _, source, row_metadata, _ in candidates:
        key = trajectory_key(source, row_metadata)
        if key in kept_trajectories:
            continue
        name = object_name(row_metadata)
        if object_counts[name] < args.max_per_object:
            kept_trajectories.add(key)
            object_counts[name] += 1

    selected_by_row_group: dict[int, list[int]] = collections.defaultdict(list)
    for _, row_group_index, row_index, source, row_metadata, task_type in candidates:
        if trajectory_key(source, row_metadata) in kept_trajectories and not is_blocked_vacant(
            row_metadata, task_type, blocked_keywords
        ):
            selected_by_row_group[row_group_index].append(row_index)

    selected_count = sum(len(indices) for indices in selected_by_row_group.values())
    output = args.output
    output.parent.mkdir(parents=True, exist_ok=True)
    with pq.ParquetWriter(str(output), parquet.schema_arrow, compression="snappy") as writer:
        for row_group_index in range(parquet.metadata.num_row_groups):
            row_indices = selected_by_row_group.get(row_group_index)
            if not row_indices:
                continue
            table = parquet.read_row_group(row_group_index)
            writer.write_table(table.take(pa.array(row_indices, type=pa.int64())))
            print(
                f"Wrote row group {row_group_index + 1}/{parquet.metadata.num_row_groups}; "
                f"{len(row_indices):,} selected examples",
                flush=True,
            )

    print(
        f"Wrote {selected_count:,} examples to {output} using score >= {args.quality_threshold}, "
        f"max {args.max_per_object} trajectories per object, and blocked vacant locations {blocked_keywords}",
        flush=True,
    )


if __name__ == "__main__":
    main()