"""Isolated batch-annotation workflows and read-only iPhone montage geometry."""
from __future__ import annotations

import argparse
from datetime import datetime, timezone
import json
from pathlib import Path
import sys
import tempfile
import threading

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))
from pallet.structure_review import DEFAULT_SOURCE, ReviewApplication, ReviewServer, sha256
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('--live-url', default='http://127.0.0.1:3389', help="Use 'sandbox' to test before deploying the backend")
    parser.add_argument('--artifacts', type=Path, default=PROJECT/'outputs/pallet_structure_review_web_validation_v5')
    args = parser.parse_args()
    from playwright.sync_api import sync_playwright, expect
    artifacts = args.artifacts.resolve(); artifacts.mkdir(parents=True, exist_ok=True)
    dataset = Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    errors, layouts = [], []
    def click(page, selector):
        page.eval_on_selector(selector, "el => el.click()")
    def configure(page, rows, cols):
        click(page, '#montage-toggle')
        page.select_option('#montage-rows', str(rows)); page.select_option('#montage-cols', str(cols))
        click(page, '#apply-montage'); ready(page)
    def keys(page): return page.evaluate('S.details.map(d=>d.target.target_key)')
    with tempfile.TemporaryDirectory(prefix='pallet-montage-', dir='/tmp/opencode') as temp:
        app = ReviewApplication(DEFAULT_SOURCE, Path(temp)/'reviews', dataset, PROJECT/'outputs/pallet_target_clustering_v1/media')
        server = ReviewServer(('127.0.0.1', 0), app)
        thread = threading.Thread(target=server.serve_forever, daemon=True); thread.start()
        base = f'http://127.0.0.1:{server.server_port}'
        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)))
                page.goto(base+'/?rows=1&cols=1#key='+app.access_key); ready(page)
                assert len(keys(page)) == 1 and app.statistics()['approved'] == 0
                configure(page, 2, 2)
                first = keys(page); assert len(first) == 4
                click(page, '[data-leg="3"]'); click(page, '[data-closure="chuan"]')
                click(page, '#notes-toggle'); page.fill('#reviewer', '自动化隔离测试（非真实人工）')
                page.fill('#note', '共享备注'); click(page, '#note-close')
                click(page, '#approve'); ready(page)
                assert app.statistics()['approved'] == 4 and not set(keys(page)) & set(first)
                batch_ids = {app.store.history(k)[0]['batch_id'] for k in first}
                assert len(batch_ids) == 1
                for k in first:
                    assert app.store.get(k)['support_leg_count'] == 3 and app.store.get(k)['closure_type'] == 'chuan'
                    assert app.store.get(k)['note'] == '共享备注'
                # Existing per-target notes must survive a shared label edit.
                for i,k in enumerate(first):
                    old = app.store.get(k)
                    app.store.save(k, dict(old, expected_revision=old['revision'], note=f'原备注{i}'))
                first_pending = app.queue({})['keys'][0]
                click(page, '#last-reviewed'); ready(page)
                assert keys(page) == first
                click(page, '[data-leg="2"]'); click(page, '[data-closure="tian"]'); click(page, '#approve'); ready(page)
                assert app.statistics()['approved'] == 4 and keys(page)[0] == first_pending
                for i,k in enumerate(first):
                    assert app.store.get(k)['support_leg_count'] == 2 and app.store.get(k)['closure_type'] == 'tian'
                    assert app.store.get(k)['note'] == f'原备注{i}'
                # A stale last member may not cause the other three to be saved.
                group = keys(page); before = {k: app.store.get(k) for k in group}
                prior_reference = page.evaluate('S.lastConfirmed')
                other = app.store.get(group[-1])
                app.store.save(group[-1], {'status':'approved','support_leg_count':4,'closure_type':'tian',
                    'reviewer':'隔离测试并发页面','note':'','expected_revision':other['revision']})
                click(page, '[data-leg="3"]'); click(page, '[data-closure="chuan"]'); click(page, '#approve')
                expect(page.locator('#error-text')).to_contain_text('整组未保存')
                assert keys(page) == group and page.evaluate('S.lastConfirmed') == prior_reference
                for k in group[:-1]: assert app.store.get(k) == before[k]
                assert app.statistics()['approved'] == 5
                page.once('dialog', lambda d: d.accept()); click(page, '#refresh'); ready(page)
                retry = keys(page); assert group[-1] not in retry
                click(page, '[data-leg="3"]'); click(page, '[data-closure="chuan"]'); click(page, '#approve'); ready(page)
                assert app.statistics()['approved'] == 9
                # One shared unknown result marks the actual four, not a fake approval.
                deferred = keys(page)
                click(page, '[data-leg="unknown"]'); click(page, '#closure-unknown'); click(page, '#defer'); ready(page)
                assert app.statistics()['approved'] == 9 and app.statistics()['deferred'] == 4
                assert all(app.store.get(k)['status'] == 'deferred' for k in deferred)
                # Query parameters survive fragment authentication and refresh.
                page.goto(base+'/?rows=3&cols=3#key='+app.access_key); ready(page)
                assert len(keys(page)) == 9 and page.evaluate('S.grid') == {'rows':3,'cols':3}
                page.reload(); ready(page); assert len(keys(page)) == 9
                page.evaluate('() => openTarget(S.keys[S.keys.length-2])'); ready(page)
                tail = keys(page); assert len(tail) == 2
                click(page, '[data-leg="3"]'); click(page, '[data-closure="chuan"]'); click(page, '#approve'); ready(page)
                assert app.statistics()['approved'] == 11
                assert all(app.store.get(k)['status'] == 'approved' for k in tail)
                # Failed image loading disables batch confirmation until reloaded.
                current = keys(page)
                def intercept(route):
                    if '/media/'+current[0]+'/crop' in route.request.url: route.abort()
                    else: route.continue_()
                page.route('**/media/*/crop*', intercept)
                page.evaluate('key => openTarget(key)', current[0])
                wait_condition(page, 'S.tiles.length>0 && !S.tiles[0].error.hidden')
                expect(page.locator('#approve')).to_be_disabled()
                assert page.evaluate('S.nativeReady') is False
                page.unroute('**/media/*/crop*', intercept); click(page, '#refresh'); ready(page)
                # Mixed known suggestions require an explicit shared selection.
                data = [{'target':{'target_key':str(i),'support_leg_count':leg,'closure_type':'chuan'},
                    'review':{'status':'pending'}} for i,leg in enumerate((2,3))]
                previous = {'target_key':'prior','status':'approved','support_leg_count':4,'closure_type':'tian'}
                result = page.evaluate('([d,p])=>groupDefaults(d,p)', [data, previous])
                assert result['values'] == {'support_leg_count':None,'closure_type':'chuan'}
                assert result['mixed'] == {'support_leg_count':True}
                data[0]['review'] = {'status':'deferred','support_leg_count':None,'closure_type':None}
                result = page.evaluate('([d,p])=>groupDefaults(d,p)', [data, previous])
                assert result['values'] == {'support_leg_count':None,'closure_type':None}
                # Confirm the minimum mode remains a true one-target operation.
                configure(page, 1, 1); assert len(keys(page)) == 1
                assert page.locator('#progress').get_attribute('max') == str(len(app.rows))
                live_url = base if args.live_url == 'sandbox' else args.live_url
                live_key = app.access_key if args.live_url == 'sandbox' else (PROJECT/'outputs/pallet_structure_human_review_v1/access_key.txt').read_text().strip()
                # View-only checks: all 1..3 row/column combinations in each
                # iPhone 13 viewport, including explicitly simulated safe insets.
                for name, width, height, safe in (
                    ('portrait_safari',390,664,(0,0,0,0)),
                    ('portrait_safari_safe',390,664,(47,0,34,0)),
                    ('portrait_fullscreen_safe',390,844,(47,0,34,0)),
                    ('landscape_safari_safe',750,342,(0,47,21,47)),
                    ('landscape_fullscreen_safe',844,390,(0,47,21,47)),
                ):
                    device = 'iPhone 13' if width < height else 'iPhone 13 landscape'
                    profile = {k:v for k,v in p.devices[device].items() if k!='default_browser_type'}
                    profile['viewport'] = {'width':width,'height':height}
                    pc = browser.new_context(**profile); phone = pc.new_page()
                    phone.on('pageerror', lambda e: errors.append(str(e)))
                    phone.goto(live_url+'/?rows=1&cols=1#key='+live_key); ready(phone)
                    phone.evaluate('''safe=>['top','right','bottom','left'].forEach((s,i)=>
                        document.documentElement.style.setProperty('--review-safe-'+s,safe[i]+'px'))''', list(safe))
                    for rows in range(1,4):
                        for cols in range(1,4):
                            phone.evaluate('''async g=>{S.grid=gridSettings(g.rows,g.cols);syncGridSettings();
                                await loadQueue();}''', {'rows':rows,'cols':cols}); ready(phone)
                            assert len(keys(phone)) == rows*cols
                            top,right,bottom,left = safe
                            rects = phone.evaluate('''()=>Array.from(document.querySelectorAll('#review-controls button,#filter-toggle,#montage-toggle'))
                                .filter(b=>b.getClientRects().length).map(b=>{const r=b.getBoundingClientRect(),hit=document.elementFromPoint(r.x+r.width/2,r.y+r.height/2);
                                return {id:b.id,x:r.x,y:r.y,w:r.width,h:r.height,hit:b.contains(hit)};})''')
                            for r in rects:
                                assert r['x']>=left and r['x']+r['w']<=width-right+1, (name,rows,cols,r)
                                assert r['y']>=top and r['y']+r['h']<=height-bottom+1, (name,rows,cols,r)
                                assert r['w']>=44 and r['h']>=44 and r['hit'], (name,rows,cols,r)
                            images = phone.locator('.image-stage').all()
                            for image in images:
                                r=image.bounding_box()
                                assert r and r['height']>0 and r['y']+r['height']<=height-bottom+1, (name,rows,cols,r)
                            assert phone.evaluate('document.documentElement.scrollWidth<=innerWidth')
                            click(phone,'#zoom')
                            if rows*cols>1:
                                phone.select_option('#zoom-target',str(rows*cols-1))
                                expect(phone.locator('#zoom-title')).to_have_text(f'图{rows*cols}/{rows*cols}')
                            for control in ('zoom-close','zoom-scale'):
                                r=phone.locator('#'+control).bounding_box()
                                assert r and r['y']>=top and r['x']+r['width']<=width-right+1
                            click(phone,'#zoom-close')
                            layouts.append({'profile':name,'rows':rows,'cols':cols,'targets':rows*cols,
                                'controls_and_images_within_safe_viewport':True,'no_page_scroll':True})
                    pc.close()
                assert not errors, errors
                browser.close()
        finally:
            server.shutdown(); server.server_close(); thread.join()
    result={'state':'passed','tested_at':datetime.now(timezone.utc).isoformat(),
        'shared_batch_save_edit_defer':True,'conflict_does_not_partially_save':True,
        'actual_tail_size_saved':True,'individual_notes_preserved_unless_edited':True,
        'query_and_reload_layout_parameters':True,'all_native_images_required':True,
        'mixed_and_manual_unknowns_not_silently_overwritten':True,'single_image_compatible':True,
        'iphone13_layouts':layouts,'javascript_errors':errors,'production_label_writes':0,
        'interaction_mode':'DOM event handlers; not physical Safari/pointer/screenshot validation',
        'live_url':args.live_url,'script_sha256':sha256(__file__)}
    (artifacts/'montage_validation.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
    print(json.dumps(result,ensure_ascii=False))


if __name__=='__main__': main()
