"""Recompute every bulk proposal and audit immutable sources and offline UX."""
from collections import Counter
from contextlib import closing
import json
import os
from pathlib import Path
import sqlite3
import sys
from zipfile import ZipFile

import numpy as np
from PIL import Image

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
from pallet.cluster_targets import digest,load_dataset,protected_snapshot
from pallet.mask_template_transfer import ImageEvidence,annotation_inventory,compatible,transfer
from pallet.pose_review_geometry import canonical,polygon_value,raster_mask


def main():
    out=PROJECT/'outputs/pallet_mask_template_bulk_v2'
    if (out/'verification.json').exists():raise ValueError('Frozen verification already exists')
    manifest=json.loads((out/'manifest.json').read_text())
    assert digest(PROJECT/'pallet/mask_template_bulk.py')==manifest['code_sha256']
    assert digest(PROJECT/'pallet/mask_template_transfer.py')==manifest['approved_transfer_code_sha256']
    assert digest(out/'reviews_snapshot.sqlite3')==manifest['snapshot_sha256']
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    _,sources=load_dataset(formal);classification=PROJECT/'outputs/pallet_appearance_center_reclassification_v1/targets.jsonl'
    assert digest(classification)==manifest['classification_sha256']
    rows={r['target_key']:r for r in map(json.loads,classification.read_text().splitlines())}
    for r in rows.values():r['size']=sources[r['frame_id']]['size']
    with closing(sqlite3.connect((out/'reviews_snapshot.sqlite3').as_uri()+'?mode=ro',uri=True)) as db:
        current,templates,status=annotation_inventory(db,rows)
    proposals=[json.loads(s) for s in (out/'proposals.jsonl').read_text().splitlines()]
    assert len({p['target_key'] for p in proposals})==len(proposals)==manifest['proposals']
    evidence=ImageEvidence(formal,rows,sources);counts=Counter()
    for p in proposals:
        key=p['target_key'];r=rows[key];t=templates[p['template']['target_key']]
        assert status[key]=='eligible' and compatible(t['row'],r)
        assert p['source']==r and p['template']['class_id']==p['class_id']==r['final_class_id']
        assert p['template']['human_event_sha256']==t['human_event_sha256']
        assert p['template']['current_payload_sha256']==t['current_payload_sha256']
        assert len(p['polygon'])==len(t['polygon'])==p['vertex_count']>4
        assert not p['human_mask_confirmed'] and not p['automatic_training_eligible'] and not p['robot_command_eligible']
        polygon_value(p['polygon'],*r['size'])
        repro,metrics=transfer(evidence.patch(t['row']['target_key']),evidence.patch(key),t['polygon'],t['row'],r)
        assert repro is not None,metrics
        np.testing.assert_allclose(repro,p['polygon'],atol=1e-6,rtol=0)
        label=json.loads((out/'labelme'/f'{key}.json').read_text())
        assert len(label['shapes'])==1 and label['shapes'][0]['points']==p['polygon']
        assert not label['flags']['human_confirmed'] and label['shapes'][0]['group_id']==r['box_index']
        np.testing.assert_array_equal(np.asarray(Image.open(out/'masks'/f'{key}.png'))>0,raster_mask(p['polygon'],*r['size']))
        np.testing.assert_array_equal(np.asarray(Image.open(out/'images'/f'{key}.png')),evidence.image(r['frame_id']))
        counts[r['final_class_id']]+=1
    outcomes=[json.loads(s) for s in (out/'outcomes.jsonl').read_text().splitlines()]
    assert len(outcomes)==len({r['target_key'] for r in outcomes})==12344
    assert set(r['target_key'] for r in outcomes if r['reason']=='proposal')=={p['target_key'] for p in proposals}
    assert sum(c['compatible_targets'] for c in manifest['classes'].values())==1194
    protected=json.loads((out/'protected_formal_before.json').read_text());assert protected_snapshot(formal)==protected
    live=PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3'
    with closing(sqlite3.connect(live.resolve().as_uri()+'?mode=ro',uri=True)) as db:
        db.execute('ATTACH DATABASE ? AS frozen',((out/'reviews_snapshot.sqlite3').as_uri()+'?mode=ro',))
        assert db.execute('SELECT COUNT(*) FROM frozen.events f LEFT JOIN main.events e ON f.id=e.id WHERE e.payload IS NULL OR f.payload!=e.payload').fetchone()[0]==0
    with ZipFile(out/'mask_template_bulk.zip') as z:
        assert z.testzip() is None
        for name in z.namelist():assert z.read(name)==(out/name).read_bytes()
    from fontTools.ttLib import TTFont
    report=(out/'report_zh.html').read_text();cmap=set(TTFont(out/'report-font.otf').getBestCmap())
    assert {ord(c) for c in report if '\u3400'<=c<='\u9fff'}<=cmap
    ordered=sorted(proposals,key=lambda p:(p['class_id'],p['metrics']['boundary_ncc']))
    for n in range((len(ordered)+7)//8):
        items=ordered[n*8:(n+1)*8];sheet=Image.new('RGB',(1480,len(items)*305),'#121923')
        for i,p in enumerate(items):sheet.paste(Image.open(out/'cases'/f'{p["target_key"]}.png'),(0,i*305))
        sheet.save(out/f'visual_review_page_{n+1}.png')
    os.environ.setdefault('PLAYWRIGHT_NODEJS_PATH','/tmp/opencode/pallet_review_browser_tools/node');sys.path.insert(0,'/tmp/opencode/pallet_review_pw132')
    from playwright.sync_api import sync_playwright
    checks=[]
    with sync_playwright() as pw:
        browser=pw.chromium.launch(executable_path='/tmp/opencode/pallet_pose_browser/chrome-linux64/chrome',headless=True,
            args=['--no-sandbox','--disable-dev-shm-usage','--disable-gpu','--disable-software-rasterizer'])
        for width in (1400,390):
            context=browser.new_context(viewport=dict(width=width,height=900));page=context.new_page();errors=[]
            page.on('pageerror',lambda e:errors.append(str(e)));page.goto((out/'report_zh.html').as_uri())
            page.evaluate('document.fonts.ready');page.evaluate("document.querySelectorAll('img').forEach(x=>x.loading='eager')")
            page.wait_for_function('Array.from(document.images).every(x=>x.complete&&x.naturalWidth>0)')
            assert page.locator('article').count()==len(proposals)
            assert page.evaluate('document.documentElement.scrollWidth<=innerWidth')
            page.locator('#filter').select_option('10');assert page.locator('article:visible').count()==counts[10]
            assert not errors;page.screenshot(path=str(out/f'html_{width}px.png'))
            checks.append(dict(width=width,all_images_loaded=True,no_overflow=True,filter_works=True,Chinese_font_loaded=True,page_errors=errors))
            context.close()
        browser.close()
    old={p['target_key'] for p in map(json.loads,(PROJECT/'outputs/pallet_mask_template_preview_v3/proposals.jsonl').read_text().splitlines())}
    result=dict(state='passed',proposals_verified=len(proposals),new_beyond_preview=len({p['target_key'] for p in proposals}-old),
        classes=dict(counts),all_accepted_registrations_recomputed=True,all_outcomes_accounted=12344,
        compatible_targets_scanned=1194,protected_formal_files_verified=len(protected),
        historical_event_payloads_verified=manifest['snapshot_events'],vertex_count_order_native_bounds_and_no_self_intersection=True,
        masks_labelme_and_original_images_match=True,all_cross_split_transfers=0,
        zip_crc_and_contents_verified=True,browser_checks=checks,production_database_writes=0,
        proposals_sha256=digest(out/'proposals.jsonl'),archive_sha256=digest(out/'mask_template_bulk.zip'),
        limitations=['Not independent mask ground truth; template labels are unconfirmed edits.',
            'Image matching gates are quality filters, not accuracy probabilities.'])
    (out/'verification.json').write_bytes(canonical(result)+b'\n');print(json.dumps(result),flush=True)


if __name__=='__main__':main()
