"""Validate independent review batches, route disagreement, emit immutable labels."""
from __future__ import annotations

import argparse
from copy import deepcopy
import hashlib
import json
from pathlib import Path

import numpy as np
from PIL import Image
from scipy.optimize import linear_sum_assignment

from pallet.annotation import (Box, Review, SceneAttributes, is_resolved, load_jsonl,
                               record_review, save_jsonl, qa_report)
from pallet.audit_proposals import iou_xywh
from pallet.data.protocol import file_digest, write_json
from pallet.review_batches import display


def _canonical(value):
    return json.dumps(value, sort_keys=True, separators=(',',':'),ensure_ascii=False)


def _validate_review(task, review):
    if review['task_id'] != task['task_id'] or not review.get('blind'):
        raise ValueError('review task mismatch or non-blind review')
    entries = {entry['index']: entry for entry in review['frames']}
    if len(entries) != len(task['frames']) or set(entries) != set(range(len(task['frames']))):
        raise ValueError('review must cover each task frame exactly once')
    for row in task['frames']:
        item = entries[row['index']]
        if item['status'] not in {'pos','negative','ignore'}:
            raise ValueError(f"invalid status at {row['index']}")
        if bool(item['boxes']) != (item['status']=='pos'):
            raise ValueError(f"status/boxes inconsistent at {row['index']}")
        if item['status']=='ignore' and not item.get('reason','').strip():
            raise ValueError('ignore requires an evidence-based reason')
        for values in item['boxes']:
            Box(*values).validate(row['width'],row['height'])
    return entries


def _consensus(a,b):
    if a['status']!=b['status'] or len(a['boxes'])!=len(b['boxes']):
        return None
    if a.get('uncertainty')=='high' or b.get('uncertainty')=='high':
        return None
    aa=a['boxes'];bb=b['boxes']
    if aa:
        scores=np.array([[iou_xywh(x,y) for y in bb] for x in aa])
        benefit=(scores>=.85).astype(float)+scores*(scores>=.85)/(min(scores.shape)+1)
        rows,cols=linear_sum_assignment(-benefit)
        if any(scores[row,col]<.85 for row,col in zip(rows,cols)):
            return None
        paired=sorted(((aa[row],bb[col]) for row,col in zip(rows,cols)),key=lambda pair:pair[0])
    else:
        paired=[]
    return {'status':a['status'], 'boxes':[[float((p+q)/2) for p,q in zip(x,y)] for x,y in paired],
            'tags':sorted(set(a.get('tags',[])) & set(b.get('tags',[]))),
            'reason':'Deterministic consensus: matching counts/status and each paired box IoU >=0.85; neither reviewer high uncertainty.'}


def ingest(directory='outputs/review_v3', base='outputs/protocol_v5/annotations_unreviewed.jsonl',
           *, side_a='a', side_b='b', adjudicator_side='c'):
    if len({side_a, side_b, adjudicator_side}) != 3 or not all(
            side.isidentifier() for side in (side_a, side_b, adjudicator_side)):
        raise ValueError('review role prefixes must be distinct identifiers')
    directory=Path(directory)
    dataset=load_jsonl(base)
    stats={'paired_batches':0,'consensus_frames':0,'adjudicated_frames':0,'pending_adjudication':0,
           'superseded_frame_ids':[],'errors':[]}
    dependencies={str(base):file_digest(base), 'ingester_code':file_digest(__file__),
                  'review_schema_code':file_digest(Path(__file__).parent/'annotation/workflow.py')}
    for task_path in sorted((directory/'tasks').glob('*.json')):
        task=json.loads(task_path.read_text());tid=task['task_id']
        paths=[directory/'reviews'/f'{side}_{tid}.json' for side in (side_a,side_b)]
        if not all(path.exists() for path in paths):
            continue
        try:
            task_frames={row['frame_id']:deepcopy(dataset.frames[row['frame_id']])
                         for row in task['frames']}
            batch_counts={'consensus_frames':0,'adjudicated_frames':0}
            superseded=[]
            batch_dependencies={}
            a,b=[json.loads(path.read_text()) for path in paths]
            aa,bb=_validate_review(task,a),_validate_review(task,b)
            if a['reviewer']==b['reviewer']:
                raise ValueError('reviewers are not independent')
            pair_hash=hashlib.sha256((_canonical(a)+_canonical(b)+file_digest(task_path)).encode()).hexdigest()
            for path in [task_path,*paths]:batch_dependencies[str(path)]=file_digest(path)
            cpath=directory/'reviews'/f'{adjudicator_side}_{tid}.json'
            cc={}
            if cpath.exists():
                c=json.loads(cpath.read_text())
                if c.get('review_pair_sha256')==pair_hash and c.get('blind_to_detector'):
                    cc={item['index']:item for item in c['frames']}
                    batch_dependencies[str(cpath)]=file_digest(cpath)
            disputes=[]
            for task_frame in task['frames']:
                index=task_frame['index'];frame=task_frames[task_frame['frame_id']]
                if frame.source_anchor_hash!=task_frame['source_anchor_hash']:
                    raise ValueError('review source changed')
                if frame.group_id!=task_frame['group_id'] or (frame.width,frame.height)!=(task_frame['width'],task_frame['height']):
                    raise ValueError('review grouping or native grid changed')
                if frame.split!=task_frame['split']:
                    superseded.append(frame.frame_id)
                    continue
                for name,digest in task_frame['views_sha256'].items():
                    path=Path(task_frame['intensity']).parent/name
                    if file_digest(path)!=digest:raise ValueError(f'review image changed: {path}')
                    with Image.open(path) as view:
                        if view.size!=(frame.width,frame.height):
                            raise ValueError(f'review image grid differs from frozen annotation: {path}')
                decision=_consensus(aa[index],bb[index])
                consensus=decision is not None
                actor=f'consensus-policy-v1-{pair_hash[:12]}'
                if decision is None and index in cc:
                    decision=cc[index]
                    actor=c.get('reviewer','independent-adjudicator')
                    if actor in {a['reviewer'],b['reviewer']}:
                        raise ValueError('adjudicator must be distinct')
                if decision is None:
                    extra=deepcopy(task_frame)
                    extra['review_a']=aa[index];extra['review_b']=bb[index]
                    cache_index=json.loads((directory/'cache_index.json').read_text())
                    if frame.frame_id in cache_index:
                        with np.load(cache_index[frame.frame_id],allow_pickle=False) as data:
                            array=data['frame']
                            linear=Path(extra['intensity']).with_name('intensity_linear.png')
                            if not linear.exists():Image.fromarray(display(array[...,1],array[...,3])).save(linear)
                            extra['intensity_linear']=str(linear)
                    disputes.append(extra)
                    continue
                if decision['status'] not in {'pos','negative','ignore'} or bool(decision['boxes'])!=(decision['status']=='pos'):
                    raise ValueError('invalid adjudicated status/boxes')
                for coords in decision['boxes']:Box(*coords).validate(frame.width,frame.height)
                for coords in decision.get('ignore_regions',[]):Box(*coords).validate(frame.width,frame.height)
                ids=[]
                for reviewer,entry in ((a['reviewer'],aa[index]),(b['reviewer'],bb[index])):
                    scene=SceneAttributes(domain=frame.domain,tags=tuple(entry.get('tags',[])))
                    review_id=hashlib.sha256(f'{pair_hash}:{frame.frame_id}:{reviewer}:proposal'.encode()).hexdigest()
                    record_review(frame,Review(reviewer,'needs_work',note=entry.get('reason',''),blind=True,review_id=review_id),
                                  status=entry['status'],boxes=[Box(*xywh) for xywh in entry['boxes']],scene=scene)
                    ids.append(frame.reviews[-1].review_id)
                final_id=hashlib.sha256(f'{pair_hash}:{frame.frame_id}:{actor}:{_canonical(decision)}'.encode()).hexdigest()
                record_review(frame,Review(actor,'adjudicate',note=decision.get('reason',''),blind=True,review_id=final_id,
                                          adjudicates=tuple(ids)),status=decision['status'],
                              boxes=[Box(*xywh) for xywh in decision['boxes']],
                              scene=SceneAttributes(domain=frame.domain,tags=tuple(decision.get('tags',[]))),
                              ignore_regions=[Box(*xywh) for xywh in decision.get('ignore_regions',[])])
                if not is_resolved(frame,require_blind=frame.split in {'val','test'}):
                    raise ValueError('adjudication failed final binding')
                batch_counts['consensus_frames' if consensus else 'adjudicated_frames']+=1
            if disputes:
                write_json(directory/'adjudication_tasks'/f'{tid}.json',{
                    'task_id':tid,'review_pair_sha256':pair_hash,
                    'instructions':'Resolve independent reviewers using original native sensor images. No fitted detector predictions are supplied. Pixel xywh, exclude cargo/forks; unclear target identity => ignore with reason, never forced positive/negative.',
                    'frames':disputes})
            dataset.frames.update(task_frames)
            dependencies.update(batch_dependencies)
            stats['superseded_frame_ids'].extend(superseded)
            stats['consensus_frames']+=batch_counts['consensus_frames']
            stats['adjudicated_frames']+=batch_counts['adjudicated_frames']
            stats['pending_adjudication']+=len(disputes)
            stats['paired_batches']+=1
        except Exception as exc:
            stats['errors'].append({'task_id':tid,'error':str(exc)})
    revision=hashlib.sha256(_canonical(dependencies).encode()).hexdigest()[:20]
    output=directory/'labels'/f'{revision}.jsonl'
    if output.exists():
        temporary=output.with_suffix('.verify.jsonl')
        save_jsonl(dataset,temporary)
        if file_digest(temporary)!=file_digest(output):
            temporary.unlink()
            raise ValueError('same review dependency fingerprint produced different labels')
        temporary.unlink()
    else:
        save_jsonl(dataset,output)
    stats.update(annotation_path=str(output.resolve()),dependencies=dependencies,quality=qa_report(dataset))
    write_json(directory/'latest.json',stats)
    return stats


if __name__=='__main__':
    parser=argparse.ArgumentParser();parser.add_argument('--directory',default='outputs/review_v3')
    parser.add_argument('--base',default='outputs/protocol_v5/annotations_unreviewed.jsonl')
    parser.add_argument('--side-a',default='a')
    parser.add_argument('--side-b',default='b')
    parser.add_argument('--adjudicator-side',default='c')
    args=parser.parse_args()
    r=ingest(args.directory,args.base,side_a=args.side_a,side_b=args.side_b,
             adjudicator_side=args.adjudicator_side)
    print(json.dumps({k:v for k,v in r.items() if k not in {'dependencies','quality'}}))
