"""v2 is an explicit new audit, never a silent waiver of strict v1 policy."""
import copy
import importlib.util
import json
from pathlib import Path

import pytest

from pallet.mask_model_training_history_v2 import compare_history
from pallet.mask_model_training_integrity import compare_gallery_extension


def payload(key, revision, value):
    return json.dumps(dict(target_key=key, revision=revision, polygon=[[0, 0], [value, 0], [value, 3]],
                           proposal_publication=15, base_proposal_id='sealed-task-proposal'))


def baseline():
    raw = payload('old', 1, 3)
    return dict(schema=[('table', 'reviews', 'reviews', 'frozen')],
        columns=dict(reviews=['target_key', 'revision', 'payload'], events=['id', 'target_key', 'revision', 'payload'],
                     metadata=['key', 'value'], sqlite_sequence=['name', 'seq']),
        tables=dict(reviews=[('old', 1, raw)], events=[(1, 'old', 1, raw)],
                    metadata=[('binding', 'unchanged')], sqlite_sequence=[('events', 1)]))


def revised():
    current = baseline()
    raw = payload('old', 2, 4)
    current['tables']['events'].append((2, 'old', 2, raw))
    current['tables']['reviews'] = [('old', 2, raw)]
    current['tables']['sqlite_sequence'] = [('events', 2)]
    return current


def task_validator(value, event):
    if value['proposal_publication'] != 15 or value['base_proposal_id'] != 'sealed-task-proposal':
        raise ValueError('Unsupported immutable task triple')
    return dict(namespace='v3', task_manifest_sha256='pinned')


def test_new_v2_accepts_provenance_bound_old_key_revision_but_v1_still_rejects():
    old, new = baseline(), revised()
    with pytest.raises(ValueError, match='TRAINED source'):
        compare_gallery_extension(old, new, {'new_key_only'}, {'old'})
    result = compare_history(old, new, task_validator)
    assert result['changed_keys'] == {'old'}
    assert result['summary']['baseline_raw_event_prefix_identical']
    assert result['summary']['baseline_current_raw_payloads_preserved_as_historical_events']
    assert not result['summary']['baseline_current_raw_payloads_unchanged']
    assert result['delta_events'][0]['revision'] == 2


@pytest.mark.parametrize('change', ['prefix', 'metadata', 'schema', 'current', 'revision', 'triple', 'removed', 'sequence'])
def test_revision_proof_rejects_tampering(change):
    old, new = baseline(), revised()
    if change == 'prefix':
        new['tables']['events'][0] = (1, 'old', 1, payload('old', 1, 99))
    elif change == 'metadata':
        new['tables']['metadata'] = [('binding', 'changed')]
    elif change == 'schema':
        new['schema'] = []
    elif change == 'current':
        new['tables']['reviews'] = [('old', 2, payload('old', 2, 99))]
    elif change == 'revision':
        new['tables']['events'][1] = (2, 'old', 1, payload('old', 1, 4))
    elif change == 'triple':
        value = json.loads(new['tables']['events'][1][3])
        value['base_proposal_id'] = 'different-task'
        new['tables']['events'][1] = (2, 'old', 2, json.dumps(value))
    elif change == 'removed':
        new['tables']['reviews'] = []
    elif change == 'sequence':
        new['tables']['sqlite_sequence'] = [('events', 99)]
    with pytest.raises(ValueError):
        compare_history(old, new, task_validator)


def test_unchanged_current_is_not_falsely_marked_superseded():
    old = baseline()
    result = compare_history(old, copy.deepcopy(old), task_validator)
    assert result['summary']['appended_events'] == 0
    assert result['summary']['baseline_current_raw_payloads_unchanged']
    assert not result['changed_keys']


def test_baseline_current_must_be_proven_in_raw_history_not_just_same_polygon():
    old, new = baseline(), revised()
    old['tables']['reviews'][0] = ('old', 1, json.dumps(json.loads(old['tables']['reviews'][0][2]), sort_keys=True))
    with pytest.raises(ValueError, match='absent from old raw history'):
        compare_history(old, new, task_validator)


def test_pidfd_wait_is_one_kernel_event_not_status_poll(monkeypatch):
    path = Path(__file__).resolve().parents[1]/'scripts/verify_mask_model_training_history_v2.py'
    spec = importlib.util.spec_from_file_location('history_v2_wait_entry', path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    calls = []
    monkeypatch.setattr(module, 'open_pidfd', lambda pid: calls.append(('open', pid)) or 12)
    monkeypatch.setattr(module.select, 'select', lambda a, b, c: calls.append(('wait', a, b, c)))
    monkeypatch.setattr(module.os, 'close', lambda fd: calls.append(('close', fd)))
    module.wait_for_process_exit(2515)
    assert calls == [('open', 2515), ('wait', [12], [], []), ('close', 12)]


def test_pidfd_api_really_available_even_when_python_omits_wrapper():
    path = Path(__file__).resolve().parents[1]/'scripts/verify_mask_model_training_history_v2.py'
    spec = importlib.util.spec_from_file_location('history_v2_real_pidfd', path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    # Own test process only: do not query/open/poll the running model worker.
    descriptor = module.open_pidfd(module.os.getpid())
    assert descriptor >= 0
    module.os.close(descriptor)
