"""Adversarial unit tests for the independent next-publication-12 worklist audit."""
import ast
import copy
import json
from pathlib import Path
import sqlite3

import numpy as np
from PIL import Image, ImageDraw
import pytest

from scripts import verify_mask_remaining_round2_requests as verifier


KEY = 'a'*24


def write_json(path, value):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_bytes(verifier.canonical(value)+b'\n')


def write_jsonl(path, values):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_bytes(b''.join(verifier.canonical(v)+b'\n' for v in values))


def row(key=KEY, cls=4, frame=None):
    return dict(target_key=key, target_id=key+'::box:0000', frame_id=frame or 'frame-'+key,
        final_class_id=cls, final_class='candidate', split='train', group_id='group', box_index=0,
        bbox=dict(x=18, y=18, width=70, height=28), size=[120, 80], policy_id='camera',
        source_pcd_sha256='pcd', image='images/'+key+'.png', viewpoint_candidate='front',
        appearance_status='ok')


def pose_value(r, revision=1, **extra):
    return dict(target_key=r['target_key'], revision=revision, source=copy.deepcopy(r),
        state='draft', polygon=verifier.rectangle(r), pose=dict(x=42), ruler={'length': 70},
        sensor={'policy': 'keep'}, selected_faces=['front'], exclusions=['top'], **extra)


def store(values=(), events=None):
    raw = {v['target_key']: json.dumps(v, ensure_ascii=False, indent=2) for v in values}
    events = events if events is not None else [(i, v['target_key'], v['revision'], raw[v['target_key']]) for i, v in enumerate(values, 1)]
    return dict(current={v['target_key']: v for v in values}, raw=raw, events=events, metadata={})


def test_verifier_has_no_new_builder_generator_import_or_old_policy_mutation():
    tree = ast.parse(Path(verifier.__file__).read_text())
    imports = []
    for node in ast.walk(tree):
        if isinstance(node, ast.ImportFrom):
            imports.append(node.module or '')
        elif isinstance(node, ast.Import):
            imports.extend(n.name for n in node.names)
    assert not any('build_mask_remaining_' in name or name == 'pallet.mask_remaining_round2' for name in imports)
    assert not any(isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id in ('setattr', 'exec') for n in ast.walk(tree))
    assert verifier.CLASSES == (4, 5, 7, 14, 22)
    assert verifier.native_quality.__module__ == 'scripts.build_mask_template_requests'


@pytest.mark.parametrize('attack', ['absent', 'failed', 'version', 'manifest', 'proposals', 'manifest_version'])
def test_matching_publication12_seal_required_before_other_source_reads(tmp_path, attack):
    root, parent = tmp_path/'worklist', tmp_path/'parent'
    root.mkdir(); parent.mkdir()
    write_json(parent/'manifest.json', {'publication_version': 11 if attack == 'manifest_version' else 12})
    write_jsonl(parent/'proposals.jsonl', [{}])
    seal = dict(state='passed', publication_version=12, manifest_sha256=verifier.digest(parent/'manifest.json'),
        proposals_sha256=verifier.digest(parent/'proposals.jsonl'))
    if attack == 'failed':
        seal['state'] = 'self_checks_passed_not_independent_verification'
    elif attack == 'version':
        seal['publication_version'] = 11
    elif attack in ('manifest', 'proposals'):
        seal[attack+'_sha256'] = '0'*64
    if attack != 'absent':
        write_json(parent/'verification.json', seal)
    before = verifier.file_inventory(tmp_path)
    with pytest.raises(ValueError, match='Matching publication-12 seal'):
        verifier.audit(root, parent)
    assert verifier.file_inventory(tmp_path) == before


def test_class_shortfalls_are_actual_and_class3_is_complete():
    proposals = [dict(target_key=f'{c}-{i}', class_id=c, source={'frame_id': f'{c}-{i}'})
        for c, n in {3: 100, 4: 97, 5: 50, 7: 100, 14: 92, 22: 0}.items() for i in range(n)]
    assert verifier.class_quotas(proposals) == {4: 3, 5: 10, 7: 0, 14: 8, 22: 10}
    proposals.pop(0)
    with pytest.raises(ValueError, match='Class 3'):
        verifier.class_quotas(proposals)


@pytest.mark.parametrize('attack', ['duplicate_key', 'same_frame', 'overquota', 'unknown_class', 'boolean_class'])
def test_parent_quotas_reject_duplicate_frame_class_or_quota_laundering(attack):
    proposals = [dict(target_key=f'3-{i}', class_id=3, source={'frame_id': f'3-{i}'}) for i in range(100)]
    if attack == 'duplicate_key':
        proposals.append(copy.deepcopy(proposals[-1]))
    elif attack == 'same_frame':
        proposals.append(dict(target_key='other', class_id=4, source={'frame_id': '3-0'}))
    else:
        cls = dict(overquota=3, unknown_class=23, boolean_class=True)[attack]
        proposals.append(dict(target_key='other', class_id=cls, source={'frame_id': 'other'}))
    with pytest.raises(ValueError):
        verifier.class_quotas(proposals)


@pytest.mark.parametrize('attack', ['deferred', 'deleted', 'confirmed', 'changed_then_returned', 'human_mask_confirmed',
    'human_pose_confirmed', 'metric_pose_confirmed', 'human_confirmed', 'ground_truth_eligible',
    'automatic_training_eligible', 'robot_command_eligible', 'nested_pose_confirmed', 'full_six_dof',
    'nested_full_six_dof', 'automatic_event', 'restored_event', 'auto_accepted', 'machine_marked',
    'machine_origin', 'review_only', 'human_edited', 'orphaned_history'])
def test_all_pose_history_protects_entire_frame_even_after_return_to_original_rectangle(attack):
    r, sibling = row(), row('b'*24, frame='frame-'+KEY)
    value = pose_value(r); old = copy.deepcopy(value)
    if attack in ('deferred', 'deleted', 'confirmed'):
        old['state'] = attack
    elif attack == 'changed_then_returned':
        old['polygon'][0][0] += 1
    elif attack in verifier.FLAGS or attack == 'full_six_dof':
        old[attack] = True
    elif attack.startswith('nested_'):
        old['pose']['full_six_dof' if attack.endswith('six_dof') else 'human_pose_confirmed'] = True
    elif attack in ('automatic_event', 'restored_event', 'auto_accepted'):
        old['event_kind'] = dict(automatic_event='unit_normalization', restored_event='annotation_restored',
            auto_accepted='mask_template_auto_accepted')[attack]
    elif attack == 'machine_marked':
        old['machine_generated'] = True
    elif attack == 'machine_origin':
        old['origin'] = 'machine_mask'
    elif attack == 'review_only':
        old['original_rectangle_review_only'] = True
    elif attack == 'human_edited':
        old['human_edited'] = True
    events = [(1, KEY, 1, json.dumps(old)), (2, KEY, 2, json.dumps(value))]
    pose = store([] if attack == 'orphaned_history' else [value], events)
    protected, frames, history = verifier.protection({KEY: r, sibling['target_key']: sibling}, pose, store(), [], [])
    assert KEY in protected and sibling['frame_id'] in frames and len(history[KEY]) == 2


def test_virgin_preferred_not_required_existing_original_pose_geometry_is_exact():
    r = row(); value = pose_value(r)
    pose = store([value]); _, _, history = verifier.protection({KEY: r}, pose, store(), [], [])
    record = dict(verifier.pose_binding(KEY, pose, history), existing_pose_current_payload=value,
        existing_pose_current_payload_raw=pose['raw'][KEY], no_pose_current_or_history=False)
    verifier.check_pose_binding(record, KEY, pose, history, True)
    assert not verifier.protection({KEY: r}, pose, store(), [], [])[0]
    for field in ('pose', 'ruler', 'sensor', 'selected_faces', 'exclusions'):
        damaged = copy.deepcopy(record)
        damaged['existing_pose_current_payload'][field] = 'overwritten'
        with pytest.raises(ValueError, match='Full existing pose'):
            verifier.check_pose_binding(damaged, KEY, pose, history, True)


@pytest.mark.parametrize('field', ['existing_pose_revision', 'existing_pose_payload_sha256', 'existing_pose_payload_raw_sha256',
    'existing_pose_geometry_sha256', 'pose_history_flags', 'preserve_existing_pose_until_intentional_human_edit',
    'preserve_current_selected_ruler_sensor_faces_and_revision', 'existing_pose_revision_is_expected_not_overwrite_authorization',
    'no_pose_current_or_history', 'existing_pose_current_payload_raw'])
def test_existing_pose_revision_raw_and_nonmask_settings_cannot_be_rebound(field):
    r = row(); value = pose_value(r); pose = store([value])
    _, _, history = verifier.protection({KEY: r}, pose, store(), [], [])
    record = dict(verifier.pose_binding(KEY, pose, history), existing_pose_current_payload=value,
        existing_pose_current_payload_raw=pose['raw'][KEY], no_pose_current_or_history=False)
    record[field] = 'tampered'
    with pytest.raises(ValueError):
        verifier.check_pose_binding(record, KEY, pose, history, True)


@pytest.mark.parametrize('kind', ['canonical', 'old_request', 'gallery_current', 'gallery_event', 'quarantine'])
def test_all_request_namespaces_canonical_gallery_events_and_quarantine_protect_global_frames(kind):
    r = row(); p = dict(target_key=KEY, class_id=4, source=r)
    gallery = store([pose_value(r)] if kind == 'gallery_current' else [],
        [(1, KEY, 1, '{}')] if kind == 'gallery_event' else [])
    protected, frames, _ = verifier.protection({KEY: r}, store(), gallery,
        [p] if kind == 'canonical' else [], [p] if kind == 'old_request' else [],
        [KEY] if kind == 'quarantine' else [])
    assert protected == {KEY} and frames == {r['frame_id']}


@pytest.fixture
def image_case(tmp_path):
    r = row(); root, formal = tmp_path/'worklist', tmp_path/'formal'
    (root/'images').mkdir(parents=True); (root/'cases').mkdir(); (formal/'images').mkdir(parents=True)
    image = np.random.default_rng(123).integers(0, 225, size=(80, 120), dtype=np.uint8)
    Image.fromarray(image).save(formal/r['image'])
    (root/r['image']).write_bytes((formal/r['image']).read_bytes())
    class Evidence:
        def image(self, frame):
            assert frame == r['frame_id']
            return image
    evidence = Evidence()
    bounds = [6, 1, 100, 63]
    crop = Image.fromarray(image[1:63, 6:100]).convert('RGB')
    ImageDraw.Draw(crop).rectangle((12, 17, 82, 45), outline=(255, 180, 40), width=1)
    crop.save(root/'cases'/f'{KEY}.png')
    quality, reason = verifier.native_quality(r, evidence)
    assert reason is None
    record = dict(target_key=KEY, source=r, native_image=f'images/{KEY}.png', contact_crop=f'cases/{KEY}.png',
        crop_native_bounds=bounds, quality=quality)
    return root, formal, r, evidence, record


def test_original_native_quality_crop_and_full_image_recomputed(image_case):
    root, formal, r, evidence, record = image_case
    verifier.inspectable_images(root, record, r, formal, evidence)


@pytest.mark.parametrize('attack', ['crop_pixel', 'full_pixel', 'bounds', 'quality', 'nan_quality', 'missing_quality', 'unsafe_path'])
def test_no_substituted_inspection_image_or_loosened_quality_passes(image_case, attack):
    root, formal, r, evidence, record = image_case
    if attack.endswith('pixel'):
        path = root/record['contact_crop' if attack == 'crop_pixel' else 'native_image']
        with Image.open(path) as image:
            data = np.array(image)
        data[0, 0] = 1
        Image.fromarray(data).save(path)
    elif attack == 'bounds':
        record['crop_native_bounds'][0] += 1
    elif attack == 'unsafe_path':
        record['contact_crop'] = '../other.png'
    elif attack == 'missing_quality':
        record['quality'].pop('clarity_score')
    else:
        record['quality']['clarity_score'] = float('nan') if attack == 'nan_quality' else 1.5
    with pytest.raises(ValueError):
        verifier.inspectable_images(root, record, r, formal, evidence)


@pytest.mark.parametrize('field,value', [('width', 49), ('height', 13), ('area', 990), ('contrast', 34)])
def test_original_minimum_width_height_area_and_contrast_gates_remain_native(image_case, field, value):
    _, _, r, evidence, _ = image_case
    if field == 'area':
        r['bbox'].update(width=55, height=18)
    elif field == 'contrast':
        class Flat:
            def image(self, frame):
                return np.full((80, 120), value, dtype=np.uint8)
        evidence = Flat()
    else:
        r['bbox'][field] = value
    _, reason = verifier.native_quality(r, evidence)
    assert reason is not None


@pytest.fixture
def review_chain(image_case):
    root, formal, r, evidence, record = image_case
    write_json(root/'input_manifest.json', {'freeze': 'source'})
    review = root/'internal/review/round_0001'
    (review/'images').mkdir(parents=True); (review/'cases').mkdir()
    for field in ('native_image', 'contact_crop'):
        (review/record[field]).write_bytes((root/record[field]).read_bytes())
        record[field+'_sha256'] = verifier.digest(review/record[field])
    pose = store(); history = {}
    record.update(verifier.pose_binding(KEY, pose, history), no_pose_current_or_history=True)
    write_jsonl(review/'shortlist.jsonl', [record])
    write_json(review/'review_input.json', {'decisions': {}})
    write_json(review/'round_manifest.json', {'previous_round_sha256': None,
        'input_manifest_sha256': verifier.digest(root/'input_manifest.json'), 'new_shortlist_keys': [KEY]})
    write_json(review/'artifact_hashes.json', verifier.file_inventory(review))
    decision = dict(approved=True, crop_inspected=True, full_image_inspected=True, note_zh='原图及局部可见。')
    write_json(root/'internal/build_decisions.json', {'decisions': {KEY: decision}})
    task = dict(record, source_visual_review_zh=decision['note_zh'], review_decision=decision,
        source_visual_review_binding=dict(review_round=review.name,
            round_manifest_sha256=verifier.digest(review/'round_manifest.json'),
            shortlist_sha256=verifier.digest(review/'shortlist.jsonl'), native_image_sha256=record['native_image_sha256'],
            contact_crop_sha256=record['contact_crop_sha256'], canonical_source_row_sha256=verifier.sha(r),
            decision_sha256=verifier.sha(decision)))
    manifest = dict(source_visual_decisions_sha256=verifier.digest(root/'internal/build_decisions.json'),
        review_round_hashes={'round_0001': verifier.digest(review/'artifact_hashes.json')})
    return root, manifest, [task], {KEY: r}, formal, evidence, pose, history, set(), set()


def test_review_rounds_bind_actual_approved_crop_and_full_png(review_chain):
    assert verifier.check_review_chain(*review_chain)[KEY]['approved'] is True


@pytest.mark.parametrize('attack', ['private_decisions', 'approved', 'crop_inspected', 'full_image_inspected', 'blank_note',
    'note', 'extra_decision', 'unapproved_task', 'round_hash', 'chain', 'input', 'shortlist', 'review_image',
    'final_image', 'skipped_round', 'protected_frame'])
def test_review_chain_rejects_uninspected_rebound_or_rewritten_sources(review_chain, attack):
    root, manifest, tasks, rows, _, _, _, _, _, frames = review_chain
    review = root/'internal/review/round_0001'
    decisions_path = root/'internal/build_decisions.json'
    value = verifier.read_json(decisions_path)
    if attack in ('approved', 'crop_inspected', 'full_image_inspected', 'blank_note', 'extra_decision', 'unapproved_task'):
        if attack == 'extra_decision':
            value['decisions']['extra'] = copy.deepcopy(value['decisions'][KEY])
        elif attack == 'unapproved_task':
            value['decisions'][KEY]['approved'] = False
        elif attack == 'blank_note':
            value['decisions'][KEY]['note_zh'] = ' '
        else:
            value['decisions'][KEY][attack] = False if attack != 'approved' else 1
        write_json(decisions_path, value)
        manifest['source_visual_decisions_sha256'] = verifier.digest(decisions_path)
    elif attack == 'private_decisions':
        write_json(decisions_path, {'decisions': {}})
    elif attack == 'note':
        tasks[0]['source_visual_review_zh'] = 'not what was reviewed'
    elif attack == 'round_hash':
        manifest['review_round_hashes']['round_0001'] = '0'*64
    elif attack in ('chain', 'input', 'shortlist'):
        path = review/'round_manifest.json'; info = verifier.read_json(path)
        info[dict(chain='previous_round_sha256', input='input_manifest_sha256', shortlist='new_shortlist_keys')[attack]] = 'wrong'
        write_json(path, info)
        write_json(review/'artifact_hashes.json', {n: h for n, h in verifier.file_inventory(review).items() if n != 'artifact_hashes.json'})
        manifest['review_round_hashes']['round_0001'] = verifier.digest(review/'artifact_hashes.json')
    elif attack in ('review_image', 'final_image'):
        path = (review if attack == 'review_image' else root)/tasks[0]['contact_crop']
        path.write_bytes(b'not the inspected image')
    elif attack == 'skipped_round':
        review.rename(review.with_name('round_0002'))
    else:
        frames.add(rows[KEY]['frame_id'])
    with pytest.raises(ValueError):
        verifier.check_review_chain(*review_chain)


def test_prior_round_decision_cannot_be_rewritten_at_build(review_chain):
    root, manifest, tasks, *_ = review_chain
    second = root/'internal/review/round_0002'
    second.mkdir()
    rejected = dict(tasks[0]['review_decision'], approved=False)
    write_json(second/'review_input.json', {'decisions': {KEY: rejected}})
    write_json(second/'round_manifest.json', dict(previous_round_sha256=manifest['review_round_hashes']['round_0001'],
        input_manifest_sha256=verifier.digest(root/'input_manifest.json'), new_shortlist_keys=[]))
    write_jsonl(second/'shortlist.jsonl', [])
    write_json(second/'artifact_hashes.json', verifier.file_inventory(second))
    manifest['review_round_hashes']['round_0002'] = verifier.digest(second/'artifact_hashes.json')
    with pytest.raises(ValueError, match='Final decisions'):
        verifier.check_review_chain(*review_chain)


@pytest.mark.parametrize('field', ['review_round', 'round_manifest_sha256', 'shortlist_sha256',
    'native_image_sha256', 'contact_crop_sha256', 'canonical_source_row_sha256', 'decision_sha256'])
def test_actual_builder_visual_review_binding_is_independently_recomputed(review_chain, field):
    review_chain[2][0]['source_visual_review_binding'][field] = 'rebound'
    with pytest.raises(ValueError, match='visual review binding'):
        verifier.check_review_chain(*review_chain)


@pytest.mark.parametrize('field', verifier.RISK_FIELDS)
def test_actual_builder_risk_flags_reject_approved_ambiguous_or_clipped_sources(field):
    decision = dict(approved=True, crop_inspected=True, full_image_inspected=True,
        note_zh='This source must not be quota-filled.', **{field: True})
    with pytest.raises(ValueError, match='cannot be approved'):
        verifier.checked_decisions(dict(schema=verifier.DECISION_SCHEMA, decisions={KEY: decision}))
    decision['approved'] = False
    assert verifier.checked_decisions(dict(schema=verifier.DECISION_SCHEMA, decisions={KEY: decision}))[KEY] == decision


@pytest.fixture
def task():
    r = row(); original = dict(r); source_record = {'native': 'frame'}
    source = dict(r, image_sha256='native', formal_manifest_sha256='formal', classification_sha256='classes',
        canonical_source_row_sha256=verifier.sha(r), formal_source_record_sha256=verifier.sha(source_record),
        classification_row_sha256=verifier.sha(original))
    value = dict(source=source, original_classification_row=original, class_id=4,
        task_kind='remaining_round2_direct_human_coverage', minimum_direct_manual_coverage_vertices=4,
        classification_review_required=True, classification_ambiguous=False,
        classification_is_candidate_not_truth=True, class_identity=dict(candidate_class='candidate', final_class_id=4,
            human_class_confirmed=False, classification_row_sha256=verifier.sha(original)),
        status='needs_manual_tracing', source_label_kind='ORIGINAL_RECTANGLE', original_rectangle=verifier.rectangle(r),
        generated_polygons=0, neighbor_propagation_promised=False, requested_required_vertex_count=None)
    value.update(dict.fromkeys((*verifier.FLAGS, 'counts_as_completed_annotation', 'accepted_candidate', 'production_saved',
        'counts_toward_published_coverage', 'human_edited', 'propagation_seed_eligible'), False))
    value.update(dict.fromkeys(('valid_four_point_manual_contour_allowed', 'extra_vertices_must_not_be_forced',
        'valid_four_point_manual_contour_is_not_transfer_seed', 'topology_must_be_manually_determined',
        'original_rectangle_alone_is_not_completed_manual_coverage', 'preserve_closed_real_quad_topology'), True))
    return value, r, original, source_record, 'formal', 'classes'


def test_task_original_rectangle_is_baseline_not_completed_mask_or_class_truth(task):
    verifier.check_task(*task)


@pytest.mark.parametrize('attack', ['class', 'policy', 'view', 'pcd', 'source_hash', 'classification_hash', 'human_class',
    'polygon', 'mask', 'labelme', 'template', 'rectangle', 'completed', 'saved', 'confirmed', 'seed',
    'force_fifth_vertex', 'disallow_quad', 'promise', 'boolean_zero', 'extra_source'])
def test_task_cannot_launder_classification_gt_geometry_or_completion(task, attack):
    value = task[0]
    if attack in ('policy', 'view', 'pcd', 'source_hash', 'classification_hash'):
        value['source'][dict(policy='policy_id', view='viewpoint_candidate', pcd='source_pcd_sha256',
            source_hash='canonical_source_row_sha256', classification_hash='classification_row_sha256')[attack]] = 'changed'
    elif attack in ('polygon', 'mask', 'labelme', 'template'):
        value[attack] = []
    elif attack == 'extra_source':
        value['source']['fake_gt'] = True
    elif attack == 'rectangle':
        value['original_rectangle'][0][0] += 1
    elif attack == 'human_class':
        value['class_identity']['human_class_confirmed'] = True
    else:
        field, changed = dict(class_=('class_id', 3), completed=('counts_as_completed_annotation', True),
            saved=('production_saved', True), confirmed=('ground_truth_eligible', True), seed=('propagation_seed_eligible', True),
            force_fifth_vertex=('extra_vertices_must_not_be_forced', False), disallow_quad=('valid_four_point_manual_contour_allowed', False),
            promise=('neighbor_propagation_promised', True), boolean_zero=('generated_polygons', False))['class_' if attack == 'class' else attack]
        value[field] = changed
    with pytest.raises(ValueError):
        verifier.check_task(*task)


def test_read_store_rejects_raw_latest_event_whitespace_substitution(tmp_path):
    r = row(); value = pose_value(r); raw = json.dumps(value)
    path = tmp_path/'pose.sqlite3'
    with sqlite3.connect(path) as db:
        db.executescript('CREATE TABLE annotations(target_key TEXT,revision INTEGER,payload TEXT);'
            'CREATE TABLE events(id INTEGER,target_key TEXT,revision INTEGER,payload TEXT);'
            'CREATE TABLE metadata(key TEXT,value TEXT);')
        db.execute('INSERT INTO annotations VALUES (?,?,?)', (KEY, 1, raw+' '))
        db.execute('INSERT INTO events VALUES (?,?,?,?)', (1, KEY, 1, raw))
    before = verifier.digest(path)
    with pytest.raises(ValueError, match='exact raw latest event'):
        verifier.read_store(path, 'annotations', {KEY: r})
    assert verifier.digest(path) == before


@pytest.mark.parametrize('name', ['pallet_mask_remaining_round2_requests_v1', 'pallet_mask_remaining_round2_requests_v23'])
def test_only_strict_new_worklist_namespace_is_accepted(tmp_path, monkeypatch, name):
    monkeypatch.setattr(verifier, 'PROJECT', tmp_path)
    parent = tmp_path/'outputs/pallet_mask_remaining_round2_v1'
    assert verifier.valid_output(tmp_path/'outputs'/name, parent).name == name


@pytest.mark.parametrize('name', ['pallet_mask_remaining_round2_requests_v1_old', 'pallet_mask_remaining_round2_requests_v',
    'pallet_mask_remaining_round2_requests_v-1', 'pallet_mask_remaining_followup_requests_v1',
    'pallet_mask_remaining_round2_v1', 'nested/pallet_mask_remaining_round2_requests_v1'])
def test_old_or_ambiguous_output_namespace_rejected(tmp_path, monkeypatch, name):
    monkeypatch.setattr(verifier, 'PROJECT', tmp_path)
    with pytest.raises(ValueError):
        verifier.valid_output(tmp_path/'outputs'/name, tmp_path/'outputs/pallet_mask_remaining_round2_v1')


@pytest.mark.parametrize('name', ['../outside', '/absolute', 'images/../../outside'])
def test_bound_hashes_cannot_escape_root(tmp_path, name):
    with pytest.raises(ValueError):
        verifier.member(tmp_path, name)


def test_seals_are_identical_exclusive_and_do_not_modify_other_files(tmp_path):
    write_json(tmp_path/'manifest.json', {'frozen': 'must remain unchanged'})
    before = verifier.digest(tmp_path/'manifest.json')
    result = dict(state='passed', request_count=50, public_assets={})
    verifier.write_seals(tmp_path, result)
    first, second = tmp_path/'verification.json', tmp_path/'independent_verification.json'
    assert first.read_bytes() == second.read_bytes() == verifier.canonical(result)+b'\n'
    assert verifier.digest(tmp_path/'manifest.json') == before
    assert set(p.name for p in tmp_path.iterdir()) == {'manifest.json', 'verification.json', 'independent_verification.json'}
    with pytest.raises(ValueError, match='Preserve existing'):
        verifier.write_seals(tmp_path, result)


@pytest.mark.parametrize('existing', ['verification.json', 'independent_verification.json'])
def test_never_replace_either_existing_seal(tmp_path, existing):
    (tmp_path/existing).write_bytes(b'user-owned')
    with pytest.raises(ValueError):
        verifier.write_seals(tmp_path, {'state': 'passed'})
    assert (tmp_path/existing).read_bytes() == b'user-owned'
    assert len(list(tmp_path.iterdir())) == 1


def test_second_exclusive_destination_race_cannot_leave_a_partial_passed_seal(tmp_path, monkeypatch):
    original_open = Path.open
    def race(path, mode='r', *args, **kwargs):
        if path.name == 'independent_verification.json' and mode == 'xb':
            with original_open(path, 'wb') as handle:
                handle.write(b'other verifier owns this')
            raise FileExistsError(path)
        return original_open(path, mode, *args, **kwargs)
    monkeypatch.setattr(Path, 'open', race)
    with pytest.raises(FileExistsError):
        verifier.write_seals(tmp_path, {'state': 'passed'})
    assert not (tmp_path/'verification.json').exists()
    assert (tmp_path/'independent_verification.json').read_bytes() == b'other verifier owns this'


def test_failed_audit_never_creates_success_seal(tmp_path, monkeypatch):
    root = tmp_path/'outputs/pallet_mask_remaining_round2_requests_v2'
    root.mkdir(parents=True)
    monkeypatch.setattr(verifier, 'PROJECT', tmp_path)
    def fail(*args):
        raise ValueError('final full store fingerprint changed')
    monkeypatch.setattr(verifier, 'audit', fail)
    with pytest.raises(ValueError, match='fingerprint changed'):
        verifier.main(['--directory', str(root), '--parent', str(tmp_path/'outputs/parent')])
    assert not list(root.iterdir())


def test_self_check_result_cannot_be_used_to_issue_independent_seals(tmp_path):
    with pytest.raises(ValueError, match='full successful audit'):
        verifier.write_seals(tmp_path, {'state': 'self_checks_passed_not_independent_verification'})
    assert not list(tmp_path.iterdir())


def make_font(path, text):
    from fontTools.fontBuilder import FontBuilder
    from fontTools.pens.ttGlyphPen import TTGlyphPen
    chars = sorted({ord(c) for c in text})
    names = ['.notdef']+[f'uni{c:04X}' for c in chars]
    builder = FontBuilder(1000, isTTF=True)
    builder.setupGlyphOrder(names)
    builder.setupCharacterMap({c: name for c, name in zip(chars, names[1:])})
    builder.setupGlyf({name: TTGlyphPen(None).glyph() for name in names})
    builder.setupHorizontalMetrics({name: (500, 0) for name in names})
    builder.setupHorizontalHeader(ascent=800, descent=-200)
    builder.setupNameTable({'familyName': 'UnitTest', 'styleName': 'Regular'})
    builder.setupOS2(sTypoAscender=800, sTypoDescender=-200, usWinAscent=800, usWinDescent=200)
    builder.setupPost()
    builder.save(path)


@pytest.fixture
def public_case(tmp_path, monkeypatch):
    project = tmp_path/'project'; root = project/'outputs/worklist'; root.mkdir(parents=True)
    monkeypatch.setattr(verifier, 'PROJECT', project)
    license_path = project/'pallet/assets/pose_review/FONT_LICENSE.txt'
    license_path.parent.mkdir(parents=True); license_path.write_text('Test font license')
    (root/'FONT_LICENSE.txt').write_bytes(license_path.read_bytes())
    pose_url = 'https://pose.example'
    task = dict(target_key=KEY, class_id=4, native_image=f'images/{KEY}.png',
        contact_crop=f'cases/{KEY}.png', pose_annotation_url=pose_url+'/?target='+KEY)
    script = ("const f=document.querySelector('#request-filter');f.addEventListener('change',()=>{let n=0;"
        "for(const a of document.querySelectorAll('article')){a.hidden=!!f.value&&a.dataset.class!==f.value;"
        "if(!a.hidden)n++;}document.querySelector('#request-count').textContent=n;});")
    text = ('<html><style>@font-face{font-family:UnitTest;src:url(\'report-font.otf\')}</style>'
        '<h1>待独立验收，尚未激活</h1><p>四点</p><select id="request-filter"><option value="">全部</option>'
        +''.join(f'<option>{c}</option>' for c in verifier.CLASSES)+'</select>'
        +f'<article id="{KEY}" data-class="4"><a href="{task["pose_annotation_url"]}">标注</a>'
        +f'<img src="{task["native_image"]}"><img src="{task["contact_crop"]}"></article>'
        +f'<script>{script}</script></html>')
    (root/'report_zh.html').write_text(text)
    make_font(root/'report-font.otf', text)
    for field in ('native_image', 'contact_crop'):
        path = root/task[field]; path.parent.mkdir(); Image.new('L', (10, 10)).save(path)
    return root, dict(public_assets=verifier.file_inventory(root)), [task], pose_url


def test_exact_public_allowlist_chinese_glyphs_pending_bytes_and_pose_route(public_case):
    verifier.check_public(*public_case)
    assert len(public_case[1]['public_assets']) == 5


@pytest.mark.parametrize('attack', ['private_asset', 'missing_asset', 'private_link', 'external_image', 'private_css',
    'raw_payload', 'activated_marker', 'hidden_card', 'duplicate_card', 'wrong_class', 'class3_filter',
    'hide_with_script', 'bad_font', 'wrong_license', 'db', 'db_backup', 'db3_backup', 'disguised_db',
    'sqlite_backup', 'wal', 'journal', 'mask', 'labelme'])
def test_public_export_cannot_expose_private_data_databases_or_unverified_completion(public_case, attack):
    root, manifest, tasks, _ = public_case
    path = root/'report_zh.html'; text = path.read_text()
    if attack == 'private_asset':
        (root/'requests.jsonl').write_text('private')
        manifest['public_assets']['requests.jsonl'] = verifier.digest(root/'requests.jsonl')
    elif attack == 'missing_asset':
        manifest['public_assets'].pop(tasks[0]['contact_crop'])
    elif attack == 'private_link':
        text += '<a href="internal/build_decisions.json">private</a>'
    elif attack == 'external_image':
        text += '<img src="https://other.example/image.png">'
    elif attack == 'private_css':
        text += '<style>@font-face{src:url("input_manifest.json")}</style>'
    elif attack == 'raw_payload':
        text += 'existing_pose_current_payload'
    elif attack == 'activated_marker':
        text = text.replace('待独立验收，尚未激活', '已上线')
    elif attack == 'hidden_card':
        text = text.replace('data-class="4"', 'data-class="4" hidden')
    elif attack == 'duplicate_card':
        text += f'<article id="{KEY}"></article>'
    elif attack == 'wrong_class':
        text = text.replace('data-class="4"', 'data-class="3"')
    elif attack == 'class3_filter':
        text = text.replace('<option>4</option>', '<option>3</option>')
    elif attack == 'hide_with_script':
        text += '<script>document.querySelector("article").hidden=true;</script>'
    elif attack == 'bad_font':
        make_font(root/'report-font.otf', 'abc')
    elif attack == 'wrong_license':
        (root/'FONT_LICENSE.txt').write_text('wrong')
    elif attack in ('mask', 'labelme'):
        (root/('masks' if attack == 'mask' else 'labelme')).mkdir()
    elif attack == 'disguised_db':
        (root/'internal').mkdir()
        (root/'internal/data.bin').write_bytes(b'SQLite format 3\x00'+b'private')
    else:
        (root/dict(db='review.db', db_backup='review.db.backup', db3_backup='review.db3.backup', sqlite_backup='snapshot.sqlite3.bak',
            wal='snapshot-wal', journal='review.db-journal')[attack]).write_text('private database')
    path.write_text(text)
    for name in manifest['public_assets']:
        manifest['public_assets'][name] = verifier.digest(root/name)
    with pytest.raises(ValueError):
        verifier.check_public(*public_case)


def write_snapshot(path, table, current, events):
    path.parent.mkdir(parents=True, exist_ok=True)
    with sqlite3.connect(path) as db:
        db.executescript(f'CREATE TABLE {table}(target_key TEXT,revision INTEGER,payload TEXT);'
            'CREATE TABLE events(id INTEGER,target_key TEXT,revision INTEGER,payload TEXT);')
        db.executemany(f'INSERT INTO {table} VALUES (?,?,?)',
            [(key, value['revision'], current['raw'][key]) for key, value in current['current'].items()])
        db.executemany('INSERT INTO events VALUES (?,?,?,?)', events)


@pytest.fixture
def source_records(tmp_path):
    parent = tmp_path/'parent'; parent.mkdir()
    completed = []
    human_values = []
    for i in range(434):
        r = row(f'{i+1:024x}')
        value = pose_value(r, event_kind='original_pose_human_revision', human_edited=True)
        value['polygon'][0][0] += 2
        human_values.append(value)
        if i < 51:
            completed.append(dict(target_key=r['target_key']))
    old_values = []
    new_values = []
    for key, (cls, revision) in verifier.ORIGINAL_REVIEWS.items():
        value = pose_value(row(key, cls), revision)
        (old_values if key in verifier.OLD_ORIGINAL_REVIEWS else new_values).append(value)
        if key in verifier.NEW_ORIGINAL_REVIEWS:
            completed.append(dict(target_key=key))
    old_pose = store(human_values[51:]+old_values)
    extra = []
    for i in range(91):
        value = copy.deepcopy(human_values[0]); value['revision'] = i+1
        extra.append((len(old_pose['events'])+len(extra)+1, value['target_key'], value['revision'], json.dumps(value)))
    human_values[0]['revision'] = 92
    events = old_pose['events']+extra
    final_values = human_values+old_values+new_values
    for value in human_values[:51]+new_values:
        events.append((len(events)+1, value['target_key'], value['revision'], json.dumps(value, ensure_ascii=False, indent=2)))
    pose = store(final_values, events)
    # Current raw bytes must literally match their latest frozen events.
    pose['raw'].update({key: raw for _, key, _, raw in events})
    write_snapshot(parent/'parent_evidence/reviews_snapshot.sqlite3', 'annotations', old_pose, old_pose['events'])
    old_statement = {'scope': 'unchanged historical two'}
    statement = dict(scoped_request_keys=sorted(p['target_key'] for p in completed), scoped_candidate_keys=[],
        reviewed_original_rectangle_keys=sorted(verifier.NEW_ORIGINAL_REVIEWS),
        old_42_unsaved_not_inferred_reviewed=True, creates_human_event=False,
        confirms_ground_truth=False, authorizes_propagation=False)
    event_by_key = {key: (event_id, revision, raw) for event_id, key, revision, raw in events}
    humans, originals = [], []
    for value in final_values:
        key = value['target_key']; event_id, revision, raw = event_by_key[key]
        record = dict(target_key=key, source=value['source'], current_revision=value['revision'], current_payload=value,
            current_payload_raw=raw, current_payload_sha256=verifier.sha(value), current_payload_raw_sha256=verifier.raw_sha(raw))
        if key in verifier.ORIGINAL_REVIEWS:
            record.update(saved_review_event_id=event_id, saved_review_revision=revision,
                saved_review_event_payload_raw=raw, saved_review_event_sha256=verifier.raw_sha(raw),
                human_edited=False, propagation_seed_eligible=False, original_rectangle_review_only=True,
                user_statement_sha256=verifier.sha(old_statement if key in verifier.OLD_ORIGINAL_REVIEWS else statement))
            originals.append(record)
        else:
            record.update(human_event_id=event_id, human_polygon_revision=revision,
                human_event_payload_raw=raw, human_event_sha256=verifier.raw_sha(raw))
            humans.append(record)
    gallery_values, prior_new = [], []
    for i in range(824):
        r = row(f'{i+10000:024x}')
        value = pose_value(r, event_kind='human_mask_gallery_revision', human_edited=True)
        value.pop('state')  # The real gallery payload uses status, not pose state.
        value['polygon'][0][0] += 2
        if i >= 639:
            p = dict(target_key=r['target_key'], class_id=4, source=r, polygon=copy.deepcopy(value['polygon']))
            if i-639 >= 53:
                p['polygon'][0][0] += 2
            prior_new.append(p)
        gallery_values.append(value)
    old_gallery = store(gallery_values[:639])
    gallery_events = old_gallery['events'][:]
    for i in range(16):
        value = copy.deepcopy(gallery_values[639]); value['revision'] = i+1
        gallery_events.append((len(gallery_events)+1, value['target_key'], value['revision'], json.dumps(value)))
    gallery_values[639]['revision'] = 17
    for value in gallery_values[639:]:
        gallery_events.append((len(gallery_events)+1, value['target_key'], value['revision'], json.dumps(value, ensure_ascii=False, indent=2)))
    gallery = store(gallery_values, gallery_events)
    gallery['raw'].update({key: raw for _, key, _, raw in gallery_events})
    write_snapshot(parent/'parent_evidence/gallery_reviews_snapshot.sqlite3', 'reviews', old_gallery, old_gallery['events'])
    gallery_sources, saved_audit = [], []
    gallery_by_key = verifier.indexed(prior_new)
    for event_id, key, revision, raw in gallery_events:
        if raw != gallery['raw'][key]:
            continue
        value = gallery['current'][key]
        record = dict(target_key=key, revision=revision, current_payload=value, current_payload_raw=raw,
            current_payload_sha256=verifier.sha(value), current_payload_raw_sha256=verifier.raw_sha(raw),
            human_event_id=event_id, human_event_payload_raw=raw, human_event_sha256=verifier.raw_sha(raw))
        gallery_sources.append(record)
        if key in gallery_by_key:
            p = gallery_by_key[key]; same = value['polygon'] == p['polygon']
            saved_audit.append(dict(target_key=key, actual_saved=True, saved_review_unchanged=same,
                polygon_changed_from_proposal=not same, human_new_edit_claim=False, proposal_sha256=verifier.sha(p),
                current_payload_sha256=record['current_payload_sha256'], current_payload_raw_sha256=record['current_payload_raw_sha256'],
                human_event_id=event_id, human_event_sha256=record['human_event_sha256']))
    statement['scoped_candidate_keys'] = sorted(gallery_by_key)
    # Latest statement hash changes only for the three NEW originals.
    for record in originals:
        if record['target_key'] in verifier.NEW_ORIGINAL_REVIEWS:
            record['user_statement_sha256'] = verifier.sha(statement)
    originals.sort(key=lambda v: (v['target_key'] not in verifier.OLD_ORIGINAL_REVIEWS, v['target_key']))
    write_jsonl(parent/'all_manual_sources.jsonl', humans)
    write_jsonl(parent/'reviewed_original_rectangle_source_records.jsonl', originals)
    write_jsonl(parent/'parent_evidence/reviewed_original_rectangle_source_records.jsonl',
        [r for r in originals if r['target_key'] in verifier.OLD_ORIGINAL_REVIEWS])
    write_json(parent/'parent_evidence/review_completion_statement.json', old_statement)
    write_json(parent/'review_completion_statement.json', statement)
    write_jsonl(parent/'parent_evidence/new_proposals.jsonl', prior_new)
    write_jsonl(parent/'gallery_source_records.jsonl', gallery_sources)
    write_jsonl(parent/'saved_review_source_audit.jsonl', saved_audit)
    write_json(parent/'saved_review_status.json', dict(actually_saved=185, pending=0,
        polygon_changed_from_proposal=132, saved_unchanged=53,
        unchanged_keys=sorted(a['target_key'] for a in saved_audit if a['saved_review_unchanged']),
        unchanged_review_interpretation_statement_sha256=verifier.sha(statement)))
    dispositions = [dict(target_key=f'{i+20000:024x}', disposition='conversation_only_not_a_saved_mask') for i in range(45)]
    for folder in (parent, parent/'parent_evidence'):
        write_jsonl(folder/'review_dispositions.jsonl', dispositions)
        write_json(folder/'review_disposition_statement.json', {'scope': 'old45 conversation only'})
    previous_keys = ((set(pose['current'])-{p['target_key'] for p in completed}) | set(gallery['current'])
        | {d['target_key'] for d in dispositions} | {f'{i+21000:024x}' for i in range(42)})
    previous = [dict(target_key=k) for k in sorted(previous_keys)]
    assert len(previous) == 1296
    return parent, pose, gallery, previous, completed


def test_all434_genuine_pose_824_gallery_and_five_separate_reviews_have_real_raw_events(source_records):
    human_keys = verifier.check_source_records(*source_records)
    assert len(human_keys) == 1258
    assert human_keys.isdisjoint(verifier.ORIGINAL_REVIEWS)


@pytest.mark.parametrize('attack', ['human_raw', 'human_event', 'gallery_raw', 'gallery_event', 'gallery_missing',
    'original_as_edit', 'original_as_seed', 'old_new_statement', 'new_old_statement', 'old_bytes',
    'broaden_scope', 'infer_old42', 'unchanged_as_edit', 'saved_without_event', 'prefix_event', 'unrelated_current',
    'old45_as_saved', 'old42_as_disposition', 'old45_statement'])
def test_source_accounting_cannot_fabricate_saved_reviews_edits_scopes_or_event_prefix(source_records, attack):
    parent, pose, gallery, _, _ = source_records
    if attack.startswith('human_') or attack.startswith('gallery_'):
        path = parent/('all_manual_sources.jsonl' if attack.startswith('human_') else 'gallery_source_records.jsonl')
        records = verifier.read_jsonl(path)
        if attack == 'gallery_missing':
            records.pop()
        elif attack.endswith('raw'):
            records[0]['current_payload_raw'] += ' '
            records[0]['current_payload_raw_sha256'] = verifier.raw_sha(records[0]['current_payload_raw'])
        else:
            records[0]['human_event_id'] = -1
        write_jsonl(path, records)
    elif attack in ('original_as_edit', 'original_as_seed', 'old_new_statement', 'new_old_statement', 'old_bytes'):
        path = parent/'reviewed_original_rectangle_source_records.jsonl'
        records = verifier.read_jsonl(path)
        old = next(r for r in records if r['target_key'] in verifier.OLD_ORIGINAL_REVIEWS)
        new = next(r for r in records if r['target_key'] in verifier.NEW_ORIGINAL_REVIEWS)
        if attack == 'original_as_edit':
            new['human_edited'] = True
        elif attack == 'original_as_seed':
            new['propagation_seed_eligible'] = True
        elif attack == 'old_new_statement':
            old['user_statement_sha256'] = new['user_statement_sha256']
        elif attack == 'new_old_statement':
            new['user_statement_sha256'] = old['user_statement_sha256']
        else:
            old['scope'] = 'rewrite immutable old2'
        write_jsonl(path, records)
    elif attack in ('broaden_scope', 'infer_old42'):
        path = parent/'review_completion_statement.json'; statement = verifier.read_json(path)
        if attack == 'broaden_scope':
            statement['scoped_request_keys'].append('unrelated-old42')
        else:
            statement['old_42_unsaved_not_inferred_reviewed'] = False
        write_json(path, statement)
    elif attack in ('unchanged_as_edit', 'saved_without_event'):
        path = parent/'saved_review_source_audit.jsonl'; records = verifier.read_jsonl(path)
        if attack == 'unchanged_as_edit':
            records[0]['human_new_edit_claim'] = True
        else:
            records[0]['human_event_sha256'] = 'invented'
        write_jsonl(path, records)
    elif attack == 'prefix_event':
        event = list(pose['events'][0]); event[3] += ' '; pose['events'][0] = tuple(event)
    elif attack in ('old45_as_saved', 'old42_as_disposition', 'old45_statement'):
        if attack == 'old45_statement':
            write_json(parent/'review_disposition_statement.json', {'scope': 'broaden to all saved'})
        else:
            path = parent/'review_dispositions.jsonl'; records = verifier.read_jsonl(path)
            if attack == 'old45_as_saved':
                records[0]['target_key'] = next(iter(gallery['current']))
            else:
                records.append(dict(target_key=f'{21000:024x}', disposition='inferred inspected'))
            write_jsonl(path, records)
    else:
        key = next(iter(pose['current']))
        # Pick an old human outside the newly completed54.
        key = next(k for k in pose['current'] if k not in {p['target_key'] for p in source_records[4]})
        pose['current'][key]['ruler']['length'] += 1
        raw = json.dumps(pose['current'][key])
        pose['raw'][key] = raw
        records = verifier.read_jsonl(parent/'all_manual_sources.jsonl')
        record = next(r for r in records if r['target_key'] == key)
        record.update(current_payload=pose['current'][key], current_payload_raw=raw,
            current_payload_sha256=verifier.sha(pose['current'][key]), current_payload_raw_sha256=verifier.raw_sha(raw))
        write_jsonl(parent/'all_manual_sources.jsonl', records)
    with pytest.raises(ValueError):
        verifier.check_source_records(*source_records)
