"""RF-DETR Small baseline on the same four floating sensor channels."""

from __future__ import annotations

from pathlib import Path
import torch
from torch import nn

from pallet.experiments.dataset import restore_boxes
from pallet.models.detector import ShallowFusion


class RFDETRDetector(nn.Module):
    def __init__(self, *, resolution=640, pretrained=True):
        super().__init__()
        from rfdetr import RFDETRSmall
        from rfdetr.config import TrainConfig
        from rfdetr.models.lwdetr import build_criterion_from_config

        # Keep the published three-channel backbone so its input weights load.
        kwargs = {"num_channels": 3, "num_classes": 1, "resolution": resolution}
        if pretrained is False:
            kwargs["pretrain_weights"] = None
        elif isinstance(pretrained, str):
            kwargs["pretrain_weights"] = pretrained
        rf = RFDETRSmall(**kwargs)
        self.model_config = rf.model_config
        self.model = rf.model.model
        self.criterion, self.postprocessor = build_criterion_from_config(
            rf.model_config, TrainConfig(dataset_dir=".")
        )
        self.resolution = resolution
        self.fusion = ShallowFusion()
        self.register_buffer("input_mean", torch.tensor(rf.means).view(1, 3, 1, 1))
        self.register_buffer("input_std", torch.tensor(rf.stds).view(1, 3, 1, 1))
        self.transfer_report = {'family':'rfdetr-small','source':str(rf.model_config.pretrain_weights),
                                'exact_loaded':[], 'new_or_transformed':[],
                                'note':'Three-channel published backbone retained; task head and sensor adapter are task-specific.'}
        if pretrained is not False and rf.model_config.pretrain_weights and Path(rf.model_config.pretrain_weights).is_file():
            checkpoint=torch.load(rf.model_config.pretrain_weights,map_location='cpu',weights_only=False)
            source=checkpoint['model']
            loaded_numel=0;total_numel=0
            for key,value in self.state_dict().items():
                total_numel+=value.numel()
                source_key=key.removeprefix('model.') if key.startswith('model.') else None
                original=source.get(source_key) if source_key else None
                if original is not None and original.shape==value.shape and torch.equal(original.cpu(),value.cpu()):
                    self.transfer_report['exact_loaded'].append(key);loaded_numel+=value.numel()
                else:self.transfer_report['new_or_transformed'].append(key)
            self.transfer_report.update(target_numel=total_numel,exact_loaded_numel=loaded_numel,
                                        target_numel_coverage=loaded_numel/max(1,total_numel))

    def forward(self, images):
        if images.ndim != 4 or images.shape[1] != 4 or not images.is_floating_point():
            raise ValueError("RF-DETR expects [B,4,H,W] float sensor tensor")
        return self.model((self.fusion(images) - self.input_mean) / self.input_std)

    def loss(self, batch):
        outputs = self(batch["img"])
        targets = []
        for idx in range(len(batch["img"])):
            keep = batch["batch_idx"] == idx
            targets.append({"labels": batch["cls"][keep, 0].long(),
                            "boxes": batch["bboxes"][keep]})
        parts = self.criterion(outputs, targets)
        total = sum(parts[key] * weight for key, weight in self.criterion.weight_dict.items()
                    if key in parts)
        return total, parts

    def decode(self, image, meta, *, conf=0.001):
        outputs = self(image)
        sizes = torch.tensor([[image.shape[-2], image.shape[-1]]], device=image.device)
        result = self.postprocessor(outputs, sizes)[0]
        keep = (result["labels"] == 0) & (result["scores"] >= conf)
        boxes = restore_boxes(result["boxes"][keep].detach().cpu().numpy(),
                              meta, size=self.resolution)
        scores = result["scores"][keep].detach().cpu().tolist()
        return [(box.tolist(), float(score)) for box, score in zip(boxes, scores)]
