"""Read-only replay of the new dataset; does not import its producer or train."""
from collections import Counter, defaultdict
from contextlib import closing
import hashlib
import json
from pathlib import Path
import sqlite3
import sys

import cv2
import numpy as np

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))
from pallet.cluster_targets import digest
from pallet.mask_model_training_data import read, jsonl, sha, context_roi, letterbox, verify_dataset
from pallet.mask_quota_saved_extension import load_formal_evidence, file_inventory
from pallet.pose_review_geometry import canonical, raster_mask, polygon_value

ROOT = PROJECT/'outputs/pallet_mask_dataset_update_v1'
OLD = PROJECT/'outputs/pallet_mask_model_improvement_v5'
SOURCE = PROJECT/'outputs/pallet_mask_continuation_sources_v14'
EXCEPTIONS = PROJECT/'outputs/pallet_mask_nonconforming_requests_v1'
FALSE_FIELDS = ('ground_truth_eligible', 'automatic_training_eligible', 'human_mask_confirmed', 'human_pose_confirmed', 'robot_command_eligible')


def require(value, message):
    if not value:
        raise ValueError(message)


def raw_store(path, immutable=False):
    with closing(sqlite3.connect(Path(path).resolve().as_uri()+'?mode=ro'+('&immutable=1' if immutable else ''), uri=True)) as db:
        db.execute('BEGIN')
        return dict(events=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id')),
            current={key: (revision, raw) for key, revision, raw in db.execute('SELECT target_key,revision,payload FROM reviews')})


def record_contract(record, row, global_groups, forbidden):
    require(row['split'] == record['formal_split'] == 'train', 'Official heldout record in model supervision')
    require(record['component'] == global_groups[record['target_key']] and record['component'] not in forbidden, 'Global leakage group differs')
    require(record.get('source_quality') != 'nonconforming' and all(record.get(f) is False for f in FALSE_FIELDS), 'Unqualified label/flags promoted')
    require(record['roi'] == context_roi(row['bbox'], row['size']) and record['original_bbox'] == row['bbox'], 'Human polygon was used to derive or alter deployment ROI')


def verify():
    output = ROOT/'readonly_verification.json'
    require(not output.exists(), 'Keep earlier read-only verification evidence')
    cv2.setNumThreads(1)
    manifest, records = verify_dataset(ROOT); old_manifest, old_records = verify_dataset(OLD)
    require(manifest['code_sha256'] == digest(PROJECT/'pallet/mask_dataset_update.py'), 'New producer pin changed')
    require(all(manifest.get(f) is False for f in FALSE_FIELDS) and manifest['retraining_started'] is False, 'Manifest eligibility/retraining claims differ')
    for directory, files in read(ROOT/'private/previous_versions_inventory.json').items():
        require(file_inventory(PROJECT/directory) == files, 'Old frozen data/model/failure artifact changed: '+directory)
    catalog = jsonl(SOURCE/'private/source_catalog.jsonl'); base = {r['target_key']: r for r in catalog}
    formal, rows, _ = load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'))
    components = read(ROOT/'private/global_components.json'); forbidden = set(components['blocked_by_formal_val_test'])
    require(components['by_target'] == read(OLD/'private/global_components.json')['by_target'], 'Old global component partition changed')
    proposals = {p['target_key']: p for p in jsonl(EXCEPTIONS/'proposals.jsonl')}
    frozen = raw_store(ROOT/'private/nonconforming_snapshot.sqlite3', True)
    bindings = {r['event_id']: r for r in jsonl(ROOT/'private/nonconforming_event_binding.jsonl')}
    require(len(frozen['current']) == len(proposals) == 7 and set(frozen['current']) == set(proposals), 'Seven genuine isolated completions required')
    latest = {}; exception_records = []
    for event_id, key, revision, raw in frozen['events']:
        value = json.loads(raw); proposal = proposals[key]
        require(value['target_key'] == key and value['revision'] == revision
            and value['base_proposal_id'] == sha(proposal) and value['proposal_publication'] == 'nonconforming-v1'
            and value['worklist_manifest_sha256'] == digest(EXCEPTIONS/'manifest.json')
            and value['proposal_polygon'] == [] and value['event_kind'] == 'human_nonconforming_mask_review'
            and value['human_edited'] is True and value['source_quality'] == 'nonconforming'
            and value['counts_toward_under50'] is False and all(value[f] is False for f in FALSE_FIELDS), 'Isolated event source/flags invalid')
        require(bindings[event_id]['payload_raw_sha256'] == hashlib.sha256(raw.encode('utf-8')).hexdigest(), 'Isolated raw UTF-8 event hash differs')
        latest[key] = (revision, raw)
    require(latest == frozen['current'], 'Isolated current is not exact latest raw event')
    for key, (revision, raw) in frozen['current'].items():
        value = json.loads(raw)
        require(value['quality_decision'] == 'redrawn_pending_quality_check' and len(value['polygon']) >= 3, 'Check-only or empty record cannot count as a manually drawn contour')
        polygon_value(value['polygon'], *rows[key]['size'])
        exception_records.append(dict(target_key=key, row=rows[key], polygon=value['polygon']))
    count = Counter(); keys, frames, image_hashes = set(), set(), set()
    for reference in catalog+exception_records:
        key = reference['target_key']; row = reference['row']; h = digest(formal/row['image'])
        require(key not in keys and row['frame_id'] not in frames and h not in image_hashes, 'Duplicate original image in coverage')
        keys.add(key); frames.add(row['frame_id']); image_hashes.add(h); count[row['final_class_id']] += 1
    coverage = read(ROOT/'annotation_coverage.json')
    require(len(keys) == coverage['total_distinct_images'] == 1559 and all(coverage['classes'][str(c)]['all_manual_contours'] == count[c] for c in range(1, 23)), 'Raw manual coverage miscounted')
    require(all(count[c] >= 50 for c in range(1, 23)) and count[19] == 50
        and coverage['classes']['19']['standard_saved'] == 43 and coverage['classes']['19']['isolated_nonconforming_redrawn'] == 7,
        'Numeric completion and pending quality were conflated')
    record_map = {r['target_key']: r for r in records}; old_map = {r['target_key']: r for r in old_records}
    require(len(record_map) == len(records) == manifest['record_count'] and set(old_map) <= set(record_map)
        and not set(record_map) & set(proposals), 'Old retained/isolated quarantine key contract failed')
    newkeys = set(record_map)-set(old_map)
    batchkeys = {p['target_key'] for p in jsonl(PROJECT/'outputs/pallet_mask_under50_requests_v6/proposals.jsonl') if p['source']['split'] == 'train'}
    require(newkeys <= batchkeys and len(newkeys) == 31, 'Unexpected supervision additions outside authorized/latest research mask review')
    assignments = {r['component']: r['development_split'] for r in old_records}; internal = defaultdict(set)
    for r in records:
        row = rows[r['target_key']]; reference = base[r['target_key']]
        record_contract(r, row, components['by_target'], forbidden)
        require(r['polygon'] == reference['polygon'] and r['source_revision'] == reference['revision']
            and r['source_payload_sha256'] == reference['payload_sha256'] and r['source_event_raw_sha256'] == reference['event_raw_sha256'], 'Supervision does not match frozen real latest manual source')
        require(r['development_split'] == assignments.get(r['component'], 'train'), 'Old dev/cal group crossed into train')
        internal[r['component']].add(r['development_split'])
        if r['target_key'] in old_map:
            old = old_map[r['target_key']]
            require(r['image_id'] == old['image_id'] and r['development_split'] == old['development_split'], 'Old image ID/split changed')
            require(digest(ROOT/r['image']) == digest(OLD/old['image']) and digest(ROOT/r['native_mask']) == digest(OLD/old['native_mask']), 'Previously frozen model pixels or labels changed')
    require(all(len(v) == 1 for v in internal.values()), 'Internal train/dev/cal leakage')
    from pycocotools import mask as mu
    native_count = 0
    for split in ('train', 'valid', 'calibration'):
        coco = read(ROOT/f'dataset/{split}/_annotations.coco.json'); square = read(ROOT/f'dataset_rfdetr/{split}/_annotations.coco.json')
        require(len(coco['images']) == len(coco['annotations']) == len(square['images']) == len(square['annotations']), 'Model export pairs differ')
        byid = {r['image_id']: r for r in records}
        for image, ann, simage, sann in zip(coco['images'], coco['annotations'], square['images'], square['annotations']):
            r = byid[image['id']]; row = rows[r['target_key']]; x1, y1, x2, y2 = context_roi(row['bbox'], row['size'])
            pixels = cv2.imread(str(formal/row['image']), cv2.IMREAD_GRAYSCALE)[y1:y2, x1:x2]
            target = raster_mask(r['polygon'], *row['size']).astype(np.uint8)[y1:y2, x1:x2]
            def decode(value):
                v = value['segmentation']; return mu.decode(dict(size=v['size'], counts=v['counts'].encode()))
            require(image['file_name'] == f'{image["id"]-1:05d}.png' and r['image_id'] == image['id'] == ann['image_id'], 'Metadata leaked into model image names or IDs are unbound')
            require(np.array_equal(cv2.imread(str(ROOT/r['image'])), np.repeat(pixels[:, :, None], 3, axis=2))
                and np.array_equal(decode(ann), target)
                and np.array_equal(cv2.imread(str(ROOT/r['native_mask']), cv2.IMREAD_GRAYSCALE) > 0, target), 'Native source/ROI/RLE mismatch')
            canvas, label, _, transform = letterbox(pixels, target, (576, 576))
            require(np.array_equal(decode(sann), label) and np.array_equal(cv2.imread(str(ROOT/f'dataset_rfdetr/{split}/{simage["file_name"]}')), np.repeat(canvas[:, :, None], 3, axis=2)), 'Square letterbox/RLE mismatch')
            native_count += 1
    live = raw_store(PROJECT/'outputs/pallet_mask_nonconforming_reviews_v1/mask_reviews.sqlite3')
    require(live['events'][:len(frozen['events'])] == frozen['events'], 'Old isolated raw event history was not preserved')
    result = dict(state='passed_readonly_raw_coverage_latest_sources_model_exports_and_holdout_replay_not_quality',
        dataset_manifest_sha256=digest(ROOT/'dataset_manifest.json'), records=len(records), original_records_preserved=263,
        new_selected=len(newkeys), native_pairs_replayed=native_count, all22_at_least50_raw_manual_contours=True,
        class19_standard43_plus_nonconforming7=True, nonconforming_source_flags_promoted=False,
        nonconforming_labels_in_model_dataset=0, formal_val_test_in_model_dataset=0,
        old_seen_internal_holdouts_moved_to_train=0, new_model_outputs_or_training_runs=0,
        old_versions_inventory_verified=True, frozen_isolated_raw_event_count=len(frozen['events']),
        later_real_isolated_revisions_not_appended_to_training=len(live['events'])-len(frozen['events']),
        independent_contour_accuracy_not_certified=True, code_sha256=digest(__file__))
    with output.open('xb') as stream:
        stream.write(canonical(result)+b'\n')
    print(json.dumps(result), flush=True)
    return result


if __name__ == '__main__':
    verify()
