"""Freeze an explicitly scoped reviewed stage before launching a pilot run."""
from __future__ import annotations

import argparse
from collections import Counter
import json
from pathlib import Path
import shutil

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


def freeze_stage(annotations,protocol,output,*,training_batches=30,review_dir='outputs/review_v3'):
    output=Path(output)
    if (output/'stage.json').exists():
        state=json.loads((output/'stage.json').read_text())
        if file_digest(output/'annotations.jsonl')!=state['annotation_sha256']:
            raise ValueError('frozen stage labels changed')
        return state
    labels=load_jsonl(annotations)
    pilot=json.loads((Path(protocol)/'pilot.json').read_text())
    allowed=set(pilot['train'])
    selected=[]
    for i in range(training_batches):
        task=json.loads((Path(review_dir)/'tasks'/f'train_{i:03d}.json').read_text())
        selected.extend(f['frame_id'] for f in task['frames'] if f['frame_id'] in allowed)
    if training_batches==30:
        selected=list(pilot['train'])
    subset={'train':selected,'val':pilot['val'],'test':pilot['test']}
    for split in ('train','val'):
        missing=[fid for fid in subset[split] if not is_resolved(labels.frames[fid],require_blind=split=='val')]
        if missing:raise ValueError(f'{split} stage unresolved: {len(missing)} frames, first={missing[:3]}')
    resolved_train=[labels.frames[fid] for fid in selected if labels.frames[fid].status in {'pos','negative'}
                    and not labels.frames[fid].ignore_regions]
    counts=Counter(f.status for f in resolved_train)
    if not counts['pos'] or not counts['negative']:
        raise ValueError('pilot training requires actual positive and negative references')
    output.mkdir(parents=True,exist_ok=True)
    shutil.copyfile(annotations,output/'annotations.jsonl')
    write_json(output/'subset.json',subset)
    state={'stage':'full_pilot' if training_batches==30 else 'preliminary_learning_check',
           'training_batches':training_batches,'train_requested':len(selected),'train_scored':len(resolved_train),
           'train_counts':dict(counts),'validation_requested':len(pilot['val']),
           'groups':len({f.group_id for f in resolved_train}),
           'annotation_sha256':file_digest(output/'annotations.jsonl'),
           'protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
           'subset_sha256':file_digest(output/'subset.json'),
           'test_scoring_authorized_in_this_stage':False}
    write_json(output/'stage.json',state)
    return state


if __name__=='__main__':
    parser=argparse.ArgumentParser();parser.add_argument('--annotations',required=True)
    parser.add_argument('--protocol',default='outputs/protocol_v5');parser.add_argument('--output',required=True)
    parser.add_argument('--training-batches',type=int,default=30);args=parser.parse_args()
    print(json.dumps(freeze_stage(args.annotations,args.protocol,args.output,training_batches=args.training_batches)))
