#!/usr/bin/env python3
"""Select a moving visual source track for every Grounding DINO result."""

from __future__ import annotations

import argparse
import json
import shutil
import subprocess
import sys
from pathlib import Path


VEHICLE_SYNONYM_TERMS = [
    "car",
    "sedan",
    "taxi",
    "suv",
    "van",
    "hatchback",
    "pickup",
    "truck",
]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--jobs", type=Path, required=True)
    parser.add_argument("--selector", type=Path, required=True)
    parser.add_argument("--reselector", type=Path, required=True)
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    jobs = json.loads(args.jobs.read_text(encoding="utf-8"))["jobs"]
    results = []
    for index, job in enumerate(jobs, 1):
        source = Path(job["grounding_raw_json"])
        target = Path(job["grounding_motion_json"])
        target.parent.mkdir(parents=True, exist_ok=True)
        command = [
            sys.executable,
            str(args.selector),
            "--input", str(source),
            "--output", str(target),
            "--frames", job["frames"],
            "--min-confidence", "0.18",
            "--max-gap", "2",
            "--terms", *job["source_terms"],
        ]
        completed = subprocess.run(command, capture_output=True, text=True, check=False)
        strict_payload = None
        if completed.returncode == 0:
            strict_payload = json.loads(target.read_text(encoding="utf-8"))

        # Grounding DINO often calls vans/pickups "car", "sedan", or "taxi".
        # If the caption-derived truck/van vocabulary yields fewer than eight
        # observations (or no track), retry with a fixed visual synonym set.
        # This remains audio-blind and is a class-level rule, not a per-clip
        # score-driven exception.
        source_class = str(job.get("source_class", ""))
        should_retry_vehicle = (
            "truck_or_van" in source_class
            and (
                strict_payload is None
                or int(strict_payload["motion_track"]["selected"]["frames"]) < 8
            )
        )
        retry_payload = None
        retry_completed = None
        retry_target = target.parent / "vehicle_synonym_retry" / target.name
        if should_retry_vehicle:
            retry_completed = subprocess.run(
                [
                    sys.executable,
                    str(args.selector),
                    "--input", str(source),
                    "--output", str(retry_target),
                    "--frames", job["frames"],
                    "--min-confidence", "0.18",
                    "--max-gap", "2",
                    "--terms", *VEHICLE_SYNONYM_TERMS,
                ],
                capture_output=True,
                text=True,
                check=False,
            )
            if retry_completed.returncode == 0:
                retry_payload = json.loads(retry_target.read_text(encoding="utf-8"))

        use_retry = retry_payload is not None and (
            strict_payload is None
            or int(retry_payload["motion_track"]["selected"]["frames"])
            > int(strict_payload["motion_track"]["selected"]["frames"])
        )

        if use_retry:
            payload = retry_payload
            payload["selection_mode"] = "dominant_motion_track_vehicle_synonyms"
            payload["motion_track"]["vehicle_synonym_retry"] = True
            target.write_text(
                json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
                encoding="utf-8",
            )
            retry_sheet = retry_target.parent / "grounding_contact_sheet.jpg"
            if retry_sheet.exists():
                shutil.copy2(retry_sheet, target.parent / "grounding_contact_sheet.jpg")
            selected = payload["motion_track"]["selected"]
            results.append({
                "rank": job["rank"], "clip_id": job["clip_id"],
                "mode": "motion_track_vehicle_synonyms",
                "track_frames": selected["frames"], "track_motion": selected["motion"],
            })
        elif strict_payload is not None:
            payload = strict_payload
            selected = payload["motion_track"]["selected"]
            results.append({
                "rank": job["rank"], "clip_id": job["clip_id"], "mode": "motion_track",
                "track_frames": selected["frames"], "track_motion": selected["motion"],
            })
        else:
            fallback = subprocess.run(
                [
                    sys.executable,
                    str(args.reselector),
                    "--input", str(source),
                    "--output", str(target),
                    "--terms", *job["source_terms"],
                    "--mode", "dominant",
                ],
                capture_output=True,
                text=True,
                check=False,
            )
            if fallback.returncode != 0:
                raise RuntimeError(
                    f"motion selector and caption-type fallback both failed for {job['clip_id']}: "
                    f"{(fallback.stderr or fallback.stdout)[-1200:]}"
                )
            payload = json.loads(target.read_text(encoding="utf-8"))
            payload["selection_mode"] = "dominant_per_frame_fallback"
            payload["motion_track"] = {
                "audio_used": False,
                "fallback": True,
                "error": (completed.stderr or completed.stdout)[-1200:],
                "terms": job["source_terms"],
            }
            target.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
            results.append({
                "rank": job["rank"], "clip_id": job["clip_id"], "mode": "fallback",
                "track_frames": sum(frame.get("source") is not None for frame in payload["frames"]),
                "error": payload["motion_track"]["error"],
            })
        print(f"[{index:03d}/{len(jobs)}] #{job['rank']:03d} {results[-1]['mode']} frames={results[-1]['track_frames']}", flush=True)
    summary = {
        "schema": "spatial_alignment.fullband100_motion_tracks.v1",
        "clips": len(results),
        "motion_tracks": sum(row["mode"].startswith("motion_track") for row in results),
        "vehicle_synonym_retries": sum(
            row["mode"] == "motion_track_vehicle_synonyms" for row in results
        ),
        "fallbacks": sum(row["mode"] == "fallback" for row in results),
        "results": results,
    }
    (args.jobs.parent / "motion_track_summary.json").write_text(
        json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
    )
    print(json.dumps({key: summary[key] for key in ("clips", "motion_tracks", "fallbacks")}, indent=2))


if __name__ == "__main__":
    main()