"""Bounded LK configuration-consensus research; never a publication or GT writer.

The ECC and original gates retain their definitions. This is a NEW algorithm:
different deterministic LK windows/pyramids, two-window agreement, and additional
per-vertex photometric/gradient support. Original code hashes are dependencies,
not an assertion that these candidates were produced by the original algorithm.
"""
from __future__ import annotations

import argparse
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
from contextlib import closing
import json
from pathlib import Path

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

from .cluster_targets import digest, load_dataset, protected_snapshot, target_key
from .mask_boundary_review import beam_boundary_audit
from .mask_template_continue import sha
from .mask_template_refined import (CLASSES, QUARANTINE, read_jsonl, readonly,
    select_diverse, snapshot_database, verify_history_preserved, write_jsonl)
from .mask_template_refined_next import gallery_templates, PARENT as HUMAN_PARENT
from .mask_template_transfer import (PROJECT, PATCH_SIZE, ImageEvidence,
    annotation_inventory, compatible, correlate, overlay, patch_matrix, transform,
    write_json)
from .pose_review_geometry import polygon_value

VERSION = 'bounded_lk_cross_window_consensus_research_v1'
OUT = PROJECT/'outputs/pallet_mask_multiscale_diagnostic_v1'
ACTIVE = PROJECT/'outputs/pallet_mask_template_refined_v3'
UNION = PROJECT/'outputs/pallet_mask_quota_feasibility_v1'
# Fixed priority: fine pyramid first, then larger windows. Never rank by FB error.
CONFIGS = tuple((window, level) for level in range(4) for window in (15, 25, 31))
SETTINGS = dict(version=VERSION, patch_size=list(PATCH_SIZE),
    configurations=[dict(window=w, max_level=l) for w, l in CONFIGS],
    baseline=dict(window=19, max_level=3),
    ecc=dict(motion='affine', iterations=100, epsilon=1e-5, gaussian_filter=5),
    lk=dict(iterations=50, epsilon=.005, initial_flow=True, min_eigenvalue=1e-5),
    original_gates=dict(initial_ncc_min=.55, ecc_min=.84, boundary_ncc_min=.78,
        boundary_band_thickness=7, forward_backward_max_original_patch_pixels=1.5,
        refinement_native_pixels='max(3, target_bbox_height * .16)',
        area_ratio_open_interval=[.72, 1.35], all_forward_backward_statuses=True,
        affine_singular_range=[.7, 1.4], affine_translation_max=28,
        positive_affine_determinant=True, beam_guard='local_beam_boundary_guard_v1:passed'),
    additional_gates=dict(distinct_windows_required=2,
        agreement_max_original_patch_pixels=1.5, local_support_window=15,
        every_vertex_ncc_min=.55, every_vertex_gradient_ncc_min=.25,
        every_vertex_source_target_std_min=3.),
    selection='first fixed-order config with another-window admissible config within 1.5 at EVERY vertex; no averaging',
    all_metrics_are_not_accuracy_probabilities=True)


def local_support(source, target, p, q, affine):
    """Compare 15x15 windows at actual tracked points using affine local axes."""
    yy, xx = np.mgrid[-7:8, -7:8]
    offsets = np.stack((xx, yy), axis=-1).astype(np.float32)
    mapped = offsets @ affine[:, :2].T
    records = []
    for a, b in zip(p, q):
        aa, bb = offsets+a, mapped+b
        inside = all(np.min(coords[..., 0]) >= 0 and np.max(coords[..., 0]) < image.shape[1]-1
            and np.min(coords[..., 1]) >= 0 and np.max(coords[..., 1]) < image.shape[0]-1
            for coords, image in ((aa, source), (bb, target)))
        left = cv2.remap(source, aa[..., 0], aa[..., 1], cv2.INTER_LINEAR).astype(np.float32)
        right = cv2.remap(target, bb[..., 0], bb[..., 1], cv2.INTER_LINEAR).astype(np.float32)
        gradients = [np.stack([cv2.Sobel(im, cv2.CV_32F, 1, 0, ksize=3)[1:-1, 1:-1],
            cv2.Sobel(im, cv2.CV_32F, 0, 1, ksize=3)[1:-1, 1:-1]]) for im in (left, right)]
        records.append(dict(ncc=correlate(left, right), gradient_ncc=correlate(*gradients),
            source_std=float(left.std()), target_std=float(right.std()), fully_inside_patch=bool(inside)))
    passed = all(v['fully_inside_patch'] and v['ncc'] >= .55 and v['gradient_ncc'] >= .25
        and min(v['source_std'], v['target_std']) >= 3. for v in records)
    return dict(passed=passed, vertices=records)


def consensus(configurations):
    """Only whole, independently admissible polygons may support one another."""
    valid = [v for v in configurations if v['metrics']['rejection'] is None and not v.get('baseline')]
    for candidate in valid:
        support = []
        for other in valid:
            if other['window'] == candidate['window']:
                continue
            distances = np.linalg.norm(np.asarray(candidate['forward_patch_vertices'])-
                np.asarray(other['forward_patch_vertices']), axis=1)
            if distances.max() <= 1.5:
                support.append(dict(window=other['window'], max_level=other['max_level'],
                    per_vertex_distance_patch_pixels=distances.tolist()))
        if support:
            return candidate, support
    return None, []


def transfer(source_image, target_image, polygon, source_row, target_row, native_target=None):
    """ECC unchanged, then bounded alternative LK with independent consensus."""
    initial_ncc = correlate(source_image, target_image)
    metrics = dict(version=VERSION, initial_ncc=initial_ncc,
        quality_metrics_are_not_accuracy_probabilities=True)
    if initial_ncc < .55:
        return None, dict(metrics, rejection='initial_similarity_below_gate', configurations=[])
    matrix = np.eye(2, 3, dtype=np.float32)
    try:
        ecc, matrix = cv2.findTransformECC(source_image, target_image, matrix, cv2.MOTION_AFFINE,
            (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 100, 1e-5), None, 5)
    except cv2.error:
        return None, dict(metrics, rejection='affine_registration_failed', configurations=[])
    metrics.update(ecc=float(ecc), affine_patch_transform=matrix.tolist())
    singular = np.linalg.svd(matrix[:, :2], compute_uv=False)
    if np.linalg.det(matrix[:, :2]) <= 0 or singular.min() < .7 or singular.max() > 1.4 or np.max(np.abs(matrix[:, 2])) > 28:
        return None, dict(metrics, rejection='excessive_affine_deformation', configurations=[])
    p = transform(np.asarray(polygon), patch_matrix(source_row)).astype(np.float32).reshape(-1, 1, 2)
    guess = transform(p[:, 0], matrix).astype(np.float32).reshape(-1, 1, 2)
    aligned = cv2.warpAffine(target_image, matrix, PATCH_SIZE, flags=cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP)
    boundary = np.zeros(source_image.shape, np.uint8)
    cv2.polylines(boundary, [np.round(p[:, 0]).astype(np.int32)], True, 255, 7)
    metrics['boundary_ncc'] = correlate(source_image[boundary > 0], aligned[boundary > 0])
    if ecc < .84 or metrics['boundary_ncc'] < .78:
        return None, dict(metrics, rejection='insufficient_image_correspondence', configurations=[])
    inverse = cv2.invertAffineTransform(patch_matrix(target_row))
    affine_polygon = transform(guess[:, 0], inverse)
    records = []
    for window, level in CONFIGS+((19, 3),):
        record = dict(window=window, max_level=level, baseline=(window, level) == (19, 3))
        trial = dict(metrics, rejection=None)
        opts = dict(winSize=(window, window), maxLevel=level,
            criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 50, .005),
            flags=cv2.OPTFLOW_USE_INITIAL_FLOW, minEigThreshold=1e-5)
        forward, good, _ = cv2.calcOpticalFlowPyrLK(source_image, target_image, p, guess.copy(), **opts)
        backward, good_back, _ = cv2.calcOpticalFlowPyrLK(target_image, source_image, forward, p.copy(), **opts)
        fb = np.linalg.norm(backward[:, 0]-p[:, 0], axis=1)
        candidate = transform(forward[:, 0], inverse)
        displacement = np.linalg.norm(candidate-affine_polygon, axis=1)
        record.update(forward_patch_vertices=forward[:, 0].tolist(), backward_patch_vertices=backward[:, 0].tolist(),
            polygon=candidate.tolist())
        trial.update(forward_backward_error_patch_pixels=fb.tolist(),
            forward_status=good.ravel().tolist(), backward_status=good_back.ravel().tolist(),
            max_vertex_refinement_native_pixels=float(displacement.max()),
            same_vertex_count=len(candidate) == len(polygon))
        if not (good.all() and good_back.all()) or not np.isfinite(fb).all() or fb.max() > 1.5:
            trial['rejection'] = 'unreliable_vertex_tracking'
        elif displacement.max() > max(3., target_row['bbox']['height']*.16):
            trial['rejection'] = 'vertex_refinement_too_large'
        else:
            try:
                record['polygon'] = polygon_value(candidate.tolist(), *target_row['size'])
            except ValueError as exc:
                trial.update(rejection='invalid_transferred_polygon', validation_error=str(exc))
            ratio = abs(cv2.contourArea(np.array(candidate, np.float32)))/max(abs(cv2.contourArea(np.array(affine_polygon, np.float32))), 1.)
            trial['refinement_area_ratio'] = ratio
            if not .72 < ratio < 1.35:
                trial['rejection'] = 'unstable_polygon_area'
        trial['original_transfer_gates_passed'] = trial['rejection'] is None
        if trial['rejection'] is None and native_target is not None:
            guard = beam_boundary_audit(native_target, candidate, affine_polygon)
            trial['boundary_guard'] = guard
            if guard['state'] != 'passed':
                trial['rejection'] = 'local_beam_boundary_review_required'
        trial['original_transfer_and_beam_gates_passed'] = trial['rejection'] is None
        if trial['rejection'] is None:
            support = local_support(source_image, target_image, p[:, 0], forward[:, 0], matrix)
            trial['local_image_support'] = support
            if not support['passed']:
                trial['rejection'] = 'weak_local_photometric_or_edge_support'
        record['metrics'] = trial
        records.append(record)
    chosen, support = consensus(records)
    if chosen is None:
        return None, dict(metrics, rejection='no_cross_window_supported_configuration', configurations=records)
    return chosen['polygon'], dict(chosen['metrics'], selected_configuration=dict(window=chosen['window'], max_level=chosen['max_level']),
        cross_window_support=support, configurations=records)


def attempt_target(key, row, templates, evidence):
    choices = [k for k, t in templates.items() if compatible(t['row'], row)]
    if not choices:
        return None, [], dict(target_key=key, class_id=row['final_class_id'], reason='no_compatible_template')
    ranked = sorted(((correlate(evidence.patch(k), evidence.patch(key)), k) for k in choices), reverse=True)
    trials = []
    for rank, (similarity, source_key) in enumerate(ranked, 1):
        if similarity < .55:
            trials.append(dict(target_key=key, template_key=source_key, class_id=row['final_class_id'],
                metrics=dict(initial_ncc=similarity, rejection='initial_similarity_below_gate', configurations=[])))
            continue
        t = templates[source_key]
        polygon, metrics = transfer(evidence.patch(source_key), evidence.patch(key), t['polygon'], t['row'], row,
            evidence.image(row['frame_id']))
        trials.append(dict(target_key=key, template_key=source_key, class_id=row['final_class_id'], metrics=metrics))
        if polygon is not None:
            return dict(polygon=polygon, metrics=metrics, template_key=source_key, template_rank=rank), trials, dict(
                target_key=key, class_id=row['final_class_id'], reason='research_candidate')
    return None, trials, dict(target_key=key, class_id=row['final_class_id'], reason='all_compatible_templates_rejected')


def generate(workers=4, classes=CLASSES):
    if OUT.exists():
        raise ValueError('Diagnostic directory already exists; do not overwrite research evidence')
    OUT.mkdir(parents=True)
    write_json(OUT/'settings.json', SETTINGS)
    manifest = json.loads((ACTIVE/'manifest.json').read_text())
    frozen_code = {name: digest(PROJECT/name) for name in ('pallet/mask_template_transfer.py',
        'pallet/mask_template_refined.py', 'pallet/mask_template_refined_next.py',
        'pallet/mask_template_continue.py', 'pallet/mask_boundary_review.py')}
    if frozen_code['pallet/mask_template_transfer.py'] != manifest['transfer_code_sha256']:
        raise ValueError('Frozen transfer dependency changed')
    formal = Path(json.loads((PROJECT/'configs/active_formal_dataset.json').read_text())['dataset'])
    classification = PROJECT/'outputs/pallet_appearance_center_reclassification_v1/targets.jsonl'
    formal_sha = digest(formal/'manifest.json')
    if formal_sha != manifest['formal_manifest_sha256'] or digest(classification) != manifest['classification_sha256']:
        raise ValueError('Formal or classification identity changed')
    annotations, sources = load_dataset(formal)
    rows = {r['target_key']: r for r in read_jsonl(classification)}
    identities = {target_key(a['frame_id'], i): (a, b) for a in annotations for i, b in enumerate(a['boxes'])}
    if set(identities) != set(rows):
        raise ValueError('Formal/classification target coverage mismatch')
    for key, row in rows.items():
        a, box = identities[key]; s = sources[a['frame_id']]
        if (row['bbox'] != box or any(row[k] != a[k] for k in ('frame_id', 'split', 'group_id')) or
                row['source_pcd_sha256'] != s['source_anchor_hash'] or row['policy_id'] != s['sensor_policy']['policy_id']):
            raise ValueError('Formal source mismatch')
        row['size'] = s['size']
    protected = protected_snapshot(formal)
    write_json(OUT/'protected_formal_before.json', protected)
    pose_live = PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3'
    gallery_live = PROJECT/'outputs/pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3'
    pose_snapshot = OUT/'reviews_snapshot.sqlite3'; gallery_snapshot = OUT/'gallery_reviews_snapshot.sqlite3'
    pose_sha = snapshot_database(pose_live, pose_snapshot)
    gallery_sha = snapshot_database(gallery_live, gallery_snapshot)
    with closing(readonly(pose_snapshot, True)) as db:
        current, pose_templates, status = annotation_inventory(db, rows)
        if json.loads(db.execute("SELECT value FROM metadata WHERE key='binding'").fetchone()[0])['formal_manifest_sha256'] != formal_sha:
            raise ValueError('Pose binding mismatch')
    with closing(readonly(gallery_snapshot, True)) as db:
        reviews = {k: json.loads(raw) for k, raw in db.execute('SELECT target_key,payload FROM reviews')}
        events = [json.loads(raw) for raw, in db.execute('SELECT payload FROM events ORDER BY id')]
        if db.execute("SELECT value FROM metadata WHERE key='formal_manifest_sha256'").fetchone()[0] != formal_sha:
            raise ValueError('Gallery binding mismatch')
    previous = read_jsonl(ACTIVE/'proposals.jsonl')
    if len(previous) != 140 or digest(ACTIVE/'proposals.jsonl') != manifest['proposals_sha256']:
        raise ValueError('Expected exactly 140 active proposals')
    templates = gallery_templates(read_jsonl(HUMAN_PARENT/'proposals.jsonl'), reviews, events, current,
        rows, HUMAN_PARENT, formal_sha, gallery_sha)
    union_summary = json.loads((UNION/'summary.json').read_text())
    if (union_summary['formal_manifest_sha256'] != formal_sha or
            union_summary['classification_sha256'] != digest(classification) or
            any(digest(PROJECT/name) != value for name, value in union_summary['frozen_gate_code_sha256'].items())):
        raise ValueError('Union human inventory formal/code identity mismatch')
    human_union = read_jsonl(UNION/'human_templates.jsonl')
    if len(human_union) != 149 or len({t['row']['target_key'] for t in human_union}) != 149:
        raise ValueError('Expected 149 distinct direct-human templates')
    for frozen in human_union:
        key = frozen['row']['target_key']; provenance = frozen['provenance']
        if provenance['store'] == 'pose':
            latest = pose_templates.get(key)
            if (latest is None or latest['human_event_sha256'] != provenance['human_event_sha256'] or
                    latest['current_payload_sha256'] != provenance['current_payload_sha256'] or key in templates):
                raise ValueError('Original human pose template changed or overlaps gallery')
            templates[key] = dict(latest, origin='original_pose_human_polygon')
        elif provenance['store'] != 'gallery' or key not in templates:
            raise ValueError('Unknown direct-human template store')
        if (templates[key]['row'] != frozen['row'] or templates[key]['polygon'] != frozen['polygon'] or
                sha(frozen['polygon']) != provenance['polygon_sha256'] or
                templates[key]['human_event_sha256'] != provenance['human_event_sha256']):
            raise ValueError('Union human polygon/source provenance mismatch')
        templates[key]['provenance'] = provenance
    if len(templates) != 149:
        raise ValueError('Union human template coverage mismatch')
    frozen_reviews = {v['target_key']: v for v in read_jsonl(ACTIVE/'refined_annotations.jsonl')}
    changed = sorted(k for k, v in reviews.items() if frozen_reviews.get(k) != v)
    write_json(OUT/'template_inventory.json', dict(templates=templates, count=len(templates),
        changed_since_refined_v3=changed, latest_saved_human_templates=True, eligibility=status,
        union_inventory_sha256=digest(UNION/'human_templates.jsonl'),
        union_summary_sha256=digest(UNION/'summary.json')))
    write_jsonl(OUT/'refined_annotations.jsonl', [reviews[k] for k in sorted(reviews)])
    excluded = {p['target_key'] for p in previous} | QUARANTINE | set(manifest.get('preserved_quarantined_targets', []))
    excluded |= set(reviews) | {e['target_key'] for e in events}
    write_json(OUT/'excluded_targets.json', sorted(excluded))
    evidence = ImageEvidence(formal, rows, sources)
    for key, t in templates.items():
        if t['origin'] == 'mask_gallery_human_revision' and not np.array_equal(
                np.asarray(Image.open(HUMAN_PARENT/'images'/f'{key}.png')), evidence.image(t['row']['frame_id'])):
            raise ValueError('Gallery and actual source image pixels disagree')
    work = []; outcomes = []
    for key, row in sorted(rows.items()):
        reason = ('excluded_active_gallery_or_quarantine' if key in excluded else status[key])
        if reason == 'eligible' and row['final_class_id'] not in classes:
            reason = 'class_not_requested'
        if reason == 'eligible':
            work.append((key, row))
        else:
            outcomes.append(dict(target_key=key, class_id=row['final_class_id'], reason=reason))
    print(json.dumps(dict(state='scanning', templates=len(templates), changed_human_templates=changed,
        work_by_class=dict(Counter(r['final_class_id'] for _, r in work)))), flush=True)
    accepted = []; attempts_count = 0; rejections = Counter(); config_rejections = Counter()
    def worker(item):
        return item, attempt_target(*item, templates, evidence)
    with (OUT/'registration_attempts.jsonl').open('wb') as audit, ThreadPoolExecutor(max_workers=workers) as pool:
        from .pose_review_geometry import canonical
        for number, ((key, row), (candidate, trials, outcome)) in enumerate(pool.map(worker, work), 1):
            outcomes.append(outcome)
            for trial in trials:
                audit.write(canonical(trial)+b'\n')
                attempts_count += 1; rejections[(row['final_class_id'], str(trial['metrics']['rejection']))] += 1
                for config in trial['metrics']['configurations']:
                    config_rejections[(row['final_class_id'], str(config['metrics']['rejection']))] += 1
            if candidate:
                t = templates[candidate['template_key']]; old = current.get(key)
                accepted.append(dict(schema=VERSION, target_key=key, class_id=row['final_class_id'], source=row,
                    polygon=candidate['polygon'], vertex_count=len(candidate['polygon']),
                    template=dict(target_key=candidate['template_key'], provenance=t['provenance'],
                        human_polygon_revision=t['human_polygon_revision'], human_event_sha256=t['human_event_sha256'],
                        origin=t['origin'], vertex_count=len(t['polygon'])),
                    metrics={k: v for k, v in candidate['metrics'].items() if k != 'configurations'},
                    template_rank=candidate['template_rank'], target_expected_revision=old['revision'] if old else 0,
                    target_snapshot_payload_sha256=sha(old) if old else None, snapshot_sha256=pose_sha,
                    formal_manifest_sha256=formal_sha, class_assignments_sha256=digest(classification),
                    status='research_candidate_pending_independent_validation', human_mask_confirmed=False,
                    human_pose_confirmed=False, ground_truth_eligible=False, automatic_training_eligible=False,
                    robot_command_eligible=False, production_saved=False))
            if number % 200 == 0:
                audit.flush()
                print(json.dumps(dict(scanned=number, accepted=dict(Counter(p['class_id'] for p in accepted)),
                    attempts=attempts_count)), flush=True)
    selected, dispositions = select_diverse(previous, accepted)
    for outcome in outcomes:
        if outcome['target_key'] in dispositions:
            outcome['selection_disposition'] = dispositions[outcome['target_key']]
    write_jsonl(OUT/'accepted_candidates.jsonl', accepted)
    write_jsonl(OUT/'selected_candidates.jsonl', selected)
    write_jsonl(OUT/'outcomes.jsonl', outcomes)
    (OUT/'cases').mkdir()
    cards = []
    for p in accepted:
        t = templates[p['template']['target_key']]
        panel = Image.new('RGB', (1480, 305), '#121923')
        panel.paste(overlay(evidence.image(t['row']['frame_id']), t['row'], t['polygon'], '#55ceff'), (0, 30))
        panel.paste(overlay(evidence.image(p['source']['frame_id']), p['source'], p['polygon'], '#ffc247'), (740, 30))
        draw = ImageDraw.Draw(panel)
        draw.text((10, 8), f"Class {p['class_id']} | saved human template -> RESEARCH candidate | independent validation pending", fill='white')
        draw.text((10, 285), f"{p['template']['target_key']} -> {p['target_key']} | {p['metrics']['selected_configuration']}", fill='white')
        panel.save(OUT/'cases'/f"{p['target_key']}.png")
        cards.append(f"<h2>Class {p['class_id']} / {p['target_key']}</h2><img width='1480' src='cases/{p['target_key']}.png'>")
    (OUT/'report.html').write_text('<!doctype html><meta charset="utf-8"><title>Multiscale research diagnostic</title>'
        '<h1>New algorithm research candidates: NOT GT, not independently validated</h1>'
        '<p>Left: current saved human template. Right: image-registered candidate. All original gates retained; '
        'additional local support and cross-window consistency gates. Exact polygons: accepted_candidates.jsonl.</p>'+''.join(cards))
    write_json(OUT/'used_image_hashes.json', evidence.used)
    after = protected_snapshot(formal)
    write_json(OUT/'protected_formal_after.json', after)
    if after != protected or any(digest(PROJECT/name) != value for name, value in frozen_code.items()):
        raise ValueError('Protected formal data or dependency code changed')
    verify_history_preserved(pose_live, pose_snapshot)
    verify_history_preserved(gallery_live, gallery_snapshot)
    counts = {cls: dict(active=sum(p['class_id'] == cls for p in previous),
        accepted=sum(p['class_id'] == cls for p in accepted), selected=sum(p['class_id'] == cls for p in selected),
        missing=max(0, 50-sum(p['class_id'] == cls for p in previous+selected))) for cls in CLASSES}
    result = dict(version=VERSION, state='research_complete_pending_independent_validation', classes=counts,
        settings_sha256=digest(OUT/'settings.json'), code_sha256=digest(__file__), frozen_dependency_hashes=frozen_code,
        snapshot_sha256=pose_sha, gallery_snapshot_sha256=gallery_sha, changed_human_templates=changed,
        formal_manifest_sha256=formal_sha, classification_sha256=digest(classification),
        active_proposals_sha256=digest(ACTIVE/'proposals.jsonl'), generation_templates=len(templates),
        scanned_eligible_targets=len(work), attempts=attempts_count,
        pair_rejections={f'{k[0]}:{k[1]}': v for k, v in sorted(rejections.items())},
        configuration_rejections={f'{k[0]}:{k[1]}': v for k, v in sorted(config_rejections.items())},
        all_five_classes_50=all(v['missing'] == 0 for v in counts.values()),
        opencv_version=cv2.__version__, numpy_version=np.__version__, opencv_threads=cv2.getNumThreads(),
        workers=workers, recursive_propagation=False, original_thresholds_relaxed=False,
        production_database_writes=0, published=False, ground_truth_confirmed=False,
        accepted_candidates_sha256=digest(OUT/'accepted_candidates.jsonl'),
        registration_attempts_sha256=digest(OUT/'registration_attempts.jsonl'))
    write_json(OUT/'manifest.json', result)
    print(json.dumps(result), flush=True)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--workers', type=int, default=4)
    parser.add_argument('--classes', type=int, nargs='+', default=list(CLASSES))
    args = parser.parse_args()
    if not 1 <= args.workers <= 8 or not set(args.classes) <= set(CLASSES):
        raise ValueError('Unsupported workers or classes')
    cv2.setNumThreads(1)
    generate(args.workers, tuple(args.classes))


if __name__ == '__main__':
    main()
