"""Stand-ins for the rclpy *executor* layer only (new code, 2026).

The released controller (path_follower.py) subclasses rclpy.node.Node and uses
it for parameters, subscriptions, a publisher, a wall-clock timer and a logger.
For lock-step execution we replace exactly that layer:

* parameters: declare_parameters/get_parameter return the configured values
  (controller, ref_path, exp_index) with the released defaults otherwise;
* create_subscription/create_timer: recorded but never driven by an executor
  (the episode loop calls state_callback/vel_callback/pub_callback itself, in
  simulation time);
* create_publisher(...).publish(msg): appends msg to node._published, so the
  published DriverInputs message is intercepted unchanged;
* get_logger(): a no-op logger (log text has no numerical effect).

Message classes (geometry_msgs, chrono_ros_interfaces, ...) are NOT stubbed:
the real ROS 2 Humble Python message types from the image are used, so field
type checks/assertions behave exactly as in the released node.
"""
import sys
import types

_INSTALLED = False


class _ParameterValue:
    def __init__(self, value):
        self.string_value = value if isinstance(value, str) else ''
        self.integer_value = value if (isinstance(value, int) and not isinstance(value, bool)) else 0
        self.double_value = float(value) if isinstance(value, float) else 0.0
        self.bool_value = value if isinstance(value, bool) else False


class _Parameter:
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def get_parameter_value(self):
        return _ParameterValue(self.value)


class _Logger:
    def __init__(self):
        self.n_messages = 0

    def _log(self, *args, **kwargs):
        self.n_messages += 1

    info = warn = warning = error = debug = fatal = _log


class _Publisher:
    def __init__(self, sink, topic):
        self._sink = sink
        self.topic = topic

    def publish(self, msg):
        self._sink.append(msg)


class Node:
    """Minimal replacement for rclpy.node.Node (see module docstring)."""

    # Parameter overrides for the next constructed node; set by the bridge.
    parameter_overrides = {}

    def __init__(self, node_name, *args, **kwargs):
        self._node_name = node_name
        self._parameters = {}
        self._published = []
        self._subscriptions = []
        self._timers = []
        self._publishers = []
        self._logger = _Logger()

    def declare_parameters(self, namespace, parameters):
        for p in parameters:
            name, default = p[0], p[1]
            self._parameters[name] = Node.parameter_overrides.get(name, default)

    def get_parameter(self, name):
        return _Parameter(name, self._parameters[name])

    def create_subscription(self, msg_type, topic, callback, qos_profile, **kwargs):
        self._subscriptions.append((msg_type, topic, callback, qos_profile))
        return object()

    def create_publisher(self, msg_type, topic, qos_profile, **kwargs):
        pub = _Publisher(self._published, topic)
        self._publishers.append((msg_type, topic, qos_profile))
        return pub

    def create_timer(self, period, callback, **kwargs):
        self._timers.append((period, callback))
        return object()

    def get_logger(self):
        return self._logger

    def destroy_node(self):
        pass


class QoSHistoryPolicy:
    KEEP_LAST = 1
    KEEP_ALL = 2


class QoSProfile:
    def __init__(self, depth=10, **kwargs):
        self.depth = depth
        self.history = QoSHistoryPolicy.KEEP_LAST


def install():
    """Install the stub rclpy modules into sys.modules (idempotent)."""
    global _INSTALLED
    if _INSTALLED:
        return
    rclpy = types.ModuleType('rclpy')
    rclpy.__file__ = __file__
    rclpy.init = lambda *a, **k: None
    rclpy.spin = lambda *a, **k: None
    rclpy.shutdown = lambda *a, **k: None
    rclpy.ok = lambda *a, **k: True
    node_mod = types.ModuleType('rclpy.node')
    node_mod.Node = Node
    qos_mod = types.ModuleType('rclpy.qos')
    qos_mod.QoSHistoryPolicy = QoSHistoryPolicy
    qos_mod.QoSProfile = QoSProfile
    rclpy.node = node_mod
    rclpy.qos = qos_mod
    sys.modules['rclpy'] = rclpy
    sys.modules['rclpy.node'] = node_mod
    sys.modules['rclpy.qos'] = qos_mod
    _INSTALLED = True