"""Build a frozen source-only teacher subset after an adjudicated 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, load_protocol, write_json


def build_subset(protocol, previous_subset, round_selection, reviewed_labels,
                 audit_groups_path, output, *, target_domain=None,
                 supplemental_selection=None, exclude_frame_selection=None):
    records, assignments, _ = load_protocol(protocol)
    by_id = {row.frame_id: row for row in records}
    prior = json.loads(Path(previous_subset).read_text())
    selected = json.loads(Path(round_selection).read_text())
    labels = load_jsonl(reviewed_labels)
    audit_groups = set(json.loads(Path(audit_groups_path).read_text()))
    target_groups = {row.group_id for row in records if row.domain == target_domain}
    excluded = audit_groups | target_groups
    excluded_frames=set()
    if exclude_frame_selection:
        exclusion=json.loads(Path(exclude_frame_selection).read_text())
        ids=exclusion['train']
        if (len(ids)!=len(set(ids)) or exclusion.get('val') or exclusion.get('test')
                or any(fid not in by_id or assignments[by_id[fid].group_id]!='train' for fid in ids)):
            raise ValueError('teacher frame exclusions must contain unique source training only')
        excluded_frames=set(ids)
    supplemental = []
    if supplemental_selection:
        supplement = json.loads(Path(supplemental_selection).read_text())
        supplemental = supplement["train"]
        if not isinstance(supplemental, list) or len(supplemental) != len(set(supplemental)):
            raise ValueError("supplemental selection must contain unique training frames")
        for fid in supplemental:
            row = by_id.get(fid)
            label = labels.frames.get(fid)
            if (row is None or assignments.get(row.group_id) != "train"
                    or label is None or not is_resolved(label, require_blind=True)
                    or label.split != "train" or label.group_id != row.group_id
                    or label.source_anchor_hash != row.source_sha256):
                raise ValueError(f"invalid independently reviewed supplemental frame: {fid}")
    train = list(dict.fromkeys(prior["train"] + selected["train"] + supplemental))
    if any(fid not in by_id for fid in train):
        raise ValueError("next teacher selection contains unknown frames")
    train = [fid for fid in train if by_id[fid].group_id not in excluded and fid not in excluded_frames]
    for fid in train:
        row = by_id[fid]
        label = labels.frames.get(fid)
        if assignments[row.group_id] != "train" or label is None or not is_resolved(label):
            raise ValueError(f"unresolved or non-training teacher frame: {fid}")
        if label.group_id != row.group_id or label.source_anchor_hash != row.source_sha256:
            raise ValueError(f"teacher label source/group changed: {fid}")
    val = [fid for fid in prior["val"] if by_id[fid].group_id not in target_groups]
    if any(assignments[by_id[fid].group_id] != "val" or not is_resolved(labels.frames[fid], require_blind=True)
           for fid in val):
        raise ValueError("next teacher validation panel is not frozen and resolved")
    if not train or not val:
        raise ValueError("next teacher needs source training and validation frames")
    next_subset = {"train": train, "val": val, "test": list(prior["test"])}
    output = Path(output)
    manifest = {"protocol_sha256": file_digest(Path(protocol) / "protocol.json"),
                "previous_subset_sha256": file_digest(previous_subset),
                "round_selection_sha256": file_digest(round_selection),
                "reviewed_labels_sha256": file_digest(reviewed_labels),
                "audit_groups_sha256": file_digest(audit_groups_path),
                "supplemental_selection_sha256": file_digest(supplemental_selection)
                if supplemental_selection else None,
                "exclude_frame_selection_sha256": file_digest(exclude_frame_selection)
                if exclude_frame_selection else None,
                "excluded_source_frames": len(excluded_frames),
                "supplemental_source_frames": len(supplemental),
                "supplemental_train_frames": sum(by_id[fid].group_id not in excluded
                                                 for fid in supplemental),
                "target_domain": target_domain,
                "train_frames": len(train), "val_frames": len(val),
                "train_groups": len({by_id[fid].group_id for fid in train})}
    if output.exists() and json.loads(output.read_text())!=next_subset:
        raise ValueError('existing teacher subset differs from frozen inputs')
    if output.with_suffix('.manifest.json').exists() and json.loads(
            output.with_suffix('.manifest.json').read_text())!=manifest:
        raise ValueError('existing teacher subset binding differs from frozen inputs')
    write_json(output,next_subset)
    write_json(output.with_suffix(".manifest.json"), manifest)
    return manifest


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--protocol", default="outputs/protocol_v5")
    parser.add_argument("--previous-subset", required=True)
    parser.add_argument("--round-selection", required=True)
    parser.add_argument("--reviewed-labels", required=True)
    parser.add_argument("--audit-groups", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--target-domain")
    parser.add_argument("--supplemental-selection")
    parser.add_argument("--exclude-frame-selection")
    args = parser.parse_args()
    print(json.dumps(build_subset(args.protocol, args.previous_subset,
                                  args.round_selection, args.reviewed_labels,
                                  args.audit_groups, args.output,
                                  target_domain=args.target_domain,
                                  supplemental_selection=args.supplemental_selection,
                                  exclude_frame_selection=args.exclude_frame_selection)))
