simulation/modules/IsaacLab/source/isaaclab_tasks/test/test_hydra.py

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""Self-contained tests for Hydra configuration utilities.

These tests verify the REPLACE-only preset system without depending on
external environment configurations.
"""

import warnings

import pytest

from isaaclab.utils.configclass import configclass

from isaaclab_tasks.utils import hydra as hydra_mod
from isaaclab_tasks.utils.hydra import (
    PresetCfg,
    _format_unknown_presets_error,
    apply_overrides,
    collect_presets,
    parse_overrides,
    preset,
    resolve_presets,
)

# =============================================================================
# Leaf config classes (reused across all test sections)
# =============================================================================


@configclass
class PhysxCfg:
    backend: str = "physx"
    dt: float = 0.005
    substeps: int = 2


@configclass
class NewtonCfg:
    backend: str = "newton"
    dt: float = 0.002
    substeps: int = 4
    solver_iterations: int = 8


@configclass
class NoiselessObservationsCfg:
    enable_corruption: bool = False
    concatenate_terms: bool = True
    noise_scale: float = 0.0


@configclass
class FastObservationsCfg:
    enable_corruption: bool = False
    concatenate_terms: bool = False
    noise_scale: float = 0.0


@configclass
class SmallPolicyCfg:
    actor_hidden_dims: list = [64, 32]


@configclass
class FastPolicyCfg:
    actor_hidden_dims: list = [32, 16]


# =============================================================================
# Composite configs using PresetCfg
# =============================================================================


@configclass
class SampleEnvCfg:
    decimation: int = 4
    sim_dt: float = 0.005


@configclass
class SampleAgentCfg:
    max_iterations: int = 1000
    learning_rate: float = 3e-4


@configclass
class SimBackendCfg(PresetCfg):
    default: PhysxCfg = PhysxCfg()
    newton_mjwarp: NewtonCfg = NewtonCfg()


@configclass
class ObsModeCfg(PresetCfg):
    default: NoiselessObservationsCfg = NoiselessObservationsCfg()
    fast: FastObservationsCfg = FastObservationsCfg()


@configclass
class PolicyModeCfg(PresetCfg):
    default: SmallPolicyCfg = SmallPolicyCfg()
    fast: FastPolicyCfg = FastPolicyCfg()


@configclass
class PresetCfgEnvCfg:
    decimation: int = 4
    backend: SimBackendCfg = SimBackendCfg()
    observations: ObsModeCfg = ObsModeCfg()


@configclass
class PresetCfgAgentCfg:
    learning_rate: float = 3e-4
    policy: PolicyModeCfg = PolicyModeCfg()


@configclass
class RootAgentCfg(PresetCfg):
    """Root-level PresetCfg -- the agent config itself is a PresetCfg."""

    default: SampleAgentCfg = SampleAgentCfg()
    fast: SampleAgentCfg = SampleAgentCfg(max_iterations=100, learning_rate=1e-3)


# -- Nested PresetCfg-inside-PresetCfg (mirrors scene.base_camera pattern) --


@configclass
class CameraSmallCfg:
    width: int = 64
    height: int = 64


@configclass
class CameraLargeCfg:
    width: int = 256
    height: int = 256


@configclass
class CameraWideCfg:
    width: int = 512
    height: int = 128


@configclass
class CameraPresetCfg(PresetCfg):
    small: CameraSmallCfg = CameraSmallCfg()
    large: CameraLargeCfg = CameraLargeCfg()
    default: CameraSmallCfg = CameraSmallCfg()


@configclass
class WideCameraPresetCfg(PresetCfg):
    small: CameraWideCfg = CameraWideCfg()
    default: CameraWideCfg = CameraWideCfg()


@configclass
class BaseSceneCfg:
    num_envs: int = 1024
    camera: PresetCfg | None = None


@configclass
class ScenePresetCfg(PresetCfg):
    default: BaseSceneCfg = BaseSceneCfg()
    wide_camera: BaseSceneCfg = BaseSceneCfg(camera=WideCameraPresetCfg())
    with_camera: BaseSceneCfg = BaseSceneCfg(camera=CameraPresetCfg())


@configclass
class NestedPresetEnvCfg:
    decimation: int = 4
    scene: ScenePresetCfg = ScenePresetCfg()


# -- Scalar PresetCfg and actuator configs (shared by scalar + dict sections) --


@configclass
class ScalarPresetCfg(PresetCfg):
    default: float = 0.0
    newton_mjwarp: float = 0.01


@configclass
class ActuatorWithPresetCfg:
    joint_names: list = [".*"]
    stiffness: float = 40.0
    damping: float = 5.0
    armature: ScalarPresetCfg = ScalarPresetCfg()


# -- Deep-nested dict configs (event term params pattern) --


@configclass
class OffsetCfg(PresetCfg):
    """Mimics task-specific offset presets (e.g., AssembledOffsetCfg)."""

    task_a: tuple = (0.0, 0.0, 0.01)
    task_b: tuple = (0.02, 0.0, 0.005)
    default: tuple = task_a


@configclass
class FractionCfg(PresetCfg):
    task_a: tuple = (0.05, 0.5)
    task_b: tuple = (0.3, 1.0)
    default: tuple = task_a


@configclass
class JointNamesCfg(PresetCfg):
    default: list[str] | None = None
    robot_a: list[str] = None
    robot_b: list[str] = None


@configclass
class EntityCfg:
    """Mimics SceneEntityCfg with a preset-valued field."""

    name: str = "robot"
    joint_names: list[str] | None = None


@configclass
class InnerTermCfg:
    """Mimics an EventTermCfg with params containing presets."""

    func: str = "reset_fn"
    params: dict = None

    def __post_init__(self):
        if self.params is None:
            self.params = {
                "offset": OffsetCfg(),
                "fraction": FractionCfg(),
                "robot_cfg": EntityCfg(name="robot", joint_names=JointNamesCfg()),
            }


@configclass
class OuterTermCfg:
    """Mimics a chained reset term with nested terms dict."""

    func: str = "chain_fn"
    params: dict = None

    def __post_init__(self):
        if self.params is None:
            self.params = {
                "terms": {
                    "step_one": InnerTermCfg(),
                }
            }


@configclass
class DeepDictEnvCfg:
    decimation: int = 4
    events: OuterTermCfg = OuterTermCfg()


@configclass
class DictPresetTermCfg:
    """Outer term where the terms dict is itself a preset (resolves to a dict)."""

    func: str = "term_choice"
    params: dict = None

    def __post_init__(self):
        if self.params is None:
            self.params = {
                "terms": preset(
                    default={
                        "strategy_a": InnerTermCfg(),
                        "strategy_b": InnerTermCfg(),
                    },
                    alt={
                        "strategy_a": InnerTermCfg(),
                    },
                ),
            }


@configclass
class PresetResolvesToDictEnvCfg:
    decimation: int = 4
    events: DictPresetTermCfg = DictPresetTermCfg()


# =============================================================================
# Helpers
# =============================================================================


def _apply(env_cfg, agent_cfg=None, global_presets=None, preset_sel=None, preset_scalar=None):
    """Collect presets, resolve defaults, build hydra dict, and apply overrides."""
    if agent_cfg is None:
        agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    return apply_overrides(
        env_cfg,
        agent_cfg,
        hydra_cfg,
        global_presets or [],
        preset_sel or [],
        preset_scalar or [],
        presets,
    )


# =============================================================================
# Fixtures
# =============================================================================


@pytest.fixture
def class_presets():
    """Fresh configs using PresetCfg pattern."""
    env_cfg = PresetCfgEnvCfg()
    agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    return env_cfg, agent_cfg, presets


# =============================================================================
# Tests: collect_presets
# =============================================================================


def test_collect_presets_class_style():
    """PresetCfg fields discovered at correct paths."""
    presets = collect_presets(PresetCfgEnvCfg())
    assert "backend" in presets
    assert set(presets["backend"].keys()) == {"default", "newton_mjwarp"}
    assert isinstance(presets["backend"]["default"], PhysxCfg)
    assert isinstance(presets["backend"]["newton_mjwarp"], NewtonCfg)


def test_legacy_newton_attribute_alias_warns():
    """Python access to the legacy ``newton`` preset aliases to ``newton_mjwarp`` during deprecation."""
    cfg = SimBackendCfg()
    with pytest.warns(FutureWarning, match="Preset 'newton' is deprecated"):
        assert cfg.newton is cfg.newton_mjwarp


def test_legacy_kamino_attribute_alias_warns():
    """Python access to the legacy ``kamino`` preset aliases to ``newton_kamino`` during deprecation."""

    @configclass
    class _SolverPresetsCfg(PresetCfg):
        default: PhysxCfg = PhysxCfg()
        newton_kamino: NewtonCfg = NewtonCfg()

    cfg = _SolverPresetsCfg()
    with pytest.warns(FutureWarning, match="Preset 'kamino' is deprecated"):
        assert cfg.kamino is cfg.newton_kamino


def test_legacy_alias_suppressed_when_legacy_name_is_real_field():
    """An env that legitimately defines ``newton`` should not warn or be remapped."""

    @configclass
    class _ShadowingCfg(PresetCfg):
        default: PhysxCfg = PhysxCfg()
        newton: PhysxCfg = PhysxCfg()
        newton_mjwarp: NewtonCfg = NewtonCfg()

    cfg = _ShadowingCfg()
    with warnings.catch_warnings():
        warnings.simplefilter("error", FutureWarning)
        assert cfg.newton is not cfg.newton_mjwarp
        assert isinstance(cfg.newton, PhysxCfg)


def test_presetcfg_attribute_error_for_unknown_attribute():
    """Plain missing attributes should raise ``AttributeError`` (not warn or alias)."""
    cfg = SimBackendCfg()
    assert not hasattr(cfg, "completely_unknown")
    with pytest.raises(AttributeError, match="completely_unknown"):
        _ = cfg.completely_unknown


def test_format_unknown_presets_error_calls_out_legacy_aliases():
    """The unknown-preset error should explicitly mention the rename for legacy aliases."""
    msg = _format_unknown_presets_error({"newton", "typo"}, {"fast": ["env"]})
    assert "newton' was renamed to 'newton_mjwarp'" in msg
    assert "typo" in msg


def test_user_stacklevel_warning_origin_is_outside_hydra_module():
    """``_normalize_preset_name`` warnings should not be attributed to hydra.py itself."""
    presets_arg = {"env": {"backend": {"default": None, "newton_mjwarp": None}}, "agent": {}}
    with warnings.catch_warnings(record=True) as caught:
        warnings.simplefilter("always", FutureWarning)
        parse_overrides(["presets=newton"], presets_arg)
    deprecations = [w for w in caught if issubclass(w.category, FutureWarning)]
    assert deprecations, "expected a FutureWarning from the legacy alias"
    assert deprecations[0].filename != hydra_mod.__file__, (
        f"warning was attributed to hydra.py ({deprecations[0].filename}); _user_stacklevel should "
        f"point outside the module"
    )


def test_collect_presets_root_level():
    """Root-level PresetCfg collected at path=''."""
    presets = collect_presets(RootAgentCfg())
    assert "" in presets
    assert set(presets[""].keys()) == {"default", "fast"}
    assert isinstance(presets[""]["default"], SampleAgentCfg)
    assert presets[""]["fast"].max_iterations == 100


# =============================================================================
# Tests: parse_overrides
# =============================================================================


def test_parse_overrides_mixed():
    """All override types categorized correctly."""
    env_cfg = PresetCfgEnvCfg()
    presets = {"env": collect_presets(env_cfg), "agent": {}}
    args = [
        "presets=fast",
        "env.decimation=10",
        "env.backend=newton_mjwarp",
        "env.backend.dt=0.001",
    ]
    global_p, sel, scalar, glob = parse_overrides(args, presets)
    assert global_p == ["fast"]
    assert ("env", "backend", "newton_mjwarp") in sel
    assert ("env.backend.dt", "0.001") in scalar
    assert "env.decimation=10" in glob


def test_parse_overrides_root_preset():
    """Root-level PresetCfg parsed as agent=<name>."""
    presets = {"env": {}, "agent": collect_presets(RootAgentCfg())}
    _, sel, _, _ = parse_overrides(["agent=fast"], presets)
    assert sel == [("agent", "", "fast")]


# =============================================================================
# Tests: apply_overrides -- PresetCfg (nested + broadcast + root)
# =============================================================================


def test_presetcfg_auto_default(class_presets):
    """'default' field auto-applied when no CLI override."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    apply_overrides(env_cfg, agent_cfg, hydra_cfg, [], [], [], presets)
    assert isinstance(env_cfg.backend, PhysxCfg)
    assert isinstance(env_cfg.observations, NoiselessObservationsCfg)
    assert isinstance(agent_cfg.policy, SmallPolicyCfg)


def test_presetcfg_cli_selection(class_presets):
    """Path selection replaces with chosen preset."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    apply_overrides(env_cfg, agent_cfg, hydra_cfg, [], [("env", "backend", "newton_mjwarp")], [], presets)
    assert isinstance(env_cfg.backend, NewtonCfg)
    assert env_cfg.backend.dt == 0.002


def test_presetcfg_global_broadcast(class_presets):
    """Global preset 'fast' broadcasts across env and agent PresetCfg fields."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    apply_overrides(env_cfg, agent_cfg, hydra_cfg, ["fast"], [], [], presets)
    assert isinstance(env_cfg.observations, FastObservationsCfg)
    assert isinstance(agent_cfg.policy, FastPolicyCfg)


def test_presetcfg_path_selection_others_default(class_presets):
    """Path preset on one field, others get auto-default."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    apply_overrides(env_cfg, agent_cfg, hydra_cfg, [], [("env", "backend", "newton_mjwarp")], [], presets)
    assert isinstance(env_cfg.backend, NewtonCfg)
    assert isinstance(env_cfg.observations, NoiselessObservationsCfg)
    assert isinstance(agent_cfg.policy, SmallPolicyCfg)


def test_root_presetcfg_auto_default():
    """Root-level PresetCfg auto-applies 'default'."""
    env_cfg, agent_cfg = _apply(SampleEnvCfg(), RootAgentCfg())
    assert isinstance(agent_cfg, SampleAgentCfg)
    assert agent_cfg.max_iterations == 1000


def test_root_presetcfg_cli_selection():
    """Root-level PresetCfg resolved via path selection."""
    env_cfg, agent_cfg = _apply(SampleEnvCfg(), RootAgentCfg(), preset_sel=[("agent", "", "fast")])
    assert isinstance(agent_cfg, SampleAgentCfg)
    assert agent_cfg.max_iterations == 100
    assert agent_cfg.learning_rate == 1e-3


def test_root_presetcfg_global_preset():
    """Root-level PresetCfg resolved via global preset."""
    env_cfg, agent_cfg = _apply(SampleEnvCfg(), RootAgentCfg(), global_presets=["fast"])
    assert isinstance(agent_cfg, SampleAgentCfg)
    assert agent_cfg.max_iterations == 100


# =============================================================================
# Tests: nested PresetCfg inside PresetCfg
# =============================================================================


def test_collect_nested_presetcfg():
    """PresetCfg inside another PresetCfg's alternatives is discovered."""
    presets = collect_presets(NestedPresetEnvCfg())
    assert "scene" in presets
    assert set(presets["scene"].keys()) == {"default", "wide_camera", "with_camera"}
    assert "scene.camera" in presets
    assert set(presets["scene.camera"].keys()) == {"small", "large", "default"}
    assert isinstance(presets["scene.camera"]["small"], CameraSmallCfg)
    assert isinstance(presets["scene.camera"]["large"], CameraLargeCfg)


def test_nested_presetcfg_pruned_when_parent_has_none():
    """When scene auto-defaults to default (camera=None), nested camera preset is pruned."""
    env_cfg, _ = _apply(NestedPresetEnvCfg())
    assert isinstance(env_cfg.scene, BaseSceneCfg)
    assert env_cfg.scene.camera is None


def test_nested_presetcfg_auto_default_with_camera():
    """When with_camera scene is selected, camera auto-defaults to small (the default)."""
    env_cfg, _ = _apply(NestedPresetEnvCfg(), global_presets=["with_camera"])
    assert isinstance(env_cfg.scene, BaseSceneCfg)
    assert isinstance(env_cfg.scene.camera, CameraSmallCfg)
    assert env_cfg.scene.camera.width == 64


def test_nested_presetcfg_global_broadcast():
    """Global preset resolves both outer and nested PresetCfg."""
    env_cfg, _ = _apply(NestedPresetEnvCfg(), global_presets=["with_camera", "large"])
    assert isinstance(env_cfg.scene, BaseSceneCfg)
    assert isinstance(env_cfg.scene.camera, CameraLargeCfg)
    assert env_cfg.scene.camera.width == 256


def test_nested_presetcfg_path_selection():
    """Path selection on nested PresetCfg resolves correctly."""
    sel = [("env", "scene", "with_camera"), ("env", "scene.camera", "large")]
    env_cfg, _ = _apply(NestedPresetEnvCfg(), preset_sel=sel)
    assert isinstance(env_cfg.scene, BaseSceneCfg)
    assert isinstance(env_cfg.scene.camera, CameraLargeCfg)
    assert env_cfg.scene.camera.width == 256


def test_nested_presetcfg_global_preset_uses_selected_parent_branch():
    """Same nested preset names should resolve inside the selected parent branch."""
    env_cfg, _ = _apply(NestedPresetEnvCfg(), global_presets=["wide_camera", "small"])

    assert isinstance(env_cfg.scene, BaseSceneCfg)
    assert isinstance(env_cfg.scene.camera, CameraWideCfg)


def test_nested_presetcfg_path_preset_uses_selected_parent_branch():
    """Unqualified public paths should still resolve against the selected active branch."""
    sel = [("env", "scene", "wide_camera"), ("env", "scene.camera", "small")]
    env_cfg, _ = _apply(NestedPresetEnvCfg(), preset_sel=sel)

    assert isinstance(env_cfg.scene, BaseSceneCfg)
    assert isinstance(env_cfg.scene.camera, CameraWideCfg)


# =============================================================================
# Tests: root-level PresetCfg with nested PresetCfg inside alternatives
# (mirrors CartpoleCameraPresetsEnvCfg structure)
# =============================================================================


@configclass
class RendererACfg:
    backend: str = "rtx"


@configclass
class RendererBCfg:
    backend: str = "warp"


@configclass
class RendererPresetCfg(PresetCfg):
    default: RendererACfg = RendererACfg()
    newton_renderer: RendererBCfg = RendererBCfg()


@configclass
class SensorBaseCfg:
    data_types: list[str] = []
    width: int = 100
    height: int = 100
    renderer: RendererPresetCfg = RendererPresetCfg()


@configclass
class SensorPresetCfg(PresetCfg):
    default: SensorBaseCfg = SensorBaseCfg(data_types=["rgb"])
    depth: SensorBaseCfg = SensorBaseCfg(data_types=["depth"])


@configclass
class RootEnvBaseCfg:
    decimation: int = 2
    sensor: SensorPresetCfg = SensorPresetCfg()
    obs_shape: list[int] = [100, 100, 3]


@configclass
class RootPresetEnvCfg(PresetCfg):
    default: RootEnvBaseCfg = RootEnvBaseCfg()
    depth: RootEnvBaseCfg = RootEnvBaseCfg(obs_shape=[100, 100, 1])


def test_root_presetcfg_with_nested_preset_collect():
    """collect_presets discovers nested PresetCfg inside root PresetCfg alternatives."""
    presets = collect_presets(RootPresetEnvCfg())
    assert "" in presets
    assert set(presets[""].keys()) == {"default", "depth"}
    assert "sensor" in presets
    assert set(presets["sensor"].keys()) == {"default", "depth"}
    assert "sensor.renderer" in presets
    assert set(presets["sensor.renderer"].keys()) == {"default", "newton_renderer"}


def test_root_presetcfg_resolve_defaults():
    """resolve_presets resolves nested PresetCfg inside root."""
    resolved = resolve_presets(RootPresetEnvCfg())
    assert isinstance(resolved, RootEnvBaseCfg)
    assert isinstance(resolved.sensor, SensorBaseCfg)
    assert resolved.sensor.data_types == ["rgb"]
    assert isinstance(resolved.sensor.renderer, RendererACfg)
    assert resolved.sensor.renderer.backend == "rtx"


@configclass
class OptionalFeatureCfg:
    buffer_size: int = 200
    export_path: str = "."


@configclass
class OptionalFeaturePresetCfg(PresetCfg):
    default = None
    enabled: OptionalFeatureCfg = OptionalFeatureCfg()


@configclass
class EnvWithOptionalFeatureCfg:
    decimation: int = 4
    optional_feature: OptionalFeaturePresetCfg = OptionalFeaturePresetCfg()


def test_presetcfg_none_default_auto_applies():
    """PresetCfg with default=None auto-applies None without crashing."""
    env_cfg, _ = _apply(EnvWithOptionalFeatureCfg())
    assert env_cfg.optional_feature is None


def test_presetcfg_none_default_cli_selects_enabled():
    """PresetCfg with default=None can be overridden to a real config via CLI."""
    env_cfg = EnvWithOptionalFeatureCfg()
    agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    sel = [("env", "optional_feature", "enabled")]
    apply_overrides(env_cfg, agent_cfg, hydra_cfg, [], sel, [], presets)
    assert isinstance(env_cfg.optional_feature, OptionalFeatureCfg)
    assert env_cfg.optional_feature.buffer_size == 200


def test_root_presetcfg_global_depth_resolves_nested():
    """Global preset=depth on root PresetCfg also resolves nested sensor and renderer."""
    env_cfg, _ = _apply(RootPresetEnvCfg(), global_presets=["depth"])
    assert isinstance(env_cfg, RootEnvBaseCfg)
    assert env_cfg.obs_shape == [100, 100, 1]
    assert isinstance(env_cfg.sensor, SensorBaseCfg), (
        f"sensor should be SensorBaseCfg, got {type(env_cfg.sensor).__name__}"
    )
    assert env_cfg.sensor.data_types == ["depth"]
    assert isinstance(env_cfg.sensor.renderer, RendererACfg), (
        f"renderer should be RendererACfg (default), got {type(env_cfg.sensor.renderer).__name__}"
    )


# =============================================================================
# Tests: scalar PresetCfg (e.g., armature=PresetCfg(default=0.0, newton_mjwarp=0.01))
# =============================================================================


@configclass
class ScalarPresetEnvCfg:
    decimation: int = 4
    actuator: ActuatorWithPresetCfg = ActuatorWithPresetCfg()


def test_scalar_presetcfg_collect():
    """Scalar PresetCfg fields collected with correct values."""
    presets = collect_presets(ScalarPresetEnvCfg())
    assert "actuator.armature" in presets
    assert presets["actuator.armature"]["default"] == 0.0
    assert presets["actuator.armature"]["newton_mjwarp"] == 0.01


def test_scalar_presetcfg_resolve_default():
    """resolve_presets replaces scalar PresetCfg with its default value."""
    cfg = ScalarPresetEnvCfg()
    resolved = resolve_presets(cfg)
    assert resolved.actuator.armature == 0.0
    assert not isinstance(resolved.actuator.armature, PresetCfg)


def test_scalar_presetcfg_auto_default():
    """Scalar PresetCfg auto-applies default=0.0 when no CLI override."""
    env_cfg, _ = _apply(ScalarPresetEnvCfg())
    assert env_cfg.actuator.armature == 0.0


def test_scalar_presetcfg_global_newton_mjwarp():
    """Global preset=newton_mjwarp replaces scalar PresetCfg with MJWarp value."""
    env_cfg, _ = _apply(ScalarPresetEnvCfg(), global_presets=["newton_mjwarp"])
    assert env_cfg.actuator.armature == 0.01


def test_scalar_presetcfg_path_selection():
    """Path selection replaces scalar PresetCfg with chosen value."""
    env_cfg, _ = _apply(ScalarPresetEnvCfg(), preset_sel=[("env", "actuator.armature", "newton_mjwarp")])
    assert env_cfg.actuator.armature == 0.01
    assert env_cfg.actuator.stiffness == 40.0


# =============================================================================
# Tests: PresetCfg inside dict values (e.g., actuators["legs"].armature)
# =============================================================================


@configclass
class RobotCfg:
    prim_path: str = "/World/Robot"
    actuators: dict = None

    def __post_init__(self):
        if self.actuators is None:
            self.actuators = {"legs": ActuatorWithPresetCfg()}


@configclass
class DictPresetEnvCfg:
    decimation: int = 4
    robot: RobotCfg = RobotCfg()


def test_collect_presets_traverses_dict_values():
    """collect_presets finds PresetCfg inside dict-held configclass values."""
    cfg = DictPresetEnvCfg()
    presets = collect_presets(cfg)
    assert "robot.actuators.legs.armature" in presets
    assert presets["robot.actuators.legs.armature"]["default"] == 0.0
    assert presets["robot.actuators.legs.armature"]["newton_mjwarp"] == 0.01


def test_resolve_presets_traverses_dict_values():
    """resolve_presets resolves PresetCfg inside dict-held configclass values."""
    cfg = DictPresetEnvCfg()
    resolved = resolve_presets(cfg)
    assert resolved.robot.actuators["legs"].armature == 0.0
    assert not isinstance(resolved.robot.actuators["legs"].armature, PresetCfg)


def test_dict_preset_auto_default():
    """Dict-held PresetCfg auto-applies default when no CLI override."""
    env_cfg, _ = _apply(DictPresetEnvCfg())
    assert env_cfg.robot.actuators["legs"].armature == 0.0


def test_dict_preset_global_newton_mjwarp():
    """Global preset=newton_mjwarp replaces dict-held scalar PresetCfg."""
    env_cfg, _ = _apply(DictPresetEnvCfg(), global_presets=["newton_mjwarp"])
    assert env_cfg.robot.actuators["legs"].armature == 0.01


def test_dict_preset_path_selection():
    """Path selection replaces dict-held scalar PresetCfg."""
    env_cfg, _ = _apply(DictPresetEnvCfg(), preset_sel=[("env", "robot.actuators.legs.armature", "newton_mjwarp")])
    assert env_cfg.robot.actuators["legs"].armature == 0.01
    assert env_cfg.robot.actuators["legs"].stiffness == 40.0


def test_dict_preset_with_factory():
    """preset() factory works inside dict-held configclass values."""

    @configclass
    class ActuatorCfgFactory:
        joint_names: list = [".*"]
        armature: object = None

        def __post_init__(self):
            if self.armature is None:
                self.armature = preset(default=0.0, newton_mjwarp=0.01, physx=0.0)

    @configclass
    class RobotCfgFactory:
        actuators: dict = None

        def __post_init__(self):
            if self.actuators is None:
                self.actuators = {"legs": ActuatorCfgFactory()}

    @configclass
    class EnvCfgFactory:
        robot: RobotCfgFactory = RobotCfgFactory()

    cfg = EnvCfgFactory()
    presets = collect_presets(cfg)
    assert "robot.actuators.legs.armature" in presets
    assert presets["robot.actuators.legs.armature"]["default"] == 0.0
    assert presets["robot.actuators.legs.armature"]["newton_mjwarp"] == 0.01
    assert presets["robot.actuators.legs.armature"]["physx"] == 0.0


# =============================================================================
# Tests: rough terrain config regressions
# =============================================================================


def test_go1_rough_newton_mjwarp_armature_preset():
    """Go1 rough terrain uses higher MJWarp armature without changing PhysX."""
    from isaaclab_tasks.manager_based.locomotion.velocity.config.go1.rough_env_cfg import UnitreeGo1RoughEnvCfg

    env_cfg, _ = _apply(UnitreeGo1RoughEnvCfg(), global_presets=["newton_mjwarp"])
    assert env_cfg.scene.robot.actuators["base_legs"].armature == 0.02

    env_cfg, _ = _apply(UnitreeGo1RoughEnvCfg())
    assert env_cfg.scene.robot.actuators["base_legs"].armature == 0.0


def test_go1_rough_legacy_newton_alias_resolves_to_newton_mjwarp():
    """Real-config alias path: ``presets=newton`` against an actual env cfg resolves to newton_mjwarp."""
    from isaaclab_tasks.manager_based.locomotion.velocity.config.go1.rough_env_cfg import UnitreeGo1RoughEnvCfg

    with pytest.warns(FutureWarning, match="Preset 'newton' is deprecated"):
        env_cfg, _ = _apply(UnitreeGo1RoughEnvCfg(), global_presets=["newton"])
    assert env_cfg.scene.robot.actuators["base_legs"].armature == 0.02


# =============================================================================
# Tests: PresetCfg inside deeply nested dicts (e.g., event term params)
# =============================================================================


def test_collect_presets_deep_nested_dicts():
    """collect_presets discovers PresetCfg inside dict->dict->configclass->dict chains."""
    cfg = DeepDictEnvCfg()
    presets = collect_presets(cfg)
    offset_path = "events.params.terms.step_one.params.offset"
    fraction_path = "events.params.terms.step_one.params.fraction"
    assert offset_path in presets, f"Expected '{offset_path}' in {list(presets.keys())}"
    assert fraction_path in presets, f"Expected '{fraction_path}' in {list(presets.keys())}"
    assert presets[offset_path]["task_a"] == (0.0, 0.0, 0.01)
    assert presets[offset_path]["task_b"] == (0.02, 0.0, 0.005)
    assert presets[fraction_path]["task_a"] == (0.05, 0.5)
    assert presets[fraction_path]["task_b"] == (0.3, 1.0)


def test_resolve_presets_deep_nested_dicts():
    """resolve_presets resolves presets inside deeply nested dicts."""
    cfg = DeepDictEnvCfg()
    resolved = resolve_presets(cfg)
    inner = resolved.events.params["terms"]["step_one"]
    assert inner.params["offset"] == (0.0, 0.0, 0.01)
    assert inner.params["fraction"] == (0.05, 0.5)
    assert not isinstance(inner.params["offset"], PresetCfg)
    assert not isinstance(inner.params["fraction"], PresetCfg)
    assert inner.params["robot_cfg"].joint_names is None
    assert not isinstance(inner.params["robot_cfg"].joint_names, PresetCfg)


def test_deep_nested_dict_auto_default():
    """Deeply nested dict presets auto-apply default when no CLI override."""
    env_cfg, _ = _apply(DeepDictEnvCfg())
    inner = env_cfg.events.params["terms"]["step_one"]
    assert inner.params["offset"] == (0.0, 0.0, 0.01)
    assert inner.params["fraction"] == (0.05, 0.5)


def test_deep_nested_dict_global_preset():
    """Global preset=task_b replaces deeply nested dict presets."""
    env_cfg, _ = _apply(DeepDictEnvCfg(), global_presets=["task_b"])
    inner = env_cfg.events.params["terms"]["step_one"]
    assert inner.params["offset"] == (0.02, 0.0, 0.005), f"offset should be task_b value, got {inner.params['offset']}"
    assert inner.params["fraction"] == (0.3, 1.0), f"fraction should be task_b value, got {inner.params['fraction']}"


def test_deep_nested_dict_path_selection():
    """Path selection replaces a specific deeply nested dict preset."""
    sel = [("env", "events.params.terms.step_one.params.offset", "task_b")]
    env_cfg, _ = _apply(DeepDictEnvCfg(), preset_sel=sel)
    inner = env_cfg.events.params["terms"]["step_one"]
    assert inner.params["offset"] == (0.02, 0.0, 0.005)
    assert inner.params["fraction"] == (0.05, 0.5)


def test_deep_nested_dict_mixed_global_and_path():
    """Global preset applies to nested dicts, path selection overrides one."""
    sel = [("env", "events.params.terms.step_one.params.fraction", "task_a")]
    env_cfg, _ = _apply(DeepDictEnvCfg(), global_presets=["task_b"], preset_sel=sel)
    inner = env_cfg.events.params["terms"]["step_one"]
    assert inner.params["offset"] == (0.02, 0.0, 0.005)
    assert inner.params["fraction"] == (0.05, 0.5)


# =============================================================================
# Tests: preset resolving to dict containing further presets
# =============================================================================


def test_collect_presets_discovers_presets_inside_dict_valued_alternatives():
    """collect_presets must recurse into dict-valued preset alternatives to
    discover further PresetCfg nodes nested inside them.
    """
    cfg = PresetResolvesToDictEnvCfg()
    presets = collect_presets(cfg)
    offset_paths = [p for p in presets if "offset" in p]
    fraction_paths = [p for p in presets if "fraction" in p]
    assert len(offset_paths) > 0, (
        f"OffsetCfg inside dict-valued preset alternative not discovered. Found: {list(presets.keys())}"
    )
    assert len(fraction_paths) > 0, (
        f"FractionCfg inside dict-valued preset alternative not discovered. Found: {list(presets.keys())}"
    )


def test_resolve_preset_resolving_to_dict_walks_contents():
    """When a preset resolves to a dict, presets inside that dict are also resolved.

    Also verifies that PresetCfg(default=None) nested inside the resolved dict
    correctly resolves to None (not skipped).
    """
    cfg = PresetResolvesToDictEnvCfg()
    resolved = resolve_presets(cfg)

    terms = resolved.events.params["terms"]
    assert isinstance(terms, dict), f"Expected dict, got {type(terms)}"
    assert not isinstance(terms, PresetCfg), "Top-level preset was not resolved"

    for name, term in terms.items():
        entity = term.params["robot_cfg"]
        assert not isinstance(entity.joint_names, PresetCfg), (
            f"PresetCfg leaked into {name}.params.robot_cfg.joint_names"
        )
        assert entity.joint_names is None
        assert not isinstance(term.params["offset"], PresetCfg)
        assert not isinstance(term.params["fraction"], PresetCfg)


def test_resolve_preset_uses_class_level_override():
    """When a robot-specific module overrides PresetCfg.default at class level
    after instances are created, resolve_presets picks up the override."""

    @configclass
    class BodyNameCfg(PresetCfg):
        default: str = "generic_body"

    @configclass
    class TermWithBody:
        func: str = "some_fn"
        params: dict = None

        def __post_init__(self):
            if self.params is None:
                self.params = {"cfg": EntityCfg(name="robot", joint_names=BodyNameCfg())}

    @configclass
    class EnvWithBody:
        events: TermWithBody = TermWithBody()

    BodyNameCfg.default = "robot_specific_body"

    cfg = EnvWithBody()
    resolved = resolve_presets(cfg)
    assert resolved.events.params["cfg"].joint_names == "robot_specific_body"
    assert not isinstance(resolved.events.params["cfg"].joint_names, PresetCfg)


def test_resolve_presets_with_selected_name_in_deeply_nested_dict():
    """resolve_presets(cfg, {"task_b"}) must select task_b alternatives
    for PresetCfg instances nested inside dict-valued preset alternatives.
    """
    cfg = PresetResolvesToDictEnvCfg()
    resolved = resolve_presets(cfg, {"task_b"})

    terms = resolved.events.params["terms"]
    assert isinstance(terms, dict)
    for name, term in terms.items():
        assert term.params["offset"] == (0.02, 0.0, 0.005), (
            f"{name}: offset should be task_b, got {term.params['offset']}"
        )
        assert term.params["fraction"] == (0.3, 1.0), (
            f"{name}: fraction should be task_b, got {term.params['fraction']}"
        )


# =============================================================================
# Tests: preset() factory function
# =============================================================================


def test_preset_factory_creates_presetcfg():
    """preset() returns a PresetCfg subclass instance with correct fields."""
    p = preset(default=0.0, high=1.0, low=-1.0)
    assert isinstance(p, PresetCfg)
    assert p.default == 0.0
    assert p.high == 1.0
    assert p.low == -1.0


def test_preset_factory_collectable():
    """preset()-created instances are discovered by collect_presets."""

    @configclass
    class FactoryEnvCfg:
        damping: object = None

        def __post_init__(self):
            if self.damping is None:
                self.damping = preset(default=5.0, high=20.0)

    cfg = FactoryEnvCfg()
    presets = collect_presets(cfg)
    assert "damping" in presets
    assert presets["damping"]["default"] == 5.0
    assert presets["damping"]["high"] == 20.0


def test_preset_factory_requires_default():
    """preset() raises ValueError when 'default' is not provided."""
    with pytest.raises(ValueError, match="default"):
        preset(high=1.0, low=-1.0)


def test_preset_factory_string_values():
    """preset() works with string values."""
    p = preset(default="cpu", gpu="cuda:0")
    assert isinstance(p, PresetCfg)
    assert p.default == "cpu"
    assert p.gpu == "cuda:0"


# =============================================================================
# Tests: _collect_fields class-vs-instance priority
# =============================================================================


def test_collect_fields_prefers_class_attr_over_instance():
    """Class-level attr mutations take priority over instance attrs in collection.

    This mirrors the pattern where robot-specific modules (e.g., joint_pos_env_cfg.py)
    mutate PresetCfg class attributes after instances are already created.
    """

    @configclass
    class MutablePresetCfg(PresetCfg):
        default: str = "original_default"
        alt: str = "alternative"

    instance = MutablePresetCfg()
    assert instance.default == "original_default"

    MutablePresetCfg.default = "robot_specific_default"

    presets = collect_presets(instance)
    assert "" in presets
    assert presets[""]["default"] == "robot_specific_default"

    MutablePresetCfg.default = "original_default"


def test_collect_fields_includes_dynamic_class_attrs():
    """Fields added to PresetCfg class at runtime are discovered."""

    @configclass
    class ExtensiblePresetCfg(PresetCfg):
        default: str = "base"
        alt_a: str = "a"

    ExtensiblePresetCfg.alt_b = "b"

    instance = ExtensiblePresetCfg()
    presets = collect_presets(instance)
    assert "" in presets
    assert "alt_b" in presets[""]
    assert presets[""]["alt_b"] == "b"

    delattr(ExtensiblePresetCfg, "alt_b")


# =============================================================================
# Tests: apply_overrides error handling
# =============================================================================


def test_apply_overrides_unknown_preset_group_raises():
    """apply_overrides raises ValueError for unknown preset group paths."""
    env_cfg = PresetCfgEnvCfg()
    agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    with pytest.raises(ValueError, match="Unknown or inactive preset group"):
        apply_overrides(env_cfg, agent_cfg, hydra_cfg, [], [("env", "nonexistent", "val")], [], presets)


def test_apply_overrides_unknown_preset_name_raises():
    """apply_overrides raises ValueError for unknown preset name."""
    env_cfg = PresetCfgEnvCfg()
    agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    with pytest.raises(ValueError, match="Unknown preset 'nonexistent'"):
        apply_overrides(env_cfg, agent_cfg, hydra_cfg, [], [("env", "backend", "nonexistent")], [], presets)


def test_apply_overrides_conflicting_globals_raises():
    """Two global presets matching the same path cause ValueError."""

    @configclass
    class TwoAltsPresetCfg(PresetCfg):
        default: str = "d"
        opt_a: str = "a"
        opt_b: str = "b"

    @configclass
    class ConflictEnvCfg:
        mode: TwoAltsPresetCfg = TwoAltsPresetCfg()

    env_cfg = ConflictEnvCfg()
    agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    with pytest.raises(ValueError, match="Conflicting global presets"):
        apply_overrides(env_cfg, agent_cfg, hydra_cfg, ["opt_a", "opt_b"], [], [], presets)


def test_apply_overrides_aliased_globals_no_conflict():
    """Two global presets resolving to equal values do not raise.

    Mirrors the dexsuite ObjectCfg pattern where ``newton_mjwarp = cube`` creates
    separate but equal dataclass instances after @configclass processing.
    """

    @configclass
    class SharedCfg:
        value: int = 42

    cube_val = SharedCfg()
    mjwarp_val = SharedCfg()

    @configclass
    class AliasedPresetCfg(PresetCfg):
        default: str = "d"
        cube: SharedCfg = cube_val
        newton_mjwarp: SharedCfg = mjwarp_val

    @configclass
    class AliasedEnvCfg:
        mode: AliasedPresetCfg = AliasedPresetCfg()

    env_cfg = AliasedEnvCfg()
    agent_cfg = PresetCfgAgentCfg()
    presets = {"env": collect_presets(env_cfg), "agent": collect_presets(agent_cfg)}
    assert presets["env"]["mode"]["cube"] is not presets["env"]["mode"]["newton_mjwarp"]
    assert presets["env"]["mode"]["cube"] == presets["env"]["mode"]["newton_mjwarp"]
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    apply_overrides(env_cfg, agent_cfg, hydra_cfg, ["cube", "newton_mjwarp"], [], [], presets)
    assert env_cfg.mode == SharedCfg()


# =============================================================================
# Tests: parse_overrides edge cases
# =============================================================================


def test_parse_overrides_multiple_global_presets():
    """Multiple comma-separated global presets are split correctly."""
    presets = {"env": {"backend": {"default": None, "newton_mjwarp": None}}, "agent": {}}
    global_p, _, _, _ = parse_overrides(["presets=fast,newton_mjwarp,debug"], presets)
    assert global_p == ["fast", "newton_mjwarp", "debug"]


def test_parse_overrides_maps_legacy_newton_preset_to_newton_mjwarp():
    """Legacy ``newton`` preset selections resolve to ``newton_mjwarp`` when available."""
    presets = {"env": {"backend": {"default": None, "newton_mjwarp": None}}, "agent": {}}
    legacy_name = "newton"

    global_p, sel, _, _ = parse_overrides(["presets=fast," + legacy_name, f"env.backend={legacy_name}"], presets)

    assert global_p == ["fast", "newton_mjwarp"]
    assert sel == [("env", "backend", "newton_mjwarp")]


def test_parse_overrides_maps_legacy_kamino_preset_to_newton_kamino():
    """Legacy ``kamino`` preset selections resolve to ``newton_kamino`` when available."""
    presets = {"env": {"solver": {"default": None, "newton_kamino": None}}, "agent": {}}
    legacy_name = "kamino"

    global_p, sel, _, _ = parse_overrides(["presets=" + legacy_name, f"env.solver={legacy_name}"], presets)

    assert global_p == ["newton_kamino"]
    assert sel == [("env", "solver", "newton_kamino")]


def test_apply_overrides_resolves_legacy_alias_in_global_and_path_selection(class_presets):
    """``apply_overrides`` resolves legacy names supplied directly (bypassing ``parse_overrides``)."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    with pytest.warns(FutureWarning, match="Preset 'newton' is deprecated"):
        apply_overrides(
            env_cfg,
            agent_cfg,
            hydra_cfg,
            global_presets=["newton"],
            preset_sel=[("env", "backend", "newton")],
            preset_scalar=[],
            presets=presets,
        )
    assert isinstance(env_cfg.backend, NewtonCfg)


def test_apply_overrides_legacy_and_current_alias_do_not_conflict(class_presets):
    """``presets=newton,newton_mjwarp`` (legacy + current) resolves to one preset, not a conflict."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    with pytest.warns(FutureWarning, match="Preset 'newton' is deprecated"):
        apply_overrides(env_cfg, agent_cfg, hydra_cfg, ["newton", "newton_mjwarp"], [], [], presets)
    assert isinstance(env_cfg.backend, NewtonCfg)


def test_parse_overrides_no_equals_treated_as_global_scalar():
    """Arguments without '=' are passed through as global scalars."""
    presets = {"env": {}, "agent": {}}
    _, _, _, global_scalar = parse_overrides(["--flag", "positional"], presets)
    assert "--flag" in global_scalar
    assert "positional" in global_scalar


def test_parse_overrides_preset_scalar_detection():
    """Scalar within a preset path is detected as preset_scalar."""
    presets = {"env": {"backend": {"default": None}}, "agent": {}}
    _, _, preset_scalar, _ = parse_overrides(["env.backend.dt=0.001", "env.backend.substeps=4"], presets)
    assert ("env.backend.dt", "0.001") in preset_scalar
    assert ("env.backend.substeps", "4") in preset_scalar


def test_parse_overrides_root_level_env_preset():
    """Root-level PresetCfg (path='') makes env=<name> a valid preset selection."""
    presets = {"env": {"": {"default": None, "fast": None}}, "agent": {}}
    _, sel, _, _ = parse_overrides(["env=fast"], presets)
    assert sel == [("env", "", "fast")]


# =============================================================================
# Tests: _parse_val
# =============================================================================


def test_parse_val_types():
    """_parse_val converts strings to correct Python types."""
    from isaaclab_tasks.utils.hydra import _parse_val

    assert _parse_val("true") is True
    assert _parse_val("True") is True
    assert _parse_val("false") is False
    assert _parse_val("none") is None
    assert _parse_val("null") is None
    assert _parse_val("42") == 42
    assert isinstance(_parse_val("42"), int)
    assert _parse_val("3.14") == 3.14
    assert isinstance(_parse_val("3.14"), float)
    assert _parse_val("hello") == "hello"
    assert _parse_val('"quoted"') == "quoted"
    assert _parse_val("'single'") == "single"


# =============================================================================
# Tests: scalar override within preset path
# =============================================================================


def test_scalar_override_within_preset_path(class_presets):
    """Scalar overrides within preset paths are applied on top of the preset."""
    env_cfg, agent_cfg, presets = class_presets
    hydra_cfg = {"env": env_cfg.to_dict(), "agent": agent_cfg.to_dict()}
    apply_overrides(
        env_cfg,
        agent_cfg,
        hydra_cfg,
        [],
        [("env", "backend", "newton_mjwarp")],
        [("env.backend.dt", "0.001")],
        presets,
    )
    assert isinstance(env_cfg.backend, NewtonCfg)
    assert env_cfg.backend.dt == 0.001
    assert env_cfg.backend.substeps == 4


# =============================================================================
# Tests: resolve_presets idempotency
# =============================================================================


def test_resolve_presets_idempotent():
    """Calling resolve_presets twice yields the same result."""
    cfg = PresetCfgEnvCfg()
    first = resolve_presets(cfg)
    second = resolve_presets(first)
    assert isinstance(second.backend, PhysxCfg)
    assert isinstance(second.observations, NoiselessObservationsCfg)
    assert second.backend.dt == first.backend.dt


def test_unknown_global_preset_name_detected():
    """A selected preset name that doesn't match any PresetCfg field is detected.

    This catches typos like presets=peg_insrt_4mm (missing 'e'). The validation
    in register_task raises ValueError before resolution begins.
    """
    cfg = PresetCfgEnvCfg()
    presets = {"env": collect_presets(cfg), "agent": {}}
    all_known = {name for alts in presets.values() for fields in alts.values() for name in fields if name != "default"}

    assert "newton_mjwarp" in all_known
    assert "typo_preset" not in all_known


def test_resolve_presets_errors_on_no_default():
    """A PresetCfg with no 'default' field and no matching selected name
    must raise ValueError, not silently linger or infinite loop."""

    @configclass
    class NoDefaultPreset(PresetCfg):
        option_a: int = 1

    @configclass
    class EnvCfg:
        mode: NoDefaultPreset = NoDefaultPreset()

    with pytest.raises(ValueError, match="no 'default' field"):
        resolve_presets(EnvCfg())


def test_resolve_presets_errors_on_chained_no_default():
    """A PresetCfg whose default is another PresetCfg with no 'default'
    must raise ValueError on the inner preset."""

    @configclass
    class InnerNoDefault(PresetCfg):
        option_a: int = 1

    @configclass
    class OuterPreset(PresetCfg):
        default: InnerNoDefault = InnerNoDefault()

    @configclass
    class EnvCfg:
        mode: OuterPreset = OuterPreset()

    with pytest.raises(ValueError, match="no 'default' field"):
        resolve_presets(EnvCfg())


def test_resolve_presets_errors_on_cyclic_preset():
    """Cyclic PresetCfg chain (A.default -> B, B.default -> A) must raise
    ValueError instead of looping forever."""

    @configclass
    class CyclicB(PresetCfg):
        pass

    @configclass
    class CyclicA(PresetCfg):
        default: CyclicB = CyclicB()

    CyclicA.default = CyclicB()
    CyclicB.default = CyclicA()

    @configclass
    class EnvCfg:
        mode: CyclicA = CyclicA()

    with pytest.raises(ValueError, match="[Cc]ycl"):
        resolve_presets(EnvCfg())


def test_resolve_presets_errors_on_cyclic_preset_at_root():
    """Cyclic PresetCfg at root level must raise ValueError, not RecursionError."""

    @configclass
    class RootCyclicB(PresetCfg):
        pass

    @configclass
    class RootCyclicA(PresetCfg):
        default: RootCyclicB = RootCyclicB()

    RootCyclicA.default = RootCyclicB()
    RootCyclicB.default = RootCyclicA()

    with pytest.raises(ValueError, match="[Cc]ycl"):
        resolve_presets(RootCyclicA())


# =============================================================================
# Tests: typed-selector validation (physics=/renderer= must hit their type)
# =============================================================================

from isaaclab.physics import PhysicsCfg as _RealPhysicsCfg  # noqa: E402

from isaaclab_tasks.utils.preset_target import PresetTarget  # noqa: E402


@configclass
class _NewtonPhysicsCfg(_RealPhysicsCfg):
    """Minimal real ``PhysicsCfg`` subclass so isinstance bucketing routes to PHYSICS."""

    dt: float = 0.002


@configclass
class _PhysxPhysicsCfg(_RealPhysicsCfg):
    dt: float = 0.005


def test_validate_typed_presets_passes_when_selector_hits_its_type():
    """``physics=newton_mjwarp`` that landed on a PhysicsCfg does not raise."""
    hydra_mod._validate_typed_presets(
        {PresetTarget.PHYSICS: {"newton_mjwarp"}},
        typed_hits={"newton_mjwarp": {PresetTarget.PHYSICS}},
    )


def test_validate_typed_presets_raises_when_selector_misses_its_type():
    """``physics=newton_mjwarp`` that never landed on a PhysicsCfg must raise."""
    with pytest.raises(ValueError, match="physics=newton_mjwarp"):
        hydra_mod._validate_typed_presets({PresetTarget.PHYSICS: {"newton_mjwarp"}}, typed_hits={})


def test_validate_typed_presets_ignores_broadcast_presets():
    """A plain ``presets=`` broadcast is never in ``requested``, so it is trusted."""
    # No typed selectors requested -> nothing to validate, even with no hits.
    hydra_mod._validate_typed_presets({}, typed_hits={})


def test_resolve_active_presets_records_physics_hit_for_selector():
    """End-to-end: selecting a name that resolves to a real PhysicsCfg records a PHYSICS hit."""

    @configclass
    class PhysicsPresetCfg(PresetCfg):
        default: _PhysxPhysicsCfg = _PhysxPhysicsCfg()
        newton_mjwarp: _NewtonPhysicsCfg = _NewtonPhysicsCfg()

    @configclass
    class EnvWithPhysicsCfg:
        physics: PhysicsPresetCfg = PhysicsPresetCfg()

    typed_hits: dict[str, set[PresetTarget]] = {}
    hydra_mod._resolve_active_presets(
        EnvWithPhysicsCfg(), ["newton_mjwarp"], {}, root_path="env", typed_hits=typed_hits
    )
    assert PresetTarget.PHYSICS in typed_hits.get("newton_mjwarp", set())
    # physics=newton_mjwarp therefore validates.
    hydra_mod._validate_typed_presets({PresetTarget.PHYSICS: {"newton_mjwarp"}}, typed_hits)


def test_resolve_active_presets_no_physics_hit_for_scalar_preset():
    """A name resolving only to a scalar records no typed hit, so a physics= selector raises."""

    @configclass
    class EnvWithScalarOnlyCfg:
        # ``newton_mjwarp`` here only tunes a scalar -- no PhysicsCfg involved.
        armature: PresetCfg = preset(default=0.0, newton_mjwarp=0.01)

    consumed: set[str] = set()
    typed_hits: dict[str, set[PresetTarget]] = {}
    hydra_mod._resolve_active_presets(
        EnvWithScalarOnlyCfg(),
        ["newton_mjwarp"],
        {},
        root_path="env",
        consumed_selected=consumed,
        typed_hits=typed_hits,
    )
    assert "newton_mjwarp" in consumed and PresetTarget.PHYSICS not in typed_hits.get("newton_mjwarp", set())
    # presets=newton_mjwarp (broadcast) is trusted: no entry in ``requested`` -> no error.
    hydra_mod._validate_typed_presets({}, typed_hits)
    # physics=newton_mjwarp (typed selector) must error.
    with pytest.raises(ValueError, match="physics=newton_mjwarp"):
        hydra_mod._validate_typed_presets({PresetTarget.PHYSICS: {"newton_mjwarp"}}, typed_hits)