"""Post-queue independent CPU evidence; does not modify pinned training code."""
from pathlib import Path

import cv2
import numpy as np
import torch

from .mask_model_training import native_metrics
from .mask_model_training_data import PROJECT, read, jsonl, write, digest, require, verify_dataset
from .mask_model_improvement import CONFIGS, GENERIC_SHA


def verify(m1, m2):
    from pycocotools import mask as mu
    results = {}
    for root in (m1, m2):
        verify_dataset(root)
    require(digest(m1/'dataset_manifest.json') == digest(m2/'dataset_manifest.json'), 'A/B frozen data differ')
    for name, config in CONFIGS.items():
        root = m1 if config['route'] == 'm1' else m2
        out = root/name
        if not (out/'completion.json').is_file():
            results[name] = dict(state='failed_or_not_started_not_complete')
            continue
        complete, start = read(out/'completion.json'), read(out/'worker_start.json')
        require(complete['actual_optimizer_updates'] == 1000, 'Wrong actual update budget')
        require(start['generic_sha256'] == GENERIC_SHA[config['route']] and
                not start['old_finetuned_checkpoint_used'], 'Contaminated pretrained start')
        require(start['dataset_manifest_sha256'] == digest(root/'dataset_manifest.json'), 'Worker data pin differs')
        for path, expected in start['code_sha256'].items():
            require(digest(root/'code_snapshot'/Path(path).name) == expected, 'Launch code snapshot changed')
        checkpoint = out/complete['checkpoint']
        require(digest(checkpoint) == complete['checkpoint_sha256'], 'Selected checkpoint changed')
        state = torch.load(checkpoint, map_location='cpu', weights_only=True)
        require(state['step'] == complete['best_step'] and isinstance(state['model'], dict), 'CPU checkpoint reload mismatch')
        selected_parameter_count = sum(v.numel() for v in state['model'].values() if isinstance(v, torch.Tensor))
        del state
        last = torch.load(out/'last.pt', map_location='cpu', weights_only=True)
        require(last['step'] == 1000, 'Last checkpoint update budget differs')
        del last
        epochs = [read(p) for p in sorted((out/'epochs').glob('*.json'))]
        require(max(e['optimizer_step'] for e in epochs) == 1000, 'Epoch evidence lacks final optimizer step')
        first = read(out/'first_actual_training_batch.json')
        require(first['optimizer_step'] == 1, 'Actual first optimizer step receipt absent')
        records = {r['target_key']: r for r in jsonl(root/'private/training_records.jsonl')}
        split_results = {}
        for split in ('dev', 'calibration'):
            predictions = jsonl(out/f'{split}_predictions.jsonl')
            expected = {k for k, r in records.items() if r['development_split'] == split}
            require(len(predictions) == len(expected) and {p['target_key'] for p in predictions} == expected,
                    'All-target evaluation membership mismatch')
            maximum = 0.
            for prediction in predictions:
                record = records[prediction['target_key']]
                require(record['formal_split'] == prediction['formal_split'] == 'train' and
                        record['component'] == prediction['component'] and
                        prediction['development_split'] == split, 'Evaluation leakage or stratum mismatch')
                encoded = prediction['native_prediction_rle']
                mask = mu.decode(dict(size=encoded['size'], counts=encoded['counts'].encode('ascii'))).astype(bool)
                target = cv2.imread(str(root/record['native_mask']), cv2.IMREAD_GRAYSCALE) > 0
                require(mask.shape == target.shape, 'Native prediction shape differs')
                metrics = native_metrics(mask, target)
                for key, value in metrics.items():
                    if value is None or isinstance(value, bool):
                        require(value == prediction[key], 'Native metric null/empty mismatch')
                    else:
                        difference = abs(value-prediction[key])
                        maximum = max(maximum, difference)
                        require(difference <= 1e-12, 'CPU native RLE metric replay differs')
                require(not prediction['ground_truth_eligible'] and not prediction['robot_command_eligible'],
                        'Prediction auto-promoted')
            quality = read(out/f'{split}_quality.json')
            require(quality['accepted_count'] == 0 and quality['accepted_quality'] is None and
                    quality['formal_val_test_prediction_count'] == 0, 'Unsupported release claim')
            split_results[split] = dict(all_outputs=len(predictions), independent_groups=len({p['component'] for p in predictions}),
                native_prediction_RLE_exact=True, cpu_metric_maximum_absolute_difference=maximum,
                predictions_sha256=digest(out/f'{split}_predictions.jsonl'),
                quality_sha256=digest(out/f'{split}_quality.json'))
        results[name] = dict(state='verified_completed_bounded_screen', actual_optimizer_updates=1000,
            CPU_checkpoint_reload=True, checkpoint_sha256=complete['checkpoint_sha256'],
            state_tensor_elements=selected_parameter_count, best_step=complete['best_step'],
            actual_first_step=first, epoch_receipts=len(epochs), splits=split_results)
    result = dict(state='passed_completed_run_evidence', runs=results,
        verification_code_sha256=digest(__file__), old_files_modified=False,
        val_test_predictions=0, no_production_activation=True)
    write(m2/'CPU_TRAINING_EVIDENCE_VERIFICATION.json', result)
    return result
