RETURN_CODE,{PAYLOAD},ECHO();

flowchart LR
    A["Command request"] --> B["Validate schema/frame/envelope"]
    B --> C["QUEUED"]
    C --> D["Mock command channel"]
    D --> E["Framer + synthetic parser"]
    E --> F{"ACK and state agree?"}
    F -->|"yes"| G["COMPLETE"]
    B -->|"invalid"| X["REJECTED"]
    D -->|"timeout/disconnect"| Y["STOPPED"]
    F -->|"no"| Z["FAULT"]

{
  "profile": "SYNTHETIC_MG400_OFFLINE_ONLY",
  "units": "mm",
  "frame": "SYNTHETIC_USER",
  "timeout_ticks": 3,
  "max_queue": 8,
  "envelope_mm": {
    "x": [-100.0, 100.0],
    "y": [-100.0, 100.0],
    "z": [0.0, 120.0],
    "r_deg": [-180.0, 180.0]
  },
  "allowed_mock_kinds": ["PLAN_JOINT", "PLAN_LINEAR", "BARRIER"]
}

Transport: MOCK_ONLY
State channel: in-memory
Command channel: in-memory
Physical command serialization: absent

# safe-smoke
from __future__ import annotations

import json
import math
import re
from dataclasses import dataclass
from enum import Enum
from pathlib import Path


class DriverError(RuntimeError):
    pass


class RobotMode(str, Enum):
    IDLE = "IDLE"
    READY = "READY"
    EXECUTING = "EXECUTING"
    STOPPED = "STOPPED"
    FAULT = "FAULT"


@dataclass(frozen=True)
class Pose:
    x: float
    y: float
    z: float
    r: float


@dataclass(frozen=True)
class Command:
    command_id: int
    kind: str
    pose: Pose | None = None


@dataclass(frozen=True)
class SyntheticReply:
    return_code: int
    payload: str
    echo: str


@dataclass(frozen=True)
class DriverConfig:
    profile: str
    frame: str
    timeout_ticks: int
    max_queue: int
    envelope: dict[str, tuple[float, float]]
    allowed_kinds: frozenset[str]


def parse_config_text(text: str) -> DriverConfig:
    raw = json.loads(text)
    expected = {"profile", "units", "frame", "timeout_ticks", "max_queue", "envelope_mm", "allowed_mock_kinds"}
    if not isinstance(raw, dict) or set(raw) != expected:
        raise DriverError("неправильна schema profile")
    if raw["profile"] != "SYNTHETIC_MG400_OFFLINE_ONLY" or raw["units"] != "mm" or raw["frame"] != "SYNTHETIC_USER":
        raise DriverError("дозволено лише synthetic offline profile")
    if not isinstance(raw["timeout_ticks"], int) or not 1 <= raw["timeout_ticks"] <= 100:
        raise DriverError("timeout_ticks поза межею")
    if not isinstance(raw["max_queue"], int) or not 1 <= raw["max_queue"] <= 100:
        raise DriverError("max_queue поза межею")
    axes = {"x", "y", "z", "r_deg"}
    if not isinstance(raw["envelope_mm"], dict) or set(raw["envelope_mm"]) != axes:
        raise DriverError("неповний envelope")
    envelope: dict[str, tuple[float, float]] = {}
    for axis, limits in raw["envelope_mm"].items():
        if not isinstance(limits, list) or len(limits) != 2 or limits[0] >= limits[1]:
            raise DriverError(f"невалідна межа {axis}")
        envelope[axis] = (float(limits[0]), float(limits[1]))
    kinds = raw["allowed_mock_kinds"]
    allowed = {"PLAN_JOINT", "PLAN_LINEAR", "BARRIER"}
    if not isinstance(kinds, list) or set(kinds) != allowed:
        raise DriverError("allowed_mock_kinds має бути точним whitelist")
    return DriverConfig(raw["profile"], raw["frame"], raw["timeout_ticks"], raw["max_queue"], envelope, frozenset(kinds))


def load_config(path: Path) -> DriverConfig:
    return parse_config_text(path.read_text(encoding="utf-8"))


class SemicolonFramer:
    def __init__(self, max_record: int = 256) -> None:
        self.buffer = bytearray()
        self.max_record = max_record

    def feed(self, chunk: bytes) -> list[bytes]:
        self.buffer.extend(chunk)
        if len(self.buffer) > self.max_record and b";" not in self.buffer:
            self.buffer.clear()
            raise DriverError("synthetic record завеликий")
        records: list[bytes] = []
        while (index := self.buffer.find(b";")) >= 0:
            records.append(bytes(self.buffer[:index + 1]))
            del self.buffer[:index + 1]
        return records


REPLY_RE = re.compile(r"^(-?\d+),\{([^{}]*)\},([A-Za-z][A-Za-z0-9_]*\([^;]*\));$")


def parse_synthetic_reply(record: bytes) -> SyntheticReply:
    try:
        text = record.decode("utf-8")
    except UnicodeDecodeError as exc:
        raise DriverError("response не є UTF-8") from exc
    match = REPLY_RE.fullmatch(text)
    if not match:
        raise DriverError("невалідний synthetic response")
    return SyntheticReply(int(match.group(1)), match.group(2), match.group(3))


class MockStateChannel:
    def __init__(self) -> None:
        self.mode = RobotMode.IDLE
        self.available = True

    def read(self) -> RobotMode:
        if not self.available:
            raise DriverError("state channel unavailable")
        return self.mode


class MockCommandChannel:
    def __init__(self, latency_ticks: int = 1) -> None:
        self.latency_ticks = latency_ticks
        self.available = True

    def execute(self, command: Command, timeout_ticks: int) -> SyntheticReply:
        if not self.available:
            raise DriverError("command channel unavailable")
        if self.latency_ticks > timeout_ticks:
            raise DriverError("mock timeout")
        return SyntheticReply(0, "ACK", f"{command.kind}()")


class MockRobotDriver:
    def __init__(self, config: DriverConfig, state: MockStateChannel, command: MockCommandChannel) -> None:
        self.config = config
        self.state_channel = state
        self.command_channel = command
        self.lifecycle: list[tuple[int, str]] = []

    def prepare_mock(self) -> None:
        if self.state_channel.read() != RobotMode.IDLE:
            raise DriverError("початковий mock-mode не IDLE")
        self.state_channel.mode = RobotMode.READY

    def _validate_pose(self, pose: Pose) -> None:
        values = {"x": pose.x, "y": pose.y, "z": pose.z, "r_deg": pose.r}
        for axis, value in values.items():
            if not math.isfinite(value):
                raise DriverError("pose містить не скінченне число")
            low, high = self.config.envelope[axis]
            if not low <= value <= high:
                raise DriverError(f"{axis} поза synthetic envelope")

    def validate_queue(self, commands: list[Command]) -> None:
        if not 1 <= len(commands) <= self.config.max_queue:
            raise DriverError("черга поза межею")
        ids = [command.command_id for command in commands]
        if len(ids) != len(set(ids)):
            raise DriverError("command_id має бути унікальним")
        for command in commands:
            if command.kind not in self.config.allowed_kinds:
                raise DriverError("kind не дозволений")
            if command.kind == "BARRIER" and command.pose is not None:
                raise DriverError("BARRIER не має pose")
            if command.kind != "BARRIER":
                if command.pose is None:
                    raise DriverError("план руху потребує pose")
                self._validate_pose(command.pose)

    def stop(self, reason: str) -> None:
        self.state_channel.mode = RobotMode.STOPPED
        self.lifecycle.append((-1, f"STOPPED:{reason}"))

    def submit(self, command: Command) -> SyntheticReply:
        try:
            mode = self.state_channel.read()
        except DriverError:
            self.stop("state unavailable")
            raise
        if mode != RobotMode.READY:
            raise DriverError("mock-driver не READY")
        self.validate_queue([command])
        self.lifecycle.extend([(command.command_id, "VALIDATED"), (command.command_id, "QUEUED")])
        self.state_channel.mode = RobotMode.EXECUTING
        try:
            reply = self.command_channel.execute(command, self.config.timeout_ticks)
        except DriverError as exc:
            self.stop(str(exc))
            raise
        self.lifecycle.append((command.command_id, "MOCK_SENT"))
        if reply.return_code != 0 or reply.echo != f"{command.kind}()":
            self.state_channel.mode = RobotMode.FAULT
            self.lifecycle.append((command.command_id, "ERROR"))
            raise DriverError("ACK/echo не узгоджені")
        self.lifecycle.extend([(command.command_id, "ACK"), (command.command_id, "COMPLETE")])
        self.state_channel.mode = RobotMode.READY
        return reply


fixture = {
    "profile": "SYNTHETIC_MG400_OFFLINE_ONLY",
    "units": "mm",
    "frame": "SYNTHETIC_USER",
    "timeout_ticks": 3,
    "max_queue": 8,
    "envelope_mm": {"x": [-100.0, 100.0], "y": [-100.0, 100.0], "z": [0.0, 120.0], "r_deg": [-180.0, 180.0]},
    "allowed_mock_kinds": ["PLAN_JOINT", "PLAN_LINEAR", "BARRIER"],
}

config = parse_config_text(json.dumps(fixture))
framer = SemicolonFramer()
assert framer.feed(b"0,{READY},RobotMo") == []
records = framer.feed(b"de();0,{DONE},Barrier();")
assert len(records) == 2
assert parse_synthetic_reply(records[0]) == SyntheticReply(0, "READY", "RobotMode()")
assert parse_synthetic_reply(records[1]).payload == "DONE"

state = MockStateChannel()
driver = MockRobotDriver(config, state, MockCommandChannel(latency_ticks=1))
driver.prepare_mock()
reply = driver.submit(Command(1, "PLAN_LINEAR", Pose(10.0, 20.0, 30.0, 0.0)))
assert reply.payload == "ACK" and state.mode == RobotMode.READY
assert [status for cid, status in driver.lifecycle if cid == 1] == ["VALIDATED", "QUEUED", "MOCK_SENT", "ACK", "COMPLETE"]

try:
    driver.submit(Command(2, "PLAN_JOINT", Pose(101.0, 0.0, 10.0, 0.0)))
except DriverError as exc:
    assert "envelope" in str(exc)
else:
    raise AssertionError("pose поза envelope має бути відхилена")

slow_state = MockStateChannel()
slow = MockRobotDriver(config, slow_state, MockCommandChannel(latency_ticks=4))
slow.prepare_mock()
try:
    slow.submit(Command(3, "BARRIER"))
except DriverError as exc:
    assert "timeout" in str(exc)
else:
    raise AssertionError("timeout має зупинити mock")
assert slow_state.mode == RobotMode.STOPPED

lost_state = MockStateChannel()
lost = MockRobotDriver(config, lost_state, MockCommandChannel())
lost.prepare_mock()
lost_state.available = False
try:
    lost.submit(Command(4, "BARRIER"))
except DriverError as exc:
    assert "unavailable" in str(exc)
else:
    raise AssertionError("втрата state channel має бути виявлена")
assert lost_state.mode == RobotMode.STOPPED

try:
    parse_synthetic_reply(b"0,{ACK},Broken")
except DriverError:
    pass
else:
    raise AssertionError("незавершений synthetic record має бути відхилений")

print(json.dumps({"result": "PASS", "checks": 9, "transport": "IN_MEMORY_MOCK", "network": False}, ensure_ascii=False))

python -m py_compile lab13_mg400_mock.py
python lab13_mg400_mock.py

chunk 1: incomplete -> buffer only
chunk 2: complete record 1 + complete record 2 -> two records
leftover: preserved until next chunk

VALIDATED -> QUEUED -> MOCK_SENT -> ACK -> COMPLETE

python lab13_mg400_mock.py