"""Safety, isolation, exact native supervision and feature-boundary regressions."""
import copy
import hashlib
import json
from pathlib import Path

import cv2
import numpy as np
import pytest
import torch

from pallet import mask_model_training_data as data
from pallet.mask_model_training import (
    ROIMaskBoundaryUNet, masked_segmentation_loss, native_metrics, quality_report, summarize,
)
from pallet.mask_model_training_rfdetr import (
    ValidityDataset, masked_dense_losses, padding_aware_mask_costs, projected_mask_logits,
)


def row(key='a', split='train', cls=3):
    return dict(target_key=key, frame_id=key, group_id=key, split=split,
        final_class_id=cls, policy_id='policy', source_pcd_sha256=key,
        bbox=dict(x=10., y=10., width=30., height=10.), size=[64, 40],
        viewpoint_candidate='近正视候选', structure_candidate='单长开口面候选',
        review_reasons=[], alignment_verified=True, crop_touches_image_edge=False)


def source(value):
    return dict(row=value, polygon=[[10, 10], [40, 10], [40, 20], [10, 20]])


def test_original_bbox_only_crop_not_polygon_or_metadata():
    value = row()
    expected = data.context_roi(value['bbox'], value['size'])
    value.update(polygon=[[0, 0], [1, 0], [1, 1]], class_id=99, pose='SECRET', group_id='different')
    assert data.context_roi(value['bbox'], value['size']) == expected == [8, 7, 42, 23]


def test_context_neighbor_intersection_quarantined():
    value, neighbor = row(), row('b')
    neighbor['bbox'] = dict(x=41., y=10., width=10., height=5.)
    reasons, _ = data.eligibility(source(value), value, [value, neighbor], 'component', set())
    assert reasons == ['known_neighbor_bbox_intersects_context_roi']


@pytest.mark.parametrize('field,value,reason', [
    ('final_class_id', 14, 'class14_long_short_surface_ambiguous'),
    ('viewpoint_candidate', 'unknown', 'unknown_or_narrow_observation_surface'),
    ('structure_candidate', 'unknown', 'unknown_or_edge_only_structure'),
    ('review_reasons', ['depth_ambiguous'], 'occlusion_depth_or_view_ambiguity'),
    ('alignment_verified', False, 'invalid_alignment_or_clipped_native_context'),
])
def test_explicit_semantic_not_saved_is_gt(field, value, reason):
    original = row()
    original[field] = value
    reasons, _ = data.eligibility(source(original), original, [original], 'x', set())
    assert reason in reasons


@pytest.mark.parametrize('split', ['val', 'test'])
def test_official_val_test_polygon_never_touched(split):
    value = row(split=split)
    # A crash if a held-out polygon were used for semantic eligibility/rasterization.
    reasons, roi = data.eligibility({'polygon': object()}, value, [], 'x', set())
    assert reasons == ['formal_val_test_label_forbidden'] and roi is None


def test_global_component_cross_split_block():
    value = row()
    reasons, _ = data.eligibility(source(value), value, [value], 'linked', {'linked'})
    assert 'global_component_linked_to_formal_val_test' in reasons


def test_global_near_duplicate_cross_class_and_policy():
    rows = {'a': row('a'), 'b': row('b', split='test', cls=22)}
    rows['b']['policy_id'] = 'other_policy'
    graph = data.Components(rows)
    random_image = np.random.default_rng(4).integers(0, 255, (40, 64), dtype=np.uint8)
    h, norm, std = data.signature(random_image)
    items = [('a', h, norm, std), ('b', h ^ 1 ^ (1 << 85), norm.copy(), std)]
    data.near_duplicate_links(items, graph, 'near', rows)
    labels = graph.labels()
    assert labels['a'] == labels['b']
    assert graph.links[0]['cross_class'] and graph.links[0]['cross_policy']


def test_global_transitive_groups_do_not_split():
    graph = data.Components(['train_a', 'unlabelled_bridge', 'test_a'])
    graph.union('train_a', 'unlabelled_bridge', 'group')
    graph.union('unlabelled_bridge', 'test_a', 'image')
    assert len(set(graph.labels().values())) == 1


def test_letterbox_aspect_nearest_padding_ignore_roundtrip():
    image = np.arange(80*20, dtype=np.uint8).reshape(20, 80)
    mask = np.zeros_like(image)
    mask[3:17, 4:75] = 1
    out, label, valid, transform = data.letterbox(image, mask, (320, 160))
    assert transform['scaled_size'] == [320, 80]
    assert transform['padding_left_top'] == [0, 40]
    assert set(np.unique(label)) == {0, 1}
    assert not valid[:40].any() and not valid[120:].any()
    assert np.array_equal(data.unletterbox(label.astype(np.float32), transform) >= .5, mask > 0)


def test_m1_ignore_padding_loss_and_gradients():
    target = torch.zeros(2, 1, 16, 32)
    target[:, :, 4:12, 8:24] = 1
    valid = torch.zeros_like(target)
    valid[:, :, 3:13] = 1
    logits = torch.zeros_like(target, requires_grad=True)
    boundary = torch.zeros_like(target, requires_grad=True)
    loss = masked_segmentation_loss(logits, boundary, target, target, valid)
    loss.backward()
    assert torch.all(logits.grad[valid == 0] == 0)
    assert torch.all(boundary.grad[valid == 0] == 0)


def test_m1_full_resolution_two_heads_no_identity_inputs():
    torch.set_num_threads(2)
    model = ROIMaskBoundaryUNet().eval()
    with torch.no_grad():
        mask, boundary = model(torch.zeros(1, 3, 160, 512))
    assert mask.shape == boundary.shape == (1, 1, 160, 512)
    assert all('class' not in name and 'pose' not in name for name, _ in model.named_parameters())


def test_empty_prediction_and_empty_acceptance_are_not_perfect(tmp_path):
    truth = np.zeros((20, 40), bool)
    truth[5:15, 10:30] = True
    metrics = native_metrics(np.zeros_like(truth), truth)
    assert metrics['iou'] == metrics['boundary_f1_1px'] == 0
    assert metrics['hd95_native_pixels'] is None
    assert summarize([])['iou_median'] is None
    record = dict(target_key='a', component='g', class_id=3, policy_id='p', surface='s',
                  structure='t', bbox_height_band='under32', bbox_height=10,
                  confidence=0., inference_seconds=.01, **metrics)
    report = quality_report(tmp_path, [record])
    assert report['delivery_rate'] == 0 and report['all']['iou_median'] == 0
    assert report['accepted']['iou_median'] is None
    assert report['by_class']['19']['count'] == 0
    assert report['formal_val_test_prediction_or_score_count'] == 0


def test_native_metrics_known_translation():
    truth = np.zeros((30, 80), bool)
    truth[10:20, 20:60] = True
    prediction = np.roll(truth, 1, axis=0)
    metrics = native_metrics(prediction, truth)
    assert metrics['iou'] == pytest.approx(9/11)
    assert metrics['hd95_native_pixels'] == 1
    assert metrics['boundary_f1_1px'] == 1


def test_rfdetr_dense_mask_padding_ignored():
    logits = torch.zeros((2, 12, 12), requires_grad=True)
    labels = torch.zeros_like(logits)
    labels[:, 4:8, 2:10] = 1
    valid = torch.zeros_like(logits)
    valid[:, 3:9] = 1
    losses = masked_dense_losses(logits, labels, valid, torch.tensor(2.))
    sum(losses.values()).backward()
    assert torch.all(logits.grad[valid == 0] == 0)
    changed = logits.detach().clone()
    changed[valid == 0] = 99
    other = masked_dense_losses(changed, labels, valid, torch.tensor(2.))
    assert all(torch.allclose(losses[k], other[k]) for k in losses)


def test_rfdetr_projected_matches_in_batch_order():
    feature = torch.arange(2*3*4*4, dtype=torch.float32).reshape(2, 3, 4, 4)
    query = torch.ones(2, 5, 3)
    outputs = dict(pred_masks=dict(spatial_features=feature, query_features=query, bias=torch.tensor(0.)))
    all_masks = projected_mask_logits(outputs)
    indices = (torch.tensor([0, 0, 1]), torch.tensor([3, 2, 4]))
    assert torch.equal(projected_mask_logits(outputs, indices), all_masks[indices])


def test_rfdetr_matcher_padding_not_negative():
    class Matcher:
        mask_point_sample_ratio = 1
    logits = torch.zeros(1, 2, 12, 12)
    target = dict(masks=torch.ones(1, 12, 12), pixel_valid=torch.zeros(12, 12))
    target['pixel_valid'][3:9, 2:10] = 1
    torch.manual_seed(1)
    original = padding_aware_mask_costs(Matcher(), {'pred_masks': logits}, [target])
    # Direct point sampling mixes boundaries; change only well-separated padding.
    logits[:, :, :1] = 99
    torch.manual_seed(1)
    other = padding_aware_mask_costs(Matcher(), {'pred_masks': logits}, [target])
    assert all(torch.allclose(a, b) for a, b in zip(original, other))


def test_immutable_dataset_tamper_rejected(tmp_path):
    (tmp_path/'private').mkdir()
    file = tmp_path/'data.bin'
    file.write_bytes(b'fixed')
    (tmp_path/'dataset_manifest.json').write_text(json.dumps(dict(
        state='immutable_research_training_dataset', formal_val_test_included=False,
        files={'data.bin': data.digest(file)})))
    file.write_bytes(b'changed')
    with pytest.raises(ValueError, match='Immutable dataset'):
        data.verify_dataset(tmp_path)


def test_gpu_binding_refuses_forbidden_or_index(monkeypatch):
    for value in ('0', 'GPU-3ce8e1e7-efb2-80a6-de52-75da2f9fa259', ''):
        monkeypatch.setenv('CUDA_VISIBLE_DEVICES', value)
        with pytest.raises(ValueError, match='authorized physical GPU'):
            data.gpu_receipt('m1')


def test_rfdetr_validity_survives_batched_subset_fetch():
    from torch.utils.data import Dataset
    class Tiny(Dataset):
        def __len__(self):
            return 2

        def __getitem__(self, index):
            return torch.zeros(3, 12, 12), {'image_id': torch.tensor([index+1])}

        def __getitems__(self, indices):
            return [self[i] for i in indices]
    transforms = {str(i): dict(output_size=[12, 12], scaled_size=[12, 4], padding_left_top=[0, 4])
                  for i in (1, 2)}
    wrapped = ValidityDataset(Tiny(), transforms)
    assert all(target['pixel_valid'].sum() == 48 for _, target in wrapped.__getitems__([0, 1]))


def test_global_audit_has_all_unlabelled_targets_and_cross_split_bridge():
    values = {k: row(k, split=s, cls=c) for k, s, c in
              [('train', 'train', 3), ('bridge', 'train', 4), ('official', 'test', 22)]}
    values['train']['group_id'] = values['bridge']['group_id'] = 'shared'
    values['bridge']['source_pcd_sha256'] = values['official']['source_pcd_sha256'] = 'same_pcd'
    images = {k: np.random.default_rng(i).integers(0, 255, (40, 64), dtype=np.uint8)
              for i, k in enumerate(values)}
    class Evidence:
        sources = {}

        def image(self, frame):
            return images[frame]
    evidence = Evidence()
    for k, value in values.items():
        value['image'] = k+'.png'
        evidence.sources[k] = {'files': {value['image']: k+'hash'}}
    labels, blocked, links, hashes = data.global_audit(values, evidence)
    assert len(hashes) == 3 and set(labels) == set(values)
    assert len(set(labels.values())) == 1 and labels['train'] in blocked


def test_changed_independent_seal_fails_before_source_use(monkeypatch):
    monkeypatch.setattr(data, 'digest', lambda _: 'foreign')
    with pytest.raises(ValueError, match='Independent seal changed'):
        data.verify_sources()


def gallery_history():
    return dict(schema=[('table', 'reviews', 'reviews', 'schema')],
        columns=dict(reviews=['target_key', 'revision', 'payload'],
                     events=['id', 'target_key', 'revision', 'payload'],
                     metadata=['key', 'value'], sqlite_sequence=['name', 'seq']),
        tables=dict(reviews=[('trained', 1, '{"raw":" old bytes "}')],
                    events=[(1, 'trained', 1, '{"raw":" old bytes "}')],
                    metadata=[('binding', 'sealed')], sqlite_sequence=[('events', 1)]))


def extended_gallery():
    current = gallery_history()
    first = json.dumps(dict(target_key='authorized_new', revision=1, value='new1'))
    last = json.dumps(dict(target_key='authorized_new', revision=2, value='new2'))
    current['tables']['events'].extend([(2, 'authorized_new', 1, first),
                                        (3, 'authorized_new', 2, last)])
    current['tables']['reviews'].append(('authorized_new', 2, last))
    current['tables']['sqlite_sequence'] = [('events', 3)]
    return current


def test_authorized_new_key_append_preserves_baseline_and_not_training_data():
    from pallet.mask_model_training_integrity import compare_gallery_extension
    result = compare_gallery_extension(gallery_history(), extended_gallery(), {'authorized_new'}, {'trained'})
    assert result['appended_events'] == 2 and result['appended_distinct_keys'] == 1
    assert result['baseline_event_prefix_raw_byte_identical']
    assert not result['frozen_training_dataset_appended']


@pytest.mark.parametrize('corruption', ['trained_raw', 'old_event', 'schema', 'metadata', 'unauthorized_key', 'latest_raw', 'sequence', 'new_relational_identity'])
def test_append_audit_refuses_old_rewrites_and_unapproved_scope(corruption):
    from pallet.mask_model_training_integrity import compare_gallery_extension
    baseline, current = gallery_history(), extended_gallery()
    if corruption == 'trained_raw':
        current['tables']['reviews'][0] = ('trained', 2, 'changed')
    elif corruption == 'old_event':
        current['tables']['events'][0] = (1, 'trained', 1, 'normalized-not-raw-equal')
    elif corruption == 'schema':
        current['schema'] = [('table', 'reviews', 'reviews', 'different schema')]
    elif corruption == 'metadata':
        current['tables']['metadata'] = [('binding', 'foreign')]
    elif corruption == 'unauthorized_key':
        current['tables']['reviews'].append(('unexpected', 1, 'extra'))
    elif corruption == 'latest_raw':
        current['tables']['reviews'][1] = ('authorized_new', 2, 'new1')
    elif corruption == 'sequence':
        current['tables']['sqlite_sequence'] = [('events', 100)]
    elif corruption == 'new_relational_identity':
        current['tables']['events'][1] = (2, 'authorized_new', 1, '{"target_key":"trained","revision":1}')
    with pytest.raises(ValueError):
        compare_gallery_extension(baseline, current, {'authorized_new'}, {'trained'})
