"""Read-only independent recomputation of audit counts/distances, not semantics.

Does not import the anomaly generator or its diagnostic module. Never trains,
modifies labels, or claims medoid/majority differences are ground-truth errors.
"""
from collections import Counter, defaultdict
import math
from pathlib import Path
import sys

import numpy as np

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT))
from pallet.cluster_targets import digest, protected_snapshot
from pallet.mask_model_training_data import verify_dataset, read, jsonl, write
from pallet.mask_quota_saved_extension import load_formal_evidence
from pallet.pose_review_geometry import raster_mask, polygon_value

OUT = PROJECT/'outputs/pallet_mask_annotation_anomalies_v2'
DATA = PROJECT/'outputs/pallet_mask_dataset_update_v1'
SOURCE = PROJECT/'outputs/pallet_mask_continuation_sources_v14'
CLUSTER = PROJECT/'outputs/pallet_target_clustering_v1/analysis/run_006'


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


def main():
    require(not (OUT/'readonly_verification.json').exists(), 'Keep earlier verification evidence')
    _, model = verify_dataset(DATA)
    sources = jsonl(SOURCE/'private/source_catalog.jsonl')+jsonl(DATA/'private/nonconforming_source_catalog.jsonl')
    source_map = {r['target_key']: r for r in sources}; model_map = {r['target_key']: r for r in model}
    formal, rows, _ = load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'))
    verification = read(OUT/'verification.json')
    for name, expected in verification['input_sha256'].items():
        require(digest(PROJECT/name) == expected, 'Frozen input/code differs')
    for name, expected in verification['diagnostic_artifacts_sha256'].items():
        require(digest(OUT/name) == expected, 'Completed diagnostic artifact differs')
    raw_rows = jsonl(CLUSTER/'targets.jsonl')
    with np.load(CLUSTER/'features.npz') as archive:
        indices, features = archive['appearance_indices'], archive['appearance_features']
    vectors = {raw_rows[int(source_i)]['target_key']: np.asarray(features[i], float) for i, source_i in enumerate(indices)}
    summary = read(OUT/'summary.json'); stats = read(OUT/'class_statistics.json')
    scopes = {}; results = {}
    for name, filename, expected_keys in (('all_saved', 'all_sources.jsonl', set(source_map)),
            ('current_model', 'training_sources.jsonl', set(model_map))):
        values = jsonl(OUT/filename); lookup = {r['target_key']: r for r in values}; scopes[name] = lookup
        require(len(values) == len(expected_keys) and set(lookup) == expected_keys, 'Audit source scope changed')
        groups = defaultdict(list); flags = Counter()
        for r in values:
            source = source_map[r['target_key']]; row = source['row']
            require(r['polygon'] == source['polygon'] and r['vertices'] == len(source['polygon'])
                and r['class_id'] == row['final_class_id'] and r['formal_split'] == row['split'], 'Source polygon/class/split changed')
            polygon_value(r['polygon'], *row['size'])
            p = np.asarray(r['polygon'], float)
            area = np.sum(p[:, 0]*np.roll(p[:, 1], -1)-np.roll(p[:, 0], -1)*p[:, 1])/2
            require((area > 0) == (r['polygon_geometry']['image_coordinate_winding'] == 'clockwise'), 'Winding differs')
            require(abs(float(area)-r['polygon_geometry']['signed_area_native_pixels']) < 1e-7, 'Signed area differs')
            groups[r['class_id']].append(r); flags.update(r['flags'])
            if name == 'current_model':
                require(r['polygon'] == model_map[r['target_key']]['polygon'] and r['development_split'] == model_map[r['target_key']]['development_split'], 'Current294 label/partition differs')
        mixed = []
        for cls, items in groups.items():
            counts = Counter(r['vertices'] for r in items); s = stats[name][str(cls)]
            require(s['vertex_count_distribution'] == {str(k): v for k, v in counts.items()} and s['n'] == len(items), 'Point-count table differs')
            modal = sorted(k for k, n in counts.items() if n == max(counts.values()))
            require(modal == s['modal_vertex_counts'], 'Modal counts differ, including ties')
            if len(counts) > 1:
                mixed.append(cls)
            x = np.stack([vectors[r['target_key']] for r in items]); distances = np.linalg.norm(x[:, None, :]-x[None, :, :], axis=2)
            mean_distances = distances.mean(axis=1)
            main_key = items[0]['class_references']['main_target_key']
            medoid = next(i for i, r in enumerate(items) if r['target_key'] == main_key)
            require(mean_distances[medoid] <= mean_distances.min()+1e-12, 'Declared reference is not an image medoid')
            for i, r in enumerate(items):
                require(r['class_references']['main_target_key'] == main_key, 'Dominant image medoid differs')
                require(abs(float(distances[i, medoid])-r['appearance']['within_class_distance_to_medoid']) < 1e-10, 'Cached image distance differs')
                require(('nonmodal_vertex_count_not_automatically_wrong' in r['flags']) == (r['vertices'] not in modal), 'Nonmodal-point flag differs')
                shape_ref = lookup[r['shape_comparison']['reference_target_key']]
                require(shape_ref['class_id'] == cls, 'Shape comparison crossed classes')
                def mask(record):
                    b = record['bbox']; q = (np.asarray(record['polygon'], float)-[b['x'], b['y']])/[b['width'], b['height']]
                    return raster_mask(q*[64, 32], 64, 32)
                a, b = mask(r), mask(shape_ref); union = np.logical_or(a, b).sum()
                distance = 1-float(np.logical_and(a, b).sum()/union) if union else 0.
                require(abs(distance-r['shape_comparison']['normalized_mask_distance']) <= 1e-6, 'Native normalized mask distance differs')
        results[name] = dict(sources=len(values), classes=len(groups), mixed_vertex_classes=sorted(mixed),
            unique_flagged_candidates=sum(bool(r['flags']) for r in values), flags=dict(flags),
            all_original_polygons_preserved=True, all_image_clockwise=all(r['polygon_geometry']['image_coordinate_winding'] == 'clockwise' for r in values))
    require(results['current_model']['mixed_vertex_classes'] == [9, 16]
        and results['all_saved']['mixed_vertex_classes'] == [2,3,5,9,10,11,12,14,15,16,17,19,20,21], 'Expected mixed-count class inventory differs')
    cases = read(OUT/'case_index.json')
    for case in cases:
        require(case['flags'] and case['target_key'] != case['reference_target_key'], 'Empty-reason or self-comparison case')
        scope = 'current_model' if case['diagnostic_scope'] == 'current294' else 'all_saved'
        r = scopes[scope][case['target_key']]
        require(case['flags'] == r['flags'] and (OUT/case['path']).is_file(), 'Displayed case scope/flags/image differs')
    visual = read(OUT/'visual_review.json')
    require(len(visual['observations']) == len({r['target_key'] for r in visual['observations']}) == 16, 'Visual check denominator differs')
    require(all(r['target_key'] in {c['target_key'] for c in cases} for r in visual['observations']), 'Visual finding has no bound comparison')
    annotation_count = 0; keypoints = 0
    for directory in ('dataset', 'dataset_rfdetr'):
        for split in ('train', 'valid', 'calibration'):
            annotations = read(DATA/directory/split/'_annotations.coco.json')['annotations']
            annotation_count += len(annotations)
            keypoints += sum('keypoints' in a or 'num_keypoints' in a for a in annotations)
    require(annotation_count == 588 and keypoints == 0, 'Do not confuse polygon vertices with semantic keypoint labels')
    require(protected_snapshot(formal) == read(PROJECT/'outputs/pallet_mask_quality_recovery_v2/private/protected_formal_before.json'), 'Formal protected data changed')
    result = dict(state='passed_readonly_source_geometry_counts_image_distances_and_scope_replay_not_GT', scopes=results,
        report_cases_verified=len(cases), selected_visual_observations=16, semantic_keypoint_annotations=0,
        model_dataset_manifest_sha256=digest(DATA/'dataset_manifest.json'), model_dataset_files_verified=897,
        original_formal_files_preserved=20768, annotations_or_classes_modified=False,
        all_candidates_not_confirmed_errors=True, code_sha256=digest(__file__))
    write(OUT/'readonly_verification.json', result)
    print({k: result[k] for k in ('state', 'report_cases_verified', 'selected_visual_observations', 'semantic_keypoint_annotations')}, flush=True)


if __name__ == '__main__':
    main()
