"""Export trained detectors to fixed-size ONNX and compare raw predictions."""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import numpy as np
import torch
from torch import nn

from pallet.models import PalletDetector, RFDETRDetector


class _ExportOutputs(nn.Module):
    def __init__(self, detector, family):
        super().__init__()
        self.detector = detector
        self.family = family

    def forward(self, image):
        prediction = self.detector(image)
        if self.family == "rfdetr-small":
            return prediction["pred_boxes"], prediction["pred_logits"]
        return prediction[0] if isinstance(prediction, (tuple, list)) else prediction


def load_detector_checkpoint(path):
    state = torch.load(path, map_location="cpu", weights_only=False)
    config = state["model_config"]
    family = config.get("family", "yolo26")
    if family == "rfdetr-small":
        model = RFDETRDetector(resolution=config["size"], pretrained=False)
    else:
        model = PalletDetector(nc=1, p2=config["p2"], family=family, pretrained=None,
                               use_fusion=config.get("use_fusion", True),
                               use_edge=config["use_edge"], use_depth=config["use_depth"],
                               use_intensity=config["use_intensity"])
    model.load_state_dict(state["model"])
    return model.eval(), config


def export_onnx(checkpoint, output):
    import onnx
    import onnxruntime as ort

    model, config = load_detector_checkpoint(checkpoint)
    family = config.get("family", "yolo26")
    if family == "rfdetr-small":
        from rfdetr.models.backbone.dinov2 import DinoV2
        for module in model.modules():
            if isinstance(module, DinoV2):
                module.shape = (config["size"], config["size"])
                module.export()
    wrapper = _ExportOutputs(model, family).eval()
    size = config["size"]
    example = torch.rand(1, 4, size, size)
    example[:, 2:] = 1
    output = Path(output)
    output.parent.mkdir(parents=True, exist_ok=True)
    names = ["boxes", "logits"] if family == "rfdetr-small" else ["predictions"]
    with torch.inference_mode():
        expected = wrapper(example)
        torch.onnx.export(wrapper, example, output, opset_version=17,
                          input_names=["sensor"], output_names=names,
                          do_constant_folding=True, dynamo=False)
    onnx.checker.check_model(str(output))
    session = ort.InferenceSession(str(output), providers=["CPUExecutionProvider"])
    actual = session.run(None, {"sensor": example.numpy()})
    expected_outputs = expected if isinstance(expected, tuple) else (expected,)
    comparisons = []
    for predicted, reference in zip(actual, expected_outputs):
        target = reference.detach().numpy()
        comparisons.append({"shape": list(predicted.shape),
                            "max_absolute_difference": float(np.max(np.abs(predicted - target)))})
        np.testing.assert_allclose(predicted, target, rtol=0.002, atol=0.003)
    cases=[]
    for name in ('missing_intensity','depth_hole'):
        probe=example.clone()
        if name=='missing_intensity':probe[:,1]=0;probe[:,3]=0
        else:
            probe[:,0,size//4:size//2,size//4:size//2]=0
            probe[:,2,size//4:size//2,size//4:size//2]=0
        with torch.inference_mode():reference=wrapper(probe)
        references=reference if isinstance(reference,tuple) else (reference,)
        predictions=session.run(None,{'sensor':probe.numpy()})
        errors=[]
        for prediction,reference in zip(predictions,references):
            target=reference.detach().numpy()
            np.testing.assert_allclose(prediction,target,rtol=.002,atol=.003)
            errors.append(float(np.max(np.abs(prediction-target))))
        cases.append({'case':name,'max_absolute_difference':errors})
    report = {"checkpoint": str(Path(checkpoint).resolve()), "onnx": str(output.resolve()),
              "family": family, "input": [1, 4, size, size], "outputs": comparisons,'mask_cases':cases,
              "note": "Raw predictions; thresholding and box coordinate restore run outside ONNX."}
    output.with_suffix(".json").write_text(json.dumps(report, indent=2), encoding="utf-8")
    return report


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--output", required=True)
    args = parser.parse_args()
    print(json.dumps(export_onnx(args.checkpoint, args.output), indent=2))


if __name__ == "__main__":
    main()
