"""CPU contracts required before either authorized GPU training queue starts."""
import copy
import types

import cv2
import numpy as np
import pytest
import torch
from torch.nn import functional as F

from pallet import mask_model_improvement_adapter as a
from pallet.mask_model_improvement import m1_loss, soft_edge_loss, CONFIGS, report
from pallet.mask_model_improvement_data import balanced_split
from pallet.mask_model_training import ROIMaskBoundaryUNet
from pallet.mask_model_training_data import letterbox, eligibility
from pallet.mask_model_training_rfdetr import ValidityDataset


@pytest.fixture(autouse=True)
def threads():
    torch.set_num_threads(2)


def factorized(batch=3, queries=39):
    torch.manual_seed(42)
    return dict(pred_masks=dict(spatial_features=torch.randn(batch, 4, 8, 12, requires_grad=True),
        query_features=torch.randn(batch, queries, 4, requires_grad=True), bias=torch.tensor(.17, requires_grad=True)))


def targets(counts=(0, 1, 2)):
    values = []
    for n in counts:
        masks = torch.zeros(n, 16, 24)
        masks[:, 5:11, 5:19] = 1
        valid = torch.zeros(16, 24, dtype=torch.bool)
        valid[3:13, 2:22] = True
        values.append(dict(masks=masks, pixel_valid=valid, labels=torch.zeros(n, dtype=torch.long),
                           boxes=torch.tensor([[.5, .5, .5, .5]]).expand(n, 4).clone()))
    return values


@pytest.mark.parametrize('point', [False, True])
def test_noncontinuous_arbitrary_batch_query_factorized_dense_loss_gradient(point):
    output = factorized()
    dense = a.mask_logits(output)
    idx = (torch.tensor([2, 0, 2, 1, 0]), torch.tensor([37, 3, 11, 27, 0]))
    projected = a.mask_logits(output, idx)
    assert torch.allclose(projected, dense[idx], atol=1e-6)
    target = torch.rand_like(projected)
    valid = torch.ones_like(target)
    loss = a.point_losses if point else a.dense_losses
    torch.manual_seed(17)
    left = sum(loss(projected, target, valid, 5).values())
    torch.manual_seed(17)
    right = sum(loss(dense[idx], target, valid, 5).values())
    parameters = tuple(output['pred_masks'].values())
    lg = torch.autograd.grad(left, parameters, retain_graph=True)
    rg = torch.autograd.grad(right, parameters)
    assert torch.allclose(left, right, atol=1e-6)
    assert all(torch.allclose(x, y, atol=2e-6) for x, y in zip(lg, rg))


@pytest.mark.parametrize('point', [False, True])
def test_zero_match_connects_spatial_query_and_bias(point):
    class Criterion:
        improvement_point_loss = point
        @staticmethod
        def _get_src_permutation_idx(indices):
            return torch.empty(0, dtype=torch.long), torch.empty(0, dtype=torch.long)
    output = factorized()
    empty = [(torch.empty(0, dtype=torch.long), torch.empty(0, dtype=torch.long))]*3
    result = a.mask_loss(Criterion(), output, targets((0, 0, 0)), empty, 1)
    sum(result.values()).backward()
    for value in output['pred_masks'].values():
        assert value.grad is not None and torch.count_nonzero(value.grad) == 0


@pytest.mark.parametrize('point', [False, True])
def test_padding_invariance_fp32_losses_and_zero_invalid_gradient(point):
    torch.manual_seed(2)
    logits = torch.randn(2, 8, 12, requires_grad=True)
    labels = torch.zeros(2, 16, 24)
    labels[:, 5:11, 4:18] = 1
    valid = torch.zeros_like(labels)
    valid[:, 4:12, 2:22] = 1
    loss = a.point_losses if point else a.dense_losses
    torch.manual_seed(42)
    reference = loss(logits, labels, valid, 2)
    sum(reference.values()).backward()
    active = F.interpolate(valid[:, None], size=(8, 12), mode='nearest-exact' if point else 'nearest')[:, 0]
    assert torch.count_nonzero(logits.grad[active == 0]) == 0
    changed = logits.detach().clone()
    changed[active == 0] = 100
    other_labels = labels.clone(); other_labels[valid == 0] = 1
    torch.manual_seed(42)
    other = loss(changed, other_labels, valid, 2)
    assert all(x.dtype == torch.float32 for x in reference.values())
    assert all(torch.allclose(reference[k], other[k], atol=1e-6) for k in reference)
    with torch.autocast('cpu', dtype=torch.bfloat16):
        torch.manual_seed(42)
        amp = loss(logits.detach(), labels, valid, 2)
    assert all(torch.allclose(reference[k], amp[k], atol=1e-6) for k in reference)


def test_matcher_factorized_dense_fp32_padding_invariance():
    class Matcher:
        mask_point_sample_ratio = 1
    output = factorized()
    target = targets()
    dense = a.mask_logits(output)
    torch.manual_seed(42)
    first = a.mask_costs(Matcher(), output, target)
    torch.manual_seed(42)
    second = a.mask_costs(Matcher(), {'pred_masks': dense}, target)
    assert first[0].shape == (3*39, 3)
    assert all(v.dtype == torch.float32 for v in first)
    assert all(torch.allclose(x, y, atol=2e-6) for x, y in zip(first, second))
    active = F.interpolate(torch.stack([t['pixel_valid'] for t in target])[:, None].float(),
                           size=(8, 12), mode='nearest-exact')
    changed = dense.detach().clone().masked_fill(active == 0, 100)
    torch.manual_seed(42)
    altered = a.mask_costs(Matcher(), {'pred_masks': changed}, target)
    assert all(torch.allclose(x, y, atol=2e-6) for x, y in zip(first, altered))
    with torch.autocast('cpu', dtype=torch.bfloat16):
        torch.manual_seed(42)
        amp = a.mask_costs(Matcher(), output, target)
    assert all(torch.allclose(x, y, atol=2e-6) for x, y in zip(first, amp))


@pytest.mark.parametrize('point', [False, True])
def test_upstream_13_groups_batch_0_1_multi_aux_encoder_all_gradients(point):
    from rfdetr.models.matcher import HungarianMatcher
    from rfdetr.models.criterion import SetCriterion
    matcher = HungarianMatcher(mask_point_sample_ratio=1)
    matcher._compute_mask_costs = types.MethodType(a.mask_costs, matcher)
    criterion = SetCriterion(1, matcher, {}, .25, ['masks'], group_detr=13)
    criterion.improvement_point_loss = point
    criterion.loss_masks = types.MethodType(a.mask_loss, criterion)
    outputs = []
    for _ in range(3):
        output = factorized()
        output.update(pred_logits=torch.randn(3, 39, 1), pred_boxes=torch.rand(3, 39, 4))
        output['pred_boxes'][..., 2:] = output['pred_boxes'][..., 2:]*.5+.1
        outputs.append(output)
    target = targets()
    indices = matcher(outputs[0], target, group_detr=13)
    assert [len(i) for i, _ in indices] == [0, 13, 26]
    assert criterion.num_boxes_for_targets(outputs[0], target).item() == 39
    outputs[0]['aux_outputs'] = [outputs[1]]
    outputs[0]['enc_outputs'] = outputs[2]
    losses = criterion(outputs[0], target)
    assert set(losses) == {f'loss_mask_{kind}{suffix}' for kind in ('ce', 'dice') for suffix in ('', '_0', '_enc')}
    sum(losses.values()).backward()
    for output in outputs:
        for value in output['pred_masks'].values():
            assert value.grad is not None and torch.isfinite(value.grad).all()
            assert value.grad.abs().sum() > 0


@pytest.mark.parametrize('shape', ['thin_horizontal', 'thin_vertical', 'slant', 'concave'])
@pytest.mark.parametrize('canvas', [(352, 264), (576, 576), (512, 160)])
def test_native_pixel_center_roundtrip_thin_slant_concave(shape, canvas):
    mask = np.zeros((32, 120), np.uint8)
    if shape == 'thin_horizontal':
        mask[14:15, 8:112] = 1
    elif shape == 'thin_vertical':
        mask[3:29, 56:57] = 1
    elif shape == 'slant':
        cv2.fillPoly(mask, [np.array([[8, 4], [111, 9], [106, 28], [12, 23]])], 1)
    else:
        cv2.fillPoly(mask, [np.array([[8, 4], [112, 4], [112, 27], [94, 27],
                                     [94, 14], [26, 14], [26, 27], [8, 27]])], 1)
    _, label, _, transform = letterbox(mask*255, mask, canvas)
    logits = torch.from_numpy(label.astype(np.float32)*24-12)
    native = a.native_logits(logits, transform).sigmoid().numpy() >= .5
    assert np.array_equal(native, mask > 0)
    identity = dict(output_size=[120, 32], scaled_size=[120, 32], native_size=[120, 32], padding_left_top=[0, 0])
    original = torch.from_numpy(mask.astype(np.float32)*24-12)
    assert torch.equal(a.native_logits(original, identity), original)


def test_query_selection_classification_only_no_ground_truth_argument():
    outputs = dict(pred_logits=torch.tensor([[[-3.], [6.], [2.]]]), pred_masks=torch.zeros(1, 3, 4, 4))
    assert a.highest_class_query(outputs)[0] == 1
    outputs['pred_masks'][0, 0] = 100  # mask area/topology cannot change query rank
    assert a.highest_class_query(outputs)[0] == 1


def test_m1_auxiliary_not_direct_mask_gradient_but_soft_edge_is_differentiable():
    model = ROIMaskBoundaryUNet().eval()
    mask, edge = model(torch.randn(1, 3, 32, 96))
    target, valid = torch.zeros_like(mask), torch.ones_like(mask)
    only_edge = F.binary_cross_entropy_with_logits(edge, target)
    gradient = torch.autograd.grad(only_edge, model.mask_head.weight, allow_unused=True, retain_graph=True)[0]
    assert gradient is None
    soft = soft_edge_loss(mask, target, valid)
    gradient = torch.autograd.grad(soft, model.mask_head.weight, retain_graph=True)[0]
    assert gradient.abs().sum() > 0
    loss = m1_loss(mask, edge, target, target, valid, 0)
    grad = torch.autograd.grad(loss, model.boundary_head.weight, allow_unused=True)[0]
    assert grad is not None and torch.count_nonzero(grad) == 0


def test_predefined_splits_single_factor_matrix_and_null_acceptance():
    records = [dict(component=str(i//2), class_id=i%4, structure='s', policy_id='p') for i in range(60)]
    folds = balanced_split(records)
    assert folds == balanced_split(list(reversed(records)))
    assert set(folds.values()) == {0, 1, 2}
    anchor = CONFIGS['A0']
    for name, factor in [('A1', 'group_uniform'), ('A2', 'edge_weight'), ('A3_freeze', 'freeze_epochs'), ('A3_photometric', 'photometric')]:
        assert {k for k in anchor if anchor[k] != CONFIGS[name][k]} == {'factor', factor}
    assert {k for k in CONFIGS['B0'] if CONFIGS['B0'][k] != CONFIGS['B1'][k]} == {'factor', 'point_loss'}
    result = report([])
    assert result['accepted_quality'] is None and result['accepted_count'] == 0
    assert 'insufficient_group_support' in result['rejection_reasons']


def test_grouped_holdout_reserves_train_class_coverage_without_model_scores():
    records = []
    for c in range(1, 14):
        for group in range(1 if c <= 5 else 2 if c <= 10 else 4):
            records.append(dict(component=f'{c}:{group}', class_id=c, structure='unknown', policy_id='p'))
    folds = balanced_split(records)
    train = {r['class_id'] for r in records if folds[r['component']] == 2}
    assert train == set(range(1, 14))
    for c in range(6, 14):
        assert any(r['class_id'] == c and folds[r['component']] == 0 for r in records)
    assert len({g for g, fold in folds.items() if fold == 0}) >= 10


def test_validity_batched_fetch_cannot_bypass_ignore():
    class Dataset:
        def __len__(self): return 2
        def __getitem__(self, i): return torch.zeros(3, 16, 24), {'image_id': torch.tensor([i+1])}
        def __getitems__(self, indices): raise AssertionError('Must not bypass insertion')
    transforms = {str(i): dict(output_size=[24, 16], scaled_size=[24, 8], padding_left_top=[0, 4]) for i in (1, 2)}
    assert all(t['pixel_valid'].sum() == 192 for _, t in ValidityDataset(Dataset(), transforms).__getitems__([0, 1]))


@pytest.mark.parametrize('split', ['val', 'test'])
def test_heldout_polygon_not_accessed(split):
    reasons, roi = eligibility({'polygon': object()}, {'split': split}, [], 'unused', set())
    assert reasons == ['formal_val_test_label_forbidden'] and roi is None
