from dataclasses import replace
import json
from types import SimpleNamespace

from PIL import Image
import numpy as np
import pytest

from pallet.annotation import AnnotationSet, Box, FrameAnnotation, save_jsonl
from pallet.data.manifest import FrameRecord
from pallet.data.protocol import file_digest
import pallet.export_anylabeling as exporter
from pallet.export_anylabeling import choose_label, label_document, validate_workspace


def frame(**kwargs):
    return FrameAnnotation('f', 'g', 'native.pcd', 100, 60, split='train',
                           source_anchor_hash='hash', **kwargs)


def test_native_rectangles_and_partial_ignore_are_not_resized():
    item = frame(status='pos', boxes=[Box(5.5, 3, 80, 40)], ignore_regions=[Box(90, 2, 5, 10)])
    result = label_document(item, 'f.png', resolved=True)
    assert result['imageWidth'] == 100 and result['imageHeight'] == 60
    assert result['imageData'] is None and result['imagePath'] == 'f.png'
    assert result['shapes'][0]['points'] == [[5.5, 3], [85.5, 43]]
    assert result['shapes'][1]['label'] == '__ignore__'
    assert result['flags']['human_reviewed'] is False


def test_empty_frames_distinguish_ignore_unreviewed_negative_and_conflict():
    unknown = label_document(frame(), 'f.png', resolved=False)
    ignored = label_document(frame(status='ignore'), 'f.png', resolved=True)
    negative = label_document(frame(status='negative'), 'f.png', resolved=True)
    conflict = label_document(frame(status='negative'), 'f.png', resolved=True, conflict=True)
    assert unknown['flags']['unreviewed'] and not unknown['flags']['confirmed_negative']
    assert ignored['flags']['ignore'] and not ignored['flags']['confirmed_negative']
    assert negative['flags']['confirmed_negative'] and not negative['flags']['unreviewed']
    assert conflict['flags']['label_conflict'] and not conflict['flags']['machine_resolved']
    assert not conflict['flags']['confirmed_negative']


def test_test_frames_never_take_proposals_and_preserve_reference_variants():
    base = replace(frame(), split='test')
    proposed = replace(base, status='pos', boxes=[Box(1, 1, 5, 5)])
    selected, _, _, _, _ = choose_label((base, 'parent'), [], [], (proposed, 'detector'))
    assert selected.status == 'unreviewed' and not selected.boxes
    a = replace(proposed, boxes=[Box(10, 5, 30, 20)])
    b = replace(proposed, boxes=[Box(11, 5, 30, 20)])
    selected, source, _, conflict, variants = choose_label(
        (base, 'parent'), [], [(a, 'reference_a'), (b, 'reference_b')], (proposed, 'detector'))
    assert conflict and source == 'reference_a' and len(variants) == 2
    assert selected.boxes == a.boxes


def test_validate_portable_pair_and_reject_crowded_box_outside_grid(tmp_path):
    images = tmp_path/'images/train'
    images.mkdir(parents=True)
    Image.new('L', (100, 60)).save(images/'f.png')
    item = frame(status='pos', boxes=[Box(0, 0, 20, 10), Box(5, 2, 20, 10)])
    doc = label_document(item, 'f.png', resolved=True)
    (images/'f.json').write_text(json.dumps(doc))
    (tmp_path/'manifest.json').write_text(json.dumps({'frames': 1}))
    (tmp_path/'frames.jsonl').write_text(json.dumps({'frame_id': 'f', 'image': 'images/train/f.png',
            'annotation': 'images/train/f.json', 'size': [100, 60]})+'\n')
    assert validate_workspace(tmp_path)['ok']
    doc['shapes'][1]['points'][1] = [101, 12]
    (images/'f.json').write_text(json.dumps(doc))
    result = validate_workspace(tmp_path)
    assert not result['ok'] and result['problems'][0]['error'] == 'rectangle outside native grid'


def test_train_suggestion_remains_unreviewed():
    base = frame()
    candidate = frame(status='pos', boxes=[Box(5, 5, 10, 10)])
    selected, source, resolved, conflict, _ = choose_label((base, 'base'), [], [], (candidate, 'teacher'))
    result = label_document(selected, 'f.png', resolved=resolved, conflict=conflict)
    assert source == 'teacher' and result['flags']['proposal_only']
    assert result['shapes'][0]['flags']['proposal_only']
    assert not result['flags']['machine_resolved'] and result['flags']['unreviewed']


@pytest.fixture
def workspace(tmp_path, monkeypatch):
    monkeypatch.setattr(exporter.shutil, 'disk_usage', lambda p: SimpleNamespace(free=100*2**30))
    root = tmp_path/'root'
    protocol = root/'outputs/protocol_v5'
    protocol.mkdir(parents=True)
    (protocol/'protocol.json').write_text('{}')
    primary = root/'labels.jsonl'
    save_jsonl(AnnotationSet([frame()]), primary)
    cache = root/'outputs/cache_v5'
    cache.mkdir(parents=True)
    (cache/'sealed_index.json').write_text(json.dumps({'f': {'path': 'unused.npz', 'sha256': 'cache'}}))
    (cache/'seal.json').write_text(json.dumps({'index_sha256': file_digest(cache/'sealed_index.json'),
        'protocol_sha256': file_digest(protocol/'protocol.json')}))
    (root/'docs').mkdir()
    (root/'docs/anylabeling_export.md').write_text('guide')
    record = FrameRecord('f', 'g', 'all', {}, {'grid': [60, 100]}, 'hash')
    monkeypatch.setattr(exporter, 'load_protocol', lambda p: ([record], {'g': 'train'}, {}))
    def discover(*args):
        return str(primary), [{'path': str(primary), 'sha256': file_digest(primary),
                               'role': 'frozen_primary'}], {}
    monkeypatch.setattr(exporter, 'discover_sources', discover)
    data = np.zeros((60, 100, 4), np.float32)
    data[..., 1] = np.arange(100)[None, :]
    data[..., 3] = 1
    monkeypatch.setattr(exporter, 'load_frame', lambda r: data)
    return root, tmp_path/'export', primary


def test_interrupted_export_resumes_without_overwriting_human_json(workspace, monkeypatch):
    root, output, _ = workspace
    original = exporter._render
    def fail(*args):
        raise RuntimeError('simulated render interruption')
    monkeypatch.setattr(exporter, '_render', fail)
    with pytest.raises(RuntimeError, match='simulated'):
        exporter.export(root, output, workers=1)
    path = next((output/'images/train').glob('*.json'))
    document = json.loads(path.read_text())
    document['flags']['human_reviewed'] = True
    document['flags']['confirmed_negative'] = True
    path.write_text(json.dumps(document))
    saved_bytes = path.read_bytes()
    monkeypatch.setattr(exporter, '_render', original)
    result = exporter.export(root, output, workers=1)
    assert result['frames'] == 1
    assert path.read_bytes() == saved_bytes
    baseline = json.loads((output/'frames.jsonl').read_text())['baseline_json_sha256']
    assert baseline != file_digest(path)
    assert exporter.validate_workspace(output)['ok']


def test_source_update_requires_new_export_version(workspace):
    root, output, primary = workspace
    exporter.export(root, output, workers=1)
    primary.write_text(primary.read_text()+'\n')
    with pytest.raises(ValueError, match='source changed'):
        exporter.export(root, output, workers=1)
