"""Chromium viewport + interaction smoke tests using an isolated review database.

The live service is visited read-only; all save/edit/defer/reset clicks go to a
temporary server with the same frozen proposals, never the human review DB.
"""
from __future__ import annotations

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

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


def wait_condition(page, expression, timeout=30):
    # Old Chromium's wait_for_function implementation uses eval inside the page,
    # which this app correctly forbids. CDP evaluation keeps CSP enabled.
    deadline = time.monotonic()+timeout
    while time.monotonic() < deadline:
        if page.evaluate(expression): return
        time.sleep(.1)
    raise AssertionError('Browser condition timed out: '+expression)


def ready(page):
    wait_condition(page, '!document.getElementById("review-content").hidden && !S.busy && S.nativeReady')


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')
    parser.add_argument('--no-screenshots', action='store_true', help='Still check DOM geometry when the host compositor cannot capture frames')
    parser.add_argument('--dom-events', action='store_true', help='Exercise DOM click handlers without compositor pointer-stability checks')
    parser.add_argument('--artifacts', type=Path, default=PROJECT/'outputs/pallet_structure_review_web_validation_v1')
    args = parser.parse_args()
    from playwright.sync_api import sync_playwright, expect
    def click(page, selector):
        if args.dom_events:
            page.eval_on_selector(selector, "el => { el.scrollIntoView({block:'center'}); el.click(); }")
        else:
            page.click(selector)
    artifacts = args.artifacts.resolve(); artifacts.mkdir(parents=True, exist_ok=True)
    dataset = Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    with tempfile.TemporaryDirectory(prefix='pallet-review-ui-', 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}'
        errors, sizes, iphone_profiles = [], [], []
        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', '--disable-background-networking'])
                context = browser.new_context(viewport={'width': 390, 'height': 844}, device_scale_factor=2,
                    is_mobile=True, has_touch=True,
                    user_agent='Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 Version/16.0 Mobile/15E148 Safari/604.1')
                page = context.new_page(); page.on('pageerror', lambda e: errors.append(str(e)))
                page.goto(base)
                expect(page.locator('#login')).to_be_visible()
                page.fill('#access-key', app.access_key); click(page, '#login-submit'); ready(page)
                fixed_total = len(app.rows)
                def progress_is(approved):
                    expect(page.locator('#approved-count')).to_have_text(f'{approved:,}')
                    expect(page.locator('#total-count')).to_have_text(f'{fixed_total:,}')
                    assert page.locator('#progress').get_attribute('max') == str(fixed_total)
                    assert page.locator('#progress').get_attribute('value') == str(approved)
                progress_is(0)
                first_key = page.locator('#target-label').inner_text()
                # Correct an original proposal via the same controls a human uses.
                click(page, '[data-leg="4"]'); click(page, '[data-closure="tian"]')
                click(page, '#notes-toggle')
                page.fill('#reviewer', '自动化隔离测试（非真实人工）')
                page.fill('#note', '只存在临时测试数据库，不用于训练或人工确认交付')
                click(page, '#note-close')
                click(page, '#approve'); ready(page)
                assert app.store.get(first_key)['support_leg_count'] == 4
                assert app.store.get(first_key)['closure_type'] == 'tian'
                progress_is(1)
                assert page.locator('#target-label').inner_text() != first_key
                second_key = page.locator('#target-label').inner_text()
                # Only missing machine attributes inherit a successfully saved
                # human label. Merely visiting/defaulting a target writes nothing.
                pool = [r for k, r in app.rows.items() if k not in (first_key, second_key)]
                unknown = next(r for r in pool if r['support_leg_count'] is None and r['closure_type'] is None)
                leg_known = next(r for r in pool if r['support_leg_count'] in (2, 3) and r['closure_type'] is None)
                closure_known = next(r for r in pool if r['support_leg_count'] is None and r['closure_type'] == 'chuan')
                both_known = next(r for r in pool if r['support_leg_count'] in (2, 3) and r['closure_type'] == 'chuan')
                for sample in (unknown, leg_known, closure_known, both_known):
                    page.evaluate('key => openTarget(key)', sample['target_key']); ready(page)
                    expected = {'leg': sample['support_leg_count'] or 4, 'closure': sample['closure_type'] or 'tian'}
                    assert page.evaluate('({leg:S.leg,closure:S.closure})') == expected
                    assert page.evaluate('S.dirty') is False
                    assert app.store.get(sample['target_key'])['revision'] == 0
                    progress_is(1)
                expect(page.locator('#inherited-hint')).to_be_hidden()
                page.evaluate('key => openTarget(key)', unknown['target_key']); ready(page)
                expect(page.locator('#inherited-hint')).to_be_visible()
                expect(page.locator('#approve')).to_be_enabled()
                page.set_viewport_size({'width': 390, 'height': 664})
                marker, row = page.locator('#inherited-hint').bounding_box(), page.locator('.selection-summary').bounding_box()
                assert marker and row and marker['x'] >= row['x'] and marker['x']+marker['width'] <= row['x']+row['width']+1
                click(page, '[data-leg="unknown"]'); click(page, '#closure-unknown')
                expect(page.locator('#inherited-hint')).to_be_hidden()
                expect(page.locator('#approve')).to_be_disabled()
                page.evaluate('key => openTarget(key)', unknown['target_key']); ready(page)
                page.reload(); ready(page)
                assert page.evaluate('({leg:S.leg,closure:S.closure})') == {'leg': 4, 'closure': 'tian'}
                # Recover the reference left by the pre-feature UI as well.
                page.evaluate("localStorage.removeItem('pallet-review-last-confirmed-reference')")
                page.reload(); ready(page)
                assert page.evaluate('S.lastConfirmed.target_key') == first_key
                old_reference = page.evaluate("localStorage.getItem('pallet-review-last-confirmed-reference')")
                page.evaluate("localStorage.setItem('pallet-review-last-confirmed-reference',JSON.stringify({source_targets_sha256:'another-source',target_key:'wrong'}))")
                page.reload(); ready(page)
                assert page.evaluate('({leg:S.leg,closure:S.closure})') == {'leg': None, 'closure': None}
                page.evaluate("value => localStorage.setItem('pallet-review-last-confirmed-reference',value)", old_reference)
                page.reload(); ready(page)
                assert page.evaluate('({leg:S.leg,closure:S.closure})') == {'leg': 4, 'closure': 'tian'}
                previous = app.store.get(first_key)
                for review_status in ('approved', 'deferred'):
                    detail = {'target': {'target_key': 'different', 'support_leg_count': 2, 'closure_type': 'chuan'},
                        'review': {'status': review_status, 'support_leg_count': None, 'closure_type': None}}
                    result = page.evaluate('([detail, previous]) => selectionDefaults(detail, previous)', [detail, previous])
                    assert result == {'values': {'support_leg_count': None, 'closure_type': None}, 'inherited': {}}
                pending_detail = {'target': {'target_key': first_key, 'support_leg_count': None, 'closure_type': None},
                    'review': {'status': 'pending'}}
                result = page.evaluate('([detail, previous]) => selectionDefaults(detail, previous)', [pending_detail, previous])
                assert result['inherited'] == {} and result['values']['support_leg_count'] is None
                pending_detail['target']['target_key'] = 'different'
                for invalid_previous in (None, dict(previous, status='deferred'), dict(previous, support_leg_count=None)):
                    result = page.evaluate('([detail, previous]) => selectionDefaults(detail, previous)', [pending_detail, invalid_previous])
                    assert result['inherited'] == {} and result['values']['closure_type'] is None
                assert len(app.store.all()) == 1
                page.evaluate('key => openTarget(key)', second_key); ready(page)
                click(page, '[data-leg="3"]'); click(page, '[data-closure="chuan"]'); click(page, '#approve'); ready(page)
                progress_is(2)
                click(page, '#last-reviewed'); ready(page)
                click(page, '[data-leg="3"]'); click(page, '#closure-unknown'); click(page, '#defer'); ready(page)
                progress_is(1)
                assert app.store.get(second_key)['status'] == 'deferred'
                assert app.store.get(second_key)['closure_type'] is None
                assert page.evaluate('S.lastConfirmed') is None
                click(page, '#last-reviewed'); ready(page)
                expect(page.locator('#review-badge')).to_have_text('无法判断')
                click(page, '#evidence-toggle')
                page.once('dialog', lambda d: d.accept())
                click(page, '#reopen'); ready(page)
                assert app.store.get(second_key)['status'] == 'pending'
                assert len(app.store.history(second_key)) == 3
                progress_is(1)
                # Original image / context / threshold / zoom and projection UI.
                click(page, '[data-view="context"]')
                wait_condition(page, 'document.getElementById("target-image").complete && document.getElementById("target-image").naturalWidth>0')
                click(page, '#zoom'); expect(page.locator('#zoom-dialog')).to_be_visible()
                click(page, '#zoom-scale'); expect(page.locator('#zoom-image')).to_have_class('double')
                click(page, '#zoom-close')
                click(page, '[data-view="threshold"]'); click(page, '[data-view="crop"]')
                click(page, '#filter-toggle'); page.select_option('#filter-state', 'approved'); click(page, '#apply-filters'); ready(page)
                progress_is(1)
                expect(page.locator('#review-badge')).to_have_text('已确认')
                expect(page.locator('[data-leg="4"]')).to_have_attribute('aria-pressed', 'true')
                page.reload(); ready(page)
                # Reload defaults to pending but database progress remains.
                progress_is(1)
                assert app.statistics()['approved'] == 1
                # Validate error states: an old revision may not overwrite a newer record.
                old_key = page.locator('#target-label').inner_text()
                old_revision = app.store.get(old_key)['revision']
                app.store.save(old_key, {'status': 'deferred', 'support_leg_count': None, 'closure_type': None,
                    'expected_revision': old_revision, 'reviewer': '隔离测试并发页面', 'note': ''})
                click(page, '[data-leg="2"]'); click(page, '[data-closure="chuan"]'); click(page, '#approve')
                expect(page.locator('#error-banner')).to_be_visible()
                expect(page.locator('#error-text')).to_contain_text('其他页面')
                assert page.locator('#target-label').inner_text() == old_key
                assert page.evaluate('S.lastConfirmed') is None
                page.once('dialog', lambda d: d.accept()); click(page, '#refresh'); ready(page)
                # Production UI: read-only screenshots at iPhone / desktop widths.
                live_key = (PROJECT/'outputs/pallet_structure_human_review_v1/access_key.txt').read_text().strip()
                live = context.new_page(); live.on('pageerror', lambda e: errors.append(str(e)))
                live.goto(args.live_url+'/#key='+live_key); ready(live)
                for width, height in ((320, 460), (320, 568), (375, 667), (375, 812), (390, 664), (390, 844), (430, 932), (844, 390), (1440, 1000)):
                    live.set_viewport_size({'width': width, 'height': height})
                    live.evaluate('window.scrollTo(0,0)')
                    wait_condition(live, 'document.documentElement.scrollWidth <= window.innerWidth')
                    bounds = live.locator('#approve').bounding_box()
                    assert bounds and bounds['x'] >= 0 and bounds['x']+bounds['width'] <= width+1
                    assert bounds['y'] >= 0 and bounds['y']+bounds['height'] <= height+1
                    controls = live.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||b.dataset.leg||b.dataset.closure||b.dataset.view,
                                x:r.x,y:r.y,width:r.width,height:r.height,unobstructed:b.contains(hit)};
                        })''')
                    for b in controls:
                        assert b['x'] >= 0 and b['x']+b['width'] <= width+1, b
                        assert b['y'] >= 0 and b['y']+b['height'] <= height+1, b
                        assert b['width'] >= 42 and b['height'] >= 44, b
                        assert b['unobstructed'], b
                    if width <= 700:
                        assert bounds['y']+bounds['height'] <= height*.65
                        image = live.locator('.image-stage').bounding_box()
                        assert image and image['y'] >= max(b['y']+b['height'] for b in controls)-1
                    if not args.no_screenshots:
                        live.screenshot(path=str(artifacts/f'viewport_{width}x{height}.png'), full_page=True)
                    sizes.append({'width': width, 'height': height, 'no_horizontal_overflow': True,
                        'all_controls_visible_without_scroll': True, 'all_controls_unobstructed': True,
                        'minimum_control_size': '42x44 CSS px', 'save_button_inside_viewport': True})
                # Cookie-based session also works after reload; no live label writes.
                live.reload(); ready(live)
                expect(live.locator('#login')).to_be_hidden()
                # iPhone 13 is 390x844 CSS px / 1170x2532 device px, with a
                # 390x664 Safari viewport. Chromium has no physical notch;
                # explicitly simulate the safe insets as well as device DPR.
                for name, device, viewport, safe in (
                    ('iphone13_safari', 'iPhone 13', (390, 664), (0, 0, 0, 0)),
                    ('iphone13_safari_safe_area', 'iPhone 13', (390, 664), (47, 0, 34, 0)),
                    ('iphone13_fullscreen_safe_area', 'iPhone 13', (390, 844), (47, 0, 34, 0)),
                    ('iphone13_landscape_safari', 'iPhone 13 landscape', (750, 342), (0, 47, 21, 47)),
                    ('iphone13_landscape_fullscreen', 'iPhone 13 landscape', (844, 390), (0, 47, 21, 47)),
                ):
                    profile = {k: v for k, v in p.devices[device].items() if k != 'default_browser_type'}
                    width, height = viewport
                    profile['viewport'] = {'width': width, 'height': height}
                    profile['screen'] = {'width': 844 if width > height else 390, 'height': 390 if width > height else 844}
                    phone_context = browser.new_context(**profile)
                    phone = phone_context.new_page(); phone.on('pageerror', lambda e: errors.append(str(e)))
                    phone.goto(args.live_url+'/#key='+live_key); ready(phone)
                    phone.evaluate('''safe => ['top','right','bottom','left'].forEach((side,i) =>
                        document.documentElement.style.setProperty('--review-safe-'+side,safe[i]+'px'))''', list(safe))
                    assert phone.evaluate('devicePixelRatio') == 3
                    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||b.dataset.leg||b.dataset.closure||b.dataset.view,
                                x:r.x,y:r.y,width:r.width,height:r.height,unobstructed:b.contains(hit)};
                        })''')
                    for b in rects:
                        assert b['x'] >= left and b['x']+b['width'] <= width-right+1, (name, b)
                        assert b['y'] >= top and b['y']+b['height'] <= height-bottom+1, (name, b)
                        assert b['width'] >= 44 and b['height'] >= 44 and b['unobstructed'], (name, b)
                    image = phone.locator('.image-stage').bounding_box()
                    assert image and image['height'] >= 80, (name, image)
                    assert image['y']+image['height'] <= height-bottom+1, (name, image)
                    assert phone.evaluate('document.documentElement.scrollWidth <= innerWidth')
                    for toggle, close in (('filter-toggle', 'filter-close'), ('notes-toggle', 'note-close'),
                                          ('evidence-toggle', 'evidence-close'), ('zoom', 'zoom-close')):
                        click(phone, '#'+toggle)
                        close_rect = phone.locator('#'+close).bounding_box()
                        assert close_rect and close_rect['y'] >= top, (name, close_rect)
                        assert close_rect['y']+close_rect['height'] <= height-bottom+1, (name, close_rect)
                        click(phone, '#'+close)
                    iphone_profiles.append({'name': name, 'viewport': profile['viewport'],
                        'screen': profile['screen'], 'device_scale_factor': 3, 'simulated_safe_insets': list(safe),
                        'all_controls_inside_safe_area': True, 'all_controls_unobstructed': True,
                        'minimum_control_size': '44x44 CSS px',
                        'image_visible_height': round(image['height'], 2), 'dialog_close_controls_safe': True})
                    phone_context.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(),
        'engine': 'Chromium (iPhone viewport/touch emulation, not a physical iPhone/Safari test)',
        'viewports': sizes, 'iphone13_profiles': iphone_profiles,
        'login_cookie_reload': True, 'confirm_correct_and_next': True,
        'edit_defer_reset_and_audit': True, 'revision_conflict_ui': True, 'context_threshold_zoom': True,
        'progress_numerator_increments_with_fixed_denominator': True,
        'fixed_denominator_after_defer_reset_filter_and_reload': True,
        'unknown_only_defaults_from_last_successful_human_confirmation': True,
        'known_and_previously_reviewed_attributes_preserved': True,
        'default_preselection_never_autosaves_or_advances_progress': True,
        'confirmed_reference_revalidated_on_reload_and_source_bound': True,
        'manual_unknown_choice_and_revoked_source_respected': True,
        'production_label_writes': 0, 'javascript_page_errors': errors,
        'screenshots_captured': not args.no_screenshots,
        'interaction_mode': 'DOM event handlers (not native pointer actionability)' if args.dom_events else 'native pointer clicks',
        'script_sha256': sha256(__file__)}
    (artifacts/'browser_validation.json').write_text(json.dumps(result, ensure_ascii=False, indent=2)+'\n')
    print(json.dumps(result, ensure_ascii=False))


if __name__ == '__main__': main()
