"""Summarize coverage and produce a prioritized review queue."""

from __future__ import annotations

from collections import Counter, defaultdict
import json
from pathlib import Path

from pallet.annotation import load_jsonl, qa_report, is_resolved, reference_eligible


def summarize(annotation_path, *, output="outputs/progress.json", queue_path="outputs/review_queue.jsonl"):
    dataset = load_jsonl(annotation_path)
    unresolved_ids = {frame.frame_id for frame in dataset.unresolved()}

    def resolved(frame):
        return is_resolved(frame, require_blind=frame.split in {'val','test'})

    status_by_split = defaultdict(Counter)
    group_by_split = defaultdict(set)
    fewshot = 0
    queue = []
    for frame in dataset.frames.values():
        split = frame.split or "unassigned"
        status_by_split[split][frame.status] += 1
        group_by_split[split].add(frame.group_id)
        has_fewshot = any(source.source == "fewshot" for source in frame.provenance)
        fewshot += has_fewshot
        if frame.frame_id not in unresolved_ids:
            continue
        # Held-out references are blind; known low-quality propagation domains
        # receive priority before easier training proposals.
        priority = 0 if split in {"val", "test"} else (
            1 if frame.dimensions_pending else
            2 if has_fewshot and frame.domain.startswith("352x264") else
            3 if has_fewshot else 4)
        queue.append({"frame_id": frame.frame_id, "split": split,
                      "group_id": frame.group_id, "domain": frame.domain,
                      "source_view": frame.image,
                      "blind_review_required": split in {"val", "test"},
                      "candidate_available": has_fewshot,
                      "dimensions_pending": frame.dimensions_pending,
                      "priority": priority})
    queue.sort(key=lambda item: (item["priority"], item["domain"], item["group_id"], item["frame_id"]))
    output_path = Path(output)
    queue_file = Path(queue_path)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    queue_file.parent.mkdir(parents=True, exist_ok=True)
    queue_file.write_text("".join(json.dumps(row) + "\n" for row in queue), encoding="utf-8")
    result = {"reference": "machine-reviewed annotations, not human ground truth",
              "annotations": str(Path(annotation_path).resolve()),
              "frames": len(dataset.frames),
              "status_by_split": {split: dict(counts) for split, counts in status_by_split.items()},
              "groups_by_split": {split: len(groups) for split, groups in group_by_split.items()},
              "fewshot_candidate_frames": fewshot,
              "queued_for_review": len(queue),
              "quality": qa_report(dataset),
              "ready_for_training": all(any(frame.split == split and frame.status in {"pos", "negative"}
                                            and resolved(frame)
                                            for frame in dataset.frames.values())
                                        for split in ("train", "val")),
              "ready_for_final_evaluation": not any(not resolved(frame) and frame.split == "test"
                                                    for frame in dataset.frames.values())}
    output_path.write_text(json.dumps(result, indent=2), encoding="utf-8")
    return result


if __name__ == "__main__":
    print(json.dumps(summarize("outputs/annotations_reviewed_v2.jsonl"), ensure_ascii=False))
