"""Independently verify preview identities, polygons, raster masks and HTML UX."""
import argparse
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
from pallet.pose_review_geometry import polygon_value,raster_mask,canonical
from pallet.mask_template_transfer import ImageEvidence,compatible,correlate,annotation_inventory


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output',type=Path,default=PROJECT/'outputs/pallet_mask_template_preview_v3')
    args=parser.parse_args();out=args.output.resolve()
    if (out/'verification.json').exists():raise ValueError('Do not overwrite verification evidence')
    manifest=json.loads((out/'manifest.json').read_text())
    assert manifest['production_database_writes']==0
    assert digest(PROJECT/'pallet/mask_template_transfer.py')==manifest['code_sha256']
    assert digest(out/'reviews_snapshot.sqlite3')==manifest['snapshot_sha256']
    formal=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    classes=PROJECT/'outputs/pallet_appearance_center_reclassification_v1/targets.jsonl'
    assert digest(classes)==manifest['classification_sha256']
    _,sources=load_dataset(formal)
    rows={r['target_key']:r for r in map(json.loads,classes.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:
        reviews,templates,eligibility=annotation_inventory(db,rows)
    proposals=[json.loads(s) for s in (out/'proposals.jsonl').read_text().splitlines()]
    evidence=ImageEvidence(formal,rows,sources)
    assert len({p['target_key'] for p in proposals})==len(proposals)==manifest['proposals']
    counts=Counter()
    for p in proposals:
        key=p['target_key'];template=templates[p['template']['target_key']];r=rows[key]
        assert eligibility[key]=='eligible' and compatible(template['row'],r)
        assert p['source']==r and p['template']['class_id']==r['final_class_id']
        assert len(p['polygon'])==len(template['polygon'])==p['vertex_count']>4
        assert p['template']['human_event_sha256']==template['human_event_sha256']
        assert not p['human_mask_confirmed'] and not p['automatic_training_eligible'] and not p['robot_command_eligible']
        polygon_value(p['polygon'],*r['size'])
        # Independent Pillow per-pixel inclusion check using cv2 pointPolygonTest
        # is avoided at exact borders; the authoritative editor rasterizer must
        # exactly reproduce the stored PNG and LabelMe coordinates.
        label=json.loads((out/'labelme'/f'{key}.json').read_text())
        assert len(label['shapes'])==1 and label['shapes'][0]['points']==p['polygon']
        assert label['shapes'][0]['group_id']==r['box_index']
        assert not label['flags']['human_confirmed']
        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
    with ZipFile(out/'mask_template_preview.zip') as z:
        assert z.testzip() is None
        for name in z.namelist():assert z.read(name)==(out/name).read_bytes()
    # Explain why template-bearing classes may have no compatible preview.
    coverage={}
    for cls in (5,12,14):
        t=[v for v in templates.values() if v['row']['final_class_id']==cls]
        candidates=[r for k,r in rows.items() if r['final_class_id']==cls and eligibility[k]=='eligible']
        pairs=[(s,r) for s in t for r in candidates if compatible(s['row'],r)]
        best=max((correlate(evidence.patch(s['row']['target_key']),evidence.patch(r['target_key'])) for s,r in pairs),default=None)
        coverage[cls]=dict(templates=len(t),eligible_targets=len(candidates),compatible_pairs=len(pairs),best_initial_ncc=best,
            reason='no_same_split_policy_view_template' if not pairs else 'image_similarity_below_initial_gate' if best<.55 else 'registration_did_not_pass')
    for batch in range((len(proposals)+4)//5):
        items=proposals[batch*5:(batch+1)*5];sheet=Image.new('RGB',(1480,305*len(items)),'#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_{batch+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
    browser_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 error:errors.append(str(error)))
            page.goto((out/'report_zh.html').as_uri())
            page.evaluate('document.fonts.ready')
            assert page.evaluate('document.fonts.check(\'16px PreviewSans\',\'掩膜标注模板类别\')')
            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]
            page.screenshot(path=str(out/f'html_{width}px.png'))
            assert not errors
            browser_checks.append(dict(viewport_width=width,images_loaded=True,no_overflow=True,class_filter=True,Chinese_font_loaded=True,page_errors=errors))
            context.close()
        browser.close()
    result=dict(state='passed',proposals_verified=len(proposals),classes=dict(counts),
        exact_vertex_count_order_and_source_id_verified=True,native_polygons_valid=True,
        masks_and_labelme_match=True,zip_crc_and_contents_match=True,original_splits_preserved=True,
        same_class_and_source_policy=True,historical_mask_edits_excluded=True,
        human_confirmation_and_training_eligibility_not_inferred=True,uncovered_template_classes=coverage,
        browser_checks=browser_checks,production_database_writes=0,
        checked_files={str(p.relative_to(out)):digest(p) for p in sorted(out.rglob('*')) if p.is_file()
            and p.suffix not in ('.sqlite3',) and '-wal' not in p.name and '-shm' not in p.name})
    (out/'verification.json').write_bytes(canonical(result)+b'\n')
    print(json.dumps(dict(state='passed',proposals=len(proposals),coverage=coverage,browser_viewports=2)))


if __name__=='__main__':main()
