"""Focused CPU checks for the depth/intensity detector."""

import torch

from pallet.models import PalletDetector, valid_depth_edges
from pallet.models.detector import P2ModalityFusion, ShallowFusion


def test_edges_require_valid_neighbor_pairs():
    depth = torch.tensor([[[[0.0, 0.1, 1.0, 0.2]]]])
    valid = torch.tensor([[[[1.0, 1.0, 0.0, 1.0]]]])
    edge = valid_depth_edges(depth, valid)
    torch.testing.assert_close(edge, torch.tensor([[[[0.1, 0.0, 0.0, 0.0]]]]))


def test_fusion_ignores_invalid_and_disabled_modalities():
    fusion = ShallowFusion(use_depth=True, use_intensity=False)
    image = torch.tensor([[[[0.2, float("nan")]], [[0.8, 0.3]], [[1.0, 0.0]], [[1.0, 1.0]]]])
    expected = torch.tensor([[[[0.2, 0.0]], [[0.0, 0.0]], [[0.1, 0.0]]]])
    torch.testing.assert_close(fusion(image), expected)
    image[:, 1] = 100.0
    torch.testing.assert_close(fusion(image), expected)


def test_p2_fusion_ignores_missing_modality_and_invalid_regions():
    torch.set_num_threads(1)
    fusion = P2ModalityFusion(channels=8, use_depth=True, use_intensity=True)
    fusion.projection.weight.data.fill_(0.1)
    image = torch.rand(1, 4, 32, 32)
    image[:, 2:] = 0.0
    image[:, 2, :, :8] = 1.0
    image[:, 3, :, 24:] = 1.0
    original = fusion(image)
    assert torch.count_nonzero(original[:, :, :, 3:5]) == 0

    changed = image.clone()
    changed[:, 0, :, 8:] = 100.0
    changed[:, 1, :, :24] = float("nan")
    torch.testing.assert_close(fusion(changed), original)
    original.sum().backward()
    assert fusion.gate.weight.grad is not None


def test_p2_detector_forward_and_edge_gradient():
    torch.set_num_threads(1)
    model = PalletDetector(nc=2, p2=True, pretrained=None).train()
    image = torch.rand(1, 4, 64, 64)
    image[:, 2:] = 1.0
    output = model(image)
    assert "one2many" in output
    assert len(output["one2many"]["feats"]) == 4
    assert [x.shape[-1] for x in output["one2many"]["feats"]] == [16, 8, 4, 2]
    output["one2many"]["scores"].sum().backward()
    assert model.edge_projection.weight.grad is not None
    assert model.p2_fusion.projection.weight.grad is not None


def test_fusion_and_p2_ablation_paths():
    torch.set_num_threads(1)
    image = torch.rand(1, 4, 64, 64)
    image[:, 2:] = 1.0
    p2_without_fusion = PalletDetector(nc=2, use_fusion=False, use_edge=False).train()
    assert p2_without_fusion.p2_fusion is None
    assert len(p2_without_fusion(image)["one2many"]["feats"]) == 4

    baseline = PalletDetector(nc=2, p2=False, use_fusion=True, use_edge=True).train()
    assert baseline.p2_fusion is None and baseline.edge_projection is None
    assert len(baseline(image)["one2many"]["feats"]) == 3


def test_pretrained_transfer_does_not_copy_shifted_p2_head(tmp_path):
    torch.set_num_threads(1)
    model = PalletDetector(nc=2, p2=True, pretrained=None)
    source = PalletDetector(nc=2, p2=False, pretrained=None)
    source.yolo.model[0].conv.weight.data.fill_(0.25)
    checkpoint = tmp_path / "source.pt"
    torch.save({"model": source.yolo, "train_args": {}}, checkpoint)
    before = model.yolo.model[19].cv2.conv.weight.detach().clone()
    transferred = model.load_pretrained(checkpoint)
    assert transferred > 0
    assert torch.all(model.yolo.model[0].conv.weight == 0.25)
    torch.testing.assert_close(model.yolo.model[19].cv2.conv.weight, before)


def test_detection_loss_accepts_four_channel_batch():
    torch.set_num_threads(1)
    model = PalletDetector(nc=2, pretrained=None).train()
    batch = {
        "img": torch.rand(1, 4, 64, 64),
        "batch_idx": torch.tensor([0]),
        "cls": torch.tensor([[1.0]]),
        "bboxes": torch.tensor([[0.5, 0.5, 0.25, 0.25]]),
    }
    batch["img"][:, 2:] = 1.0
    losses, metrics = model.loss(batch)
    assert losses.ndim == 1 and torch.isfinite(losses).all()
    assert "box_loss" in metrics
    losses.sum().backward()
    assert model.edge_projection.weight.grad is not None


def test_yolov8_baselines_keep_original_head_and_reconstructed_cspnext():
    torch.set_num_threads(1)
    from pallet.models.detector import CSPNeXtReplacement
    for family in ("yolov8", "yolov8-cspnext"):
        model = PalletDetector(nc=1, p2=False, family=family, pretrained=None).train()
        image = torch.rand(1, 4, 64, 64)
        image[:, 2:] = 1
        output = model(image)
        assert len(output) == 3
        loss, _ = model.loss({"img": image, "batch_idx": torch.tensor([0]),
                              "cls": torch.zeros((1, 1)),
                              "bboxes": torch.tensor([[0.5, 0.5, 0.2, 0.2]])})
        assert torch.isfinite(loss.sum())
        if family == "yolov8-cspnext":
            assert isinstance(model.yolo.model[2], CSPNeXtReplacement)
