"""Read-only remaining-class contracts; mutation fixtures are in-memory only."""
import copy
import hashlib
import json
import sqlite3

import numpy as np
import pytest
from PIL import Image

from pallet import mask_remaining_classes as audit
from pallet import mask_quota_100_continue as prior
from pallet.mask_template_transfer import annotation_inventory, rectangle
from pallet.pose_review_geometry import 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=22, 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 save(db, key='manual', cls=22, polygon=QUAD, auto=True, frame=None):
    r = row(key, cls, frame)
    human = dict(target_key=key, revision=6, state='draft', source=copy.deepcopy(r),
        binding='binding', polygon=copy.deepcopy(polygon), **dict.fromkeys(audit.FALSE_FLAGS, False))
    event_raw = json.dumps(human, indent=2)
    value = dict(human, revision=7, event_kind='unit_normalization') if auto else human
    raw = json.dumps(value, indent=1)
    db.execute('INSERT INTO annotations VALUES (?,?,?)', (key, value['revision'], raw))
    db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)', (key, 6, event_raw))
    if auto:
        db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)', (key, 7, raw))
    return r, raw, event_raw


def test_constants_are_remaining17_not_frozen_five_and_no_publication10():
    assert audit.CLASSES == (3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22)
    assert audit.GENERATION_NAMESPACE == 'remaining_classes_generation'
    assert audit.TARGET_PER_CLASS == 100
    assert audit.OUTPUT.name == 'pallet_mask_remaining_classes_v1'
    assert audit.PARENT.name == 'pallet_mask_quota_100_complete_v1'
    assert prior.GENERATION_NAMESPACE == 'quota100_continue_generation'
    assert audit.MANUAL_SCHEMA == 'saved_pose_mask_gallery_entry_v1'
    assert not hasattr(audit, 'PUBLICATION_VERSION')
    assert not hasattr(audit, 'attempt_target')


@pytest.mark.parametrize('cls', audit.CLASSES)
@pytest.mark.parametrize('polygon', [QUAD, POLYGON])
def test_exact_human_freeze_supports_all17_without_class_filter_or_database_writes(cls, polygon):
    with database() as db:
        r, raw, human_raw = save(db, cls=cls, polygon=polygon)
        before = db.total_changes
        candidate = audit.validated_manual_source(db, 'manual', r, 'snapshot', 'binding')
        assert db.total_changes == before
    value, metadata, record = candidate
    assert value['polygon'] == polygon
    assert metadata['human_polygon_revision'] == 6 and metadata['snapshot_revision'] == 7
    assert record['current_payload_raw'] == raw and record['human_event_payload_raw'] == human_raw
    assert record['current_payload_raw_sha256'] == hashlib.sha256(raw.encode()).hexdigest()
    assert record['human_event_sha256'] == hashlib.sha256(human_raw.encode()).hexdigest()
    assert record['human_event_sha256'] != audit.sha(json.loads(human_raw))
    p = audit.saved_manual_proposal('manual', r, candidate, 'snapshot', 'formal', 'classification')
    assert p['schema'] == audit.MANUAL_SCHEMA and p['source'] == r and p['class_id'] == cls
    assert p['polygon'] == polygon and p['vertex_count'] == len(polygon)
    assert p['manual_four_point_source'] == (len(polygon) == 4)
    assert p['propagation_seed_eligible'] == (len(polygon) > 4)
    assert ('template' in p) == (len(polygon) > 4)
    assert ('human_source' in p) == (len(polygon) == 4)
    assert p['manual_source_kind'] == 'existing_saved_human_reuse_remaining_classes'
    assert 'manual_request_sha256' not in p
    assert not any(p[f] for f in audit.FALSE_FLAGS)
    assert not p['machine_transfer_performed'] and not p['new_human_edit_created']
    assert not p['pose_store_written'] and not p['gallery_store_written']


@pytest.mark.parametrize('attack', ['rectangle', 'shifted_rectangle', 'reversed_rectangle',
    'no_event', 'auto_only', 'latest_human_mismatch', 'deleted', 'deferred', 'confirmed',
    'gt', 'training', 'robot', 'metric_confirmed', 'event_confirmed', 'wrong_current_source',
    'wrong_event_source', 'wrong_binding', 'event_binding', 'event_class', 'current_class',
    'self_intersection', 'triangle', 'nonfinite', 'event_revision', 'stale_current',
    'machine_human_event', 'unchanged_machine_then_save', 'explicitly_not_human',
    'machine_current', 'machine_then_normalization'])
def test_provenance_adversarial_four_point_sources_are_never_reused(attack):
    with database() as db:
        r, raw, event_raw = save(db, auto=False)
        value, event = json.loads(raw), json.loads(event_raw)
        if attack in ('rectangle', 'shifted_rectangle', 'reversed_rectangle'):
            polygon = rectangle(r)
            if attack == 'shifted_rectangle':
                polygon = polygon[1:]+polygon[:1]
            if attack == 'reversed_rectangle':
                polygon = polygon[::-1]
            value['polygon'] = event['polygon'] = polygon
        elif attack == 'no_event':
            db.execute('DELETE FROM events')
        elif attack == 'auto_only':
            value['event_kind'] = event['event_kind'] = 'axes_normalization'
        elif attack == 'latest_human_mismatch':
            event['polygon'][0][0] += .5
        elif attack in ('deleted', 'deferred'):
            value['state'] = attack
        elif attack in ('confirmed', 'gt', 'training', 'robot', 'metric_confirmed'):
            value[dict(confirmed='human_mask_confirmed', gt='ground_truth_eligible',
                training='automatic_training_eligible', robot='robot_command_eligible',
                metric_confirmed='metric_pose_confirmed')[attack]] = True
        elif attack == 'event_confirmed':
            event['human_pose_confirmed'] = True
        elif attack in ('wrong_current_source', 'wrong_event_source'):
            (value if attack == 'wrong_current_source' else event)['source']['split'] = 'test'
        elif attack in ('wrong_binding', 'event_binding'):
            (value if attack == 'wrong_binding' else event)['binding'] = 'wrong'
        elif attack in ('event_class', 'current_class'):
            (event if attack == 'event_class' else value)['source']['final_class_id'] = 99
        elif attack == 'self_intersection':
            value['polygon'] = event['polygon'] = [QUAD[0], QUAD[2], QUAD[1], QUAD[3]]
        elif attack == 'triangle':
            value['polygon'] = event['polygon'] = QUAD[:3]
        elif attack == 'nonfinite':
            value['polygon'][0][0] = event['polygon'][0][0] = float('nan')
        elif attack == 'event_revision':
            event['revision'] = 3
        elif attack == 'stale_current':
            later = dict(event, revision=8)
            db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',
                ('manual', 8, json.dumps(later)))
        elif attack == 'machine_human_event':
            event['machine_draft'] = True
        elif attack == 'unchanged_machine_then_save':
            machine = dict(event, revision=4, event_kind='mask_template_proposal')
            # Explicit IDs make this an earlier actual machine event.
            db.execute('UPDATE events SET id=2')
            db.execute('INSERT INTO events(id,target_key,revision,payload) VALUES (?,?,?,?)',
                (1, 'manual', 4, json.dumps(machine)))
        elif attack == 'explicitly_not_human':
            event['human_edited'] = False
        elif attack in ('machine_current', 'machine_then_normalization'):
            machine = dict(event, revision=7, event_kind='mask_template_proposal')
            value = machine
            db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',
                ('manual', 7, json.dumps(machine)))
            if attack == 'machine_then_normalization':
                value = dict(machine, revision=8, event_kind='axes_normalization')
                db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',
                    ('manual', 8, json.dumps(value)))
            db.execute('UPDATE annotations SET revision=?', (value['revision'],))
        db.execute('UPDATE annotations SET payload=?', (json.dumps(value),))
        db.execute('UPDATE events SET payload=? WHERE revision=6', (json.dumps(event),))
        with pytest.raises(ValueError):
            audit.validated_manual_source(db, 'manual', r, 'snapshot', 'binding')


def test_changed_polygon_after_machine_is_real_human_but_auto_after_human_does_not_count_as_edit():
    with database() as db:
        r, _, _ = save(db)
        machine = dict(target_key='manual', source=r, state='draft', revision=1,
            polygon=rectangle(r), event_kind='mask_template_proposal')
        db.execute('UPDATE events SET id=id+10')
        db.execute('INSERT INTO events(id,target_key,revision,payload) VALUES (?,?,?,?)',
            (1, 'manual', 1, json.dumps(machine)))
        value, metadata, record = audit.validated_manual_source(db, 'manual', r, 'snapshot', 'binding')
    assert value['revision'] == 7 and metadata['human_polygon_revision'] == 6
    assert record['human_event_id'] == 11


def test_source_audit_preserves_protection_and_excludes_saved_pose_only_rectangles():
    with database() as db:
        rows = {}
        for key in ('fine', 'quad', 'pose_only', 'history_restored', 'old_frame', 'quarantine',
                'confirmed', 'deleted', 'deferred', 'gallery'):
            r, raw, _ = save(db, key=key, polygon=POLYGON if key == 'fine' else QUAD)
            rows[key] = r
            if key in ('confirmed', 'deleted', 'deferred', 'pose_only', 'history_restored'):
                v = json.loads(raw)
                if key == 'confirmed':
                    v['human_mask_confirmed'] = True
                elif key in ('deleted', 'deferred'):
                    v['state'] = key
                else:
                    v['polygon'] = rectangle(r)
                db.execute('UPDATE annotations SET payload=? WHERE target_key=?', (json.dumps(v), key))
                db.execute('UPDATE events SET payload=? WHERE target_key=? AND revision=7', (json.dumps(v), key))
                if key == 'pose_only':
                    v['revision'] = 6
                    v.pop('event_kind', None)
                    db.execute('UPDATE events SET payload=? WHERE target_key=? AND revision=6', (json.dumps(v), key))
        changes = db.total_changes
        current, status, candidates, records = audit.audit_sources(db, rows, 'snapshot', 'binding',
            {rows['old_frame']['frame_id']}, {'quarantine'}, {'gallery'})
        assert changes == db.total_changes
    assert set(candidates) == {'fine', 'quad'}
    assert status['pose_only'] == 'eligible'
    assert status['history_restored'] == 'human_mask_history_protected'
    reasons = {r['target_key']: r['reason'] for r in records}
    assert reasons['confirmed'] == 'confirmed_protected'
    assert reasons['deleted'] == 'deleted' and reasons['deferred'] == 'deferred'
    assert reasons['old_frame'] == 'inherited_500_frame_protected'
    assert reasons['gallery'] == 'gallery_history_protected'
    assert reasons['quarantine'] == 'quarantined'
    assert reasons['pose_only'] == reasons['history_restored'] == 'original_rectangle_not_human_mask'


def test_global_frame_ownership_is_scarcity_first_maximum_matching_not_class_number_order():
    rows = {r['target_key']: r for r in [row('c3shared', 3, 'shared'),
        row('c19shared', 19, 'shared'), row('c3free', 3, 'common-only'), row('c3extra', 3),
        row('c17free', 17, 'scarce17'), row('c17shared', 17, 'scarce19'),
        row('c19other', 19, 'scarce19')]}
    assignments, counts, order = audit.assign_frames(rows, list(rows), {'c3shared'}, goal=1)
    by_frame = {a['frame_id']: a for a in assignments}
    assert counts[3] == counts[17] == counts[19] == 1
    assert order.index(17) < order.index(19) < order.index(3)
    assert by_frame['common-only']['class_id'] == 3
    assert by_frame['shared']['class_id'] in (3, 19)
    assert len(by_frame) == len(assignments)
    assert assignments == audit.assign_frames(rows, list(reversed(rows)), {'c3shared'}, goal=1)[0]


def test_duplicate_human_frame_selects_one_scarce_class_and_one_deterministic_target():
    rows = {r['target_key']: r for r in [row('common', 12, 'shared'),
        row('scarce-z', 22, 'shared'), row('scarce-a', 22, 'shared'), row('other', 12)]}
    assignments, counts, order = audit.assign_frames(rows, rows, {'common', 'scarce-z', 'scarce-a'})
    selected = {a['target_key'] for a in assignments if a['actual_saved_human']}
    assert selected == {'scarce-a'}
    assert order.index(22) < order.index(12)
    assert counts[12] == counts[22] == 1


def test_per_class_limit100_and_capacity_is_never_dupefilled():
    rows = {r['target_key']: r for r in [row(f'19-{i}', 19) for i in range(92)]+
        [row(f'17-{i}', 17) for i in range(105)]+[row(f'22-{i}', 22) for i in range(110)]}
    assignments, capacity, _ = audit.assign_frames(rows, rows, set(rows))
    actual = [a for a in assignments if a['phase'] == 'quota_capacity_matching']
    assert capacity[19] == 92 and capacity[17] == capacity[22] == 100
    assert len(actual) == 292
    assert len({a['frame_id'] for a in assignments}) == len(assignments)
    assert all(sum(a['class_id'] == c for a in actual) <= 100 for c in audit.CLASSES)


def test_inventory_all17_reports_class19_96_raw_92_after_old500_and_crossclass_blocks():
    rows = {r['target_key']: r for r in [row(f'19-{i}', 19) for i in range(96)]+[row('common', 3, 'frame-19-0')]}
    old_frames = {'frame-19-'+str(i) for i in range(4)}
    pool = [k for k, r in rows.items() if r['frame_id'] not in old_frames]
    assignments, capacity, _ = audit.assign_frames(rows, pool, set())
    counts = audit.class_inventory(rows, old_frames, pool, assignments, [], {}, [], capacity)
    assert set(counts) == set(audit.CLASSES)
    c = counts[19]
    assert c['distinct_frames'] == 96 and c['inherited_500_blocked_frames'] == 4
    assert c['remaining_unique_unprotected'] == c['capacity_matching_distinct_frames'] == 92
    assert c['structural_shortfall_before_inherited_constraints'] == 4
    assert c['inherited_image_crossclass_constraint_shortfall'] == 4
    assert c['capacity_shortfall'] == 8 and c['missing'] == 100
    assert all(v['proposed_target'] == 100 for v in counts.values())


def test_manual_quad_drawables_are_exact_and_not_machine_or_gt(tmp_path):
    with database() as db:
        r, _, _ = save(db)
        candidate = audit.validated_manual_source(db, 'manual', r, 'snapshot', 'binding')
    p = audit.saved_manual_proposal('manual', r, candidate, 'snapshot', 'formal', 'class')
    class Evidence:
        def image(self, frame):
            return np.zeros((16, 24), np.uint8)
    for directory in ('cases', 'images', 'masks', 'labelme'):
        (tmp_path/directory).mkdir()
    prior.package_manual_preview(tmp_path, [p], Evidence())
    label = audit.read_json(tmp_path/'labelme/manual.json')
    assert label['shapes'][0]['points'] == QUAD
    assert not label['flags']['machine_draft'] and not label['flags']['human_confirmed']
    assert np.array_equal(np.asarray(Image.open(tmp_path/'masks/manual.png')) > 0, raster_mask(QUAD, 24, 16))


def test_snapshot_and_backup_immutable_and_live_current_changes_fail(tmp_path):
    live, frozen = tmp_path/'live.sqlite3', tmp_path/'frozen.sqlite3'
    with sqlite3.connect(live) as db:
        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);')
        db.execute('INSERT INTO annotations VALUES (?,?,?)', ('key', 1, '{}'))
        db.execute('INSERT INTO events VALUES (?,?,?,?)', (1, 'key', 1, '{}'))
    frozen_sha = audit.snapshot_database(live, frozen)
    assert frozen.stat().st_mode & 0o777 == 0o400
    assert audit.digest(tmp_path/'backups/frozen.sqlite3') == frozen_sha
    prior.verify_sources_current(live, frozen, 'annotations')
    audit.verify_history_preserved(live, frozen)
    with sqlite3.connect(live) as db:
        db.execute('UPDATE events SET payload=?', ('changed',))
    with pytest.raises(ValueError, match='history changed'):
        audit.verify_history_preserved(live, frozen)
    with pytest.raises(ValueError, match='Concurrent human saves'):
        prior.verify_sources_current(live, frozen, 'annotations')


def test_output_refuses_existing_or_outside_outputs_before_reading_inputs(tmp_path):
    out = tmp_path/'existing'
    out.mkdir()
    marker = out/'user.txt'
    marker.write_text('keep')
    with pytest.raises(ValueError, match='new outputs directory'):
        audit.generate(out)
    assert marker.read_text() == 'keep'
    with pytest.raises(ValueError, match='new outputs directory'):
        audit.generate(tmp_path/'new-outside-outputs')
    assert not (tmp_path/'new-outside-outputs').exists()
