import json

import pytest
from PIL import Image

from pallet.annotation import (AnnotationSet, Box, FrameAnnotation, Review, export_coco,
                               is_resolved, record_review)
from pallet.annotation import load_jsonl, save_jsonl
from pallet.data.protocol import file_digest
from pallet.review_ingest import _validate_review, _consensus, ingest


def test_resolved_ignore_is_counted_as_handled_but_never_exported_as_negative():
    frame=FrameAnnotation('f','g','x.png',32,32,source_anchor_hash='source',split='val')
    record_review(frame,Review('a','approve',note='sensor image unobservable'),status='ignore')
    record_review(frame,Review('b','approve',note='sensor has no usable returns'))
    assert is_resolved(frame,require_blind=True)
    assert not AnnotationSet([frame]).unresolved()
    assert not export_coco(AnnotationSet([frame]))['images']


def test_invalid_adjudication_does_not_modify_review_history():
    frame=FrameAnnotation('f','g','x.png',32,32,source_anchor_hash='source')
    with pytest.raises(ValueError,match='existing independent'):
        record_review(frame,Review('c','adjudicate',adjudicates=('missing1','missing2')),
                      status='pos',boxes=[Box(1,1,4,4)])
    assert frame.status=='unreviewed' and frame.reviews==[]


def test_out_of_bounds_native_coordinates_are_rejected():
    task={'task_id':'v','frames':[{'index':0,'width':352,'height':264}]}
    review={'task_id':'v','reviewer':'a','blind':True,'frames':[
        {'index':0,'status':'pos','boxes':[[153,257,190,23]]}]}
    with pytest.raises(ValueError,match='outside image'):
        _validate_review(task,review)
    assert _consensus({'status':'pos','boxes':[[1,1,10,10]],'uncertainty':'high'},
                      {'status':'pos','boxes':[[1,1,10,10]],'uncertainty':'low'}) is None


def test_crowded_consensus_uses_unique_optimal_box_pairs():
    a = {'status': 'pos', 'boxes': [[1, 1, 20, 10], [30, 1, 20, 10]],
         'uncertainty': 'low'}
    b = {'status': 'pos', 'boxes': [[30, 1, 20, 10], [1, 1, 20, 10]],
         'uncertainty': 'low'}
    decision = _consensus(a, b)
    assert decision is not None
    assert decision['boxes'] == [[1.0, 1.0, 20.0, 10.0],
                                 [30.0, 1.0, 20.0, 10.0]]
    b['boxes'] = [[1, 1, 20, 10], [2, 1, 20, 10]]
    assert _consensus(a, b) is None


def test_consensus_matching_prioritizes_all_pairs_above_threshold(monkeypatch):
    a = {'status': 'pos', 'boxes': [[1, 1, 10, 10], [21, 1, 10, 10]]}
    b = {'status': 'pos', 'boxes': [[1, 21, 10, 10], [21, 21, 10, 10]]}
    scores = {(1, 1): .99, (1, 21): .86, (21, 1): .86, (21, 21): .84}
    monkeypatch.setattr('pallet.review_ingest.iou_xywh',
                        lambda left, right: scores[(left[0], right[0])])
    assert _consensus(a, b) is not None


def test_fresh_audit_review_roles_are_ingested_without_reusing_old_reviewers(tmp_path):
    frame = FrameAnnotation('f', 'g', 'raw.pcd', 4, 4,
                            source_anchor_hash='raw', split='train')
    base = tmp_path / 'base.jsonl'
    save_jsonl(AnnotationSet([frame]), base)
    directory = tmp_path / 'review'
    (directory / 'tasks').mkdir(parents=True)
    (directory / 'reviews').mkdir()
    image = directory / 'intensity.png'
    Image.new('L', (4, 4)).save(image)
    task = {'task_id': 'train_000', 'frames': [{
        'index': 0, 'frame_id': 'f', 'group_id': 'g', 'split': 'train',
        'source_anchor_hash': 'raw', 'width': 4, 'height': 4,
        'intensity': str(image), 'views_sha256': {'intensity.png': file_digest(image)}}]}
    (directory / 'tasks' / 'train_000.json').write_text(json.dumps(task))
    for side in ('d', 'e'):
        review = {'task_id': 'train_000', 'reviewer': f'fresh-{side}',
                  'blind': True, 'frames': [{'index': 0, 'status': 'negative',
                                              'boxes': [], 'reason': 'empty view'}]}
        (directory / 'reviews' / f'{side}_train_000.json').write_text(json.dumps(review))
    result = ingest(directory, base, side_a='d', side_b='e', adjudicator_side='f')
    assert result['pending_adjudication'] == 0
    resolved = load_jsonl(result['annotation_path']).frames['f']
    assert resolved.status == 'negative' and is_resolved(resolved)
    assert {'fresh-d', 'fresh-e'} <= {review.reviewer for review in resolved.reviews}
    assert any(review.reviewer.startswith('consensus-policy-v1-')
               for review in resolved.reviews)

    second = tmp_path / 'second'
    (second / 'tasks').mkdir(parents=True)
    (second / 'reviews').mkdir()
    (second / 'tasks' / 'train_000.json').write_text(json.dumps(task))
    for side in ('g', 'h'):
        review = {'task_id': 'train_000', 'reviewer': f'fresh-{side}',
                  'blind': True, 'frames': [{'index': 0, 'status': 'negative',
                                              'boxes': [], 'reason': 'empty view'}]}
        (second / 'reviews' / f'{side}_train_000.json').write_text(json.dumps(review))
    repeated = ingest(second, result['annotation_path'], side_a='g', side_b='h',
                      adjudicator_side='i')
    assert not repeated['errors'] and repeated['consensus_frames'] == 1
    twice = load_jsonl(repeated['annotation_path']).frames['f']
    assert len(twice.reviews) == 6

    Image.new('L', (5, 4)).save(image)
    task['frames'][0]['views_sha256']['intensity.png'] = file_digest(image)
    (second / 'tasks' / 'train_000.json').write_text(json.dumps(task))
    bad_grid = ingest(second, result['annotation_path'], side_a='g', side_b='h',
                      adjudicator_side='i')
    assert 'grid differs' in bad_grid['errors'][0]['error']


def test_failed_batch_does_not_publish_earlier_frame_decisions(tmp_path):
    frames = [FrameAnnotation(fid, 'g', 'raw.pcd', 4, 4,
                              source_anchor_hash=f'raw-{fid}', split='train')
              for fid in ('first', 'second')]
    base = tmp_path / 'base.jsonl'
    save_jsonl(AnnotationSet(frames), base)
    directory = tmp_path / 'review'
    (directory / 'tasks').mkdir(parents=True)
    (directory / 'reviews').mkdir()
    image = directory / 'intensity.png'
    Image.new('L', (4, 4)).save(image)
    task_frames = [{'index': index, 'frame_id': fid, 'group_id': 'g',
                    'split': 'train', 'source_anchor_hash': 'raw-first',
                    'width': 4, 'height': 4, 'intensity': str(image),
                    'views_sha256': {'intensity.png': file_digest(image)}}
                   for index, fid in enumerate(('first', 'second'))]
    (directory / 'tasks' / 'train_000.json').write_text(json.dumps({
        'task_id': 'train_000', 'frames': task_frames}))
    for side in ('a', 'b'):
        (directory / 'reviews' / f'{side}_train_000.json').write_text(json.dumps({
            'task_id': 'train_000', 'reviewer': side, 'blind': True,
            'frames': [{'index': index, 'status': 'negative', 'boxes': []}
                       for index in range(2)]}))
    result = ingest(directory, base)
    assert result['paired_batches'] == 0 and result['errors']
    saved = load_jsonl(result['annotation_path'])
    assert all(frame.status == 'unreviewed' and not frame.reviews
               for frame in saved.frames.values())
