def close(self) -> None:
    """Closes the connection (alias for disconnect)."""
    self.disconnect()

def connect(self) -> None:
    """Connects to the VISA resource."""
    if self.instrument is not None:
        # Already connected or connection attempt made, ensure clean state if re-connecting
        try:
            self.instrument.close()
        except Exception:
            # Ignore errors on close if already disconnected or in bad state
            pass
        self.instrument = None

    try:
        # Type ignore for open_resource as pyvisa's stubs might not be perfectly aligned
        # with all resource types, but MessageBasedResource is common.
        resource = self.rm.open_resource(self.address)
        if not isinstance(resource, pyvisa.resources.MessageBasedResource):
            raise InstrumentConnectionError(
                f"Resource at {self.address} is not a MessageBasedResource. Type: {type(resource).__name__}"
            )
        self.instrument = resource
        self.instrument.timeout = self._timeout_ms  # pyvisa timeout is in milliseconds
    except pyvisa.Error as e:  # Catch specific pyvisa errors
        raise InstrumentConnectionError(
            f"Failed to connect to VISA resource {self.address}: {e}"
        ) from e
    except Exception as e:  # Catch other potential errors during connection
        raise InstrumentConnectionError(
            f"An unexpected error occurred while connecting to VISA resource {self.address}: {e}"
        ) from e

def disconnect(self) -> None:
    """Disconnects from the VISA resource."""
    if self.instrument is not None:
        try:
            self.instrument.close()
        except pyvisa.Error as e:
            # Log or handle error during close if necessary
            raise InstrumentConnectionError(
                f"Error disconnecting from VISA resource {self.address}: {e}"
            ) from e
        except Exception as e:
            raise InstrumentConnectionError(
                f"An unexpected error occurred while disconnecting VISA resource {self.address}: {e}"
            ) from e
        finally:
            self.instrument = None

def get_timeout(self) -> int:
    """Gets the communication timeout in milliseconds."""
    # Return the locally stored timeout, as reading from instrument might not always be reliable
    # or could cause unnecessary communication. The local value is the source of truth for new connections
    # and attempts to set it on the instrument.
    return self._timeout_ms

def query(self, cmd: str, delay: float | None = None) -> str:
    """Sends a query to the instrument and returns the string response."""
    if self.instrument is None:
        raise InstrumentConnectionError("Not connected to VISA resource. Call connect() first.")
    try:
        response = self.instrument.query(cmd, delay=delay)
        return response.strip()
    except pyvisa.Error as e:  # pyvisa.VisaIOError is a common one here
        raise InstrumentCommunicationError(
            f"Failed to query '{cmd}' from {self.address}: {e}"
        ) from e
    except Exception as e:
        raise InstrumentCommunicationError(
            f"An unexpected error occurred querying '{cmd}' from {self.address}: {e}"
        ) from e

def query_raw(self, cmd: str, delay: float | None = None) -> bytes:
    """Sends a query and returns the raw bytes response."""
    if self.instrument is None:
        raise InstrumentConnectionError("Not connected to VISA resource. Call connect() first.")
    try:
        # pyvisa's query_binary_values might be more appropriate for some raw data,
        # but query_ascii_values(..., converter='s') or direct read after write can also work.
        # For simplicity and generality, using write then read_raw.
        # Ensure the instrument is configured for binary transfer if needed.
        self.instrument.write(cmd)
        if delay is not None:
            time.sleep(delay)
        data = self.instrument.read_bytes(self.instrument.chunk_size)  # Or read_raw()
        return data
    except pyvisa.Error as e:
        raise InstrumentCommunicationError(
            f"Failed to query_raw '{cmd}' from {self.address}: {e}"
        ) from e
    except Exception as e:
        raise InstrumentCommunicationError(
            f"An unexpected error occurred during query_raw '{cmd}' from {self.address}: {e}"
        ) from e

def set_timeout(self, timeout_ms: int) -> None:
    """Sets the communication timeout in milliseconds."""
    if timeout_ms <= 0:
        raise ValueError("Timeout must be positive.")
    self._timeout_ms = timeout_ms
    if self.instrument:
        try:
            self.instrument.timeout = timeout_ms
        except pyvisa.Error as e:
            # Log this, but don't necessarily fail the operation if instrument is disconnected
            # or doesn't support dynamic timeout setting in its current state.
            # Consider raising InstrumentConfigurationError if strictness is required.
            print(
                f"Warning: Could not set timeout on VISA resource {self.address} (instrument may be disconnected or unresponsive): {e}"
            )
        except Exception as e:
            print(
                f"Warning: An unexpected error occurred setting timeout on VISA resource {self.address}: {e}"
            )

def write(self, cmd: str) -> None:
    """Writes a command to the instrument."""
    if self.instrument is None:
        raise InstrumentConnectionError("Not connected to VISA resource. Call connect() first.")
    try:
        self.instrument.write(cmd)
    except pyvisa.Error as e:
        raise InstrumentCommunicationError(
            f"Failed to write command '{cmd}' to {self.address}: {e}"
        ) from e
    except Exception as e:
        raise InstrumentCommunicationError(
            f"An unexpected error occurred writing command '{cmd}' to {self.address}: {e}"
        ) from e

def close(self) -> None:
    self.disconnect()

def connect(self) -> None:
    """
    Ensures the instrument is registered with Lamb and ready.
    """
    self._ensure_connected()
    # Optionally, ping instrument status endpoint here
    lamb_logger.info(f"Connected to Lamb instrument '{self.instrument_address}'.")

def disconnect(self) -> None:
    lamb_logger.info(
        f"LambBackend for '{self.instrument_address}' disconnected (simulated, as client is per-request or context-managed)."
    )
    pass

def get_timeout(self) -> int:
    return int(self._timeout_sec * 1000)

def query(self, cmd: str, delay: float | None = None) -> str:
    self._ensure_connected()
    lamb_logger.debug(f"QUERY to '{self.instrument_address}': {cmd}")
    try:
        with httpx.Client(timeout=self._timeout_sec) as client:
            response = client.post(
                f"{self.base_url}/instrument/query",
                json={"visa_string": self.instrument_address, "command": cmd},
                headers={"Accept": "application/json", "Accept-Charset": "utf-8"},
            )
            response.raise_for_status()
            content: str = response.content.decode("utf-8")
            return content.strip()
    except httpx.HTTPStatusError as e:
        raise InstrumentCommunicationError(
            f"Lamb server query failed: {e.response.status_code} - {e.response.text}"
        ) from e
    except httpx.RequestError as e:
        raise InstrumentCommunicationError(f"Network error during Lamb query: {e}") from e

def query_raw(self, cmd: str, delay: float | None = None) -> bytes:
    self._ensure_connected()
    lamb_logger.debug(f"QUERY_RAW to '{self.instrument_address}': {cmd}")
    try:
        with httpx.Client(timeout=self._timeout_sec) as client:
            response = client.post(
                f"{self.base_url}/instrument/query_raw",
                json={"visa_string": self.instrument_address, "command": cmd},
                headers={"Accept": "application/octet-stream"},
            )
            response.raise_for_status()
            return response.content
    except httpx.HTTPStatusError as e:
        raise InstrumentCommunicationError(
            f"Lamb server query_raw failed: {e.response.status_code} - {e.response.text}"
        ) from e
    except httpx.RequestError as e:
        raise InstrumentCommunicationError(f"Network error during Lamb query_raw: {e}") from e

def set_timeout(self, timeout_ms: int) -> None:
    if timeout_ms <= 0:
        self._timeout_sec = 0.001
    else:
        self._timeout_sec = timeout_ms / 1000.0
    lamb_logger.debug(f"LambBackend timeout set to {self._timeout_sec} seconds.")

def write(self, cmd: str) -> None:
    self._ensure_connected()
    lamb_logger.debug(f"WRITE to '{self.instrument_address}': {cmd}")
    try:
        with httpx.Client(timeout=self._timeout_sec) as client:
            response = client.post(
                f"{self.base_url}/instrument/write",
                json={"visa_string": self.instrument_address, "command": cmd},
                headers={"Accept": "application/json", "Accept-Charset": "utf-8"},
            )
            response.raise_for_status()
    except httpx.HTTPStatusError as e:
        raise InstrumentCommunicationError(
            f"Lamb server write failed: {e.response.status_code} - {e.response.text}"
        ) from e
    except httpx.RequestError as e:
        raise InstrumentCommunicationError(f"Network error during Lamb write: {e}") from e

def close(self) -> None:
    self.disconnect()

def connect(self) -> None:  # noqa: D401
    "Establish connection (no-op in simulation)."
    logger.debug("%s: connect()", self.model)

def disconnect(self) -> None:
    "Close connection (no-op)."
    logger.debug("%s: disconnect()", self.model)

def get_timeout(self) -> int:
    return self.timeout_ms

def query(self, cmd: str, delay: float | None = None) -> str:
    "Handle a SCPI query and return a **decoded** string."
    if delay:
        time.sleep(delay)
    response = self._handle_command(cmd, expect_response=True)
    if isinstance(response, bytes):
        resp_str = response.decode("utf-8", errors="ignore")
    else:
        resp_str = response
    logger.debug("%s QUERY ‹%s› → %s", self.model, cmd.strip(), resp_str)
    return resp_str

def query_raw(self, cmd: str, delay: float | None = None) -> bytes:
    if delay:
        time.sleep(delay)
    # Execute in raw mode to preserve binary responses
    resp = self._handle_command_raw(cmd)
    return resp

def set_timeout(self, timeout_ms: int) -> None:
    self.timeout_ms = timeout_ms

def write(self, cmd: str) -> None:
    "Handle a SCPI write."
    logger.debug("%s WRITE ‹%s›", self.model, cmd.strip())
    self._handle_command(cmd)

def __getattr__(self, name):
    """Delegate other attributes to the wrapped backend."""
    return getattr(self.backend, name)

def close(self):
    """Close the backend and write the simulation profile."""
    if hasattr(self.backend, "close") and callable(self.backend.close):
        self.backend.close()
    print("DEBUG: Calling generate_profile from RecordingBackend.close()")
    self.generate_profile()

def generate_profile(self):
    """Generate the YAML simulation profile from the log."""
    print(f"DEBUG: generate_profile called. Output path: {self.output_path}")
    scpi_map = {}
    for entry in self.log:
        if entry["type"] == "query":
            scpi_map[entry["command"]] = entry["response"]
        elif entry["type"] == "query_raw":
            command_slug = re.sub(r"[^a-zA-Z0-9]", "_", entry["command"])
            binary_filename = f"{command_slug}.bin"
            binary_filepath = Path(self.output_path).parent / binary_filename
            with open(binary_filepath, "wb") as f:
                f.write(entry["response"])
            scpi_map[entry["command"]] = {"binary": binary_filename}
        elif entry["type"] == "write":
            # For writes, we record the command with an empty response,
            # which is suitable for commands that don't return a value.
            scpi_map[entry["command"]] = ""

    profile = self.base_profile
    if "simulation" not in profile:
        profile["simulation"] = {}
    profile["simulation"]["scpi"] = scpi_map
    print(f"DEBUG: Profile data to be written: {profile}")
    if self.output_path:
        try:
            output_file = Path(self.output_path)
            print(f"DEBUG: Creating parent directory for {output_file}")
            output_file.parent.mkdir(parents=True, exist_ok=True)
            print(f"DEBUG: Writing to file {output_file}")
            with open(output_file, "w") as f:
                yaml.dump(profile, f, sort_keys=False)
            print("DEBUG: File write complete.")
            LOGGER.info(f"Simulation profile saved to {self.output_path}")
        except Exception as e:
            print(f"DEBUG: ERROR in generate_profile: {e}")
    else:
        # In a real scenario, this would go to a user cache directory.
        # For now, let's just print it if no path is provided.
        print("DEBUG: No output path provided. Printing to stdout.")
        print(yaml.dump(profile, sort_keys=False))

def query(self, command: str, *args, **kwargs):
    """Query to the instrument, log it, and return the response."""
    if hasattr(self.backend, "query") and callable(self.backend.query):
        response = self.backend.query(command, *args, **kwargs)
        self.log.append(
            {
                "type": "query",
                "command": command.strip(),
                "response": getattr(response, "strip", lambda: response)(),
            }
        )
        return response
    raise NotImplementedError("Backend does not support query method.")

def query_raw(self, command: str, *args, **kwargs):
    """Query to the instrument, log it, and return the response."""
    if hasattr(self.backend, "query_raw") and callable(self.backend.query_raw):
        response = self.backend.query_raw(command, *args, **kwargs)
        self.log.append({"type": "query_raw", "command": command.strip(), "response": response})
        return response
    raise NotImplementedError("Backend does not support query_raw method.")

def read(self) -> str:
    """Read from the instrument and log it."""
    response = self.backend.read()
    self.log.append({"type": "read", "response": response.strip()})
    return response

def write(self, command: str, *args, **kwargs):
    """Write a command to the instrument and log it."""
    self.log.append({"type": "write", "command": command.strip()})
    if hasattr(self.backend, "write") and callable(self.backend.write):
        result = self.backend.write(command, *args, **kwargs)
        return result
    raise NotImplementedError("Backend does not support write method.")

def close(self) -> None:
    """Close the backend connection."""
    self.disconnect()

def connect(self) -> None:
    LOGGER.debug("ReplayBackend for '%s': Connected.", self._model_name)

def disconnect(self) -> None:
    LOGGER.debug("ReplayBackend for '%s': Disconnected.", self._model_name)

@classmethod
def from_session_file(cls, session_file: str | Path, profile_key: str) -> "ReplayBackend":
    """Create a ReplayBackend from a session file."""
    return cls(session_file, profile_key)

def get_timeout(self) -> int:
    """Get timeout (returns default for replay)."""
    return 5000  # Default value

def query(self, cmd: str, delay: float | None = None) -> str:
    """Execute a query command and return the response."""
    entry = self._get_next_log_entry("query", cmd)
    return entry.get("response", "")

def query_raw(self, cmd: str, delay: float | None = None) -> bytes:
    """Execute a raw query command and return bytes response."""
    entry = self._get_next_log_entry("query_raw", cmd)
    # Assuming the response is stored as a string that needs encoding
    return str(entry.get("response", "")).encode("utf-8")

def set_timeout(self, timeout_ms: int) -> None:
    """Set timeout (no-op for replay)."""
    pass

def write(self, cmd: str) -> None:
    """Execute a write command."""
    self._get_next_log_entry("write", cmd)

def close(self):
    # The file writing is now handled by save_session or CLI command
    self.original_backend.close()

def connect(self) -> None:
    self.original_backend.connect()

def disconnect(self) -> None:
    self.original_backend.disconnect()

def get_timeout(self) -> int:
    return self.original_backend.get_timeout()

def query(self, cmd: str, delay: float | None = None) -> str:
    # Handle the case where the underlying backend doesn't support delay parameter
    try:
        response = self.original_backend.query(cmd, delay=delay)
    except TypeError:
        # Fallback for backends that don't support delay parameter
        response = self.original_backend.query(cmd)

    self._log_event({"type": "query", "command": cmd.strip(), "response": response.strip()})
    return response

def query_raw(self, cmd: str, delay: float | None = None) -> bytes:
    try:
        response = self.original_backend.query_raw(cmd, delay=delay)
    except TypeError:
        response = self.original_backend.query_raw(cmd)

    # Note: Storing raw bytes in YAML is tricky. Consider base64 encoding for robustness.
    # For simplicity here, we'll decode assuming it's representable as a string.
    try:
        response_str = response.decode("utf-8", errors="ignore")
    except Exception:
        response_str = f"<binary data of length {len(response)}>"

    self._log_event({"type": "query_raw", "command": cmd.strip(), "response": response_str})
    return response

def save_session(self, profile_key: str):
    """Save the recorded session to the output file."""
    if self.output_file is None:
        # No file output configured, session is stored in the list
        return

    # Map profile keys to instrument types for test compatibility
    instrument_key = self._get_instrument_key(profile_key)

    session_data = {instrument_key: {"profile": profile_key, "log": self._command_log}}

    # Load existing session data if file exists
    existing_data: dict[str, Any] = {}
    if os.path.exists(self.output_file):
        try:
            with open(self.output_file) as f:
                existing_data = yaml.safe_load(f) or {}
        except Exception:
            # If file is corrupted or empty, start fresh
            existing_data = {}

    # Merge with existing data
    existing_data.update(session_data)

    # Create parent directory if it doesn't exist
    try:
        os.makedirs(os.path.dirname(self.output_file), exist_ok=True)
    except (OSError, PermissionError) as e:
        raise FileNotFoundError(f"Cannot create directory for {self.output_file}: {e}") from e

    # Write to file
    with open(self.output_file, "w") as f:
        yaml.dump(existing_data, f, default_flow_style=False)

def set_timeout(self, timeout_ms: int) -> None:
    self.original_backend.set_timeout(timeout_ms)

def write(self, cmd: str) -> None:
    self._log_event({"type": "write", "command": cmd.strip()})
    self.original_backend.write(cmd)