"""Locked recipe provenance, official optimizer groups and runnable status."""
import hashlib
import importlib.util
import json
from pathlib import Path

import pytest
import torch
from torch import nn

from pallet.experiments.recipes import (
    build_rfdetr_optimizer, build_rfdetr_param_groups, build_ultralytics_optimizer,
    get_recipe_spec, resolve_ultralytics_auto, validate_parameter_coverage,
)


def test_specs_preserve_defaults_and_make_run_status_explicit():
    for family in ("yolo26", "yolov8", "yolov8-cspnext", "rfdetr-small"):
        default = get_recipe_spec(family, "official_default")
        constrained = get_recipe_spec(family)
        assert default["research_overrides"] == {}
        assert default["official_defaults"] == constrained["official_defaults"]
        assert constrained["training_status"] == "runnable_sensor_research_integration"
        assert not constrained["blockers"]
        json.dumps(constrained, allow_nan=False)
        for source in constrained["sources"]:
            root = Path(importlib.util.find_spec(source["package"]).origin).parent
            assert source["sha256"] == hashlib.sha256((root / source["file"]).read_bytes()).hexdigest()
    yolo = get_recipe_spec("yolo26")
    rf = get_recipe_spec("rfdetr-small")
    assert yolo["official_defaults"]["train"]["nbs"] == 64
    assert yolo["research_overrides"]["train"]["nbs"] == 16
    assert yolo["official_defaults"]["train"]["mosaic"] == 1.0
    assert yolo["augmentation"]["mosaic"] == 0.0
    assert rf["official_defaults"]["model"]["resolution"] == 512
    assert rf["official_defaults"]["train"]["grad_accum_steps"] == 1
    assert rf["research_overrides"]["train"]["grad_accum_steps"] == 4
    assert get_recipe_spec("rfdetr-small", "project_adamw_pilot")["ema"] == {"enabled": False}


@pytest.mark.parametrize("kwargs", [{"batch_size": 3}, {"batch_size": 0}, {"batch_size": True}])
def test_invalid_constraint_batch(kwargs):
    with pytest.raises(ValueError):
        get_recipe_spec("yolo26", **kwargs)


def test_auto_optimizer_strict_iterations_boundary():
    assert resolve_ultralytics_auto(num_train_samples=1600, epochs=100, batch_size=4,
                                   nbs=16, nc=1) == {
        "name": "AdamW", "lr": 0.002, "momentum": 0.9,
        "iterations": 10000, "warmup_bias_lr": 0.0}
    above = resolve_ultralytics_auto(num_train_samples=1601, epochs=100, batch_size=4, nbs=16)
    assert above["name"] == "MuSGD" and above["iterations"] == 10100
    with pytest.raises(ValueError):
        resolve_ultralytics_auto(num_train_samples=0, epochs=1, batch_size=4)


class ToyHead(nn.Module):
    def __init__(self):
        super().__init__()
        self.cv3 = nn.Linear(4, 2)
        self.other = nn.Linear(4, 2)
        self.logit_scale = nn.Parameter(torch.ones(()))
        self.bn = nn.BatchNorm1d(4)


class ToyYolo(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.ModuleList([ToyHead()])


@pytest.mark.parametrize("samples,expected", [(1600, "AdamW"), (1601, "MuSGD")])
def test_upstream_yolo_groups_and_musgd_head_boost(samples, expected):
    model = ToyYolo()
    optimizer = build_ultralytics_optimizer(model, num_train_samples=samples, epochs=100)
    assert type(optimizer).__name__ == expected
    report = validate_parameter_coverage(model, optimizer.param_groups, trainable_only=False)
    by_name = {name: group for group in report for name in group["parameter_names"]}
    if expected == "AdamW":
        assert by_name["model.0.cv3.bias"]["weight_decay"] == 0
        assert by_name["model.0.cv3.weight"]["weight_decay"] == 0.0005
        assert by_name["model.0.bn.weight"]["weight_decay"] == 0
        assert by_name["model.0.logit_scale"]["weight_decay"] == 0
        assert by_name["model.0.cv3.weight"]["lr"] == 0.002
    else:
        assert by_name["model.0.cv3.weight"]["use_muon"] is True
        assert by_name["model.0.cv3.weight"]["lr"] == 0.03
        assert by_name["model.0.other.weight"]["lr"] == 0.01


def test_coverage_rejects_missing_duplicate_foreign_and_empty():
    model = nn.Linear(2, 1)
    with pytest.raises(ValueError, match="missing"):
        validate_parameter_coverage(model, [{"params": [model.weight]}])
    with pytest.raises(ValueError, match="duplicate"):
        validate_parameter_coverage(model, [{"params": [model.weight, model.weight, model.bias]}])
    with pytest.raises(ValueError, match="foreign"):
        validate_parameter_coverage(model, [{"params": [nn.Parameter(torch.ones(1))]}])
    with pytest.raises(ValueError, match="no parameters"):
        validate_parameter_coverage(nn.Identity(), [])


@pytest.mark.filterwarnings("ignore:.*pretrain_weights=None.*")
def test_rf_actual_encoder_groups_and_explicit_adapter_coverage():
    from pallet.models.rfdetr import RFDETRDetector
    package = Path(importlib.util.find_spec("rfdetr").origin).parent
    source_spec = importlib.util.spec_from_file_location("test_rf_groups", package / "training/param_groups.py")
    source_module = importlib.util.module_from_spec(source_spec)
    source_spec.loader.exec_module(source_module)
    get_param_dict = source_module.get_param_dict
    from types import SimpleNamespace

    torch.set_num_threads(1)
    model = RFDETRDetector(resolution=64, pretrained=False)
    with pytest.raises(ValueError, match="missing.*fusion"):
        build_rfdetr_param_groups(model, core_model=model.model)
    optimizer = build_rfdetr_optimizer(model, core_model=model.model, allow_adapter_parameters=True)
    groups = optimizer.param_groups
    report = validate_parameter_coverage(model, groups)
    direct = get_param_dict(SimpleNamespace(lr=1e-4, lr_encoder=1.5e-4,
        lr_component_decay=.7, lr_vit_layer_decay=.8, weight_decay=1e-4,
        out_feature_indexes=model.model_config.out_feature_indexes), model.model)
    direct_map = {id(p): (g["lr"], g.get("weight_decay", 1e-4)) for g in direct for p in g["params"]}
    ours = {id(p): (g["lr"], g["weight_decay"]) for g in groups for p in g["params"]}
    assert all(ours[key] == value for key, value in direct_map.items())
    by_name = {name: group for group in report for name in group["parameter_names"]}
    encoder = {n: g for n, g in by_name.items() if n.startswith("model.backbone.0.encoder")}
    assert len({g["lr"] for g in encoder.values()}) > 2
    assert any(g["weight_decay"] == 0 for g in encoder.values())
    assert any(g["weight_decay"] == 1e-4 for g in encoder.values())
    assert all(g["lr"] == pytest.approx(7e-5) for n, g in by_name.items() if "transformer.decoder" in n)
    assert all(g["recipe_extension"] == "sensor_adapter_base_lr_weight_decay"
               and g["lr"] == 1e-4 for n, g in by_name.items() if n.startswith("fusion."))
    before = {n: p.detach().clone() for n, p in model.fusion.named_parameters()}
    batch = {"img": torch.rand(1, 4, 64, 64), "batch_idx": torch.zeros(1, dtype=torch.long),
             "cls": torch.zeros((1, 1)), "bboxes": torch.tensor([[.5, .5, .2, .2]])}
    loss, _ = model.loss(batch)
    loss.backward()
    assert all(p.grad is not None and torch.isfinite(p.grad).all() for p in model.fusion.parameters())
    optimizer.step()
    assert any(not torch.equal(before[n], p) for n, p in model.fusion.named_parameters())
    # Frozen parameters are deliberately omitted, while active parameters retain exact coverage.
    next(model.fusion.parameters()).requires_grad_(False)
    validate_parameter_coverage(model, build_rfdetr_param_groups(
        model, core_model=model.model, allow_adapter_parameters=True))


@pytest.mark.parametrize("indexes", [[], [1, 0], [0, 0], [-1], [True]])
def test_rf_rejects_invalid_layer_indices_before_upstream_grouping(indexes):
    with pytest.raises(ValueError, match="out_feature_indexes"):
        build_rfdetr_param_groups(nn.Linear(2, 1), out_feature_indexes=indexes)
