"""Fail-closed post-run evidence. Never edits pinned workers or prior receipts."""
from __future__ import annotations

from pathlib import Path
import hashlib
import shutil
import traceback

import cv2
import numpy as np
import torch

from .mask_model_training import native_metrics, summarize
from .mask_model_training_data import PROJECT, read, jsonl, write, digest, require, verify_dataset
from .mask_model_training_history_v2 import compare_history
from .mask_model_training_integrity import database_rows
from .mask_quality_recovery import POSE, GALLERY, fingerprint
from .mask_model_improvement_data import preservation, provenance_registry, load_formal_evidence
from .mask_model_improvement import GENERIC_SHA, CONFIGS

V3 = PROJECT/'outputs/pallet_mask_model_improvement_v3'
V4 = PROJECT/'outputs/pallet_mask_model_improvement_v4'
EXPECTED = {name: ('v3' if name.startswith('A') else 'v4') for name in
            ('A0', 'A1', 'A2', 'A3_freeze', 'A3_photometric', 'B0', 'B1')}


def global_budget(roots=None, *, limit=25*2**30, reserve=10*2**30):
    roots = roots or [PROJECT/f'outputs/pallet_mask_model_improvement_v{v}' for v in range(1, 5)]
    sizes = {str(p): sum(f.stat().st_size for f in p.rglob('*') if f.is_file()) for p in roots}
    free = shutil.disk_usage(roots[-1]).free
    total = sum(sizes.values())
    require(total < limit, 'GLOBAL v1..v4 experiment budget >=25GiB')
    require(free >= reserve, 'GLOBAL project reserve <10GiB')
    return dict(state='passed_global_all_versions_budget', versions=sizes, all_versions_bytes=total,
                project_free_bytes=free, maximum_all_versions_bytes=limit, minimum_reserve_bytes=reserve,
                old_files_deleted=False, scope='All v1/v2 failed or rejected evidence PLUS v3/v4, including checkpoints and temporary files')


def assert_root(name, root):
    expected = V3 if EXPECTED[name] == 'v3' else V4
    require(Path(root).resolve() == expected, f'Wrong evidence root for {name}; failed v3 B0 cannot substitute v4')


def all_completed(results):
    """No vacuous/all-empty success, no missing-run fallback, exact run/root set."""
    return (set(results) == set(EXPECTED) and all(
        r.get('state') == 'verified_completed_1000_updates' and r.get('actual_optimizer_updates') == 1000
        and r.get('root_version') == EXPECTED[name] for name, r in results.items()))


def verify_run(name, root, dataset):
    from pycocotools import mask as mu
    assert_root(name, root)
    out = root/name
    complete, start = read(out/'completion.json'), read(out/'worker_start.json')
    plan = read(root/'execution_plan.json')
    require(complete['state'] == 'completed_bounded_exploratory_screen_not_release' and complete['name'] == name,
            'Not a genuine successful completion receipt')
    require(not (out/'failure.json').exists(), 'Run has a failure receipt, not completed evidence')
    require(complete['actual_optimizer_updates'] == 1000 and start['optimizer_updates_budget'] == 1000,
            'Actual/budget optimizer updates must both equal1000')
    require(start['seed'] == 42 and start['config'] == CONFIGS[name], 'Declared single-factor/seed changed')
    route = 'm1' if name.startswith('A') else 'm2'
    require(start['generic_sha256'] == GENERIC_SHA[route] and not start['old_finetuned_checkpoint_used'],
            'Not the fixed generic pretrained start')
    expected_uuid = 'GPU-3315c096-fef4-7350-483a-7c5f5ca2b619' if route == 'm1' else 'GPU-09ed84c8-4dee-efc0-dc1d-deda5177e4e8'
    require(start['gpu']['uuid'] == complete['gpu']['uuid'] == expected_uuid and
            start['gpu']['cuda_visible_devices'] == expected_uuid, 'GPU binding differs')
    require(start['dataset_manifest_sha256'] == plan['dataset_manifest_sha256'] == digest(root/'dataset_manifest.json'),
            'Launch/freeze data pin differs')
    require(start['code_sha256'] == plan['code_sha256'], 'Worker and execution plan code pins differ')
    for path, expected in start['code_sha256'].items():
        require(digest(root/'code_snapshot'/Path(path).name) == expected and digest(PROJECT/path) == expected,
                'Frozen launch/live code pin differs: '+path)
    require(digest(root/'contracts_execution_pin.xml') == plan['contracts_junit_sha256'], 'Contract receipt changed')
    require(digest(root/'private/source_binding.json') == plan['source_binding_sha256'], 'Source binding changed')
    for stage in ('before', 'after_freeze'):
        require(digest(root/f'private/preservation_{stage}.json') == plan[f'preservation_{stage}_sha256'],
                'Static preservation pin changed')
    checkpoint = out/complete['checkpoint']
    require(checkpoint.resolve().is_relative_to(out) and digest(checkpoint) == complete['checkpoint_sha256'], 'Best checkpoint pin differs')
    best = torch.load(checkpoint, map_location='cpu', weights_only=True)
    require(best['step'] == complete['best_step'] and 1 <= best['step'] <= 1000, 'Selected best step differs')
    state_elements = sum(v.numel() for v in best['model'].values() if isinstance(v, torch.Tensor))
    del best
    last = torch.load(out/'last.pt', map_location='cpu', weights_only=True)
    require(last['step'] == 1000, 'CPU-loaded last checkpoint is not actual1000 updates')
    del last
    epochs = [read(p) for p in sorted((out/'epochs').glob('*.json'))]
    steps = [e['optimizer_step'] for e in epochs]
    require(steps and all(a < b for a, b in zip(steps, steps[1:])) and steps[-1] == 1000,
            'Optimizer-step epoch receipts are not monotonic through1000')
    running_best, selected_step = -1., None
    for epoch in epochs:
        score = epoch['dev_macro_group_iou']
        if score > running_best + .001:
            running_best, selected_step = score, epoch['optimizer_step']
    require(selected_step == complete['best_step'], 'Predeclared native selection replay differs')
    first = read(out/'first_actual_training_batch.json')
    require(first['optimizer_step'] == 1 and first['state'] == 'actual_forward_backward_optimizer_step_succeeded',
            'Actual first optimizer step missing')
    if name == 'A3_freeze':
        require(all(e['encoder_frozen'] == (e['epoch'] <= 5) for e in epochs), '5epoch freeze-only contract differs')
    split_results = {}
    for split in ('dev', 'calibration'):
        predictions = jsonl(out/f'{split}_predictions.jsonl')
        expected = {k for k, r in dataset.items() if r['development_split'] == split}
        require(len(predictions) == len(expected) and {p['target_key'] for p in predictions} == expected,
                'All-target native output membership differs')
        maximum = 0.
        for p in predictions:
            record = dataset[p['target_key']]
            require(record['formal_split'] == p['formal_split'] == 'train' and record['component'] == p['component']
                    and p['development_split'] == split, 'Leakage/evaluation group mismatch')
            rle = p['native_prediction_rle']
            prediction = mu.decode(dict(size=rle['size'], counts=rle['counts'].encode('ascii'))).astype(bool)
            target = cv2.imread(str(root/record['native_mask']), cv2.IMREAD_GRAYSCALE) > 0
            require(prediction.shape == target.shape, 'Prediction/native reference shapes differ')
            metrics = native_metrics(prediction, target)
            for key, value in metrics.items():
                if value is None or isinstance(value, bool):
                    require(value == p[key], 'Empty/null native metric differs')
                else:
                    delta = abs(value-p[key]); maximum = max(maximum, delta)
                    require(delta <= 1e-12, 'Native RLE CPU metric replay differs')
            require(not p['ground_truth_eligible'] and not p['robot_command_eligible'], 'Prediction promoted to GT/robot')
        quality = read(out/f'{split}_quality.json')
        require(quality['all'] == summarize(predictions) and quality['accepted_count'] == 0 and
                quality['accepted_quality'] is None and not quality['deployment_authorized'], 'Quality/release report differs')
        split_results[split] = dict(all_outputs=len(predictions), independent_groups=len({p['component'] for p in predictions}),
            CPU_native_RLE_metric_replay='passed; NOT a CPU/GPU model-inference bitexact assertion',
            maximum_absolute_metric_difference=maximum, quality=quality['all'],
            macro_group_iou=quality['macro_group_iou'], macro_class_iou=quality['macro_class_iou'],
            predictions_sha256=digest(out/f'{split}_predictions.jsonl'), quality_sha256=digest(out/f'{split}_quality.json'))
    return dict(state='verified_completed_1000_updates', root_version=EXPECTED[name],
        actual_optimizer_updates=1000, last_checkpoint_cpu_loaded_step=1000, best_step=complete['best_step'],
        completion_sha256=digest(out/'completion.json'), best_checkpoint_sha256=complete['checkpoint_sha256'],
        state_tensor_elements=state_elements, epoch_receipts=len(epochs), splits=split_results,
        CPU_model_inference_bitexact_verified=False)


def static_and_history(audit):
    formal, rows, _ = load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'))
    require(preservation(formal) == read(V3/'private/preservation_before.json'), 'Old static before/after differs')
    binding = read(V3/'private/source_binding.json')
    source = PROJECT/binding['source']
    require(all(digest(source/n) == h for n, h in binding['source_files'].items()), 'v10 frozen source snapshot changed')
    require(fingerprint(POSE) == binding['summary']['pose_fingerprint'], 'Pose store changed')
    validator = provenance_registry(rows, source/'private/pose_snapshot.sqlite3')
    frozen = database_rows(source/'private/gallery_snapshot.sqlite3', True)
    observed = database_rows(GALLERY)
    history = compare_history(frozen, observed, validator)
    selected = {r['target_key']: r for r in jsonl(V3/'private/training_records.jsonl')}
    stores = {k: database_rows(source/f'private/{k}_snapshot.sqlite3', True) for k in ('pose', 'gallery')}
    for r in selected.values():
        store = stores['pose' if r['source_origin'] == 'saved_pose' else 'gallery']
        columns = store['columns']['events']
        hits = [event for event in store['tables']['events']
                if event[columns.index('target_key')] == r['target_key'] and
                hashlib.sha256(event[columns.index('payload')].encode()).hexdigest() == r['source_event_raw_sha256']]
        require(len(hits) == 1, 'Frozen mask raw event is not uniquely recoverable')
    superseded = [dict(target_key=k, split=selected[k]['development_split'],
        frozen_revision=selected[k]['source_revision'], observed_revision=history['new_current'][k]['revision'])
        for k in sorted(history['changed_keys']) if k in selected]
    write(audit/'bound_concurrent_appends.jsonl', history['delta_events'], lines=True)
    return dict(state='passed_static_preservation_append_aware_history', old_frozen_files=694,
        old_checkpoints=2, static_inventory_before_after_identical=True,
        source_version='v10', raw_event_prefix_preserved=True, source_mask_events_recoverable=True,
        new_namespaces_allowed_if_independently_sealed_and_real_event_triples_bound=True,
        current_payloads_required_to_stay_unchanged=False, dynamically_appended_training_masks=0,
        observed_history=history['summary'], superseded_selected_references=superseded)


def finalize(audit=None):
    audit = audit or V4/'strict_audit_v1'
    require(not audit.exists(), 'Fresh strict audit required; preserve failed audit versions')
    audit.mkdir(mode=0o700)
    results, checks, errors = {}, {}, []
    try:
        checks['global_budget_before'] = global_budget()
    except Exception as exc:
        errors.append(dict(check='global_budget_before', error=str(exc)))
    datasets = {}
    try:
        manifests = {}
        for version, root in (('v3', V3), ('v4', V4)):
            manifest, records = verify_dataset(root)
            manifests[version] = digest(root/'dataset_manifest.json')
            datasets[version] = {r['target_key']: r for r in records}
            require(len(records) == 263 and manifest['splits'] == dict(train=172, dev=86, calibration=5), 'Wrong fixed263 freeze')
            require(manifest['independent_components'] == dict(train=13, dev=10, calibration=2), 'Wrong grouped freeze')
        require(manifests['v3'] == manifests['v4'], 'A/B dataset byte pins differ')
        checks['data_freeze'] = dict(state='passed', dataset_sha256=manifests['v3'], labels=263,
                                    independent_groups=dict(train=13, dev=10, calibration=2))
    except Exception as exc:
        errors.append(dict(check='data_freeze', error=str(exc)))
    for name, version in EXPECTED.items():
        root = V3 if version == 'v3' else V4
        if not (root/name/'completion.json').is_file():
            failure = root/name/'failure.json'
            results[name] = dict(state='failed_not_complete' if failure.is_file() else 'partial_or_not_started_not_complete',
                root_version=version, actual_optimizer_updates=None,
                failure_sha256=digest(failure) if failure.is_file() else None)
            continue
        try:
            require('data_freeze' in checks, 'Cannot verify run without passed frozen dataset')
            results[name] = verify_run(name, root, datasets[version])
        except Exception as exc:
            results[name] = dict(state='invalid_evidence_not_complete', root_version=version,
                                 actual_optimizer_updates=None, error=str(exc))
    try:
        checks['static_history'] = static_and_history(audit)
    except Exception as exc:
        errors.append(dict(check='static_history', error=str(exc), traceback=traceback.format_exc()))
    try:
        checks['global_budget_after'] = global_budget()
    except Exception as exc:
        errors.append(dict(check='global_budget_after', error=str(exc)))
    independent = PROJECT/'outputs/pallet_mask_model_improvement_independent_v1/report.json'
    complete = all_completed(results) and not errors
    result = dict(state='completed_all_7_strict_training_evidence_verified_not_released' if complete else 'partial_or_failed_strict_audit_NOT_all_completed',
        all_seven_training_completed_and_required_evidence_verified=complete, expected_roots=EXPECTED,
        runs=results, checks=checks, errors=errors,
        open_findings=[dict(kind='CPU_GPU_model_inference_threshold_difference', status='open_no_predeclared_tolerance',
            run='A3_freeze', independent_observed_differing_pixels=2,
            independent_CPU_probabilities=[.50008559, .49983293],
            CPU_model_inference_bitexact_claim=False, frozen_GPU_RLE_modified=False,
            interpretation='CPU native RLE metric replay and checkpoint reload are NOT CPU inference pixel equivalence; no posthoc tolerance invented')],
        independent_review_sha256=digest(independent),
        strict_code_sha256=digest(__file__), supersedes_old_evidence_completion_wording=True,
        old_evidence_and_handoffs_overwritten=False, release_state='blocked',
        calibration_groups=2, release_minimum_groups=10, accepted_quality=None, production_deliveries=0,
        automatic_A4_A5_or_new_seeds=False, formal_val_test_prediction_count=0, production_activation=False)
    write(audit/'STRICT_FINAL_HANDOFF.json', result)
    snapshot = audit/'strict_code_snapshot.py'
    with snapshot.open('xb') as stream:
        stream.write(Path(__file__).read_bytes())
    snapshot.chmod(0o600)
    # No old FINAL_HANDOFF.json is replaced. This is the authoritative correction.
    return result
