"""Read-only new-experiment verifier; writes only a new private receipt.

Checks all dataset/RLE mappings, launch-source snapshots, checkpoint hashes and
epoch receipts. Optionally recomputes M1 native development metrics on CPU from
the frozen checkpoint. Never imports/loads any old task checkpoint or val/test
label, and never evaluates a running/uncompleted route.
"""
from __future__ import annotations

import argparse
from collections import Counter
import json
from pathlib import Path
import sys

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))

import cv2
import numpy as np
from pycocotools import mask as coco_mask

from pallet.mask_model_training_data import (
    OUTPUT, digest, jsonl, letterbox, read, require, verify_dataset, verify_sources, write,
)


def verify(output=OUTPUT, route='m1', recompute=False):
    output = Path(output).resolve()
    out = output/route
    completion = read(out/'completion.json')
    require(completion['state'] == 'completed_internal_research_training_only', 'Completed route required')
    manifest, records = verify_dataset(output)
    _, _, _, protection = verify_sources(allow_authorized_supplement_appends=True,
        trained_keys={r['target_key'] for r in records})
    launch = read(out/'worker_start.json')
    for name, expected in launch['code_sha256'].items():
        require(digest(out/'code_snapshot'/Path(name).name) == expected, 'Launch source snapshot changed')
    require(digest(out/completion['checkpoint']) == completion['checkpoint_sha256'], 'Completed checkpoint changed')
    transforms = read(output/'private/rfdetr_transforms.json')
    for split in ('train', 'valid'):
        native = read(output/'dataset'/split/'_annotations.coco.json')
        square = read(output/'dataset_rfdetr'/split/'_annotations.coco.json')
        for image_record, annotation, square_annotation in zip(native['images'], native['annotations'], square['annotations']):
            image = cv2.imread(str(output/'dataset'/split/image_record['file_name']), cv2.IMREAD_GRAYSCALE)
            mask = cv2.imread(str(output/'private/native_masks'/image_record['file_name']), cv2.IMREAD_GRAYSCALE) > 0
            require(np.array_equal(coco_mask.decode(annotation['segmentation']) > 0, mask), 'Native RLE differs')
            _, transformed, valid, transform = letterbox(image, mask, (576, 576))
            require(np.array_equal(coco_mask.decode(square_annotation['segmentation']), transformed), 'Mapped RLE differs')
            require(not transformed[valid == 0].any() and transforms[str(image_record['id'])] == transform,
                    'Letterbox / ignore mapping differs')
    saved = jsonl(out/'internal_development_predictions.jsonl')
    require(len(saved) == manifest['splits']['dev'] and all(r['formal_split'] == 'train' for r in saved),
            'Internal quality denominator or formal split changed')
    recomputed = None
    if recompute:
        require(route == 'm1', 'CPU mask recomputation currently supports completed M1 only')
        import torch
        from scipy import ndimage
        from pallet.mask_model_training import ROIDataset, ROIMaskBoundaryUNet
        torch.set_num_threads(4)
        model = ROIMaskBoundaryUNet().eval()
        model.load_state_dict(torch.load(out/'best.pt', map_location='cpu', weights_only=True)['model'])
        selected = read(out/'frozen_selection.json')
        by_key = {r['target_key']: r for r in saved}
        metrics = []
        with torch.no_grad():
            for image, _, _, _, record, transform, target in ROIDataset(output, records, 'dev').items:
                logits, _ = model(image[None])
                probability = logits.sigmoid()[0, 0].numpy()
                left, top = transform['padding_left_top']
                width, height = transform['scaled_size']
                native = cv2.resize(probability[top:top+height, left:left+width],
                                   tuple(transform['native_size']), interpolation=cv2.INTER_LINEAR)
                prediction = native >= selected['calibrated_mask_threshold']
                iou = np.count_nonzero(prediction & target)/np.count_nonzero(prediction | target)
                require(prediction.any(), 'Unexpected empty prediction in M1 recomputation')
                edge_a = prediction & ~ndimage.binary_erosion(prediction, np.ones((3, 3), bool), border_value=0)
                edge_b = target & ~ndimage.binary_erosion(target, np.ones((3, 3), bool), border_value=0)
                a = ndimage.distance_transform_edt(~edge_b)[edge_a]
                b = ndimage.distance_transform_edt(~edge_a)[edge_b]
                precision, recall = np.mean(a <= 1), np.mean(b <= 1)
                hd95 = float(np.quantile(np.r_[a, b], .95))
                f1 = float(2*precision*recall/max(precision+recall, 1e-12))
                saved_record = by_key[record['target_key']]
                # Small CUDA/CPU float rounding can shift a few threshold pixels;
                # explicitly bound tolerances in native metric units.
                require(abs(iou-saved_record['iou']) < .002, 'CPU/CUDA native IoU discrepancy')
                require(abs(hd95-saved_record['hd95_native_pixels']) < .2, 'CPU/CUDA native HD95 discrepancy')
                require(abs(f1-saved_record['boundary_f1_1px']) < .01, 'CPU/CUDA native boundary F1 discrepancy')
                metrics.append(dict(iou=float(iou), hd95_native_pixels=hd95, boundary_f1_1px=f1))
        recomputed = dict(count=len(metrics), iou_median=float(np.median([r['iou'] for r in metrics])),
            hd95_native_pixels_median=float(np.median([r['hd95_native_pixels'] for r in metrics])),
            boundary_f1_1px_median=float(np.median([r['boundary_f1_1px'] for r in metrics])),
            device='cpu', checkpoint_reloaded=True, gt_not_model_input=True)
    audit = jsonl(output/'private/eligibility_audit.jsonl')
    approval = read(output/'private/visual_semantic_approval.json')
    summary = dict(state='passed_data_binding_checkpoint_and_internal_metrics_only', route=route,
        checkpoint_sha256=completion['checkpoint_sha256'],
        completed_epochs=completion['epochs_trained'], splits=manifest['splits'],
        components=manifest['independent_components'], native_rle_roundtrips_verified=len(records),
        original_formal_train_source_denominator=658,
        eligible_for_single_face_visual_review=sum(not r['reasons'] for r in audit),
        visually_approved=len(approval['approved_indices']), visual_quarantine=len(approval['rejected_indices']),
        total_training_reference_coverage=len(records)/658,
        internal_dev_prediction_coverage=len(saved)/manifest['splits']['dev'],
        formal_val_test_predictions=0, raw_pose_or_access_code_exports=0,
        protected_formal_files_verified=protection['protected_formal_files'],
        baseline_store_raw_history_schema_config_frozen_code_preserved=True,
        live_fingerprints_identical_to_initial=protection['live_fingerprints_identical_to_initial'],
        authorized_external_append_audit=protection['authorized_external_append_audit'],
        recomputed_m1_native_metrics=recomputed,
        quality_does_not_authorize_production_or_GT=True)
    write(out/'verification.json', summary)
    print(json.dumps(summary), flush=True)
    return summary


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output', type=Path, default=OUTPUT)
    parser.add_argument('--route', default='m1')
    parser.add_argument('--recompute-m1-cpu', action='store_true')
    args = parser.parse_args()
    verify(args.output, args.route, args.recompute_m1_cpu)
