"""Publication11 contracts; mutation fixtures never touch production SQLite."""
import copy
import json
import sqlite3

import numpy as np
import pytest
from PIL import Image

from pallet import mask_remaining_continue as cont
from pallet.mask_template_transfer import rectangle
from pallet.pose_review_geometry import canonical, raster_mask


QUAD = [[1.1, 1.5], [20, 1], [20.1, 9], [1, 10]]
POLYGON = [[1, 1], [20, 1], [20, 10], [15, 10], [15, 5], [5, 5], [5, 10], [1, 10]]


def row(key, cls=3, frame=None):
    return dict(target_key=key, target_id='target-'+key, frame_id=frame or 'frame-'+key,
        final_class_id=cls, split='train', group_id='group-'+key, box_index=0,
        policy_id='camera', viewpoint_candidate='front', source_pcd_sha256='pcd',
        bbox=dict(x=1, y=1, width=19, height=9), size=[24, 16])


def database():
    db = sqlite3.connect(':memory:')
    db.executescript('CREATE TABLE annotations(target_key TEXT,revision INTEGER,payload TEXT);'
        'CREATE TABLE events(id INTEGER PRIMARY KEY,target_key TEXT,revision INTEGER,payload TEXT);')
    return db


def payload(r, polygon=None, revision=2):
    return dict(target_key=r['target_key'], revision=revision, state='draft', source=copy.deepcopy(r),
        binding='binding', polygon=copy.deepcopy(rectangle(r) if polygon is None else polygon),
        reviewer='real reviewer', pose=dict(robot_command_eligible=False), **dict.fromkeys(cont.FALSE_FLAGS, False))


def insert(db, value, raw=None):
    raw = json.dumps(value, indent=2) if raw is None else raw
    db.execute('INSERT INTO annotations VALUES (?,?,?)', (value['target_key'], value['revision'], raw))
    db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',
        (value['target_key'], value['revision'], raw))
    return raw


def statement(key):
    return dict(statement_zh=cont.USER_STATEMENT, scoped_request_keys=[key], reviewed_original_rectangle_keys=[key])


def proposal(key, cls=3, frame=None):
    return dict(target_key=key, class_id=cls, source=row(key, cls, frame), metrics={})


def request(r):
    return dict(target_key=r['target_key'], class_id=r['final_class_id'],
        source=dict(r, formal_manifest_sha256='formal'), pose_annotation_url='https://example.invalid/'+r['target_key'])


def test_constants_and_frozen_original_engine_identity():
    assert cont.PUBLICATION_VERSION == 11
    assert cont.GENERATION_NAMESPACE == 'remaining_continue_generation'
    assert cont.OUTPUT.name == 'pallet_mask_remaining_continue_v1'
    assert cont.PARENT.name == 'pallet_mask_remaining_expand_v1'
    assert cont.REQUESTS.name == 'pallet_mask_remaining_direct_requests_v2'
    assert cont.attempt_target is cont.original.attempt_target
    assert cont.original.CLASSES == (1, 2, 9, 10, 15)
    assert len(cont.HISTORICAL_NAMESPACES) == 9
    assert cont.REVIEW_SCHEMA == cont.REVIEW_ORIGIN == 'reviewed_original_rectangle_entry_v1'


def test_original_review_binds_real_raw_event_without_claiming_human_polygon_edit():
    r = row('box', 4); value = payload(r)
    with database() as db:
        raw = insert(db, value); before = db.total_changes
        v, metadata, record = cont.exact_original_rectangle_review(db, 'box', r, 'snapshot', 'binding', statement('box'))
        assert db.total_changes == before
        with pytest.raises(ValueError):
            cont.remaining.validated_manual_source(db, 'box', r, 'snapshot', 'binding')
    assert v == value and record['current_payload_raw'] == record['saved_review_event_payload_raw'] == raw
    assert record['saved_review_event_id'] == 1 and record['saved_review_revision'] == 2
    assert record['saved_pose_review_source'] and record['user_reviewed_no_change']
    assert not record['human_edited'] and not record['propagation_seed_eligible']
    assert not any(record[f] for f in cont.FALSE_FLAGS)
    assert 'human_polygon_revision' not in record and 'human_polygon_revision' not in metadata
    assert metadata['pose_review']['user_statement_sha256'] == cont.sha(statement('box'))


@pytest.mark.parametrize('attack', ['target', 'revision', 'binding', 'split', 'bbox', 'frame', 'policy',
    'class', 'viewpoint', 'changed_quad', 'deleted', 'deferred', 'confirmed', 'gt', 'train', 'robot',
    'nested_robot', 'auto', 'machine', 'origin', 'absent_event', 'different_raw', 'newer_event',
    'older_modified', 'older_confirmed', 'older_machine', 'statement', 'scope', 'duplicate_current', 'duplicate_event'])
def test_original_review_rejects_identity_state_history_flags_and_missing_user_authority(attack):
    r = row('box', 7); value = payload(r); s = statement('box')
    if attack in ('target', 'revision', 'binding'):
        value[{'target': 'target_key', 'revision': 'revision', 'binding': 'binding'}[attack]] = 'wrong'
    elif attack in ('split', 'bbox', 'frame', 'policy', 'class', 'viewpoint'):
        f = {'frame': 'frame_id', 'policy': 'policy_id', 'class': 'final_class_id', 'viewpoint': 'viewpoint_candidate'}.get(attack, attack)
        value['source'][f] = 'wrong'
    elif attack == 'changed_quad':
        value['polygon'] = QUAD
    elif attack in ('deleted', 'deferred', 'confirmed'):
        value['state'] = attack
    elif attack in ('gt', 'train', 'robot'):
        value[{'gt': 'ground_truth_eligible', 'train': 'automatic_training_eligible', 'robot': 'robot_command_eligible'}[attack]] = True
    elif attack == 'nested_robot':
        value['pose']['robot_command_eligible'] = True
    elif attack == 'auto':
        value['event_kind'] = next(iter(cont.AUTO_EVENTS))
    elif attack == 'machine':
        value['machine_draft'] = True
    elif attack == 'origin':
        value['origin'] = 'unknown_machine'
    elif attack == 'statement':
        s['statement_zh'] = 'Completed something else'
    elif attack == 'scope':
        s['scoped_request_keys'] = []
    with database() as db:
        if attack.startswith('older_'):
            old = payload(r, revision=1)
            if attack == 'older_modified':
                old['polygon'] = QUAD
            elif attack == 'older_confirmed':
                old['ground_truth_eligible'] = True
            else:
                old['machine_transfer_performed'] = True
            db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)', ('box', 1, json.dumps(old)))
        # Keep relational identities fixed to expose malformed payload fields.
        raw = json.dumps(value, indent=2)
        db.execute('INSERT INTO annotations VALUES (?,?,?)', ('box', 2, raw))
        if attack != 'absent_event':
            event_raw = json.dumps(value) if attack == 'different_raw' else raw
            db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)', ('box', 2, event_raw))
        if attack in ('duplicate_event', 'newer_event'):
            db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',
                ('box', 2 if attack == 'duplicate_event' else 3, raw))
        if attack == 'duplicate_current':
            db.execute('INSERT INTO annotations VALUES (?,?,?)', ('box', 2, raw))
        with pytest.raises(ValueError):
            cont.exact_original_rectangle_review(db, 'box', r, 'snapshot', 'binding', s)


def test_completed_modified_quads_and_reviewed_boxes_have_separate_schemas_and_rendering_branches(tmp_path):
    rs = {r['target_key']: r for r in (row('modified', 5), row('original', 4))}
    with database() as db:
        insert(db, payload(rs['modified'], QUAD)); insert(db, payload(rs['original']))
        candidates = {'modified': cont.remaining.validated_manual_source(db, 'modified', rs['modified'], 'snapshot', 'binding')}
        reviewed = {'original': cont.exact_original_rectangle_review(db, 'original', rs['original'], 'snapshot', 'binding', statement('original'))}
        before = db.total_changes
        manual = cont.completed_manual_proposals([request(r) for r in rs.values()], candidates, reviewed, rs, [],
            'snapshot', 'formal', 'classification')
        assert db.total_changes == before
    values = {p['target_key']: p for p in manual}
    assert values['modified']['schema'] == cont.MANUAL_SCHEMA
    assert values['modified']['origin'] == cont.prior.POSE_ORIGIN and values['modified']['human_edited']
    assert values['modified']['manual_four_point_source']
    assert values['original']['schema'] == cont.REVIEW_SCHEMA and not values['original']['human_edited']
    assert values['original']['source_label_kind'] == 'REVIEWED_ORIGINAL_RECTANGLE'
    for p in manual:
        assert 'template' not in p and 'human_source' in p
        assert not p['propagation_seed_eligible'] and not p['machine_transfer_performed']
        assert not p['new_human_edit_created'] and p['metrics'] == {}
        assert not any(p[f] for f in cont.FALSE_FLAGS)
    class Evidence:
        def image(self, frame):
            return np.zeros((16, 24), np.uint8)
    for d in ('cases', 'images', 'masks', 'labelme'):
        (tmp_path/d).mkdir()
    cont.package_manual_preview(tmp_path, manual, Evidence())
    for key, r in rs.items():
        label = cont.read_json(tmp_path/'labelme'/f'{key}.json')
        assert label['imagePath'] == '../images/'+key+'.png'
        assert label['annotation_scope'] == 'single_target_mask_review_not_full_frame'
        assert label['flags']['human_edited'] == (key == 'modified')
        assert not label['flags']['machine_draft'] and not label['flags']['ground_truth_eligible']
        assert len(label['shapes']) == 1
        assert np.array_equal(np.asarray(Image.open(tmp_path/'masks'/f'{key}.png')) > 0,
            raster_mask(values[key]['polygon'], *r['size']))
    assert cont.generation_templates(candidates, {'modified'}, {}, set(), 'formal', 'classification') == {}


@pytest.mark.parametrize('attack', ['locked_frame', 'locked_key', 'quarantine', 'gallery', 'class', 'split', 'formal', 'missing'])
def test_completed_sources_fail_closed(attack):
    r = row('manual', 4)
    with database() as db:
        insert(db, payload(r, QUAD))
        candidates = {'manual': cont.remaining.validated_manual_source(db, 'manual', r, 'snapshot', 'binding')}
    req = request(r); previous = []; quarantine = []; gallery = []
    if attack == 'locked_frame':
        previous = [proposal('locked', 22, r['frame_id'])]
    elif attack == 'locked_key':
        previous = [proposal('manual', 4)]
    elif attack == 'quarantine':
        quarantine = ['manual']
    elif attack == 'gallery':
        gallery = ['manual']
    elif attack in ('class', 'split', 'formal'):
        if attack == 'class':
            req['class_id'] = 1
        else:
            req['source']['split' if attack == 'split' else 'formal_manifest_sha256'] = 'wrong'
    else:
        candidates = {}
    with pytest.raises(ValueError):
        cont.completed_manual_proposals([req], candidates, {}, {'manual': r}, previous,
            'snapshot', 'formal', 'classification', quarantine, gallery)


def test_only_remaining_counted_pose_and_actually_saved_gallery_seed_no_old5_or_other_unsaved():
    rs = {r['target_key']: r for r in (row('quad', 4), row('seed', 3), row('old5', 1), row('unrelated', 3))}
    with database() as db:
        for k, r in rs.items():
            insert(db, payload(r, QUAD if k == 'quad' else POLYGON))
        candidates = {k: cont.remaining.validated_manual_source(db, k, r, 'snapshot', 'binding') for k, r in rs.items()}
    gallery = {'saved': dict(row=row('saved', 3), polygon=POLYGON, origin=cont.original.GALLERY_ORIGIN,
        saved_review_unchanged=True, new_human_edit_created=False)}
    templates = cont.generation_templates(candidates, {'quad', 'seed'}, gallery, {'saved'}, 'formal', 'classification')
    assert set(templates) == {'saved', 'seed'}
    assert templates['saved']['saved_review_unchanged'] and not templates['saved']['new_human_edit_created']
    assert all(t['rendering_id'].startswith('remaining_continue_generation:') for t in templates.values())
    with pytest.raises(ValueError):
        cont.generation_templates(candidates, {'old5'}, gallery, set(), 'formal', 'classification')
    with pytest.raises(ValueError):
        cont.generation_templates(candidates, {'seed'}, gallery, {'unsaved'}, 'formal', 'classification')


def test_filled6_and13_never_attempt_and_all_locked_frames_protected_across_classes():
    locked = [proposal(f'full{c}-{i}', c) for c in (6, 13) for i in range(100)]
    rs = [row('c6', 6), row('c13', 13), row('active', 3), row('crossclass', 19, locked[0]['source']['frame_id'])]
    rows = {r['target_key']: r for r in rs}
    work, outcomes = cont.target_inventory(rows, locked, dict.fromkeys(rows, 'eligible'), set(), set(), set())
    assert [k for k, _ in work] == ['active']
    reasons = {v['target_key']: v['reason'] for v in outcomes}
    assert reasons == {'c6': 'locked_class_quota_full', 'c13': 'locked_class_quota_full', 'crossclass': 'locked_counted_frame'}
    selected = cont.expand.select_locked_diverse(locked, [proposal('attemptfull', 6), proposal('new', 3)])[0]
    assert [p['target_key'] for p in selected] == ['new']


def test_coverage_keeps_modified_and_original_review_and_old_conversation_dispositions_separate():
    previous = [proposal('saved', 3), proposal('old-unsaved', 1), proposal('old-discussion', 1), proposal('old-pose', 4)]
    manual = [proposal('modified', 4), proposal('original', 7)]
    manual[0]['schema'] = cont.MANUAL_SCHEMA; manual[1]['schema'] = cont.REVIEW_SCHEMA
    new = [proposal('machine', 3)]
    reviews = {'saved': dict(event_kind='human_mask_gallery_revision', human_edited=True, polygon=POLYGON, state='draft')}
    sources = [dict(target_key=k, manual_four_point_source=True) for k in ('old-pose', 'modified')]
    counts = cont.class_counts(previous, manual, new, reviews, sources, [dict(target_key='original')],
        [dict(target_key='old-discussion')], {}, {p['target_key']: p['source'] for p in previous+manual+new}, [], [],
        dict.fromkeys(cont.ALL_CLASSES, 100))
    assert counts[4]['saved_human'] == counts[4]['modified_pose_source_records'] == 2
    assert counts[7]['saved_human'] == 0 and counts[7]['reviewed_original_rectangle'] == counts[7]['db_stored_human_review'] == 1
    assert counts[7]['pending_machine_raw'] == 0 and counts[7]['manual_modified_added'] == 0
    assert counts[1]['user_reviewed_no_change'] == counts[1]['no_new_server_review'] == 1
    assert counts[3]['saved_gallery_human'] == counts[3]['new_machine_pending'] == 1


def test_rendering_inventory_preserves_historical_objects_and_distinct_review_branch():
    old = proposal('old'); old['rendering_id'] = 'old_generation:seed'
    historical = dict(rendering_id=old['rendering_id'], polygon=POLYGON)
    parent = dict(templates=[historical], manual_source_renderings=[], rendering_by_target={'old': old['rendering_id']})
    p = dict(proposal('original', 4), rendering_id='remaining_continue_generation:review_source:original',
        polygon=rectangle(row('original', 4)), human_source=dict(origin=cont.REVIEW_ORIGIN),
        original_rectangle_review_only=True, human_edited=False)
    before = canonical(parent)
    inv = cont.rendering_inventory(parent, {}, [p], [old, p], set())
    assert canonical(parent) == before and inv['templates'] == [historical]
    assert inv['manual_source_renderings'][0]['original_rectangle_review_only']
    assert not inv['manual_source_renderings'][0]['human_edited']
    assert not inv['manual_source_renderings'][0]['manual_four_point_source']


def test_chinese_report_all22_only_new_default_and_review_only_labels(tmp_path):
    fields = ('old_total', 'manual_modified_added', 'reviewed_original_rectangle', 'saved_human',
        'new_candidates', 'total', 'missing', 'saved_pose_human', 'saved_gallery_human',
        'db_stored_human_review', 'capacity_matching_distinct_frames')
    counts = {c: dict.fromkeys(fields, 0) for c in cont.ALL_CLASSES}
    status = dict(unchanged_keys=[])
    cont.build_report(tmp_path, [], counts, set(), set(), set(), {}, set(), status, {})
    text = (tmp_path/'report_zh.html').read_text()
    assert 'id="only-new" checked' not in text
    assert all(f'<option value="{c}">{c}</option>' in text for c in cont.ALL_CLASSES)
    assert 'max-width:1090px' in text and 'overflow-x:auto' in text
    assert cont.USER_STATEMENT in text and '本轮新增机器候选 0 份' in text
    p = dict(proposal('original', 4), original_rectangle_review_only=True)
    cont.build_report(tmp_path, [p], counts, {'new'}, {'original'}, set(), {}, set(), status, {})
    text = (tmp_path/'report_zh.html').read_text()
    assert 'id="only-new" checked' in text
    assert 'data-kind="reviewed_original_rectangle"' in text
    assert '仅计复核覆盖，不是人工改绘或模板' in text
    assert cont.read_json(tmp_path/'font_coverage.json')['all_report_Chinese_present']


def test_generation_rejects_existing_outside_and_invalid_workers_before_any_write(tmp_path):
    existing = tmp_path/'existing'; existing.mkdir(); marker = existing/'user.txt'; marker.write_text('keep')
    with pytest.raises(ValueError, match='new outputs directory'):
        cont.generate(existing)
    assert marker.read_text() == 'keep'
    with pytest.raises(ValueError, match='new outputs directory'):
        cont.generate(tmp_path/'outside')
    with pytest.raises(ValueError, match='Workers'):
        cont.generate(cont.PROJECT/'outputs/nonexistent-invalid-workers-continue-test', workers=0)
