"""Bind a fresh source-training audit to an annotation round."""
from __future__ import annotations

import argparse
import json
from pathlib import Path

from pallet.annotation.workflow import is_resolved, load_jsonl
from pallet.data.protocol import file_digest, write_json


def create_report(round_dir, panel_path, reviewed_labels, output):
    round_dir = Path(round_dir)
    state = json.loads((round_dir / "round.json").read_text())
    panel = json.loads(Path(panel_path).read_text())
    if state["state"] != "awaiting_review":
        raise ValueError("round is not awaiting review")
    if panel["protocol_sha256"] != state["protocol_sha256"] or panel["input_labels_sha256"] != state["input_labels_sha256"]:
        raise ValueError("audit panel is not bound to this round protocol and input labels")
    if set(group["group_id"] for group in panel["groups"]) != set(state["audit_groups"]):
        raise ValueError("audit panel groups differ from reserved round groups")
    before = load_jsonl(state["input_labels"])
    after = load_jsonl(reviewed_labels)
    old_reviewers = {}
    fresh_reviewers = {}
    for fid in panel["frame_ids"]:
        previous = before.frames[fid]
        current = after.frames[fid]
        if previous.group_id not in state["audit_groups"] or previous.group_id != current.group_id:
            raise ValueError(f"audit frame escaped reserved groups: {fid}")
        if not is_resolved(previous, require_blind=True) or not is_resolved(current, require_blind=True):
            raise ValueError(f"audit frame is not independently resolved: {fid}")
        old = {review.reviewer for review in previous.reviews}
        new = {review.reviewer for review in current.reviews} - old
        if len(new) < 2:
            raise ValueError(f"audit frame lacks fresh independent reviewers: {fid}")
        old_reviewers[fid] = sorted(old)
        fresh_reviewers[fid] = sorted(new)
    report = {"round_id": state["round_id"],
              "protocol_sha256": state["protocol_sha256"],
              "frame_ids": sorted(panel["frame_ids"]),
              "audit_groups": state["audit_groups"],
              "before_labels": state["input_labels"],
              "before_labels_sha256": file_digest(state["input_labels"]),
              "after_labels": str(Path(reviewed_labels).resolve()),
              "after_labels_sha256": file_digest(reviewed_labels),
              "panel_sha256": file_digest(panel_path),
              "prior_reviewers": old_reviewers,
              "fresh_reviewers": fresh_reviewers}
    write_json(output, report)
    return report


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--round", required=True)
    parser.add_argument("--panel", required=True)
    parser.add_argument("--reviewed-labels", required=True)
    parser.add_argument("--output", required=True)
    args = parser.parse_args()
    result = create_report(args.round, args.panel, args.reviewed_labels, args.output)
    print(json.dumps({"round_id": result["round_id"],
                      "audit_frames": len(result["frame_ids"]),
                      "output": args.output}))
