import json
from dataclasses import replace
from types import SimpleNamespace

import pytest

from pallet.annotation import AnnotationSet, Box, FrameAnnotation, Review, load_jsonl, record_review, save_jsonl
from pallet.annotation import merge_snapshots
from pallet.data.protocol import write_json


def test_merge_only_independent_resolved_source_training_frames(tmp_path, monkeypatch):
    protocol = tmp_path / 'protocol'
    protocol.mkdir()
    (protocol / 'protocol.json').write_text('{}')
    rows = [SimpleNamespace(frame_id='t', group_id='source', source_sha256='raw-t'),
            SimpleNamespace(frame_id='v', group_id='validation', source_sha256='raw-v')]
    assignments = {'source': 'train', 'validation': 'val'}
    monkeypatch.setattr(merge_snapshots, 'load_protocol',
                        lambda _: (rows, assignments, {}))
    train = FrameAnnotation('t', 'source', 'raw.pcd', 16, 16,
                            split='train', source_anchor_hash='raw-t')
    validation = FrameAnnotation('v', 'validation', 'raw.pcd', 16, 16,
                                 split='val', source_anchor_hash='raw-v')
    record_review(validation, Review('val-a', 'approve'), status='negative')
    record_review(validation, Review('val-b', 'approve'))
    primary = tmp_path / 'primary.jsonl'
    save_jsonl(AnnotationSet([train, validation]), primary)

    reviewed = FrameAnnotation('t', 'source', 'raw.pcd', 16, 16,
                               split='train', source_anchor_hash='raw-t')
    record_review(reviewed, Review('train-a', 'approve'), status='pos',
                  boxes=[Box(1, 2, 8, 4)])
    record_review(reviewed, Review('train-b', 'approve'))
    supplemental = tmp_path / 'supplemental.jsonl'
    save_jsonl(AnnotationSet([reviewed, validation]), supplemental)
    selected = tmp_path / 'selection.json'
    write_json(selected, {'train': ['t']})
    output = tmp_path / 'merged.jsonl'
    result = merge_snapshots.merge_source_train(primary, supplemental,
                                                 protocol, selected, output)
    merged = load_jsonl(output)
    assert result['inserted'] == 1
    assert merged.frames['t'].status == 'pos'
    assert merged.frames['v'] == load_jsonl(primary).frames['v']
    with pytest.raises(ValueError, match='already exists'):
        merge_snapshots.merge_source_train(primary, supplemental,
                                           protocol, selected, output)

    write_json(selected, {'train': ['v']})
    with pytest.raises(ValueError, match='non-source'):
        merge_snapshots.merge_source_train(primary, supplemental,
                                           protocol, selected, tmp_path / 'bad_source.jsonl')

    write_json(selected, {'train': ['t']})
    with pytest.raises(ValueError, match='no new'):
        merge_snapshots.merge_source_train(output, supplemental,
                                           protocol, selected, tmp_path / 'again.jsonl')


def test_supplemental_selection_excludes_frozen_audit_and_binds_sources(tmp_path,monkeypatch):
    protocol=tmp_path/'protocol'
    protocol.mkdir()
    (protocol/'protocol.json').write_text('{}')
    rows=[SimpleNamespace(frame_id=fid,group_id=group,source_sha256=f'raw-{fid}',domain='target')
          for fid,group in [('new','train'),('audit','audit'),('validation','val')]]
    assignments={'train':'train','audit':'train','val':'val'}
    monkeypatch.setattr(merge_snapshots,'load_protocol',lambda _: (rows,assignments,{}))
    original=[]
    reviewed=[]
    for row in rows:
        split=assignments[row.group_id]
        old=FrameAnnotation(row.frame_id,row.group_id,'raw.pcd',16,16,
                            split=split,source_anchor_hash=row.source_sha256)
        candidate=FrameAnnotation(row.frame_id,row.group_id,'raw.pcd',16,16,
                                  split=split,source_anchor_hash=row.source_sha256)
        record_review(candidate,Review(f'{row.frame_id}-a','approve',blind=True),status='negative')
        record_review(candidate,Review(f'{row.frame_id}-b','approve',blind=True))
        original.append(old)
        reviewed.append(candidate)
    primary=tmp_path/'primary.jsonl'
    supplemental=tmp_path/'supplemental.jsonl'
    save_jsonl(AnnotationSet(original),primary)
    save_jsonl(AnnotationSet(reviewed),supplemental)
    output=tmp_path/'selection.json'
    manifest=merge_snapshots.select_unresolved_source_train(
        primary,supplemental,protocol,['audit'],output)
    assert manifest['selected_frames']==1
    assert json.loads(output.read_text())=={'train':['new'],'val':[],'test':[]}
    assert merge_snapshots.select_unresolved_source_train(
        primary,supplemental,protocol,['audit'],output)==manifest
    target_selection=tmp_path/'target_selection.json'
    target_manifest=merge_snapshots.select_unresolved_source_train(
        primary,supplemental,protocol,['audit'],target_selection,target_domain='target')
    assert target_manifest['selected_frames']==0
    unbound=tmp_path/'unsafe_selection.json'
    write_json(unbound,{'train':['new']})
    with pytest.raises(ValueError,match='non-source'):
        merge_snapshots.merge_source_train(primary,supplemental,protocol,
                                            unbound,tmp_path/'target_merge.jsonl',target_domain='target')
    supplemental.write_text(supplemental.read_text()+'\n')
    with pytest.raises(ValueError,match='bound inputs'):
        merge_snapshots.merge_source_train(primary,supplemental,protocol,
                                            output,tmp_path/'bad_merge.jsonl')


def test_conflict_merge_requires_fresh_blind_chain_and_keeps_other_splits(tmp_path,monkeypatch):
    protocol=tmp_path/'protocol'
    protocol.mkdir()
    (protocol/'protocol.json').write_text('{}')
    rows=[SimpleNamespace(frame_id='t',group_id='source',source_sha256='raw-t'),
          SimpleNamespace(frame_id='v',group_id='validation',source_sha256='raw-v')]
    monkeypatch.setattr(merge_snapshots,'load_protocol',
                        lambda _: (rows,{'source':'train','validation':'val'},{}))
    train=FrameAnnotation('t','source','raw.pcd',16,16,
                          split='train',source_anchor_hash='raw-t')
    validation=FrameAnnotation('v','validation','raw.pcd',16,16,
                               split='val',source_anchor_hash='raw-v')
    record_review(train,Review('old','approve',blind=True),status='negative')
    record_review(train,Review('old2','approve',blind=True))
    primary=tmp_path/'primary.jsonl'
    save_jsonl(AnnotationSet([train,validation]),primary)
    candidate=load_jsonl(primary)
    changed=candidate.frames['t']
    record_review(changed,Review('new-a','needs_work',blind=True,review_id='a'),
                  status='pos',boxes=[Box(1,2,8,4)])
    record_review(changed,Review('new-b','needs_work',blind=True,review_id='b'),
                  status='pos',boxes=[Box(1,2,8,4)])
    record_review(changed,Review('new-c','adjudicate',blind=True,
                                  review_id='c',adjudicates=('a','b')),
                  status='pos',boxes=[Box(1,2,8,4)])
    adjudicated=tmp_path/'adjudicated.jsonl'
    save_jsonl(candidate,adjudicated)
    selection=tmp_path/'conflicts.json'
    write_json(selection,{'train':['t'],'val':[],'test':[]})
    write_json(selection.with_suffix('.manifest.json'),{
        'purpose':'independent visual adjudication; no snapshot overwrites',
        'protocol_sha256':merge_snapshots.file_digest(protocol/'protocol.json'),
        'frames':1})
    merged=tmp_path/'merged.jsonl'
    result=merge_snapshots.merge_adjudicated_conflicts(primary,adjudicated,
                                                         protocol,selection,merged)
    assert result['corrected_train_frames']==1
    assert load_jsonl(merged).frames['t'].status=='pos'
    assert load_jsonl(merged).frames['v']==validation
    with pytest.raises(ValueError,match='already exists'):
        merge_snapshots.merge_adjudicated_conflicts(primary,adjudicated,
                                                     protocol,selection,merged)

    candidate.frames['v'].status='ignore'
    corrupted=tmp_path/'corrupted.jsonl'
    save_jsonl(candidate,corrupted)
    with pytest.raises(ValueError,match='unselected frame'):
        merge_snapshots.merge_adjudicated_conflicts(primary,corrupted,
                                                     protocol,selection,tmp_path/'bad.jsonl')


def test_reviewed_subset_overlay_is_bound_to_selected_blind_train_frames(tmp_path,monkeypatch):
    protocol=tmp_path/'protocol'
    protocol.mkdir()
    (protocol/'protocol.json').write_text('{}')
    rows=[SimpleNamespace(frame_id='t',group_id='source',source_sha256='raw-t'),
          SimpleNamespace(frame_id='v',group_id='validation',source_sha256='raw-v')]
    monkeypatch.setattr(merge_snapshots,'load_protocol',
                        lambda _: (rows,{'source':'train','validation':'val'},{}))
    train=FrameAnnotation('t','source','raw.pcd',16,16,
                          split='train',source_anchor_hash='raw-t')
    validation=FrameAnnotation('v','validation','raw.pcd',16,16,
                               split='val',source_anchor_hash='raw-v')
    primary=tmp_path/'primary.jsonl'
    save_jsonl(AnnotationSet([train,validation]),primary)
    reviewed=load_jsonl(primary)
    frame=reviewed.frames['t']
    boxes=[Box(1,2,8,4)]
    record_review(frame,Review('fresh-a','needs_work',blind=True),
                  status='pos',boxes=boxes)
    record_review(frame,Review('fresh-b','needs_work',blind=True),
                  status='pos',boxes=boxes)
    proposal_ids=tuple(review.review_id for review in frame.reviews)
    record_review(frame,Review('fresh-c','adjudicate',blind=True,
                               adjudicates=proposal_ids),status='pos',boxes=boxes)
    reviewed_path=tmp_path/'reviewed.jsonl'
    save_jsonl(reviewed,reviewed_path)
    selection=tmp_path/'selection.json'
    write_json(selection,{'train':['t'],'val':[],'test':[]})
    output=tmp_path/'merged.jsonl'
    result=merge_snapshots.merge_reviewed_subset(primary,reviewed_path,
                                                  protocol,selection,output)
    merged=load_jsonl(output)
    assert result['overlaid_source_train_frames']==1
    assert merged.frames['t'].status=='pos'
    assert merged.frames['v']==validation
    with pytest.raises(ValueError,match='already exists'):
        merge_snapshots.merge_reviewed_subset(primary,reviewed_path,
                                               protocol,selection,output)

    tampered=load_jsonl(reviewed_path)
    tampered.frames['t'].reviews[0]=replace(tampered.frames['t'].reviews[0],blind=False)
    tampered_path=tmp_path/'tampered.jsonl'
    save_jsonl(tampered,tampered_path)
    with pytest.raises(ValueError,match='resolved blind'):
        merge_snapshots.merge_reviewed_subset(primary,tampered_path,
                                               protocol,selection,tmp_path/'bad.jsonl')
