"""Freeze an independently reviewed source-training panel with immutable membership."""
from __future__ import annotations

import argparse
from dataclasses import asdict
import json
from pathlib import Path

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


def freeze_train_panel(annotations, selection, protocol, output):
    members=json.loads(Path(selection).read_text())['train']
    if not members or len(members)!=len(set(members)):
        raise ValueError('training panel must contain unique frames')
    records,assignments,_=load_protocol(protocol)
    by_id={row.frame_id:row for row in records}
    labels=load_jsonl(annotations)
    frames=[]
    forbidden={'detector','fewshot','sam3','model','segmentation'}
    for fid in members:
        row=by_id.get(fid)
        frame=labels.frames.get(fid)
        if (row is None or assignments.get(row.group_id)!='train'
                or frame is None or frame.split!='train'
                or frame.group_id!=row.group_id or frame.source_anchor_hash!=row.source_sha256
                or not is_resolved(frame,require_blind=True)
                or any(p.source.lower() in forbidden for p in frame.provenance)):
            raise ValueError(f'not an independent resolved source-training frame: {fid}')
        frames.append(frame)
    output=Path(output)
    manifest_path=output.with_suffix('.manifest.json')
    identity={'split':'train','frames':len(frames),
              'counts':{status:sum(frame.status==status for frame in frames)
                        for status in ('pos','negative','ignore')},
              'protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
              'selection_sha256':file_digest(selection),
              'source_labels_sha256':file_digest(annotations)}
    if output.exists():
        if not manifest_path.exists():
            raise ValueError('existing training panel lacks its identity manifest')
        old=json.loads(manifest_path.read_text())
        if (old!={**identity,'label_sha256':file_digest(output)}
                or {fid:asdict(frame) for fid,frame in load_jsonl(output).frames.items()}
                !={frame.frame_id:asdict(frame) for frame in frames}):
            raise ValueError('frozen training panel cannot be replaced')
        return old
    save_jsonl(AnnotationSet(frames),output)
    identity['label_sha256']=file_digest(output)
    write_json(manifest_path,identity)
    return identity


if __name__=='__main__':
    parser=argparse.ArgumentParser()
    parser.add_argument('--annotations',required=True)
    parser.add_argument('--selection',required=True)
    parser.add_argument('--protocol',default='outputs/protocol_v5')
    parser.add_argument('--output',required=True)
    args=parser.parse_args()
    print(json.dumps(freeze_train_panel(args.annotations,args.selection,args.protocol,args.output)))
