"""Plan resumable blind-review batches across a frozen protocol."""
from __future__ import annotations

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

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


def plan_queue(protocol, primary_labels, supplemental_labels, output, *, batch_limit=1024,
               inflight_selections=()):
    if batch_limit < 1 or batch_limit > 1024:
        raise ValueError('review batch limit must be between 1 and 1024 frames')
    records,assignments,_=load_protocol(protocol)
    from pallet.data.eligibility import eligible_records, exclusion_ids
    records = eligible_records(records)
    retired = exclusion_ids()
    primary=load_jsonl(primary_labels)
    supplemental=[load_jsonl(path) for path in supplemental_labels]
    waiting={split:[] for split in ('train','val','test')}
    active={split:set() for split in waiting}
    for path in inflight_selections:
        selection=json.loads(Path(path).read_text())
        ids_by_split={split:[] for split in waiting}
        if isinstance(selection,list):
            for item in selection:
                if not isinstance(item,dict) or item.get('split') not in waiting:
                    raise ValueError(f'in-flight review index is invalid: {path}')
                ids_by_split[item['split']].append(item.get('frame_id'))
        elif isinstance(selection,dict):
            ids_by_split={split:selection.get(split,[]) for split in waiting}
        else:
            raise ValueError(f'in-flight review selection is invalid: {path}')
        for split in waiting:
            ids=ids_by_split[split]
            if not isinstance(ids,list) or any(not isinstance(fid,str) for fid in ids):
                raise ValueError(f'in-flight review selection is invalid: {path}')
            if len(ids)!=len(set(ids)) or active[split] & set(ids):
                raise ValueError(f'duplicate in-flight review frame in {path}')
            active[split].update(ids)
    if any(ids & retired for ids in active.values()):
        raise ValueError('In-flight selection contains frames retired by user; regenerate from active dataset')
    resolved=Counter()
    resolved_ids={split:set() for split in waiting}
    conflicts=[]
    for row in records:
        split=assignments[row.group_id]
        frame=primary.frames.get(row.frame_id)
        if frame is None or frame.group_id!=row.group_id or frame.split!=split or frame.source_anchor_hash!=row.source_sha256:
            raise ValueError(f'primary annotation differs from frozen source: {row.frame_id}')
        valid=[]
        for source, candidate in [(str(primary_labels),frame)] + [
                (str(path),data.frames.get(row.frame_id))
                for path,data in zip(supplemental_labels,supplemental)]:
            if candidate is None or not is_resolved(candidate,require_blind=True):
                continue
            if (candidate.split!=split or candidate.group_id!=row.group_id
                    or candidate.source_anchor_hash!=row.source_sha256):
                raise ValueError(f'supplemental annotation differs from frozen source: {row.frame_id}')
            valid.append((source,candidate))
        if valid:
            digests={annotation_digest(candidate) for _,candidate in valid}
            if len(digests)>1:
                conflicts.append({'frame_id':row.frame_id,'split':split,
                                  'sources':[source for source,_ in valid],
                                  'payload_hashes':sorted(digests)})
            else:
                resolved[split]+=1
                resolved_ids[split].add(row.frame_id)
        else:
            waiting[split].append(row.frame_id)
    all_waiting={split:set(ids) for split,ids in waiting.items()}
    inflight_completed={}
    for split in waiting:
        completed=active[split] & resolved_ids[split]
        if not active[split] <= all_waiting[split] | completed:
            raise ValueError(f'in-flight selection contains resolved or non-{split} frame, or unresolved conflict')
        inflight_completed[split]=len(completed)
        active[split]-=completed
        waiting[split]=[fid for fid in waiting[split] if fid not in active[split]]
    output=Path(output)
    manifest={'protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
              'primary_labels_sha256':file_digest(primary_labels),
              'supplemental_labels_sha256':{str(path):file_digest(path)
                                             for path in supplemental_labels},
              'inflight_selections_sha256':{str(path):file_digest(path)
                                            for path in inflight_selections},
              'batch_limit':batch_limit,'resolved':dict(resolved),
              'inflight_completed':inflight_completed,
              'inflight':{split:len(ids) for split,ids in active.items()},
              'waiting':{split:len(ids) for split,ids in waiting.items()},
              'conflicts':conflicts,
              'reference_rule':'Validation/test tasks require independent blind reviews; no detector labels are accepted.'}
    selections={}
    for split,ids in waiting.items():
        for offset in range(0,len(ids),batch_limit):
            selections[f'{split}_{offset//batch_limit:03d}.json']={
                "train":ids[offset:offset+batch_limit] if split=='train' else [],
                "val":ids[offset:offset+batch_limit] if split=='val' else [],
                "test":ids[offset:offset+batch_limit] if split=='test' else []}
    if output.exists():
        manifest_path=output/'manifest.json'
        if (not manifest_path.exists() or json.loads(manifest_path.read_text())!=manifest
                or {path.name for path in output.glob('*.json') if path.name!='manifest.json'}
                !=set(selections)):
            raise ValueError('existing work queue belongs to different frozen inputs')
        for name,selection in selections.items():
            if json.loads((output/name).read_text())!=selection:
                raise ValueError(f'existing work queue selection changed: {name}')
    else:
        output.mkdir(parents=True)
        for name,selection in selections.items():
            write_json(output/name,selection)
        write_json(output/'manifest.json',manifest)
    return {'resolved':dict(resolved),'inflight_completed':inflight_completed,
            'inflight':manifest['inflight'],
            'waiting':manifest['waiting'],
            'conflicts':len(conflicts),
            'batches':{split:(len(ids)+batch_limit-1)//batch_limit
                       for split,ids in waiting.items()}}


def conflict_selection(manifest_path, protocol, output):
    """Freeze conflicting source-train frames for separate visual adjudication."""
    manifest_path=Path(manifest_path)
    manifest=json.loads(manifest_path.read_text())
    records,assignments,_=load_protocol(protocol)
    by_id={row.frame_id:row for row in records}
    if manifest['protocol_sha256']!=file_digest(Path(protocol)/'protocol.json'):
        raise ValueError('conflict queue protocol changed')
    for source,digest in manifest['supplemental_labels_sha256'].items():
        if file_digest(source)!=digest:
            raise ValueError(f'conflict queue supplemental snapshot changed: {source}')
    if manifest['conflicts']:
        primary_source=manifest['conflicts'][0]['sources'][0]
        if file_digest(primary_source)!=manifest['primary_labels_sha256']:
            raise ValueError('conflict queue primary snapshot changed')
    ids=[]
    for item in manifest['conflicts']:
        fid=item['frame_id']
        row=by_id.get(fid)
        if (row is None or item['split']!='train'
                or assignments[row.group_id]!='train'
                or len(item['sources'])<2 or len(item['payload_hashes'])<2):
            raise ValueError(f'non-training or unverifiable conflict: {fid}')
        if item['sources'][0]!=primary_source or any(
                source not in manifest['supplemental_labels_sha256']
                for source in item['sources'][1:]):
            raise ValueError(f'conflict sources differ from frozen queue: {fid}')
        ids.append(fid)
    if len(ids)!=len(set(ids)):
        raise ValueError('duplicate conflict frame')
    selection={'train':ids,'val':[],'test':[]}
    output=Path(output)
    binding={'queue_manifest_sha256':file_digest(manifest_path),
             'protocol_sha256':manifest['protocol_sha256'],'frames':len(ids),
             'purpose':'independent visual adjudication; no snapshot overwrites'}
    if output.exists() and json.loads(output.read_text())!=selection:
        raise ValueError('existing conflict selection changed')
    if output.with_suffix('.manifest.json').exists() and json.loads(output.with_suffix('.manifest.json').read_text())!=binding:
        raise ValueError('existing conflict selection binding changed')
    write_json(output,selection)
    write_json(output.with_suffix('.manifest.json'),binding)
    return binding


if __name__=='__main__':
    parser=argparse.ArgumentParser()
    parser.add_argument('--protocol',default='outputs/protocol_v5')
    parser.add_argument('--primary-labels',required=True)
    parser.add_argument('--supplemental-labels',action='append',default=[])
    parser.add_argument('--inflight-selection',action='append',default=[])
    parser.add_argument('--output',required=True)
    parser.add_argument('--batch-limit',type=int,default=1024)
    args=parser.parse_args()
    print(json.dumps(plan_queue(args.protocol,args.primary_labels,args.supplemental_labels,
                                args.output,batch_limit=args.batch_limit,
                                inflight_selections=args.inflight_selection)))
