"""Prepare the final 10 Class9 + 15 Class10 direct-manual tasks, never activate.

--review stages native crops and full images for explicit visual decisions.
--build requires those decisions, seals the static package and tests its layout.
Only this new script and its own output are written; existing helpers are read-only.
"""
from __future__ import annotations

import argparse
from collections import Counter, defaultdict
from contextlib import closing
from datetime import datetime, timezone
import hashlib
import html
import json
import math
import os
from pathlib import Path
import re
import shutil
import sys

import cv2
import numpy as np
from PIL import Image, ImageDraw, ImageFont

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))
from pallet.cluster_targets import digest, protected_snapshot
from pallet.mask_quota_saved_extension import file_inventory, load_formal_evidence
from pallet.mask_template_refined import QUARANTINE, read_jsonl, readonly, verify_history_preserved, write_jsonl
from pallet.mask_template_transfer import annotation_inventory, rectangle, unchanged_rectangle, write_json
from pallet.pose_review_geometry import canonical, polygon_value
from scripts.build_mask_template_requests import database_fingerprint, native_quality, patch_vector, render_case, signature

OUT = PROJECT/'outputs/pallet_mask_quota_100_final_requests_v1'
BASE = PROJECT/'outputs/pallet_mask_quota_100_continue_v1'
POSE = PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3'
GALLERY = PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3'
ACCESS = PROJECT/'outputs/pallet_pose_review_managed_v1/public_access.json'
FONT = Path('/tmp/opencode/pallet_pose_design/NotoSansCJKsc-Regular.otf')
QUOTAS = {9: 10, 10: 15}
BASE_COUNTS = {1: 100, 2: 100, 9: 90, 10: 85, 15: 100}
OLD_REQUESTS = [PROJECT/'outputs'/d/'requests.jsonl' for d in (
    'pallet_mask_template_requests_v1', 'pallet_mask_class10_manual_supplement_v2',
    'pallet_mask_quota_100_requests_v2')]


def require(condition, message):
    if not condition:
        raise ValueError(message)


def read_json(path):
    return json.loads(Path(path).read_text())


def sha(value):
    return hashlib.sha256(canonical(value)).hexdigest()


def prepare():
    cv2.setNumThreads(1)
    manifest = read_json(BASE/'manifest.json')
    proposals = read_jsonl(BASE/'proposals.jsonl')
    require(len(proposals) == len({p['source']['frame_id'] for p in proposals}) == 475 and
        Counter(p['class_id'] for p in proposals) == BASE_COUNTS, 'Expected exactly 475 cumulative frames')
    require(manifest['publication_version'] == 8 and manifest['saved_human'] == 321 and
        manifest['old_pending_machine'] == 88 and manifest['new_machine_pending'] == 66,
        'Baseline human/pending decomposition differs')
    require(manifest['saved_review_status']['actually_saved'] == 39 and
        manifest['saved_review_status']['pending'] == 45, 'Expected prior84 actual39/unsaved45')
    for name in ('proposals', 'new_proposals', 'template_inventory'):
        suffix = '.json' if name == 'template_inventory' else '.jsonl'
        require(digest(BASE/(name+suffix)) == manifest[name+'_sha256'], 'Baseline hash differs: '+name)
    formal, rows, evidence = load_formal_evidence(manifest)
    original_rows = {r['target_key']: r for r in read_jsonl(
        PROJECT/'outputs/pallet_appearance_center_reclassification_v1/targets.jsonl')}
    for row in rows.values():
        require(row['image'] == evidence.sources[row['frame_id']]['image'], 'Formal image identity differs')
    fingerprints, history_checks = {}, {}
    for kind, live, name, field in [('pose', POSE, 'reviews_snapshot.sqlite3', 'snapshot_sha256'),
            ('gallery', GALLERY, 'gallery_reviews_snapshot.sqlite3', 'gallery_snapshot_sha256')]:
        frozen = BASE/name
        require(digest(frozen) == manifest[field], 'Snapshot binding differs')
        verify_history_preserved(live, frozen)
        fingerprints[kind] = database_fingerprint(frozen, True)
        require(database_fingerprint(live) == fingerprints[kind], 'Live store changed; new immutable evidence needed')
        history_checks[kind] = dict(snapshot_path=str(frozen.relative_to(PROJECT)), snapshot_sha256=digest(frozen),
            backup_path=str((BASE/'backups'/name).relative_to(PROJECT)),
            backup_sha256=digest(BASE/'backups'/name), all_frozen_event_bytes_preserved=True,
            live_logically_equal_to_frozen=True, table_counts=fingerprints[kind]['table_counts'])
        require(history_checks[kind]['backup_sha256'] == digest(frozen), 'Backup snapshot differs')
    require(fingerprints['pose']['table_counts']['annotations'] == 4778 and
        fingerprints['pose']['table_counts']['events'] == 10731 and
        fingerprints['gallery']['table_counts']['reviews'] == 203 and
        fingerprints['gallery']['table_counts']['events'] == 213, 'Actual-now review counts differ')
    with closing(readonly(BASE/'reviews_snapshot.sqlite3', True)) as db:
        current, pose_templates, status = annotation_inventory(db, rows)
        events = [(i, k, rev, raw, json.loads(raw)) for i, k, rev, raw in db.execute(
            'SELECT id,target_key,revision,payload FROM events ORDER BY id')]
        current_raw = {k: raw for k, raw in db.execute('SELECT target_key,payload FROM annotations')}
    with closing(readonly(BASE/'gallery_reviews_snapshot.sqlite3', True)) as db:
        reviews = {k: json.loads(raw) for k, raw in db.execute('SELECT target_key,payload FROM reviews')}
        gallery_events = [(k, raw, json.loads(raw)) for k, raw in db.execute('SELECT target_key,payload FROM events ORDER BY id')]
    inventory = read_json(BASE/'template_inventory.json')
    templates = {t['row']['target_key']: t for t in inventory['templates']
        if t['rendering_id'].startswith('quota100_continue_generation:')}
    require(len(templates) == manifest['generation_templates'] == 325, 'Expected 325 direct saved-human seeds')
    new_keys = {p['target_key'] for p in read_jsonl(BASE/'new_proposals.jsonl')}
    unsaved45 = set(manifest['saved_review_status']['pending_keys'])
    require(len(new_keys) == 66 and not (new_keys | unsaved45).intersection(templates), 'Unsaved machine seed leakage')
    for key, t in templates.items():
        require(t['row'] == rows[key] and len(t['polygon']) > 4, 'Seed identity differs')
        if t['origin'] == 'mask_gallery_human_revision':
            v = reviews[key]
            require(v['polygon'] == t['polygon'] and v['revision'] == t['human_polygon_revision'] and
                v.get('human_edited') is True and v.get('event_kind') == 'human_mask_gallery_revision' and
                any(k == key and hashlib.sha256(raw.encode()).hexdigest() == t['human_event_sha256']
                    for k, raw, _ in gallery_events), 'Gallery seed lacks exact human event')
        else:
            require(key in pose_templates and all(t[f] == pose_templates[key][f] for f in
                ('polygon', 'revision', 'human_event_sha256', 'current_payload_sha256')), 'Pose seed provenance differs')
    history = defaultdict(list)
    special = set()
    for i, key, revision, raw, v in events:
        modified = bool(v.get('polygon')) and not unchanged_rectangle(v['polygon'], rows[key])
        flags = dict(state=v.get('state'), human_mask_confirmed=bool(v.get('human_mask_confirmed')),
            human_pose_confirmed=bool(v.get('human_pose_confirmed')), mask_modified=modified,
            original_rectangle=unchanged_rectangle(v.get('polygon'), rows[key]))
        history[key].append(dict(event_id=i, revision=revision, event_kind=v.get('event_kind'),
            payload_raw_sha256=hashlib.sha256(raw.encode()).hexdigest(), **flags))
        if modified or flags['state'] in ('deleted', 'deferred') or flags['human_mask_confirmed'] or flags['human_pose_confirmed']:
            special.add(key)
    for key, value in current.items():
        if (value.get('polygon') and not unchanged_rectangle(value['polygon'], rows[key])) or value.get('state') in ('deleted', 'deferred') or value.get('human_mask_confirmed') or value.get('human_pose_confirmed'):
            special.add(key)
    gallery_history = set(reviews) | {k for k, _, _ in gallery_events}
    quarantine = QUARANTINE | set(manifest.get('preserved_quarantined_targets', [])) | set(manifest.get('quarantined_targets', []))
    old_requests = [r for path in OLD_REQUESTS for r in read_jsonl(path)]
    old_keys = {r['target_key'] for r in old_requests}
    require(len(old_requests) == len(old_keys) == 61, 'Expected original24 + supplement13 + current24 request keys')
    latest_requests = read_jsonl(OLD_REQUESTS[-1])
    require(len(latest_requests) == 24 and all(r['target_key'] in current and
        current[r['target_key']].get('polygon') and not unchanged_rectangle(current[r['target_key']]['polygon'], rows[r['target_key']])
        for r in latest_requests), 'All current24 must have actual saved manual contours (valid four-point allowed)')
    for r in latest_requests:
        polygon_value(current[r['target_key']]['polygon'], *rows[r['target_key']]['size'])
    require(any(r['class_id'] == 9 and len(current[r['target_key']]['polygon']) == 4 and r['target_key'] not in templates
        for r in latest_requests), 'Saved four-point Class9 must not be silently promoted to seed')
    human_keys = set(pose_templates) | {t['row']['target_key'] for t in inventory['templates']}
    protected = ({p['target_key'] for p in proposals} | gallery_history | special | quarantine | human_keys | old_keys |
        {k for k, reason in status.items() if reason != 'eligible'})
    protected_frames = {rows[k]['frame_id'] for k in protected}
    eligible = {k: r for k, r in rows.items() if r['final_class_id'] in QUOTAS and status[k] == 'eligible'
        and k not in protected and r['frame_id'] not in protected_frames and (k not in history or k in current)
        and all(e['original_rectangle'] for e in history.get(k, []))
        and (k not in current or unchanged_rectangle(current[k].get('polygon'), r))}
    groups, all_groups, human_groups = defaultdict(list), defaultdict(list), defaultdict(list)
    for k, t in templates.items():
        human_groups[signature(t['row'])].append(k)
    usable, rejected = {}, Counter()
    for key, row in sorted(eligible.items()):
        all_groups[signature(row)].append(key)
        quality, reason = native_quality(row, evidence)
        if reason:
            rejected[f'{row["final_class_id"]}:{reason}'] += 1
            continue
        usable[key] = dict(quality=quality, exact_signature_human_template_keys=human_groups[signature(row)],
            exact_view_human_template_absent=not human_groups[signature(row)],
            no_pose_current_or_history=key not in current and key not in history)
        groups[signature(row)].append(key)
    for sig, keys in groups.items():
        vectors = np.array([patch_vector(evidence, k) for k in keys])
        for i, key in enumerate(keys):
            others = [j for j, k in enumerate(keys) if rows[k]['frame_id'] != rows[key]['frame_id']]
            distance = float(np.mean([np.sum((vectors[i]-vectors[j])**2) for j in others])) if others else 0.
            usable[key].update(medoid_mean_squared_patch_distance=distance,
                compatible_neighbor_count=len({rows[k]['frame_id'] for k in all_groups[sig] if rows[k]['frame_id'] != rows[key]['frame_id']}),
                usable_compatible_neighbor_count=len({rows[keys[j]]['frame_id'] for j in others}))
        for rank, key in enumerate(sorted(keys, key=lambda k: (usable[k]['medoid_mean_squared_patch_distance'], k)), 1):
            usable[key]['medoid_rank'] = rank
    paths = [Path(__file__), PROJECT/'scripts/build_mask_template_requests.py',
        PROJECT/'pallet/mask_template_transfer.py', PROJECT/'pallet/mask_template_refined.py',
        PROJECT/'pallet/mask_quota_saved_extension.py', PROJECT/'pallet/cluster_targets.py',
        PROJECT/'pallet/pose_review_geometry.py',
        PROJECT/'outputs/pallet_appearance_center_reclassification_v1/targets.jsonl'] + OLD_REQUESTS
    paths += [BASE/name for name in ('manifest.json', 'proposals.jsonl', 'new_proposals.jsonl',
        'template_inventory.json', 'reviews_snapshot.sqlite3', 'gallery_reviews_snapshot.sqlite3')]
    inputs = {str(p.relative_to(PROJECT)): digest(p) for p in paths}
    pools = {c: dict(eligible=sum(r['final_class_id'] == c for r in eligible.values()),
        usable=sum(rows[k]['final_class_id'] == c for k in usable),
        usable_no_pose_current_or_history=sum(rows[k]['final_class_id'] == c and v['no_pose_current_or_history']
            for k, v in usable.items())) for c in QUOTAS}
    return dict(formal=formal, rows=rows, original_rows=original_rows, evidence=evidence, manifest=manifest,
        templates=templates, current=current, current_raw=current_raw, history=history, eligible=eligible,
        usable=usable, rejected=dict(rejected), protected=protected, protected_frames=protected_frames,
        inputs=inputs, fingerprints=fingerprints, history_checks=history_checks, pools=pools,
        configs=file_inventory(PROJECT/'configs'), excluded_diagnostic_counts=dict(cumulative_frames=475,
            unsaved_pub7_machine_frames_already_in_cumulative=45, new_machine_candidates=66,
            gallery_history_targets=len(gallery_history), protected_pose_history_targets=len(special),
            human_seed_targets=len(human_keys), old_request_targets=61, current_completed_request_targets=24,
            quarantine_targets=len(quarantine), protected_frames=len(protected_frames)))


def ranked(data, decisions=None, require_approved=False):
    chosen, frames = [], set()
    rows, usable = data['rows'], data['usable']
    decisions = decisions or {}
    for cls, quota in QUOTAS.items():
        sigs, groups, splits = Counter(), Counter(), Counter()
        pool = [k for k in usable if rows[k]['final_class_id'] == cls and
            decisions.get(k, {}).get('approved') is not False and
            (not require_approved or decisions.get(k, {}).get('approved') is True) and
            rows[k]['group_id'] not in decisions.get('__excluded_source_groups__', {})]
        for _ in range(quota):
            options = [k for k in pool if k not in chosen and rows[k]['frame_id'] not in frames]
            if not options:
                break
            def rank(k):
                v, r = usable[k], rows[k]
                score = (.45*(1-v['medoid_mean_squared_patch_distance']/4) + .35*v['quality']['clarity_score'] +
                    .20*min(math.log1p(v['quality']['bbox_area_native_pixels'])/math.log(10001), 1))
                return (not v['no_pose_current_or_history'], not v['exact_view_human_template_absent'],
                    sigs[signature(r)], groups[r['group_id']], splits[r['split']], -score, k)
            key = min(options, key=rank); row = rows[key]
            chosen.append(key); frames.add(row['frame_id'])
            sigs[signature(row)] += 1; groups[row['group_id']] += 1; splits[row['split']] += 1
    return chosen


def montage(root, items, filename, full=False):
    width, height = (680, 580) if full else (680, 260)
    sheet = Image.new('RGB', (2*width, math.ceil(len(items)/2)*height), '#111923')
    draw = ImageDraw.Draw(sheet); font = ImageFont.truetype(str(FONT), 17)
    for i, item in enumerate(items):
        row, key = item['source'], item['target_key']
        x, y = i % 2*width, i//2*height
        draw.text((x+8, y+4), f'{item["request_order"]:02d} Class {row["final_class_id"]} | {key}', font=font, fill='white')
        draw.text((x+8, y+30), f'{row["split"]} | {row["policy_id"]} | pose={item["existing_pose_record"]}', font=font, fill='#b8d6ee')
        with Image.open(root/item['native_image' if full else 'contact_crop']) as image:
            image = image.convert('RGB')
            if full:
                r = row['bbox']; ImageDraw.Draw(image).rectangle((r['x'], r['y'], r['x']+r['width'], r['y']+r['height']), outline='#ffb428', width=1)
            scale = min((width-20)/image.width, (height-65)/image.height)
            image = image.resize((round(image.width*scale), round(image.height*scale)), Image.Resampling.NEAREST)
            sheet.paste(image, (x+10, y+60))
    sheet.save(root/filename)


def review():
    require(not (OUT/'manifest.json').exists(), 'Never overwrite a sealed package')
    require(not OUT.exists() or (OUT/'internal/review/shortlist.jsonl').exists(), 'Unknown staging directory')
    data = prepare()
    path = OUT/'internal/source_visual_decisions.json'
    decisions = read_json(path) if path.exists() else {}
    keys = ranked(data, decisions)
    root = OUT/'internal/review'; (root/'cases').mkdir(parents=True, exist_ok=True); (root/'images').mkdir(exist_ok=True)
    shortlist = []
    for order, key in enumerate(keys, 1):
        row = data['rows'][key]
        render_case(row, data['evidence'], root/'cases'/f'{key}.png')
        shutil.copyfile(data['formal']/row['image'], root/'images'/f'{key}.png')
        shortlist.append(dict(target_key=key, source=row, request_order=order, existing_pose_record=key in data['current'],
            native_image=f'images/{key}.png', contact_crop=f'cases/{key}.png', **data['usable'][key]))
    write_jsonl(root/'shortlist.jsonl', shortlist)
    for start in range(0, len(shortlist), 6):
        for full in (False, True):
            montage(root, shortlist[start:start+6], f'{"full" if full else "crop"}_{start+1:02d}.png', full)
    write_json(root/'diagnostic.json', dict(pools=data['pools'], rejections=data['rejected'],
        exclusions=data['excluded_diagnostic_counts'], selected=len(keys),
        class_counts=dict(Counter(data['rows'][k]['final_class_id'] for k in keys))))
    print(json.dumps(read_json(root/'diagnostic.json'), ensure_ascii=False, indent=2))


def page(requests, data, pose_url):
    esc = html.escape
    counts = Counter(r['class_id'] for r in requests)
    table = ''.join(f'<tr><td>{c}</td><td>{n}</td><td>{100-n}</td><td>{counts[c]}</td></tr>' for c, n in BASE_COUNTS.items())
    cards = []
    for r in requests:
        key, s = r['target_key'], r['source']
        preserve = (f'已有原始矩形位姿保存记录，当前修订 r{r["existing_pose_revision"]}，历史 {len(r["pose_history_flags"])} 条。'
            '全部历史掩膜保持原始矩形。必须保留当前位姿、选中面、标尺、传感器及排除设置；修订仅用于并发检查，不授权覆盖。'
            if r['existing_pose_record'] else '无既有位姿当前保存记录或事件历史。')
        ref = (f'同类／划分／策略／视角人工参考：{r["closest_human_reference_key"]}；仅参考键，不复制顶点。'
            if r['closest_human_reference_key'] else '没有严格同类／划分／策略／视角人工参考；不跨划分借用或虚构拓扑。')
        cards.append(f'''<article id="{key}"><h2>{r['request_order']:02d} · Class {r['class_id']} · 待人工描绘</h2>
<p><code>{key}</code></p><p><a class="action" target="_blank" rel="noopener" href="{esc(r['pose_annotation_url'],quote=True)}">打开原位姿标注</a></p>
<p>{esc(r['reason_zh'])}</p><p class="notice">{esc(preserve)}</p>
<p>来源：{esc(s['frame_id'])}<br>原划分：{esc(s['split'])} · 视角：{esc(str(s['viewpoint_candidate']))}<br>
来源策略：{esc(s['policy_id'])}<br>来源组：{esc(s['group_id'])}</p>
<figure><img src="{r['contact_crop']}" alt="Class {r['class_id']} 原生局部与原始矩形"><figcaption>橙线仅为原始矩形，不是已描绘掩膜；本包没有轮廓提案。</figcaption></figure>
<p>逐张来源复查：{esc(r['source_visual_review_zh'])}（助手可描绘性检查，不是人工类别或真值确认。）</p>
<p>原生框 {s['bbox']['width']:.1f} × {s['bbox']['height']:.1f} 像素。严格兼容其他帧 {r['compatible_neighbor_count']}，清晰其他帧 {r['usable_compatible_neighbor_count']}；数量及代表性评分不是成功率。</p>
<p>{esc(ref)}</p><p>沿用正式候选类别，尚非人工类别确认；原分类复核标记：<code>{esc(', '.join(r['classification_review_flags']) or '无附加标记')}</code>。</p>
<details><summary>完整原生图像</summary><img loading="lazy" src="{r['native_image']}" alt="完整原生强度图像"></details>
<p>needs_manual_tracing · 未激活 · 不计入475。按真实可见结构人工描绘；类别可疑、遮挡或边界不清时暂缓，不为配额凑数。</p></article>''')
    limits = '；'.join(f'Class {c}：清晰池 {v["usable"]}，其中无位姿当前及历史 {v["usable_no_pose_current_or_history"]}' for c, v in data['pools'].items())
    return f'''<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>最后25张直接人工描绘任务 · 待命未激活</title><style>
@font-face{{font-family:RequestSans;src:url('report-font.otf')}}*{{box-sizing:border-box}}body{{font:16px/1.65 RequestSans,sans-serif;background:#111923;color:#edf2f7;max-width:1200px;margin:auto;padding:20px}}
a{{color:#8ed7ff}}code{{font-family:monospace;user-select:all}}article,.notice{{border:1px solid #536479;border-radius:10px;padding:16px;margin:18px 0;background:#192432}}
p,code,li,h1,h2{{overflow-wrap:anywhere}}img{{max-width:100%;height:auto;display:block;margin:10px auto}}figure{{margin:12px 0}}figure img{{width:100%;image-rendering:pixelated}}figcaption{{color:#bdcbd8}}
.action{{display:inline-block;padding:8px 12px;border-radius:6px;background:#17496b}}table{{border-collapse:collapse;width:100%;table-layout:fixed}}td,th{{border:1px solid #536479;padding:6px;overflow-wrap:anywhere}}
@media(max-width:480px){{body{{padding:10px;font-size:15px}}article,.notice{{padding:10px}}td,th{{font-size:13px}}}}
</style></head><body><h1>最后25张：直接人工描绘任务</h1>
<div class="notice"><strong>待命未激活。五类各100目标尚未完成。</strong>
<p>最新生成的第八版累计475个不同帧：321份已保存人工轮廓、88份旧待复核机器候选、66份新增待复核机器候选。
本包不替代主会话独立验封，不宣称该版本或本任务清单已在线激活；原配置、服务与数据库不变。</p>
<p>此前新增84张中实际保存39张、尚无保存记录45张；未保存不表示用户没有看过。45张已包含在475内，本清单全部排除。
现有24个请求均有实际保存轮廓，其中一个Class9有效四点人工轮廓可计直接人工覆盖，但不作超过四点模板种子。</p>
<p><strong>本次10张Class9＋15张Class10是新不同帧，保存前不计入475。</strong>每项完成真实人工描绘、保存并重新核验来源、类别、不同帧和原划分后，可独立补一个覆盖名额；即使没有可增长邻居也成立，不承诺匹配或扩增成功。</p>
<p>若全部25项通过后续核验，累计覆盖可到500、五类各100；这不是500份已确认真值。机器候选仍需复核，不自动进入训练或机器人控制。</p></div>
<table><tr><th>类别</th><th>累计不同帧</th><th>距100缺额</th><th>待描绘</th></tr>{table}</table>
<h2>选择与保护边界</h2><p>排除全部475帧、所有人工种子帧、图册任何当前与历史、位姿实际掩膜改动／删除／暂缓／确认历史、隔离目标及全部旧请求帧；同帧其他框也排除。
只从正式类别池选择原生结构清晰、中等或较大框、较少遮挡的来源，逐张检查局部和完整原生图。可疑来源不为凑数入选。</p>
<p>优先无位姿当前及历史，再优先缺失的同类／划分／来源策略／视角人工覆盖，兼顾来源组与划分多样性和图块代表性。unknown只与unknown相容；连续帧不声称独立场景。
{esc(limits)}。全新清晰来源不足时，只允许全部历史始终为原矩形的位姿保存记录；每项保留完整当前载荷与修订校验元数据，不覆盖位姿。</p>
<p>按实际轮廓决定拓扑；有效形状若确实只需四点，允许保存并计直接人工覆盖，不强加第五点。超过四点且满足来源资格的已保存轮廓才可另行作为模板种子；原始矩形本身不算人工完成。</p>
<p>仅提供来源原图与原始矩形，没有生成多边形或递归传播。位姿链接来自构建时受管 public_access.json 的当前 public_url；沿用原有登录方式，隧道地址可能变化。</p>
{''.join(cards)}<footer><p>独立待办，不是完成标注或在线发布。仅允许53个公开资源：报告、字体、许可及25对局部／原图。
<a href="FONT_LICENSE.txt">字体许可</a> · <a href="{esc(pose_url,quote=True)}">原位姿入口</a></p></footer></body></html>'''


def build_font(text):
    from fontTools import subset
    from fontTools.ttLib import TTFont
    required = {ord(c) for c in text if '\u3400' <= c <= '\u9fff'}
    with TTFont(FONT) as font:
        require(required <= set(font.getBestCmap()), 'Source Chinese glyph missing')
        sub = subset.Subsetter(); sub.populate(text=text); sub.subset(font); font.save(OUT/'report-font.otf')
    with TTFont(OUT/'report-font.otf') as font:
        require(required <= set(font.getBestCmap()), 'Subset Chinese glyph missing')
    shutil.copyfile(PROJECT/'pallet/assets/pose_review/FONT_LICENSE.txt', OUT/'FONT_LICENSE.txt')
    write_json(OUT/'font_coverage.json', dict(all_report_Chinese_present=True, chinese_glyphs=len(required),
        source_sha256=digest(FONT), subset_sha256=digest(OUT/'report-font.otf')))


def layout_check(requests):
    """Local file-only Chromium inspection: no live website/service mutations."""
    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
    executable = '/tmp/opencode/pallet_pose_browser/chrome-linux64/chrome'
    results = []
    with sync_playwright() as pw:
        browser = pw.chromium.launch(executable_path=executable, headless=True,
            args=['--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu', '--disable-software-rasterizer'])
        for width, height in ((390, 844), (1440, 1000)):
            p = browser.new_page(viewport=dict(width=width, height=height))
            p.goto((OUT/'report_zh.html').as_uri())
            p.evaluate("async () => {document.querySelectorAll('details').forEach(d=>d.open=true); document.querySelectorAll('img').forEach(i=>i.loading='eager'); await document.fonts.ready; await Promise.all([...document.images].map(i=>i.decode()));}")
            result = p.evaluate("""() => ({viewport:innerWidth, scrollWidth:document.documentElement.scrollWidth,
                clientWidth:document.documentElement.clientWidth, articleCount:document.querySelectorAll('article').length,
                imageCount:document.images.length, allImagesLoaded:[...document.images].every(i=>i.complete&&i.naturalWidth>0),
                fontLoaded:document.fonts.check('16px RequestSans'),
                overflowingElements:[...document.querySelectorAll('body *')].filter(e=>e.getBoundingClientRect().right>innerWidth+.5||e.getBoundingClientRect().left<-.5).map(e=>e.tagName).slice(0,20)})""")
            require(result['scrollWidth'] == result['clientWidth'] and not result['overflowingElements'] and
                result['articleCount'] == 25 and result['imageCount'] == 50 and result['allImagesLoaded'] and result['fontLoaded'], 'Report layout/image/font failure')
            p.evaluate("document.querySelectorAll('details').forEach(d=>d.open=false)")
            p.screenshot(path=str(OUT/'internal'/f'layout_{width}.png'))
            result['state'] = 'passed'; results.append(result)
            p.close()
        browser.close()
    write_json(OUT/'layout_verification.json', dict(state='passed', report_sha256=digest(OUT/'report_zh.html'),
        local_file_only=True, live_site_modified=False, results=results))


def build():
    require((OUT/'internal/review/shortlist.jsonl').exists() and not (OUT/'manifest.json').exists(),
        'Stage review first; never overwrite a sealed package')
    data = prepare()
    decisions = read_json(OUT/'internal/source_visual_decisions.json')
    keys = ranked(data, decisions, require_approved=True)
    require(Counter(data['rows'][k]['final_class_id'] for k in keys) == QUOTAS, 'Do not fabricate under-quota tasks')
    staged = {r['target_key']: r for r in read_jsonl(OUT/'internal/review/shortlist.jsonl')}
    require(all(k in staged and decisions[k].get('crop_inspected') and decisions[k].get('full_image_inspected')
        and decisions[k].get('note_zh') for k in keys), 'Every selected crop and full image requires explicit review')
    before = protected_snapshot(data['formal'])
    require(len(before) == 20768, 'Protected formal inventory differs')
    pose_url = read_json(ACCESS)['public_url'].rstrip('/')
    require(pose_url.startswith('https://') and '?' not in pose_url, 'Unexpected managed pose URL')
    (OUT/'images').mkdir(exist_ok=True); (OUT/'cases').mkdir(exist_ok=True)
    requests = []
    for order, key in enumerate(keys, 1):
        row, v, old = data['rows'][key], data['usable'][key], data['current'].get(key)
        refs = v['exact_signature_human_template_keys']
        refkey = min(refs, key=lambda k: (float(np.sum((patch_vector(data['evidence'], key)-patch_vector(data['evidence'], k))**2)), k)) if refs else None
        ref = data['templates'].get(refkey)
        source = dict(row, image_sha256=digest(data['formal']/row['image']),
            formal_manifest_sha256=data['manifest']['formal_manifest_sha256'],
            classification_sha256=data['manifest']['classification_sha256'],
            classification_row_sha256=sha(data['original_rows'][key]),
            formal_source_record_sha256=sha(data['evidence'].sources[row['frame_id']]))
        shutil.copyfile(data['formal']/row['image'], OUT/'images'/f'{key}.png')
        bounds = render_case(row, data['evidence'], OUT/'cases'/f'{key}.png')
        reason = ('补充严格同类／划分／策略／视角缺失的人工覆盖；' if v['exact_view_human_template_absent'] else '补充兼容组合中的来源变化；')
        reason += '直接人工描绘完成并核验后独立补一个覆盖名额，不依赖邻居增长，不承诺匹配成功。'
        if old:
            reason += '全新清晰来源不足，采用全部历史始终为原矩形的位姿记录，保留现有位姿载荷与修订。'
        requests.append(dict(schema='manual_mask_template_request_v1', request_order=order, target_key=key,
            class_id=row['final_class_id'], class_identity=dict(candidate_class=row['final_class'],
                final_class_id=row['final_class_id'], human_class_confirmed=False,
                classification_row_sha256=source['classification_row_sha256']),
            source=source, original_classification_row=data['original_rows'][key], source_label_kind='ORIGINAL_RECTANGLE',
            original_rectangle=rectangle(row), status='needs_manual_tracing', activation_state='prepared_notactivated',
            task_kind='direct_manual_mask_coverage', reason=reason, reason_zh=reason,
            source_visual_review_zh=decisions[key]['note_zh'],
            source_visual_review_kind='assistant_source_clarity_review_NOT_human_class_or_GT_confirmation',
            classification_review_flags=row.get('classification_review_flags', []),
            existing_pose_record=old is not None, existing_pose_revision=old['revision'] if old else 0,
            existing_pose_payload_sha256=sha(old) if old else None,
            existing_pose_payload_raw_sha256=hashlib.sha256(data['current_raw'][key].encode()).hexdigest() if old else None,
            existing_pose_current_payload=old,
            existing_pose_geometry_sha256=sha({k: old.get(k) for k in ('pose', 'ruler', 'sensor', 'selected_faces', 'exclusions')}) if old else None,
            pose_history_present=bool(data['history'].get(key)), pose_history_flags=data['history'].get(key, []),
            latest_pose_event_revision=max((e['revision'] for e in data['history'].get(key, [])), default=0),
            all_pose_history_masks_unmodified=True, preserve_existing_pose_until_intentional_human_edit=True,
            preserve_current_selected_ruler_sensor_faces_and_revision=True,
            existing_pose_revision_is_expected_not_overwrite_authorization=True,
            compatible_neighbor_count=v['compatible_neighbor_count'], usable_compatible_neighbor_count=v['usable_compatible_neighbor_count'],
            neighbor_count_semantics='Exact class/split/policy/view distinct other frames; not transfer success or probability; direct manual task does not depend on neighbors',
            exact_view_human_template_absent=v['exact_view_human_template_absent'],
            diagnostic_compatible_template_ids=refs, exact_signature_human_template_keys=refs,
            medoid_rank=v['medoid_rank'], medoid_mean_squared_patch_distance=v['medoid_mean_squared_patch_distance'],
            image_quality=v['quality'], quality_metrics_are_not_probabilities=True,
            closest_human_reference_key=refkey, closest_human_reference_store=ref['origin'] if ref else None,
            closest_human_reference_revision=ref.get('human_polygon_revision') if ref else None,
            requested_required_vertex_count=None, topology_must_be_manually_determined=True,
            minimum_manual_template_vertices=5, minimum_direct_manual_coverage_vertices=3,
            valid_four_point_manual_contour_allowed=True, extra_vertices_must_not_be_forced=True,
            original_rectangle_alone_is_not_completed_manual_coverage=True,
            valid_four_point_manual_contour_is_not_transfer_seed=True, reference_vertices_copied=False,
            direct_coverage_credit_after_save_and_reverification=1, guaranteed_neighbor_growth=0,
            pose_annotation_url=pose_url+'/?target='+key, native_image=f'images/{key}.png',
            contact_crop=f'cases/{key}.png', crop_native_bounds=bounds,
            human_mask_confirmed=False, human_pose_confirmed=False, accepted_candidate=False,
            ground_truth_eligible=False, automatic_training_eligible=False, robot_command_eligible=False,
            production_saved=False, counts_as_completed_annotation=False, counts_toward_475=False, generated_polygons=0))
    write_jsonl(OUT/'requests.jsonl', requests)
    text = page(requests, data, pose_url); (OUT/'report_zh.html').write_text(text)
    build_font(text)
    montage(OUT, requests, 'selection_contact.png')
    montage(OUT, requests, 'selection_full_native_contact.png', full=True)
    write_jsonl(OUT/'selection_ranking.jsonl', [dict(target_key=k, class_id=data['rows'][k]['final_class_id'], **v)
        for k, v in sorted(data['usable'].items())])
    write_json(OUT/'snapshot_backup_metadata.json', data['history_checks'])
    write_json(OUT/'used_image_hashes.json', data['evidence'].used)
    write_json(OUT/'protected_formal_before.json', before)
    layout_check(requests)
    after = protected_snapshot(data['formal']); write_json(OUT/'protected_formal_after.json', after)
    require(before == after, 'Protected formal files changed')
    require(all(digest(PROJECT/name) == value for name, value in data['inputs'].items()), 'Frozen input changed')
    require(file_inventory(PROJECT/'configs') == data['configs'], 'Configuration changed concurrently')
    require(all(digest(data['formal']/name) == value for name, value in data['evidence'].used.items()), 'Evidence image changed')
    require(read_json(ACCESS)['public_url'].rstrip('/') == pose_url, 'Managed pose URL changed')
    for kind, live, name in [('pose', POSE, 'reviews_snapshot.sqlite3'), ('gallery', GALLERY, 'gallery_reviews_snapshot.sqlite3')]:
        verify_history_preserved(live, BASE/name)
        require(database_fingerprint(live) == data['fingerprints'][kind], 'Live reviews changed during build')
    require(len(keys) == len({r['source']['frame_id'] for r in requests}) == 25, 'Duplicate frame or shortfall')
    for r in requests:
        key = r['target_key']
        require(key in data['eligible'] and key not in data['protected'] and r['source']['frame_id'] not in data['protected_frames'], 'Protected target selected')
        require(r['original_rectangle'] == rectangle(data['rows'][key]) and len(r['original_rectangle']) == 4 and
            digest(OUT/r['native_image']) == r['source']['image_sha256'], 'Source image/rectangle differs')
        if r['existing_pose_record']:
            require(unchanged_rectangle(r['existing_pose_current_payload']['polygon'], data['rows'][key]) and
                all(e['original_rectangle'] and e['mask_modified'] is False and e['state'] not in ('deleted', 'deferred') and not e['human_mask_confirmed'] and
                    not e['human_pose_confirmed'] for e in r['pose_history_flags']), 'Existing pose history unsafe')
        if r['closest_human_reference_key']:
            require(signature(data['rows'][r['closest_human_reference_key']]) == signature(data['rows'][key]), 'Cross-signature reference')
    names = ['report_zh.html', 'report-font.otf', 'FONT_LICENSE.txt'] + [r[f] for r in requests for f in ('native_image', 'contact_crop')]
    public = {name: digest(OUT/name) for name in sorted(names)}
    require(len(public) == 53 and all(re.fullmatch(
        r'(report_zh\.html|report-font\.otf|FONT_LICENSE\.txt|(?:cases|images)/[0-9a-f]{24}\.png)', n) for n in public), 'Public allowlist differs')
    require(not list(OUT.rglob('*.sqlite*')) and not list(OUT.rglob('*.db')) and not (OUT/'masks').exists()
        and not (OUT/'labelme').exists(), 'Unexpected private database or generated mask')
    counts = Counter(r['class_id'] for r in requests)
    now = datetime.now(timezone.utc).isoformat()
    manifest = dict(schema='manual_mask_template_requests_v1', state='verified_static_manual_tracing_requests',
        activation_state='prepared_notactivated', created_at=now, request_count=25, class_counts=dict(counts),
        requested_class_counts=QUOTAS, unmet_request_counts={c: QUOTAS[c]-counts[c] for c in QUOTAS},
        class_selection_pools=data['pools'], baseline_directory=str(BASE.relative_to(PROJECT)),
        baseline_manifest_state=data['manifest']['state'], baseline_publication_version=8,
        baseline_distinct_frames=475, baseline_class_counts=BASE_COUNTS, baseline_gaps={c: 100-n for c,n in BASE_COUNTS.items()},
        baseline_saved_human=321, baseline_old_pending=88, baseline_new_pending=66,
        previous84_actual_saved=39, previous84_no_saved_record=45, unsaved_does_not_imply_not_viewed=True,
        current24_actual_saved=24, saved_valid_four_point_class9_not_used_as_seed=True,
        five_class_100_goal_completed=False, possible_distinct_frames_after_all25_save_and_reverification=500,
        direct_manual_tasks_do_not_depend_on_matching_or_neighbor_growth=True,
        independent_baseline_verification_or_online_activation_claimed=False,
        recommendation='Main session independently verifies pub8 and this package, then may activate a derived v2; preserve this standby package',
        requests_sha256=digest(OUT/'requests.jsonl'), existing_pose_request_count=sum(r['existing_pose_record'] for r in requests),
        no_pose_current_or_history_request_count=sum(not r['existing_pose_record'] and not r['pose_history_present'] for r in requests),
        missing_exact_human_compatibility_request_count=sum(r['exact_view_human_template_absent'] for r in requests),
        selected_group_counts=dict(Counter(r['source']['group_id'] for r in requests)),
        selected_split_counts=dict(Counter(r['source']['split'] for r in requests)),
        selected_policy_counts=dict(Counter(r['source']['policy_id'] for r in requests)),
        selected_view_counts=dict(Counter(r['source']['viewpoint_candidate'] for r in requests)),
        excluded_diagnostic_counts=data['excluded_diagnostic_counts'], image_quality_rejections=data['rejected'],
        source_visual_review_summary=dict(inspected_targets=sum(not k.startswith('__') for k in decisions),
            individually_rejected_targets=sum(v.get('approved') is False for k, v in decisions.items() if not k.startswith('__')),
            excluded_source_groups=decisions.get('__excluded_source_groups__', {}),
            excluded_groups_are_current_selection_preferences_not_all_members_unusable_claims=True,
            selected_crops_and_full_native_images_inspected=25),
        direct_human_reference_inventory_count=325, unsaved_candidates_used_as_seeds_or_references=0,
        selection_priority=['no_pose_current_or_history', 'missing_exact_class_split_policy_view_human_reference',
            'signature_diversity', 'group_diversity', 'split_diversity', 'medoid_clarity_larger_area', 'individual_crop_and_full_native_visual_review'],
        ranking_score='0.45*(1-mean_squared_distance/4)+0.35*clarity+0.20*min(log1p(native_bbox_area)/log(10001),1)',
        medoid_objective='Mean squared distance between 64x28 zero-mean unit-L2 patches, same exact signature, different frame; not probabilities',
        native_quality_gates=dict(min_width=50,min_height=14,min_area=1000,min_margin=1,min_p95_p05=35,
            min_bright_fraction=.12,max_saturated_fraction=.65,min_gradient_fraction=.025),
        compatibility_policy='Exact class/split/source_policy/view; unknown matches unknown only',
        pose_public_url=pose_url, pose_public_url_authority='managed public_access.json public_url, current at build',
        frozen_input_sha256=data['inputs'], configuration_sha256=data['configs'],
        database_logical_fingerprints=data['fingerprints'], latest_snapshot_live_history_comparison=data['history_checks'],
        protected_formal_files_verified=len(before), evidence_images_verified=len(data['evidence'].used),
        source_visual_decisions_sha256=digest(OUT/'internal/source_visual_decisions.json'),
        layout_verification_sha256=digest(OUT/'layout_verification.json'),
        production_database_writes=0, configuration_writes=0, service_writes=0, publication_changes=0,
        generated_polygons=0, completed_manual_labels=0, accepted_candidates=False, human_confirmation_inferred=False,
        counts_toward_baseline=0, ground_truth_eligible=False, automatic_training_eligible=False, public_assets=public)
    write_json(OUT/'manifest.json', manifest)
    verification = dict(schema='manual_mask_template_request_verification_v1', state='passed', verified_at=now,
        request_count=25, class_counts=dict(counts), manifest_sha256=digest(OUT/'manifest.json'),
        requests_sha256=digest(OUT/'requests.jsonl'), public_assets=public, public_asset_count=53,
        all_request_targets_live_eligible=True, latest_quota_snapshots_match_live_logically=True,
        all_frozen_history_event_bytes_preserved=True, existing_pose_preservation_explicit=True,
        all_source_identities_and_hashes_verified=True, native_images_byte_identical_to_formal_sources=True,
        all_selected_crops_and_full_source_images_inspected=True, only_original_rectangle_annotations=True,
        no_generated_polygons_or_reference_vertex_proposals=True, no_protected_frames_selected=True,
        all_475_baseline_frames_and_61_old_requests_excluded=True, no_unsaved_machine_seeds_or_references=True,
        exact_same_class_split_policy_view_references=True, no_private_databases_in_output=True,
        protected_formal_files_unchanged=True, active_config_files_unchanged=True,
        all_report_Chinese_present=True, pose_url_current_at_verification=True,
        layout_390_and_desktop_no_horizontal_overflow=True,
        production_database_writes=0, configuration_writes=0, service_writes=0, publication_changes=0,
        activated=False, activation_state='prepared_notactivated', generated_polygons=0,
        completed_manual_labels=0, ground_truth_eligible=False, independent_baseline_verification_claimed=False)
    write_json(OUT/'verification.json', verification)
    require(all(digest(OUT/n) == value for n, value in public.items()), 'Public asset changed')
    (OUT/'README.md').write_text('# 最后25张直接人工描绘任务（待命未激活）\n\n'
        'Class9 10张、Class10 15张，25个新不同帧。保存并重新核验之前不计入475。\n'
        '475=321已保存人工+88旧待复核+66新待复核；五类各100尚未完成。原84项实际39保存、45未保存，不等于未看。\n'
        '报告 `report_zh.html`；任务 `requests.jsonl`；自检 `verification.json`。\n'
        '只允许 public_assets 列出的53个资源对外提供；联系表、载荷、快照备份元数据均为内部资料，无私有数据库副本。\n'
        '有效四点人工轮廓可计直接人工覆盖，但不是超过四点模板种子；不要强加点数或虚构拓扑。\n'
        '本包不激活；主会话独立核验后可构建派生v2并负责通知。无配置、服务或标注数据库写入。\n')
    write_json(OUT/'artifact_hashes.json', file_inventory(OUT))
    print(json.dumps(dict(state='passed', request_count=25, class_counts=dict(counts),
        existing_pose_requests=manifest['existing_pose_request_count'], public_asset_count=53,
        requests_sha256=digest(OUT/'requests.jsonl'), manifest_sha256=digest(OUT/'manifest.json'),
        verification_sha256=digest(OUT/'verification.json'), diagnostics=data['pools'], activated=False), ensure_ascii=False, indent=2))


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    mode = parser.add_mutually_exclusive_group(required=True)
    mode.add_argument('--review', action='store_true')
    mode.add_argument('--build', action='store_true')
    args = parser.parse_args()
    review() if args.review else build()
