"""Measure lossless image savings and verify actual browser image cache reuse."""
from __future__ import annotations

import argparse
from collections import Counter,defaultdict
from datetime import datetime,timezone
import hashlib
import io
import json
from pathlib import Path
import sys
import tempfile
import threading

from PIL import Image

PROJECT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(PROJECT))
from pallet.structure_review import DEFAULT_SOURCE,ReviewApplication,ReviewHandler,ReviewServer,sha256,within
from scripts.check_structure_review_ui import ready,wait_condition


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--browser-path',required=True)
    parser.add_argument('--artifacts',type=Path,default=PROJECT/'outputs/pallet_structure_review_web_validation_v6')
    parser.add_argument('--per-class',type=int,default=3)
    args=parser.parse_args()
    if not 1<=args.per_class<=10:parser.error('--per-class must be 1..10')
    from playwright.sync_api import sync_playwright
    out=args.artifacts.resolve();out.mkdir(parents=True,exist_ok=True)
    dataset=Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    with tempfile.TemporaryDirectory(prefix='pallet-transfer-',dir='/tmp/opencode') as temp:
        app=ReviewApplication(DEFAULT_SOURCE,Path(temp)/'reviews',dataset,PROJECT/'outputs/pallet_target_clustering_v1/media')
        grouped=defaultdict(list)
        for row in app.rows.values():grouped[row['final_class_id']].append(row)
        sample=[]
        for _,rows in sorted(grouped.items()):
            sample+=sorted(rows,key=lambda r:hashlib.sha256(r['target_key'].encode()).digest())[:args.per_class]
        totals=defaultdict(lambda:{'images':0,'previous_png_bytes':0,'compressed_bytes':0})
        formats=Counter();checks=0;protected={}
        for row in sample:
            key=row['target_key'];e=row['structure_projection_evidence']
            paths=[within(dataset,row['image'])]
            for rel in (e.get('threshold_mask'),e.get('foreground_mask'),(e.get('pointcloud_evidence') or {}).get('native_mask')):
                if rel:paths.append(within(app.source,rel))
            for path in paths:protected[path]=sha256(path)
            for kind in app.detail(key)['image_kinds']:
                pixels,raw=app.image_pixels(key,kind)
                if raw is None:
                    buffer=io.BytesIO();pixels.save(buffer,format='PNG');raw=buffer.getvalue()
                compressed,mime=app.transfer_image(key,kind,True)
                assert len(compressed)<=len(raw)
                for data in (compressed,app.image(key,kind)):
                    with Image.open(io.BytesIO(data)) as decoded:
                        assert decoded.size==pixels.size
                        assert decoded.convert('RGBA').tobytes()==pixels.convert('RGBA').tobytes()
                    checks+=1
                formats[mime]+=1
                totals[kind]['images']+=1
                totals[kind]['previous_png_bytes']+=len(raw)
                totals[kind]['compressed_bytes']+=len(compressed)
        assert all(sha256(p)==h for p,h in protected.items())
        before=sum(v['previous_png_bytes'] for v in totals.values())
        after=sum(v['compressed_bytes'] for v in totals.values())
        transfers=[]
        class Handler(ReviewHandler):
            def respond(self,status,body=b'',mime='application/json; charset=utf-8',headers=None):
                if self.path.startswith('/media/'):
                    transfers.append({'path':self.path,'status':status,'bytes':len(body) if status==200 else 0,'mime':mime})
                super().respond(status,body,mime,headers)
        server=ReviewServer(('127.0.0.1',0),app);server.RequestHandlerClass=Handler
        thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
        def images_ready(page):
            ready(page)
            wait_condition(page,'S.tiles.every(t=>!t.image.hidden && t.image.complete && t.image.naturalWidth>0)')
        def click(page,selector):page.eval_on_selector(selector,'el=>el.click()')
        errors=[]
        try:
            with sync_playwright() as p:
                browser=p.chromium.launch(executable_path=args.browser_path,headless=True,
                    args=['--no-sandbox','--disable-dev-shm-usage','--disable-gpu'])
                context=browser.new_context(viewport={'width':390,'height':664},device_scale_factor=3,is_mobile=True,has_touch=True)
                page=context.new_page();page.on('pageerror',lambda e:errors.append(str(e)))
                base=f'http://127.0.0.1:{server.server_port}'
                page.goto(base+'/?rows=2&cols=2#key='+app.access_key);images_ready(page)
                assert len(transfers)==4 and all('/crop?' in t['path'] for t in transfers)
                initial=len(transfers)
                click(page,'[data-view="crop"]');images_ready(page)
                assert len(transfers)==initial
                click(page,'[data-view="context"]');images_ready(page)
                assert len(transfers)==initial+4
                mark=len(transfers)
                click(page,'[data-view="crop"]');images_ready(page)
                assert len(transfers)==mark
                click(page,'#zoom')
                wait_condition(page,'document.getElementById("zoom-image").complete && document.getElementById("zoom-image").naturalWidth>0')
                page.select_option('#zoom-target','3')
                wait_condition(page,'document.getElementById("zoom-image").complete && document.getElementById("zoom-image").naturalWidth>0')
                assert len(transfers)==mark
                click(page,'#zoom-close')
                click(page,'[data-view="threshold"]');images_ready(page)
                assert len(transfers)==mark+4
                mark=len(transfers)
                click(page,'[data-view="crop"]');images_ready(page)
                click(page,'[data-view="threshold"]');images_ready(page)
                assert len(transfers)==mark
                click(page,'[data-view="crop"]');images_ready(page)
                mark=len(transfers)
                page.reload();images_ready(page)
                reload_transfers=transfers[mark:]
                assert all(t['status']==304 and t['bytes']==0 for t in reload_transfers)
                assert not app.store.all() and not errors
                browser.close()
        finally:
            server.shutdown();server.server_close();thread.join()
        result={'state':'passed','tested_at':datetime.now(timezone.utc).isoformat(),
            'sample_targets':len(sample),'appearance_classes':len(grouped),'by_image_kind':dict(totals),
            'previous_png_bytes':before,'compressed_bytes':after,'payload_reduction_fraction':1-after/before,
            'selected_formats':dict(formats),'pixel_exact_decode_checks':checks,
            'source_assets_hash_unchanged':len(protected),'no_resolution_reduction':True,
            'only_selected_view_loaded_initially':True,'repeat_views_zero_additional_image_transfers':True,
            'zoom_reuses_loaded_native_resolution_image':True,
            'reload_additional_image_bytes':sum(t['bytes'] for t in reload_transfers),
            'server_image_requests_during_browser_check':transfers,
            'private_cache_authentication_and_304':'covered by HTTP regression tests',
            'production_label_writes':0,'javascript_errors':errors,
            'interaction_mode':'DOM events; not physical Safari/pointer/screenshot validation',
            'script_sha256':sha256(__file__)}
        (out/'transfer_validation.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
        print(json.dumps({k:v for k,v in result.items() if k!='server_image_requests_during_browser_check'},ensure_ascii=False))


if __name__=='__main__':main()
