"""Reserve source-training sessions before fitting an annotation teacher."""
from __future__ import annotations

import argparse
from collections import defaultdict
import json
from pathlib import Path

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


def reserve_audit(protocol, subset_path, annotations_path, output, *, per_domain=2,
                  target_domain=None):
    if per_domain < 1:
        raise ValueError("per_domain must be positive")
    records, assignments, _ = load_protocol(protocol)
    subset = json.loads(Path(subset_path).read_text())
    labels = load_jsonl(annotations_path)
    train_ids = set(subset["train"])
    groups = defaultdict(list)
    domain_for_group = {}
    for row in records:
        if row.frame_id not in train_ids or row.domain == target_domain:
            continue
        if assignments[row.group_id] != "train":
            raise ValueError(f"pilot training frame has wrong split: {row.frame_id}")
        frame = labels.frames.get(row.frame_id)
        if frame is None or frame.group_id != row.group_id or frame.source_anchor_hash != row.source_sha256:
            raise ValueError(f"audit source label is missing or changed: {row.frame_id}")
        if (frame.status in {"pos", "negative"} and not frame.ignore_regions
                and is_resolved(frame)):
            groups[row.group_id].append(row.frame_id)
            domain_for_group[row.group_id] = row.domain
    by_domain = defaultdict(list)
    for group, ids in groups.items():
        by_domain[domain_for_group[group]].append((group, ids))
    if not by_domain:
        raise ValueError("no independently reviewed source training frames for audit")
    chosen = []
    for domain, candidates in sorted(by_domain.items()):
        candidates.sort(key=lambda item: (-len(item[1]), item[0]))
        dates = set()
        selected = []
        for group, ids in candidates:
            date = group.split("/", 1)[0]
            if date not in dates:
                selected.append((group, ids))
                dates.add(date)
            if len(selected) == per_domain:
                break
        for item in candidates:
            if len(selected) == per_domain:
                break
            if item not in selected:
                selected.append(item)
        if len(selected) < per_domain:
            raise ValueError(f"domain {domain} has too few independent audit groups")
        chosen.extend((domain, group, ids) for group, ids in selected)
    audit_groups = sorted(group for _, group, _ in chosen)
    audit_frame_ids = {row.frame_id for row in records if row.group_id in audit_groups}
    target_groups = {row.group_id for row in records if row.domain == target_domain}
    target_frame_ids = {row.frame_id for row in records if row.group_id in target_groups}
    teacher = {split: [fid for fid in subset[split] if fid not in
                       (audit_frame_ids if split == "train" else set()) | target_frame_ids]
               if split in {"train", "val"} else list(subset[split])
               for split in ("train", "val", "test")}
    teacher_groups = {row.group_id for row in records if row.frame_id in teacher["train"]}
    if teacher_groups.intersection(set(audit_groups) | target_groups) or not teacher["train"]:
        raise ValueError("teacher training overlaps audit groups or is empty")
    panel = {"protocol_sha256": file_digest(Path(protocol) / "protocol.json"),
             "input_labels_sha256": file_digest(annotations_path),
             "pilot_subset_sha256": file_digest(subset_path),
             "target_domain": target_domain,
             "groups": [{"domain": domain, "group_id": group,
                         "frame_ids": sorted(ids)} for domain, group, ids in chosen],
             "frame_ids": sorted(fid for _, _, ids in chosen for fid in ids),
             "instructions": "Re-review native sensor views independently in every round; model proposals and prior reviewer boxes remain hidden."}
    output = Path(output)
    output.mkdir(parents=True, exist_ok=True)
    write_json(output / "audit_groups.json", audit_groups)
    write_json(output / "teacher_subset.json", teacher)
    write_json(output / "audit_panel.json", panel)
    return {"audit_groups": len(audit_groups), "audit_frames": len(panel["frame_ids"]),
            "teacher_train_frames": len(teacher["train"]),
            "domains": sorted(by_domain)}


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--protocol", default="outputs/protocol_v5")
    parser.add_argument("--subset", required=True)
    parser.add_argument("--annotations", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--per-domain", type=int, default=2)
    parser.add_argument("--target-domain")
    args = parser.parse_args()
    print(json.dumps(reserve_audit(args.protocol, args.subset, args.annotations,
                                   args.output, per_domain=args.per_domain,
                                   target_domain=args.target_domain)))
