#!/usr/bin/env python3
"""
MCRO Tracking Dump
==================

Scan a directory of MCRO JSON files and emit a single CSV containing:

  - json_filename   (the JSON file name on disk)
  - filename        (the PDF filename from the JSON, if present)
  - case_id         (from case.case_id)
  - cluster_id      (from case.cluster_id)
  - tracking_*      (one column for every key found under data["tracking"])

This is a diagnostic tool to verify that the tracking fix process wrote
the expected values into every JSON.

Usage:
  python3 mcro_tracking_dump.py \
      --input /path/to/json_dir \
      --out tracking_dump.csv \
      [--pattern "*.json"] \
      [--recurse]
"""

import argparse
import csv
import json
from pathlib import Path
from typing import Any, Dict, List
import sys


def main():
    ap = argparse.ArgumentParser(description="Dump tracking fields from MCRO JSON files into a single CSV.")
    ap.add_argument("--input", required=True, help="Directory containing JSON files")
    ap.add_argument("--out", required=True, help="Output CSV file path")
    ap.add_argument("--pattern", default="*.json", help='Glob for JSON files (default: "*.json")')
    ap.add_argument("--recurse", action="store_true", help="Recurse into subdirectories")
    args = ap.parse_args()

    json_dir = Path(args.input)
    if not json_dir.is_dir():
        print(f"[error] Input directory does not exist or is not a directory: {json_dir}", file=sys.stderr)
        sys.exit(1)

    if args.recurse:
        files = sorted(json_dir.rglob(args.pattern))
    else:
        files = sorted(json_dir.glob(args.pattern))

    if not files:
        print(f"[warn] No JSON files matched {args.pattern} under {json_dir}", file=sys.stderr)
        sys.exit(0)

    rows: List[Dict[str, Any]] = []
    tracking_keys = set()

    # First pass: collect rows and union of all tracking keys
    for jp in files:
        try:
            data = json.loads(jp.read_text(encoding="utf-8"))
        except Exception as e:
            print(f"[warn] Skipping {jp}: failed to parse JSON ({e})", file=sys.stderr)
            continue

        if not isinstance(data, dict):
            print(f"[warn] Skipping {jp}: JSON root is not an object", file=sys.stderr)
            continue

        case = data.get("case") or {}
        tracking = data.get("tracking") or {}

        # Record which tracking keys exist at all
        for k in tracking.keys():
            tracking_keys.add(k)

        row = {
            "json_filename": jp.name,
            "filename": data.get("filename", ""),
            "case_id": case.get("case_id"),
            "cluster_id": case.get("cluster_id"),
            "_tracking": tracking,  # temp container, we'll expand later
        }
        rows.append(row)

    tracking_keys = sorted(tracking_keys)

    # Build final CSV header
    fieldnames = ["json_filename", "filename", "case_id", "cluster_id"]
    fieldnames.extend([f"tracking_{k}" for k in tracking_keys])

    out_path = Path(args.out)
    out_path.parent.mkdir(parents=True, exist_ok=True)

    with out_path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()

        for row in rows:
            tracking = row.pop("_tracking") or {}
            out_row: Dict[str, Any] = {
                "json_filename": row["json_filename"],
                "filename": row["filename"],
                "case_id": row["case_id"],
                "cluster_id": row["cluster_id"],
            }
            for k in tracking_keys:
                out_row[f"tracking_{k}"] = tracking.get(k)
            writer.writerow(out_row)

    print(f"[ok] Wrote tracking dump for {len(rows)} JSON files to: {out_path.resolve()}")


if __name__ == "__main__":
    main()