rpc.cpp

Go to the documentation of this file.

 
 
#include "profinet/rpc.h"
 
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <random>
#include <ranges>
#include <sstream>
 
#include "profinet/cyclic.h"
 
namespace profinet::rpc
{
// NOLINTBEGIN(readability-identifier-naming)
// RPC blocks
inline constexpr std::uint8_t VERSION_HIGH = 0x01;
inline constexpr std::uint8_t VERSION_LOW = 0x00;
// NOLINTEND(readability-identifier-naming)
 
namespace
{
 
std::array<std::uint8_t, uuidLenght> RandomUuidBytes()
{
  static thread_local std::mt19937 rng{std::random_device{}()};
  static constexpr int maxByteValue = 255;
  static thread_local std::uniform_int_distribution<int> dist(0, maxByteValue);
  std::array<std::uint8_t, uuidLenght> out{};
  for (auto& b : out)
  {
    b = static_cast<std::uint8_t>(dist(rng));
  }
  return out;
}
 
std::uint16_t RandomNonzeroU16()
{
  static thread_local std::mt19937 rng{std::random_device{}()};
 
  static constexpr int maxU16Value = 0xFFFF;
  static thread_local std::uniform_int_distribution<int> dist(0, maxU16Value);
  const int v = dist(rng);
  return static_cast<std::uint16_t>(v == 0 ? 1 : v);
}
 
std::array<std::uint8_t, uuidLenght> BuildObjectUuid(std::uint8_t b10, std::uint8_t b11, std::uint8_t b12, std::uint8_t b13,
                                                     std::uint8_t b14, std::uint8_t b15)
{
  // OBJECT_UUID_PREFIX (10 bytes, per protocol.py): DE A0 00 00 + first 6
  // bytes of the shared PROFINET UUID suffix (6C 97 11 D1 82 71).
 
  // Protocol constant hex values for the header
  static constexpr std::uint8_t pnPrefixByte0 = 0xDE;
  static constexpr std::uint8_t pnPrefixByte1 = 0xA0;
  static constexpr std::uint8_t pnPrefixByte2 = 0x00;
  static constexpr std::uint8_t pnPrefixByte3 = 0x00;
 
  // UUID field indices mapped to official UUID structure
  static constexpr std::size_t uuidIdxTimeLow0 = 0;
  static constexpr std::size_t uuidIdxTimeLow1 = 1;
  static constexpr std::size_t uuidIdxTimeLow2 = 2;
  static constexpr std::size_t uuidIdxTimeLow3 = 3;
 
  static constexpr std::size_t uuidIdxTimeMid0 = 4;
  static constexpr std::size_t suffixBytesToCopy = 6;
 
  static constexpr std::size_t uuidIdxNode0 = 10;
  static constexpr std::size_t uuidIdxNode1 = 11;
  static constexpr std::size_t uuidIdxNode2 = 12;
  static constexpr std::size_t uuidIdxNode3 = 13;
  static constexpr std::size_t uuidIdxNode4 = 14;
  static constexpr std::size_t uuidIdxNode5 = 15;
 
  std::array<std::uint8_t, uuidLenght> objectUuid{};
 
  // Write the fixed 4-byte PROFINET protocol prefix (into time_low)
  objectUuid[uuidIdxTimeLow0] = pnPrefixByte0;
  objectUuid[uuidIdxTimeLow1] = pnPrefixByte1;
  objectUuid[uuidIdxTimeLow2] = pnPrefixByte2;
  objectUuid[uuidIdxTimeLow3] = pnPrefixByte3;
 
  // Copy the 6-byte shared suffix (populates time_mid, time_hi, and clock_seq)
  std::ranges::copy(kPnUuidSuffix | std::views::take(suffixBytesToCopy),
                    (objectUuid | std::views::drop(uuidIdxTimeMid0)).begin());
 
  // Populate the trailing 6 unique bytes (populates node ID)
  objectUuid[uuidIdxNode0] = b10;
  objectUuid[uuidIdxNode1] = b11;
  objectUuid[uuidIdxNode2] = b12;
  objectUuid[uuidIdxNode3] = b13;
  objectUuid[uuidIdxNode4] = b14;
  objectUuid[uuidIdxNode5] = b15;
 
  return objectUuid;
}
 
} // namespace
 
// =============================================================================
// UUID helpers
// =============================================================================
 
std::string UuidBytesToString(const std::array<std::uint8_t, uuidLenght>& data)
{
  // Explicit indices for each byte position in the 16-byte UUID array
  static constexpr std::size_t timeLow0 = 0;
  static constexpr std::size_t timeLow1 = 1;
  static constexpr std::size_t timeLow2 = 2;
  static constexpr std::size_t timeLow3 = 3;
 
  static constexpr std::size_t timeMid0 = 4;
  static constexpr std::size_t timeMid1 = 5;
 
  static constexpr std::size_t timeHi0 = 6;
  static constexpr std::size_t timeHi1 = 7;
 
  static constexpr std::size_t clockSeq0 = 8;
  static constexpr std::size_t clockSeq1 = 9;
 
  static constexpr std::size_t nodeDataStartIndex = 10;
  static constexpr int nodeDataLength = 6;
 
  // DCE/RPC UUIDs: first 3 fields little-endian, last 2 big-endian.
  const std::uint32_t timeLow = static_cast<std::uint32_t>(data[timeLow0]) |
                                (static_cast<std::uint32_t>(data[timeLow1]) << OneOctetShift) |
                                (static_cast<std::uint32_t>(data[timeLow2]) << TwoOctetsShift) |
                                (static_cast<std::uint32_t>(data[timeLow3]) << ThreeOctetsShift);
 
  auto timeMid = static_cast<std::uint16_t>(data[timeMid0] | (data[timeMid1] << OneOctetShift));
  auto timeHi = static_cast<std::uint16_t>(data[timeHi0] | (data[timeHi1] << OneOctetShift));
  auto clockSeq = static_cast<std::uint16_t>((data[clockSeq0] << OneOctetShift) | data[clockSeq1]);
 
  // Format the first tracking segments and cleanly append the remaining hex data
  const std::string out = std::format("{:08x}-{:04x}-{:04x}-{:04x}-{}",
                                      timeLow, timeMid, timeHi, clockSeq,
                                      ToHex(&data[nodeDataStartIndex], nodeDataLength));
  return out;
}
 
std::array<std::uint8_t, uuidLenght> StringToUuidBytes(const std::string& uuidStr)
{
  // UUID Structural Constants
  static constexpr std::size_t expectedHexLength = 32;
  static constexpr int hexBase = 16;
  static constexpr std::size_t singleByteHexLength = 2;
 
  // Component Substring Offsets and Lengths
  static constexpr std::size_t timeLowOffset = 0;
  static constexpr std::size_t timeLowLength = 8;
 
  static constexpr std::size_t timeMidOffset = 8;
  static constexpr std::size_t timeMidLength = 4;
 
  static constexpr std::size_t timeHiOffset = 12;
  static constexpr std::size_t timeHiLength = 4;
 
  static constexpr std::size_t clockSeqOffset = 16;
  static constexpr std::size_t clockSeqLength = 4;
 
  // Explicit indices for each byte position in the 16-byte UUID array
  static constexpr std::size_t timeLow0 = 0;
  static constexpr std::size_t timeLow1 = 1;
  static constexpr std::size_t timeLow2 = 2;
  static constexpr std::size_t timeLow3 = 3;
 
  static constexpr std::size_t timeMid0 = 4;
  static constexpr std::size_t timeMid1 = 5;
 
  static constexpr std::size_t timeHi0 = 6;
  static constexpr std::size_t timeHi1 = 7;
 
  static constexpr std::size_t clockSeq0 = 8;
  static constexpr std::size_t clockSeq1 = 9;
 
  // Data Loop Constants
  static constexpr int nodeDataLength = 6;
  static constexpr std::size_t nodeDataStartHexOffset = 20;
  static constexpr std::size_t nodeDataOutputStartIndex = 10;
 
  std::string hex;
  hex.reserve(expectedHexLength);
  for (const char c : uuidStr)
  {
    if (c != '-')
    {
      hex.push_back(c);
    }
  }
  if (hex.size() != expectedHexLength)
  {
    throw std::invalid_argument("Invalid UUID string: " + uuidStr);
  }
 
  // Helper lambda to parse a single 2-character hex pair into a byte
  auto byteAt = [&](std::size_t stringIdx) -> std::uint8_t
  {
    return static_cast<std::uint8_t>(std::stoul(hex.substr(stringIdx, singleByteHexLength), nullptr, hexBase));
  };
 
  const std::uint32_t timeLow = static_cast<std::uint32_t>(std::stoul(hex.substr(timeLowOffset, timeLowLength), nullptr, hexBase));
  const std::uint16_t timeMid = static_cast<std::uint16_t>(std::stoul(hex.substr(timeMidOffset, timeMidLength), nullptr, hexBase));
  const std::uint16_t timeHi = static_cast<std::uint16_t>(std::stoul(hex.substr(timeHiOffset, timeHiLength), nullptr, hexBase));
  const std::uint16_t clockSeq = static_cast<std::uint16_t>(std::stoul(hex.substr(clockSeqOffset, clockSeqLength), nullptr, hexBase));
 
  std::array<std::uint8_t, uuidLenght> out{};
  // Unpack fields into big-endian network byte order using your shifts and masks
  out[timeLow0] = static_cast<std::uint8_t>(timeLow & LowByteMask);
  out[timeLow1] = static_cast<std::uint8_t>((timeLow >> OneOctetShift) & LowByteMask);
  out[timeLow2] = static_cast<std::uint8_t>((timeLow >> TwoOctetsShift) & LowByteMask);
  out[timeLow3] = static_cast<std::uint8_t>((timeLow >> ThreeOctetsShift) & LowByteMask);
  out[timeMid0] = static_cast<std::uint8_t>(timeMid & LowByteMask);
  out[timeMid1] = static_cast<std::uint8_t>((timeMid >> OneOctetShift) & LowByteMask);
  out[timeHi0] = static_cast<std::uint8_t>(timeHi & LowByteMask);
  out[timeHi1] = static_cast<std::uint8_t>((timeHi >> OneOctetShift) & LowByteMask);
  out[clockSeq0] = static_cast<std::uint8_t>((clockSeq >> OneOctetShift) & LowByteMask);
  out[clockSeq1] = static_cast<std::uint8_t>(clockSeq & LowByteMask);
 
  // Fill the remaining 6 bytes (Node ID segment)
  for (std::size_t i = 0; i < nodeDataLength; ++i)
  {
    out.at(nodeDataOutputStartIndex + i) = byteAt(nodeDataStartHexOffset + (i * singleByteHexLength));
  }
  return out;
}
 
// =============================================================================
// EPM
// =============================================================================
 
std::string EPMEndpoint::InterfaceName() const
{
  std::string lower = interfaceUuid;
  std::ranges::transform(lower, lower.begin(), ::tolower);
 
  if (lower == UUID_PNIO_DEVICE)
  {
    return "PNIO-Device";
  }
  if (lower == UUID_PNIO_CONTROLLER)
  {
    return "PNIO-Controller";
  }
  if (lower == "dea00003-6c97-11d1-8271-00a02442df7d")
  {
    return "PNIO-Supervisor";
  }
  if (lower == "dea00004-6c97-11d1-8271-00a02442df7d")
  {
    return "PNIO-ParameterServer";
  }
  if (lower == UUID_EPM_V4)
  {
    return "EPM";
  }
  return "Unknown(" + interfaceUuid + ")";
}
 
namespace
{
 
std::optional<EPMEndpoint> ParseEpmTower(const Bytes& towerData)
{
  if (towerData.size() < 4)
  {
    return std::nullopt;
  }
 
  std::size_t offset = 0;
  auto floorCount = static_cast<std::uint16_t>(towerData[0] | (towerData[1] << OneOctetShift));
 
  offset += 2;
 
  EPMEndpoint endpoint;
 
  for (std::uint16_t floorIdx = 0; floorIdx < floorCount; ++floorIdx)
  {
    if (offset + 4 > towerData.size())
    {
      break;
    }
 
    auto lhsLen = static_cast<std::uint16_t>(towerData[offset] | (towerData[offset + 1] << OneOctetShift));
    offset += 2;
    if (offset + lhsLen > towerData.size())
    {
      break;
    }
    const std::uint8_t* lhsData = &towerData[offset];
    offset += lhsLen;
 
    if (offset + 2 > towerData.size())
    {
      break;
    }
    auto rhsLen = static_cast<std::uint16_t>(towerData[offset] | (towerData[offset + 1] << OneOctetShift));
    offset += 2;
    if (offset + rhsLen > towerData.size())
    {
      break;
    }
    const std::uint8_t* rhsData = &towerData[offset];
    offset += rhsLen;
 
    if (lhsLen < 1)
    {
      continue;
    }
    const std::uint8_t protocolId = lhsData[0];
 
    if (protocolId == 0x0D && lhsLen >= 19)
    {
      if (floorIdx == 0)
      {
        std::array<std::uint8_t, uuidLenght> uuidBytes{};
        std::memcpy(uuidBytes.data(), lhsData + 1, uuidLenght);
        endpoint.interfaceUuid = UuidBytesToString(uuidBytes);
        endpoint.interfaceVersionMajor = static_cast<std::uint16_t>(lhsData[17] | (lhsData[18] << OneOctetShift));
        if (rhsLen >= 2)
        {
          endpoint.interfaceVersionMinor = static_cast<std::uint16_t>(rhsData[0] | (rhsData[1] << OneOctetShift));
        }
      }
    }
    else if (protocolId == 0x0A)
    {
      endpoint.protocol = "ncadg_ip_udp";
    }
    else if (protocolId == 0x08 && rhsLen >= 2)
    {
      endpoint.port = static_cast<std::uint16_t>((rhsData[0] << OneOctetShift) | rhsData[1]); // big-endian
    }
    else if (protocolId == 0x09 && rhsLen >= 4)
    {
      endpoint.ipAddress = std::to_string(rhsData[0]) + "." + std::to_string(rhsData[1]) + "." +
                           std::to_string(rhsData[2]) + "." + std::to_string(rhsData[3]);
    }
  }
 
  if (endpoint.interfaceUuid.empty())
  {
    return std::nullopt;
  }
  return endpoint;
}
 
std::uint32_t ReadU32Le(const std::uint8_t* p)
{
  return static_cast<std::uint32_t>(p[0]) | (static_cast<std::uint32_t>(p[1]) << OneOctetShift) |
         (static_cast<std::uint32_t>(p[2]) << TwoOctetsShift) | (static_cast<std::uint32_t>(p[3]) << ThreeOctetsShift);
}
std::uint16_t ReadU16Le(const std::uint8_t* p)
{
  return static_cast<std::uint16_t>(p[0] | (p[1] << OneOctetShift));
}
void WriteU16Le(Bytes& out, std::uint16_t v)
{
  out.push_back(static_cast<std::uint8_t>(v & LowByteMask));
  out.push_back(static_cast<std::uint8_t>(v >> OneOctetShift));
}
void WriteU32Le(Bytes& out, std::uint32_t v)
{
  out.push_back(static_cast<std::uint8_t>(v & LowByteMask));
  out.push_back(static_cast<std::uint8_t>((v >> OneOctetShift) & LowByteMask));
  out.push_back(static_cast<std::uint8_t>((v >> TwoOctetsShift) & LowByteMask));
  out.push_back(static_cast<std::uint8_t>((v >> ThreeOctetsShift) & LowByteMask));
}
 
} // namespace
 
std::vector<EPMEndpoint> EpmLookup(asio::io_context& ioContext, const std::string& ip, std::uint16_t port, double timeoutSec,
                                   std::optional<std::string> interfaceFilter)
{
  std::vector<EPMEndpoint> results;
 
  // const int fd = ::socket(AF_INET, SOCK_DGRAM, 0);
  // if (fd < 0)
  // {
  //   return results;
  // }
 
  // timeval tv{};
  // tv.tv_sec = static_cast<time_t>(timeoutSec);
  // static constexpr int microsecondsPerSecond = 1'000'000;
  // tv.tv_usec = static_cast<suseconds_t>((timeoutSec - static_cast<double>(tv.tv_sec)) * microsecondsPerSecond);
  // ::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
  // sockaddr_in addr{};
  // addr.sin_family = AF_INET;
  // addr.sin_port = htons(port);
  // if (::inet_pton(AF_INET, ip.c_str(), &addr.sin_addr) != 1)
  // {
  //   ::close(fd);
  //   return results;
  // }
  RpcTransport transport(ioContext);
 
  transport.Open(ip, port);
 
  // Build little-endian RPC header (kFixedSize, 80 bytes).
  auto activityUuidArr = RandomUuidBytes();
  Bytes activityUuidBytes(activityUuidArr.begin(), activityUuidArr.end());
  auto objectUuidBytes = std::array<std::uint8_t, uuidLenght>{}; // NULL object UUID
  auto interfaceUuidBytes = StringToUuidBytes(UUID_EPM_V4);
 
  Bytes header;
  header.push_back(4);                    // version
  header.push_back(PNRPCHeader::REQUEST); // packet_type = REQUEST, 0x00
  header.push_back(0x20);                 // flags1
  header.push_back(0x00);                 // flags2
  header.push_back(0x10);
  header.push_back(0x00);
  header.push_back(0x00); // drep (little-endian)
  header.push_back(0);    // serial_high
  header.insert(header.end(), objectUuidBytes.begin(), objectUuidBytes.end());
  header.insert(header.end(), interfaceUuidBytes.begin(), interfaceUuidBytes.end());
  header.insert(header.end(), activityUuidBytes.begin(), activityUuidBytes.end());
  WriteU32Le(header, 0); // server_boot_time
  WriteU32Le(header, 3); // interface_version
  WriteU32Le(header, 0); // sequence_number
  WriteU16Le(header, EPM_LOOKUP);
  WriteU16Le(header, 0xFFFF); // interface_hint
  WriteU16Le(header, 0xFFFF); // activity_hint
  const std::size_t lengthOfBodyOffset = header.size();
  WriteU16Le(header, 0); // length_of_body placeholder, patched below
  WriteU16Le(header, 0); // fragment_number
  header.push_back(0);   // authentication_protocol
  header.push_back(0);   // serial_low
 
  const std::uint32_t inquiryType = interfaceFilter ? EPM_INQUIRY_INTERFACE : EPM_INQUIRY_ALL;
  Bytes body;
  WriteU32Le(body, inquiryType);
  if (interfaceFilter)
  {
    auto ifaceBytes = StringToUuidBytes(*interfaceFilter);
    body.insert(body.end(), ifaceBytes.begin(), ifaceBytes.end());
    WriteU16Le(body, 1);
    WriteU16Le(body, 0);
  }
  else
  {
    body.insert(body.end(), 16, 0);
    WriteU16Le(body, 0);
    WriteU16Le(body, 0);
  }
  WriteU32Le(body, 0);   // vers option
  WriteU32Le(body, 0);   // entry handle
  WriteU32Le(body, 100); // max ents
 
  header[lengthOfBodyOffset] = static_cast<std::uint8_t>(body.size() & LowByteMask);
  header[lengthOfBodyOffset + 1] = static_cast<std::uint8_t>((body.size() >> OneOctetShift) & LowByteMask);
  // header was built with a 2-byte placeholder at lengthOfBodyOffset and
  // is already exactly 80 bytes (the fixed RPC header size); no resize needed.
 
  Bytes request = header;
  request.insert(request.end(), body.begin(), body.end());
 
  // if (::sendto(fd, request.data(), request.size(), 0, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0)
  // {
  //   ::close(fd);
  //   return results;
  // }
  auto timeoutInMilliSeconds = std::chrono::floor<std::chrono::milliseconds>(std::chrono::duration<double>(timeoutSec));
  Bytes data =
      transport.SendReceive(
          request,
          timeoutInMilliSeconds);
 
  // Bytes data(RECEIVE_BUFFER_LENGTH);
  //  const ssize_t n = ::recv(fd, data.data(), data.size(), 0);
  //  ::close(fd);
  //  if (n <= 0)
  //  {
  //    return results;
  //  }
 
  if (static_cast<std::size_t>(data.size()) < PNRPCHeader::kFixedSize)
  {
    return results;
  }
  // data.resize(static_cast<std::size_t>(n));
 
  const std::uint8_t respType = data[1];
  if (respType == 0x03 || respType != 0x02)
  {
    return results; // FAULT or not RESPONSE
  }
 
  std::uint16_t bodyLen = ReadU16Le(&data[74]);
  if (PNRPCHeader::kFixedSize + static_cast<std::size_t>(bodyLen) > data.size())
  {
    bodyLen = static_cast<std::uint16_t>(data.size() - PNRPCHeader::kFixedSize);
  }
  Bytes bodyData(data.begin() + PNRPCHeader::kFixedSize, data.begin() + PNRPCHeader::kFixedSize + bodyLen);
  if (bodyData.size() < 12)
  {
    return results;
  }
 
  std::size_t offset = 4; // skip entry_handle
  const std::uint32_t numEnts = ReadU32Le(&bodyData[offset]);
  offset += 4;
  offset += 12; // skip array metadata (max_count, offset, actual_count)
 
  for (std::uint32_t i = 0; i < numEnts; ++i)
  {
    if (offset + uuidLenght > bodyData.size())
    {
      break;
    }
    std::array<std::uint8_t, uuidLenght> entryUuidBytes{};
    std::memcpy(entryUuidBytes.data(), &bodyData[offset], uuidLenght);
    const std::string entryObjectUuid = UuidBytesToString(entryUuidBytes);
    offset += uuidLenght;
 
    if (offset + 4 > bodyData.size())
    {
      break;
    }
    offset += 4; // tower_p pointer
 
    if (offset + 4 > bodyData.size())
    {
      break;
    }
    const std::uint32_t annotationLen = ReadU32Le(&bodyData[offset]);
    offset += 4;
 
    std::string annotation;
    if (annotationLen > 0 && offset + annotationLen <= bodyData.size())
    {
      const std::size_t end = offset + annotationLen;
      std::size_t trim = end;
      while (trim > offset && bodyData[trim - 1] == 0)
      {
        --trim;
      }
      annotation = std::string(bodyData.begin() + offset, bodyData.begin() + trim);
    }
    offset += annotationLen;
    offset = (offset + 3) & ~static_cast<std::size_t>(3);
 
    if (offset + 4 > bodyData.size())
    {
      break;
    }
    const std::uint32_t towerLen = ReadU32Le(&bodyData[offset]);
    offset += 4;
 
    if (offset + towerLen > bodyData.size())
    {
      break;
    }
    const Bytes towerData(bodyData.begin() + offset, bodyData.begin() + offset + towerLen);
    offset += towerLen;
    offset = (offset + 3) & ~static_cast<std::size_t>(3);
 
    auto endpoint = ParseEpmTower(towerData);
    if (endpoint)
    {
      endpoint->objectUuid = entryObjectUuid;
      endpoint->annotation = annotation;
      results.push_back(*endpoint);
    }
  }
 
  return results;
}
 
dcp::DCPDeviceDescription GetStationInfo(const EthernetSocket& sock,
                                         const MacAddress& src,
                                         const std::string& name,
                                         int timeoutSec)
{
  dcp::SendRequest(sock, src, dcp::BlockKey{PNDCPBlock::NAME_OF_STATION.first, PNDCPBlock::NAME_OF_STATION.second},
                   Bytes(name.begin(), name.end()));
  auto responses = dcp::ReadResponse(sock, src, timeoutSec, /*once=*/true);
 
  if (responses.empty())
  {
    dcp::SendDiscover(sock, src);
    responses = dcp::ReadResponse(sock, src, timeoutSec);
    for (const auto& [Mac, Blocks] : responses)
    {
      dcp::DCPDeviceDescription desc(Mac, Blocks);
      std::string lowerDescName = desc.name;
      std::string lowerTarget = name;
      std::ranges::transform(lowerDescName, lowerDescName.begin(), ::tolower);
      std::ranges::transform(lowerTarget, lowerTarget.begin(), ::tolower);
      if (lowerDescName == lowerTarget)
      {
        return desc;
      }
    }
    throw DCPDeviceNotFoundError("Device with name '" + name + "' not found");
  }
 
  const auto& [Mac, Blocks] = *responses.begin();
  // NOLINTNEXTLINE(modernize-return-braced-init-list)
  return dcp::DCPDeviceDescription(Mac, Blocks);
}
 
// =============================================================================
// IOCRSetup
// =============================================================================
 
std::vector<std::string> IOCRSetup::Validate() const
{
  std::vector<std::string> warnings;
  const double cycleMs = CycleTimeMs();
  if (cycleMs < 1)
  {
    warnings.emplace_back("Cycle time too fast - sub-1ms is impractical without hardware support");
  }
  else if (cycleMs < cyclic::MIN_CYCLE_MS)
  {
    warnings.emplace_back("Cycle time may cause jitter (8ms+ recommended)");
  }
  if (watchdogFactor < 3)
  {
    warnings.emplace_back("Watchdog factor too low (use 6+)");
  }
  if (slots.empty())
  {
    warnings.emplace_back("No IO slots configured");
  }
  return warnings;
}
 
// =============================================================================
// RPCCon
// =============================================================================
 
RPCCon::RPCCon(const dcp::DCPDeviceDescription& info, RPCConOptions options)
    : info(info),
      timeout(options.timeoutSec),
      sessionKey(RandomNonzeroU16()),
      rpcTransport{std::make_unique<RpcTransport>(ioContext)},
      ccontrolTransport{std::make_unique<RpcTransport>(ioContext)}
{
  arUuid = RandomUuidBytes();
  activityUuid = RandomUuidBytes();
 
  localObjectUuid = BuildObjectUuid(0x00, 0x01, 0x76, 0x54, 0x32, 0x10);
  remoteObjectUuid =
      BuildObjectUuid(0x00, 0x01, info.deviceHigh, info.deviceLow, info.vendorHigh, info.vendorLow);
 
  rpcTransport->Open(info.ip, options.rpcPort);
  std::string anyIp = asio::ip::address_v4(asio::detail::socket_ops::network_to_host_long(INADDR_ANY)).to_string();
  ccontrolTransport->Open(anyIp, options.rpcPort, true);
}
 
RPCCon::~RPCCon()
{
  Close();
}
 
PNRPCHeader RPCCon::CreateRpc(std::uint16_t operation, const Bytes& nrd)
{
  PNRPCHeader h;
  h.version = 4;
  h.packetType = PNRPCHeader::REQUEST;
  h.flags1 = 0x20;
  h.flags2 = 0x00;
  h.dataRepresentation = {0x00, 0x00, 0x00};
  h.serialNrHigh = 0;
  h.objectUuid = remoteObjectUuid;
  h.interfaceUuid = PNRPCHeader::IfaceUuidDevice();
  h.activityUuid = activityUuid;
  h.serverBootTime = 0;
  h.interfaceVersion = 1;
  h.sequenceNumber = sequenceNumber++;
  h.operationNumber = operation;
  h.interfaceHint = 0xFFFF;
  h.activityHint = 0xFFFF;
  h.lengthOfBody = static_cast<std::uint16_t>(nrd.size());
  h.fragmentNumber = 0;
  h.authenticationProtocol = 0;
  h.serialNrLow = 0;
  h.payload = nrd;
  return h;
}
 
PNNRDData RPCCon::CreateNrd(const Bytes& payload)
{
  PNNRDData nrd;
  nrd.argsMaximumStatus = 1500;
  nrd.argsLength = static_cast<std::uint32_t>(payload.size());
  nrd.maximumCount = 1500;
  nrd.offset = 0;
  nrd.actualCount = static_cast<std::uint32_t>(payload.size());
  nrd.payload = payload;
  return nrd;
}
 
Bytes RPCCon::BuildAlarmCrBlock(int transport, int priority) const
{
  auto properties = static_cast<std::uint32_t>((transport << 1) | priority);
 
  PNBlockHeader header;
  header.blockType = PNAlarmCRBlockReq::BLOCK_TYPE;
  header.blockLength = static_cast<std::uint16_t>(PNAlarmCRBlockReq::kSize - 4);
  header.blockVersionHigh = VERSION_HIGH;
  header.blockVersionLow = VERSION_LOW;
 
  PNAlarmCRBlockReq alarmCr;
  std::memcpy(alarmCr.blockHeader.data(), header.ToBytes().data(), blockHeaderLenght);
  alarmCr.alarmCrType = 0x0001;
  alarmCr.etherTypeLT = transport == 0 ? PROFINET_ETHERTYPE : IP_ETHERTYPE;
  alarmCr.alarmCrProperties = properties;
  alarmCr.rtaTimeoutFactor = PNAlarmCRBlockReq::DEFAULT_RTA_TIMEOUT_FACTOR;
  alarmCr.rtaRetries = PNAlarmCRBlockReq::DEFAULT_RTA_RETRIES;
  alarmCr.localAlarmReference = alarmRef;
  alarmCr.maxAlarmDataLength = PNAlarmCRBlockReq::DEFAULT_MAX_ALARM_DATA_LENGTH;
  alarmCr.alarmCrTagHeaderHigh = PNAlarmCRBlockReq::DEFAULT_TAG_HEADER_HIGH;
  alarmCr.alarmCrTagHeaderLow = PNAlarmCRBlockReq::DEFAULT_TAG_HEADER_LOW;
 
  return alarmCr.ToBytes();
}
 
int RPCCon::ParseAlarmCrResponse(const Bytes& responseData)
{
  std::size_t offset = 0;
  while (offset + blockHeaderLenght <= responseData.size())
  {
    auto hdr = PeekBlockHeader(responseData, offset);
    if (hdr.blockType == PNAlarmCRBlockRes::BLOCK_TYPE)
    {
      const Bytes blockBytes(responseData.begin() + offset, responseData.end());
      try
      {
        auto res = PNAlarmCRBlockRes::Parse(blockBytes);
        return res.localAlarmReference;
      }
      // NOLINTNEXTLINE(bugprone-empty-catch)
      catch (const std::exception&)
      {
        // fall through and keep scanning
      }
    }
    offset += 4 + hdr.blockLength;
  }
  return -1;
}
/*
dit zou ook moeten werken... zie ff niet waarom niet voor de auma,,,
 
Bytes RPCCon::BuildIocrBlock(int iocrType, int iocrReference, const IOCRSetup& setup)
{
  Bytes objectsData;
  std::uint16_t frameOffset = 0;
 
  for (const auto& slot : setup.slots)
  {
    const std::uint16_t dataLen = iocrType == 1 ? slot.inputLength : slot.outputLength;
    if (dataLen > 0)
    {
      IOCRAPIObject obj;
      obj.slotNumber = slot.slot;
      obj.subslotNumber = slot.subslot;
      obj.frameOffset = frameOffset;
      Bytes objBytes = obj.ToBytes();
      objectsData.insert(objectsData.end(), objBytes.begin(), objBytes.end());
 
      frameOffset = static_cast<std::uint16_t>(frameOffset + dataLen + 1);
    }
  }
 
  Bytes iocsData;
  std::uint16_t iocsCount = 0;
  for (const auto& slot : setup.slots)
  {
    if (iocrType == 1 && slot.inputLength > 0)
    {
      continue;
    }
    if (iocrType == 2 && slot.outputLength > 0)
    {
      continue;
    }
    IOCRAPIObject iocsObj;
    iocsObj.slotNumber = slot.slot;
    iocsObj.subslotNumber = slot.subslot;
    iocsObj.frameOffset = frameOffset;
    Bytes objBytes = iocsObj.ToBytes();
    iocsData.insert(iocsData.end(), objBytes.begin(), objBytes.end());
    frameOffset = static_cast<std::uint16_t>(frameOffset + 1);
    ++iocsCount;
  }
 
  const std::uint16_t dataLength = std::max<std::uint16_t>(40, frameOffset);
  const std::uint32_t iocrProperties = 0x00000001; // RT_CLASS_1
 
  std::uint16_t numObjects = 0;
  for (const auto& slot : setup.slots)
  {
    if ((iocrType == 1 && slot.inputLength > 0) || (iocrType == 2 && slot.outputLength > 0))
    {
      ++numObjects;
    }
  }
 
  Bytes apiBlock;
  wire::PutU32(apiBlock, 0); // api
  wire::PutU16(apiBlock, numObjects);
  apiBlock.insert(apiBlock.end(), objectsData.begin(), objectsData.end());
  wire::PutU16(apiBlock, iocsCount);
  apiBlock.insert(apiBlock.end(), iocsData.begin(), iocsData.end());
 
  const std::size_t totalSize = PNIOCRBlockReqHeader::kSize + apiBlock.size();
  auto blockLength = static_cast<std::uint16_t>(totalSize - 4);
 
  PNBlockHeader header;
  header.blockType = PNIOCRBlockReqHeader::BLOCK_TYPE;
  header.blockLength = blockLength;
  header.blockVersionHigh = VERSION_HIGH;
  header.blockVersionLow = VERSION_LOW;
 
  PNIOCRBlockReqHeader iocrHeader;
  std::memcpy(iocrHeader.blockHeader.data(), header.ToBytes().data(), blockHeaderLenght);
  iocrHeader.iocrType = static_cast<std::uint16_t>(iocrType);
  iocrHeader.iocrReference = static_cast<std::uint16_t>(iocrReference);
  iocrHeader.etherTypeLT = PROFINET_ETHERTYPE;
  iocrHeader.iocrProperties = iocrProperties;
  iocrHeader.dataLength = dataLength;
  iocrHeader.frameId = static_cast<std::uint16_t>((iocrType == 1 ? 0xC000 : 0xC000) + iocrReference);
  iocrHeader.sendClockFactor = setup.sendClockFactor;
  iocrHeader.reductionRatio = setup.reductionRatio;
  // iocrHeader.phase = 1;
  iocrHeader.phase = 8;
  iocrHeader.sequence = 0;
  iocrHeader.frameSendOffset = 0xFFFFFFFF;
  iocrHeader.watchdogFactor = setup.watchdogFactor;
  iocrHeader.dataHoldFactor = setup.dataHoldFactor;
  iocrHeader.iocrTagHeader = 0xC000;
  iocrHeader.iocrMulticastMac = {};
  iocrHeader.numberOfApis = 1;
 
  Bytes out = iocrHeader.ToBytes();
  out.insert(out.end(), apiBlock.begin(), apiBlock.end());
  return out;
}
*/
 
/* Dit werkt! maar is volgens mij fragiel en incorrect
Bytes RPCCon::BuildIocrBlock(int iocrType,
                             int iocrReference,
                             const IOCRSetup& setup)
{
  // ------------------------------------------------------------
  // Build IO Data Objects
  // ------------------------------------------------------------
 
  Bytes objectsData;
 
  int frameOffset = -1;
  std::uint16_t numObjects = 0;
 
  for (const auto& slot : setup.slots)
  {
    ++frameOffset;
 
    @*
     * Python:
     *
     * if iocr_type == 2 and slot.output_length == 0:
     *     continue
     * elif iocr_type == 1 and slot.output_length > 0:
     *     continue
     *
     * if iocr_type == 1:
     *     ...
     * else:
     *     continue
     *@
 
    if (iocrType == 2 && slot.outputLength == 0)
    {
      continue;
    }
    else if (iocrType == 1 && slot.outputLength > 0)
    {
      continue;
    }
 
    // if (iocrType == 1)
    //{
    IOCRAPIObject obj;
    obj.slotNumber = slot.slot;
    obj.subslotNumber = slot.subslot;
    obj.frameOffset = static_cast<std::uint16_t>(frameOffset);
 
    Bytes objBytes = obj.ToBytes();
 
    objectsData.insert(objectsData.end(),
                       objBytes.begin(),
                       objBytes.end());
 
    ++numObjects;
    //}
    // else
    //{
    //  // Exact Python behaviour.
    //  continue;
    //}
  }
 
  // ------------------------------------------------------------
  // Build IOCS Objects
  // ------------------------------------------------------------
 
  Bytes iocsData;
 
  frameOffset = -1;
  std::uint16_t iocsCount = 0;
 
  for (const auto& slot : setup.slots)
  {
    ++frameOffset;
 
    @*
     * Python:
     *
     * if iocr_type == 1 and slot.output_length == 0:
     *     continue
     *
     * if iocr_type == 2 and slot.output_length > 0:
     *     continue
     *
 
    if (iocrType == 1 && slot.outputLength == 0)
    {
      continue;
    }
 
    if (iocrType == 2 && slot.outputLength > 0)
    {
      continue;
    }
 
    IOCRAPIObject iocsObj;
 
    iocsObj.slotNumber = slot.slot;
    iocsObj.subslotNumber = slot.subslot;
 
    if (iocrType == 1)
    {
      // Python hard-coded value.
      iocsObj.frameOffset = 42;
    }
    else
    {
      // Python uses slot index.
      iocsObj.frameOffset =
          static_cast<std::uint16_t>(frameOffset);
    }
 
    Bytes objBytes = iocsObj.ToBytes();
 
    iocsData.insert(iocsData.end(),
                    objBytes.begin(),
                    objBytes.end());
 
    ++iocsCount;
  }
 
 
  // ------------------------------------------------------------
  // Data length
  // ------------------------------------------------------------
 
  @*
   * Python:
   *
   * data_length = max(42, frame_offset) + 1
   *@
 
  const std::uint16_t dataLength =
      static_cast<std::uint16_t>(
          std::max(42, frameOffset) + 1);
 
  const std::uint32_t iocrProperties = 0x00000001;
 
  // ------------------------------------------------------------
  // Build API block
  // ------------------------------------------------------------
 
  Bytes apiBlock;
 
  wire::PutU32(apiBlock, 0); // API
  wire::PutU16(apiBlock, numObjects);
 
  apiBlock.insert(apiBlock.end(),
                  objectsData.begin(),
                  objectsData.end());
 
  wire::PutU16(apiBlock, iocsCount);
 
  apiBlock.insert(apiBlock.end(),
                  iocsData.begin(),
                  iocsData.end());
 
  // ------------------------------------------------------------
  // Block length
  // ------------------------------------------------------------
 
  const std::size_t totalSize =
      PNIOCRBlockReqHeader::kSize + apiBlock.size();
 
  const std::uint16_t blockLength =
      static_cast<std::uint16_t>(totalSize - 4);
 
  PNBlockHeader blockHeader;
 
  blockHeader.blockType = PNIOCRBlockReqHeader::BLOCK_TYPE;
  blockHeader.blockLength = blockLength;
  blockHeader.blockVersionHigh = VERSION_HIGH;
  blockHeader.blockVersionLow = VERSION_LOW;
 
  // ------------------------------------------------------------
  // Build IOCR header
  // ------------------------------------------------------------
 
  PNIOCRBlockReqHeader iocrHeader;
 
  const Bytes headerBytes = blockHeader.ToBytes();
 
  std::copy(headerBytes.begin(),
            headerBytes.end(),
            iocrHeader.blockHeader.begin());
 
  iocrHeader.iocrType =
      static_cast<std::uint16_t>(iocrType);
 
  iocrHeader.iocrReference =
      static_cast<std::uint16_t>(iocrReference);
 
  iocrHeader.etherTypeLT =
      PROFINET_ETHERTYPE;
 
  iocrHeader.iocrProperties =
      iocrProperties;
 
  iocrHeader.dataLength =
      dataLength;
 
  @*
   * Python:
   *
   * frame_id = 0xC000 + iocr_reference - 1
   *@
 
  iocrHeader.frameId =
      static_cast<std::uint16_t>(
          0xC000 + iocrReference - 1);
 
  iocrHeader.sendClockFactor =
      setup.sendClockFactor;
 
  iocrHeader.reductionRatio =
      setup.reductionRatio;
 
  iocrHeader.phase = 8;
 
  iocrHeader.sequence = 0;
 
  iocrHeader.frameSendOffset =
      0xFFFFFFFF;
 
  iocrHeader.watchdogFactor =
      setup.watchdogFactor;
 
  iocrHeader.dataHoldFactor =
      setup.dataHoldFactor;
 
  iocrHeader.iocrTagHeader =
      0xC000;
 
  iocrHeader.iocrMulticastMac = {};
 
  iocrHeader.numberOfApis = 1;
 
  // ------------------------------------------------------------
  // Serialize
  // ------------------------------------------------------------
 
  Bytes out = iocrHeader.ToBytes();
 
  out.insert(out.end(),
             apiBlock.begin(),
             apiBlock.end());
  std::string msg = ToHex(out);
  return out;
}
*/
/* troep!
Bytes RPCCon::BuildIocrBlock(int iocrType,
                             int iocrReference,
                             const IOCRSetup& setup)
{
  Bytes objectsData;
  Bytes iocsData;
 
  std::uint16_t frameOffset = 0;
  std::uint16_t numObjects = 0;
  std::uint16_t iocsCount = 0;
 
  // -------------------------------------------------------------------------
  // 1. Build IO Data Objects & IOCS Objects
  // -------------------------------------------------------------------------
  for (const auto& slot : setup.slots)
  {
    // OUTPUT CR (0x0001): Controller Output -> Device Input
    if (iocrType == 1)
    {
      if (slot.outputLength > 0)
      {
        // Add Output Data Object
        IOCRAPIObject obj;
        obj.slotNumber = slot.slot;
        obj.subslotNumber = slot.subslot;
        obj.frameOffset = frameOffset;
 
        Bytes objBytes = obj.ToBytes();
        objectsData.insert(objectsData.end(), objBytes.begin(), objBytes.end());
 
        // Offset advances by Data Length + 1 Byte IOPS (Provider Status)
        frameOffset += static_cast<std::uint16_t>(slot.outputLength + 1);
        ++numObjects;
      }
 
      // Consumer Status (IOCS) returned for Input subslots
      if (slot.inputLength > 0)
      {
        IOCRAPIObject iocsObj;
        iocsObj.slotNumber = slot.slot;
        iocsObj.subslotNumber = slot.subslot;
        iocsObj.frameOffset = iocsCount; // 1-byte IOCS per subslot
 
        Bytes iocsBytes = iocsObj.ToBytes();
        iocsData.insert(iocsData.end(), iocsBytes.begin(), iocsBytes.end());
        ++iocsCount;
      }
    }
    // INPUT CR (0x0002): Device Output -> Controller Input
    else if (iocrType == 2)
    {
      if (slot.inputLength > 0)
      {
        // Add Input Data Object
        IOCRAPIObject obj;
        obj.slotNumber = slot.slot;
        obj.subslotNumber = slot.subslot;
        obj.frameOffset = frameOffset;
 
        Bytes objBytes = obj.ToBytes();
        objectsData.insert(objectsData.end(), objBytes.begin(), objBytes.end());
 
        // Offset advances by Data Length + 1 Byte IOPS (Provider Status)
        frameOffset += static_cast<std::uint16_t>(slot.inputLength + 1);
        ++numObjects;
      }
 
      // Consumer Status (IOCS) returned for Output subslots
      if (slot.outputLength > 0)
      {
        IOCRAPIObject iocsObj;
        iocsObj.slotNumber = slot.slot;
        iocsObj.subslotNumber = slot.subslot;
        iocsObj.frameOffset = iocsCount; // 1-byte IOCS per subslot
 
        Bytes iocsBytes = iocsObj.ToBytes();
        iocsData.insert(iocsData.end(), iocsBytes.begin(), iocsBytes.end());
        ++iocsCount;
      }
    }
  }
 
  // -------------------------------------------------------------------------
  // 2. Data Length & Minimum Frame Padding (40-byte Ethernet minimum)
  // -------------------------------------------------------------------------
  // Total data length = IO Data + IOPS + IOCS
  std::uint16_t calculatedLength = frameOffset + iocsCount;
 
  // PROFINET RT frame payload must be at least 40 bytes
  const std::uint16_t dataLength = std::max<std::uint16_t>(40, calculatedLength);
 
  // -------------------------------------------------------------------------
  // 3. Assemble API Block Header & Data
  // -------------------------------------------------------------------------
  Bytes apiBlock;
  wire::PutU32(apiBlock, 0); // API = 0
 
  wire::PutU16(apiBlock, numObjects);
  apiBlock.insert(apiBlock.end(), objectsData.begin(), objectsData.end());
 
  wire::PutU16(apiBlock, iocsCount);
  apiBlock.insert(apiBlock.end(), iocsData.begin(), iocsData.end());
 
  // -------------------------------------------------------------------------
  // 4. Assemble Main IOCR Header
  // -------------------------------------------------------------------------
  const std::size_t totalSize = PNIOCRBlockReqHeader::kSize + apiBlock.size();
  const std::uint16_t blockLength = static_cast<std::uint16_t>(totalSize - 4);
 
  PNBlockHeader blockHeader;
  blockHeader.blockType = PNIOCRBlockReqHeader::BLOCK_TYPE; // 0x0102
  blockHeader.blockLength = blockLength;
  blockHeader.blockVersionHigh = VERSION_HIGH;
  blockHeader.blockVersionLow = VERSION_LOW;
 
  PNIOCRBlockReqHeader iocrHeader;
  const Bytes headerBytes = blockHeader.ToBytes();
  std::copy(headerBytes.begin(), headerBytes.end(), iocrHeader.blockHeader.begin());
 
  iocrHeader.iocrType = static_cast<std::uint16_t>(iocrType);
  iocrHeader.iocrReference = static_cast<std::uint16_t>(iocrReference);
  iocrHeader.etherTypeLT = PROFINET_ETHERTYPE;
  iocrHeader.iocrProperties = 0x00000001; // RT_CLASS_1
  iocrHeader.dataLength = dataLength;
  iocrHeader.frameId = static_cast<std::uint16_t>(0xC000 + iocrReference - 1);
 
  iocrHeader.sendClockFactor = setup.sendClockFactor;
  iocrHeader.reductionRatio = setup.reductionRatio;
  iocrHeader.phase = 8;
  iocrHeader.sequence = 0;
  iocrHeader.frameSendOffset = 0xFFFFFFFF;
  iocrHeader.watchdogFactor = setup.watchdogFactor;
  iocrHeader.dataHoldFactor = setup.dataHoldFactor;
  iocrHeader.iocrTagHeader = 0xC000;
  iocrHeader.iocrMulticastMac = {};
  iocrHeader.numberOfApis = 1;
 
  // -------------------------------------------------------------------------
  // 5. Serialize
  // -------------------------------------------------------------------------
  Bytes out = iocrHeader.ToBytes();
  out.insert(out.end(), apiBlock.begin(), apiBlock.end());
 
  return out;
}
*/
/*
Bytes RPCCon::BuildIocrBlock(int iocrType,
                             int iocrReference,
                             const IOCRSetup& setup)
{
  // ===========================================================================
  // AUMA SGx / CDT IOCR layout
  //
  // The AUMA CDT uses the following IOCR arrangement:
  //
  // INPUT CR (iocrType == 1)
  //
  //   IODataObjects:
  //       slot 0 / 0x0001 -> frame offset 0
  //       slot 0 / 0x0002 -> frame offset 1
  //       slot 0 / 0x0003 -> frame offset 2
  //       slot 0 / 0x0004 -> frame offset 3
  //       slot 0 / 0x8000 -> frame offset 4
  //       slot 0 / 0x8001 -> frame offset 5
  //       slot 0 / 0x8002 -> frame offset 6
  //       slot 1 / 0x0001 -> frame offset 7
  //
  //   IOCSObjects:
  //       slot 2 / 0x0001 -> frame offset 42
  //
  //
  // OUTPUT CR (iocrType == 2)
  //
  //   IODataObjects:
  //       slot 2 / 0x0001 -> frame offset 8
  //
  //   IOCSObjects:
  //       slot 0 / 0x0001 -> frame offset 0
  //       slot 0 / 0x0002 -> frame offset 1
  //       slot 0 / 0x0003 -> frame offset 2
  //       slot 0 / 0x0004 -> frame offset 3
  //       slot 0 / 0x8000 -> frame offset 4
  //       slot 0 / 0x8001 -> frame offset 5
  //       slot 0 / 0x8002 -> frame offset 6
  //       slot 1 / 0x0001 -> frame offset 7
  //
  // DataLength is 43 (0x002b) for both IOCRs.
  //
  // ===========================================================================
 
  // ---------------------------------------------------------------------------
  // Locate the configured slots.
  // ---------------------------------------------------------------------------
 
  const auto findSlot = [&setup](std::uint16_t slotNumber,
                                 std::uint16_t subslotNumber)
      -> const IOSlot*
  {
    const auto it = std::ranges::find_if(
        setup.slots,
        [slotNumber, subslotNumber](const IOSlot& slot)
    {
      return slot.slot == slotNumber &&
             slot.subslot == subslotNumber;
    });
 
    return it != setup.slots.end() ? &(*it) : nullptr;
  };
 
  // ---------------------------------------------------------------------------
  // The AUMA configuration requires these exact entries.
  // ---------------------------------------------------------------------------
 
  static constexpr std::array<std::pair<std::uint16_t, std::uint16_t>, 7>
      kDapSubslots{
          {
              {0, 0x0001},
              {0, 0x0002},
              {0, 0x0003},
              {0, 0x0004},
              {0, 0x8000},
              {0, 0x8001},
              {0, 0x8002},
          }};
 
  const IOSlot* actuatorInput = findSlot(1, 0x0001);
  const IOSlot* actuatorOutput = findSlot(2, 0x0001);
 
  if (actuatorInput == nullptr)
  {
    throw std::runtime_error(
        "AUMA IOCR configuration is missing Slot 1 / Subslot 0x0001");
  }
 
  if (actuatorOutput == nullptr)
  {
    throw std::runtime_error(
        "AUMA IOCR configuration is missing Slot 2 / Subslot 0x0001");
  }
 
  // ---------------------------------------------------------------------------
  // Build IOData and IOCS API object lists.
  // ---------------------------------------------------------------------------
 
  Bytes objectsData;
  Bytes iocsData;
 
  std::uint16_t numObjects = 0;
  std::uint16_t iocsCount = 0;
 
  // ===========================================================================
  // INPUT CR
  // ===========================================================================
  //
  // CDT:
  //
  //   NumberOfIODataObjects = 8
  //
  //   slot/subslot             offset
  //   --------------------------------
  //   0/0001                     0
  //   0/0002                     1
  //   0/0003                     2
  //   0/0004                     3
  //   0/8000                     4
  //   0/8001                     5
  //   0/8002                     6
  //   1/0001                     7
  //
  //   NumberOfIOCSObjects = 1
  //
  //   2/0001                    42
  //
  // ===========================================================================
 
  if (iocrType == 1)
  {
    std::uint16_t frameOffset = 0;
 
    // Seven DAP/interface/port objects.
    for (const auto& [slotNumber, subslotNumber] : kDapSubslots)
    {
      const IOSlot* slot = findSlot(slotNumber, subslotNumber);
 
      if (slot == nullptr)
      {
        throw std::runtime_error(
            "AUMA IOCR configuration is missing DAP subslot");
      }
 
      IOCRAPIObject obj;
      obj.slotNumber = slot->slot;
      obj.subslotNumber = slot->subslot;
      obj.frameOffset = frameOffset++;
 
      const Bytes objBytes = obj.ToBytes();
      objectsData.insert(
          objectsData.end(),
          objBytes.begin(),
          objBytes.end());
 
      ++numObjects;
    }
 
    // Actuator input data.
    //
    // CDT puts this object at offset 7.
    {
      IOCRAPIObject obj;
      obj.slotNumber = actuatorInput->slot;
      obj.subslotNumber = actuatorInput->subslot;
      obj.frameOffset = frameOffset++;
 
      const Bytes objBytes = obj.ToBytes();
      objectsData.insert(
          objectsData.end(),
          objBytes.begin(),
          objBytes.end());
 
      ++numObjects;
    }
 
    // The output submodule is the consumer of this INPUT CR.
    //
    // Its IOCS is at byte offset 42.
    {
      IOCRAPIObject obj;
      obj.slotNumber = actuatorOutput->slot;
      obj.subslotNumber = actuatorOutput->subslot;
      obj.frameOffset = 42;
 
      const Bytes objBytes = obj.ToBytes();
      iocsData.insert(
          iocsData.end(),
          objBytes.begin(),
          objBytes.end());
 
      ++iocsCount;
    }
  }
 
  // ===========================================================================
  // OUTPUT CR
  // ===========================================================================
  //
  // CDT:
  //
  //   NumberOfIODataObjects = 1
  //
  //   slot/subslot             offset
  //   --------------------------------
  //   2/0001                     8
  //
  //   NumberOfIOCSObjects = 8
  //
  //   slot/subslot             offset
  //   --------------------------------
  //   0/0001                     0
  //   0/0002                     1
  //   0/0003                     2
  //   0/0004                     3
  //   0/8000                     4
  //   0/8001                     5
  //   0/8002                     6
  //   1/0001                     7
  //
  // ===========================================================================
 
  if (iocrType == 2)
  {
    // Eight IOCS entries for the input-side objects.
    std::uint16_t iocsOffset = 0;
 
    for (const auto& [slotNumber, subslotNumber] : kDapSubslots)
    {
      const IOSlot* slot = findSlot(slotNumber, subslotNumber);
 
      if (slot == nullptr)
      {
        throw std::runtime_error(
            "AUMA IOCR configuration is missing DAP subslot");
      }
 
      IOCRAPIObject obj;
      obj.slotNumber = slot->slot;
      obj.subslotNumber = slot->subslot;
      obj.frameOffset = iocsOffset++;
 
      const Bytes objBytes = obj.ToBytes();
      iocsData.insert(
          iocsData.end(),
          objBytes.begin(),
          objBytes.end());
 
      ++iocsCount;
    }
 
    // Actuator input IOCS.
    {
      IOCRAPIObject obj;
      obj.slotNumber = actuatorInput->slot;
      obj.subslotNumber = actuatorInput->subslot;
      obj.frameOffset = iocsOffset++;
 
      const Bytes objBytes = obj.ToBytes();
      iocsData.insert(
          iocsData.end(),
          objBytes.begin(),
          objBytes.end());
 
      ++iocsCount;
    }
 
    // Actuator output data.
    //
    // CDT starts this at offset 8 because the first eight bytes
    // of the output frame are occupied by the IOCS data.
    {
      IOCRAPIObject obj;
      obj.slotNumber = actuatorOutput->slot;
      obj.subslotNumber = actuatorOutput->subslot;
      obj.frameOffset = 8;
 
      const Bytes objBytes = obj.ToBytes();
      objectsData.insert(
          objectsData.end(),
          objBytes.begin(),
          objBytes.end());
 
      ++numObjects;
    }
  }
 
  // ---------------------------------------------------------------------------
  // AUMA CDT uses DataLength = 0x002b (43) for both IOCRs.
  //
  // Input:
  //
  //   DAP/status area       7 bytes
  //   actuator input       34 bytes
  //   actuator IOPS         1 byte
  //   actuator IOCS         1 byte
  //   --------------------------------
  //                         43 bytes
  //
  // Output:
  //
  //   IOCS area              8 bytes
  //   actuator output       16 bytes
  //   remaining IOCR area   19 bytes
  //   --------------------------------
  //                         43 bytes
  //
  // ---------------------------------------------------------------------------
 
  constexpr std::uint16_t dataLength = 0x002b;
 
  // ---------------------------------------------------------------------------
  // Build API block.
  //
  // NumberOfAPIs = 1
  // API = 0
  // ---------------------------------------------------------------------------
 
  Bytes apiBlock;
 
  wire::PutU32(apiBlock, 0); // API = 0
 
  wire::PutU16(
      apiBlock,
      numObjects);
 
  apiBlock.insert(
      apiBlock.end(),
      objectsData.begin(),
      objectsData.end());
 
  wire::PutU16(
      apiBlock,
      iocsCount);
 
  apiBlock.insert(
      apiBlock.end(),
      iocsData.begin(),
      iocsData.end());
 
  // ---------------------------------------------------------------------------
  // IOCR header.
  // ---------------------------------------------------------------------------
 
  PNBlockHeader blockHeader;
  blockHeader.blockType = PNIOCRBlockReqHeader::BLOCK_TYPE; // 0x0102
 
  // IOCR header + API block, excluding the 4-byte BlockType/BlockLength.
  const std::size_t totalSize =
      PNIOCRBlockReqHeader::kSize + apiBlock.size();
 
  blockHeader.blockLength =
      static_cast<std::uint16_t>(totalSize - 4);
 
  blockHeader.blockVersionHigh = VERSION_HIGH;
  blockHeader.blockVersionLow = VERSION_LOW;
 
  PNIOCRBlockReqHeader iocrHeader;
 
  const Bytes headerBytes = blockHeader.ToBytes();
 
  std::copy(
      headerBytes.begin(),
      headerBytes.end(),
      iocrHeader.blockHeader.begin());
 
  iocrHeader.iocrType =
      static_cast<std::uint16_t>(iocrType);
 
  iocrHeader.iocrReference =
      static_cast<std::uint16_t>(iocrReference);
 
  iocrHeader.etherTypeLT =
      PROFINET_ETHERTYPE; // 0x8892
 
  iocrHeader.iocrProperties =
      0x00000001; // RT_CLASS_1
 
  iocrHeader.dataLength =
      dataLength; // 0x002b
 
  // CDT:
  //   Input  CR -> 0xC000
  //   Output CR -> 0xC001
  iocrHeader.frameId =
      static_cast<std::uint16_t>(
          0xC000 + iocrReference - 1);
 
  iocrHeader.sendClockFactor =
      setup.sendClockFactor;
 
  iocrHeader.reductionRatio =
      setup.reductionRatio;
 
  iocrHeader.phase = 8;
  iocrHeader.sequence = 0;
 
  iocrHeader.frameSendOffset =
      0xFFFFFFFF;
 
  iocrHeader.watchdogFactor =
      setup.watchdogFactor;
 
  iocrHeader.dataHoldFactor =
      setup.dataHoldFactor;
 
  iocrHeader.iocrTagHeader =
      0xC000;
 
  iocrHeader.iocrMulticastMac = {};
 
  // Exactly one API: API 0.
  iocrHeader.numberOfApis = 1;
 
  // ---------------------------------------------------------------------------
  // Serialize.
  // ---------------------------------------------------------------------------
 
  Bytes out = iocrHeader.ToBytes();
 
  out.insert(
      out.end(),
      apiBlock.begin(),
      apiBlock.end());
 
  return out;
}
*/
Bytes RPCCon::BuildIocrBlock(int iocrType, int iocrReference, const IOCRSetup& setup)
{
  // ===========================================================================
  // Build the IOCR from the resolved IO configuration.
  //
  // IOCRSetup::slots is the canonical resolved configuration produced by
  // BuildIoSlots().
  //
  // The two IOSlot flags determine whether a slot participates in the
  // corresponding IOCR:
  //
  //   inputIocrObject  -> Input CR
  //   outputIocrObject -> Output CR
  //
  // Within an IOCR:
  //
  //   INPUT CR:
  //       inputIocrObject  -> IODataObject
  //       outputIocrObject -> IOCSObject
  //
  //   OUTPUT CR:
  //       outputIocrObject -> IODataObject
  //       inputIocrObject  -> IOCSObject
  //
  // This deliberately contains no knowledge of AUMA, Phoenix, slot numbers,
  // subslot numbers, module identifiers, or application data sizes.
  // ===========================================================================
 
  constexpr std::uint16_t kInputIocrType = 1;
  constexpr std::uint16_t kOutputIocrType = 2;
 
  if (iocrType != kInputIocrType && iocrType != kOutputIocrType)
  {
    throw std::invalid_argument("BuildIocrBlock: unsupported IOCR type " + std::to_string(iocrType));
  }
 
  if (setup.dataLength == 0)
  {
    throw std::invalid_argument("BuildIocrBlock: IOCR dataLength must be greater than zero");
  }
 
  if (setup.dataLength > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: IOCR dataLength exceeds uint16_t");
  }
 
  // ---------------------------------------------------------------------------
  // Collect IOData and IOCS objects.
  //
  // We keep the objects in the same order as setup.slots. This is important:
  // BuildIoSlots() defines the resolved configuration order, and therefore
  // also defines the deterministic wire representation.
  // ---------------------------------------------------------------------------
 
  std::vector<IOCRAPIObject> ioDataObjects;
  std::vector<IOCRAPIObject> iocsObjects;
 
  for (const IOSlot& slot : setup.slots)
  {
    std::cerr
        << "IO slot "
        << slot.slot << "/"
        << std::hex << slot.subslot << std::dec
        << " in=" << slot.inputLength
        << " out=" << slot.outputLength
        << " inputIoData=" << slot.inputIoData
        << " outputIoData=" << slot.outputIoData
        << " inputIocs=" << slot.inputIocs
        << " outputIocs=" << slot.outputIocs
        << '\n';
    // const bool inputObject = slot.includeInInputIocr;
    // const bool outputObject = slot.includeInOutputIocr;
 
    if (iocrType == kInputIocrType)
    {
      if (slot.inputIoData)
      {
        ioDataObjects.push_back({slot.slot, slot.subslot, 0});
      }
 
      if (slot.outputIocs)
      {
        iocsObjects.push_back({slot.slot, slot.subslot, 0});
      }
    }
    else
    {
      if (slot.outputIoData)
      {
        ioDataObjects.push_back({slot.slot, slot.subslot, 0});
      }
 
      if (slot.inputIocs)
      {
        iocsObjects.push_back({slot.slot, slot.subslot, 0});
      }
    }
  }
 
  // ---------------------------------------------------------------------------
  // Validate object counts before converting to the wire uint16_t fields.
  // ---------------------------------------------------------------------------
 
  if (ioDataObjects.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: too many IODataObjects");
  }
 
  if (iocsObjects.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: too many IOCSObjects");
  }
 
  // ---------------------------------------------------------------------------
  // Calculate frame offsets.
  //
  // The AUMA/CDT layout demonstrates an important distinction:
  //
  //   - an IODataObject's frameOffset points to its process-data bytes;
  //   - an IOCSObject's frameOffset points to its one-byte IOCS;
  //   - an IODataObject also has an implicit one-byte IOPS following its data.
  //
  // Zero-length IODataObjects used by the DAP/PDEV configuration still occupy
  // one byte in the cyclic frame layout in the AUMA configuration. Therefore
  // a zero-length IODataObject advances the data offset by one byte.
  //
  // For a data-bearing IODataObject, advance by:
  //
  //       data length + one IOPS byte
  //
  // IOCS objects each consume one byte.
  // ---------------------------------------------------------------------------
 
  std::size_t dataOffset = 0;
  if (iocrType == kInputIocrType)
  {
    // -------------------------------------------------------------------------
    // INPUT CR
    //
    // IOData:
    //   input data / DAP bytes / IOPS
    //
    // followed by:
    //   IOCS
    // -------------------------------------------------------------------------
 
    for (auto& object : ioDataObjects)
    {
      const auto slotIt = std::ranges::find_if(setup.slots,
                                               [&object](const IOSlot& slot)
      {
        return slot.slot == object.slotNumber && slot.subslot == object.subslotNumber;
      });
 
      if (slotIt == setup.slots.end())
      {
        throw std::logic_error("BuildIocrBlock: IODataObject no longer exists in configuration");
      }
 
      const IOSlot& slot = *slotIt;
 
      const std::size_t dataSize = slot.inputLength;
      /*
          const std::size_t dataSize =
              (iocrType == kInputIocrType)
                  ? slot.inputLength
                  : slot.outputLength;
      */
      if (dataOffset > std::numeric_limits<std::uint16_t>::max())
      {
        throw std::invalid_argument("BuildIocrBlock: IOData frame offset exceeds uint16_t");
      }
      const std::size_t before = dataOffset;
      object.frameOffset = static_cast<std::uint16_t>(dataOffset);
 
      // Even a zero-length DAP/PDEV IODataObject occupies one byte in the
      // configured AUMA cyclic frame layout.
      const std::size_t objectSize = std::max<std::size_t>(dataSize, 1);
 
      // Data followed by its IOPS byte.
      dataOffset += objectSize;
 
      if (dataSize > 0)
      {
        ++dataOffset;
      }
      std::cerr
          << "slot "
          << slot.slot << "/"
          << std::hex << slot.subslot << std::dec
          << " dataSize=" << dataSize
          << " before=" << before
          << " after=" << dataOffset
          << '\n';
    }
 
    // ---------------------------------------------------------------------------
    // IOCS offsets.
    //
    // IOCS objects occupy one byte each.
    //
    // For the AUMA layout:
    //
    //   INPUT CR:
    //       input data:
    //           DAP objects        0..6
    //           actuator input       7
    //           actuator IOPS       41
    //           actuator IOCS       42
    //
    //   OUTPUT CR:
    //       IOCS:
    //           DAP/PDEV objects    0..7
    //       output data:
    //           actuator output       8
    //
    // The IOCS area is therefore not simply appended after all IODataObjects.
    // It has to be placed according to the direction-specific cyclic layout.
    //
    // For INPUT CR, IOCS follows the Input IOData/IOPS area.
    // For OUTPUT CR, IOCS precedes the Output IOData area.
    // ---------------------------------------------------------------------------
 
    // IOCS follows the input IOData/IOPS area.
    std::size_t iocsOffset = dataOffset;
 
    /*    if (iocrType == kInputIocrType)
        {
          // Input IOData area comes first.
          iocsOffset = dataOffset;
        }
        else
        {
          // Output CR places IOCS before output process data.
          iocsOffset = iocsObjects.size();
        }
    */
    for (auto& object : iocsObjects)
    {
      if (iocsOffset > std::numeric_limits<std::uint16_t>::max())
      {
        throw std::invalid_argument("BuildIocrBlock: IOCS frame offset exceeds uint16_t");
      }
 
      object.frameOffset = static_cast<std::uint16_t>(iocsOffset);
      ++iocsOffset;
    }
 
    // ---------------------------------------------------------------------------
    // Determine the minimum cyclic frame size required by the generated objects.
    //
    // The configured IOCR dataLength may be larger than this minimum. That is
    // allowed because the device can have reserved/padding bytes in the cyclic
    // data area.
    // ---------------------------------------------------------------------------
 
    //    std::size_t minimumDataLength = 0;
    const std::size_t minimumDataLength =
        dataOffset + iocsObjects.size();
    /*
        if (iocrType == kInputIocrType)
        {
          // Input IOData + their IOPS bytes.
          minimumDataLength = dataOffset;
          // IOCS follows the input data area.
          minimumDataLength = std::max(minimumDataLength, iocsObjects.size() + dataOffset);
        }
        else
        {
          // Output IOCS area followed by output process data.
          minimumDataLength = iocsObjects.size() + dataOffset;
        }
    */
    if (minimumDataLength > setup.dataLength)
    {
      throw std::invalid_argument(
          "BuildIocrBlock: configured dataLength " +
          std::to_string(setup.dataLength) +
          " is smaller than the minimum required cyclic data length " +
          std::to_string(minimumDataLength));
    }
  }
  else
  {
    // -------------------------------------------------------------------------
    // OUTPUT CR
    //
    // IOCS comes first:
    //
    //   IOCS
    //   output IOData
    // -------------------------------------------------------------------------
 
    const std::size_t iocsLength = iocsObjects.size();
 
    for (auto& object : iocsObjects)
    {
      if (dataOffset > std::numeric_limits<std::uint16_t>::max())
      {
        throw std::invalid_argument("BuildIocrBlock: IOCS frame offset exceeds uint16_t");
      }
 
      object.frameOffset = static_cast<std::uint16_t>(dataOffset);
      ++dataOffset;
    }
 
    // dataOffset now points immediately after the IOCS area.
    for (auto& object : ioDataObjects)
    {
      const auto slotIt = std::ranges::find_if(setup.slots, [&object](const IOSlot& slot)
      {
        return slot.slot == object.slotNumber && slot.subslot == object.subslotNumber;
      });
 
      if (slotIt == setup.slots.end())
      {
        throw std::logic_error("BuildIocrBlock: IODataObject no longer exists in configuration");
      }
 
      const IOSlot& slot = *slotIt;
 
      const std::size_t dataSize = slot.outputLength;
 
      if (dataOffset > std::numeric_limits<std::uint16_t>::max())
      {
        throw std::invalid_argument("BuildIocrBlock: IOData frame offset exceeds uint16_t");
      }
 
      object.frameOffset = static_cast<std::uint16_t>(dataOffset);
 
      const std::size_t objectSize = std::max<std::size_t>(dataSize, 1);
 
      dataOffset += objectSize;
 
      // Output data has no IOPS included in this offset calculation here.
      //
      // If your wire layout requires an IOPS byte for output IOData objects,
      // add it here exactly as done for input data.... Ralph
    }
 
    const std::size_t minimumDataLength = dataOffset;
 
    if (minimumDataLength > setup.dataLength)
    {
      throw std::invalid_argument(
          "BuildIocrBlock: configured dataLength " +
          std::to_string(setup.dataLength) +
          " is smaller than the minimum required cyclic data length " +
          std::to_string(minimumDataLength));
    }
  }
 
  // ---------------------------------------------------------------------------
  // Serialize API 0.
  // ---------------------------------------------------------------------------
  std::cerr
      << "IOCR type=" << iocrType
      << " reference=" << iocrReference
      << " dataLength=" << setup.dataLength
      << " IODataObjects=" << ioDataObjects.size()
      << " IOCSObjects=" << iocsObjects.size()
      << '\n';
 
  for (const auto& object : ioDataObjects)
  {
    std::cerr
        << "  IOData slot=" << object.slotNumber
        << " subslot=0x" << std::hex << object.subslotNumber
        << std::dec
        << " offset=" << object.frameOffset
        << '\n';
  }
 
  for (const auto& object : iocsObjects)
  {
    std::cerr
        << "  IOCS   slot=" << object.slotNumber
        << " subslot=0x" << std::hex << object.subslotNumber
        << std::dec
        << " offset=" << object.frameOffset
        << '\n';
  }
 
  Bytes apiBlock;
 
  // API = 0
  wire::PutU32(apiBlock, 0);
 
  wire::PutU16(apiBlock, static_cast<std::uint16_t>(ioDataObjects.size()));
 
  for (const IOCRAPIObject& object : ioDataObjects)
  {
    const Bytes bytes = object.ToBytes();
    apiBlock.insert(apiBlock.end(), bytes.begin(), bytes.end());
  }
 
  wire::PutU16(apiBlock, static_cast<std::uint16_t>(iocsObjects.size()));
 
  for (const IOCRAPIObject& object : iocsObjects)
  {
    const Bytes bytes = object.ToBytes();
    apiBlock.insert(apiBlock.end(), bytes.begin(), bytes.end());
  }
 
  // ---------------------------------------------------------------------------
  // Build IOCR block header.
  // ---------------------------------------------------------------------------
 
  PNBlockHeader blockHeader;
 
  blockHeader.blockType = PNIOCRBlockReqHeader::BLOCK_TYPE; // 0x0102
 
  // The IOCR fixed header is followed by the API block.
  //
  // blockLength excludes:
  //   - BlockType      2 bytes
  //   - BlockLength    2 bytes
  //
  const std::size_t totalSize = PNIOCRBlockReqHeader::kSize + apiBlock.size();
 
  if (totalSize < 4 || totalSize - 4 > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: IOCR block is too large");
  }
 
  blockHeader.blockLength = static_cast<std::uint16_t>(totalSize - 4);
 
  blockHeader.blockVersionHigh = VERSION_HIGH;
  blockHeader.blockVersionLow = VERSION_LOW;
 
  PNIOCRBlockReqHeader iocrHeader;
 
  const Bytes blockHeaderBytes = blockHeader.ToBytes();
 
  std::ranges::copy(blockHeaderBytes, iocrHeader.blockHeader.begin());
 
  iocrHeader.iocrType = static_cast<std::uint16_t>(iocrType);
  iocrHeader.iocrReference = static_cast<std::uint16_t>(iocrReference);
  iocrHeader.etherTypeLT = PROFINET_ETHERTYPE; // 0x8892
  iocrHeader.iocrProperties = 0x00000001;      // RT_CLASS_1
  iocrHeader.dataLength = static_cast<std::uint16_t>(setup.dataLength);
 
  // Preserve the existing controller convention:
  //
  //   Input  CR -> 0xC000
  //   Output CR -> 0xC001
  //
  iocrHeader.frameId = static_cast<std::uint16_t>(0xC000 + iocrReference - 1);
 
  iocrHeader.sendClockFactor = setup.sendClockFactor;
  iocrHeader.reductionRatio = setup.reductionRatio;
 
  // These are currently controller/protocol configuration values rather
  // than GSDML-derived slot properties.
  iocrHeader.phase = 8;
  iocrHeader.sequence = 0;
  iocrHeader.frameSendOffset = 0xFFFFFFFF;
  iocrHeader.watchdogFactor = setup.watchdogFactor;
  iocrHeader.dataHoldFactor = setup.dataHoldFactor;
  iocrHeader.iocrTagHeader = 0xC000;
  iocrHeader.iocrMulticastMac = {};
 
  // One API: API 0.
  iocrHeader.numberOfApis = 1;
 
  // ---------------------------------------------------------------------------
  // Serialize complete block.
  // ---------------------------------------------------------------------------
 
  Bytes out = iocrHeader.ToBytes();
 
  out.insert(out.end(), apiBlock.begin(), apiBlock.end());
 
  return out;
}
/*
template <typename SlotT>
std::pair<rt::IOCRConfig, rt::IOCRConfig> BuildIocrConfigs(
    const std::vector<SlotT>& slots,
    std::uint16_t inputFrameId,
    std::uint16_t outputFrameId,
    std::uint16_t sendClockFactor = 32,
    std::uint16_t reductionRatio = 32,
    int watchdogFactor = 3)
{
  // =========================================================================
  // INPUT IOCR: Device -> Controller
  //
  // C_SDU layout:
  //
  //   IOCS for every submodule without input data
  //   input process data
  //   IOPS for every input-data submodule
  //
  // For this AUMA device:
  //
  //   8 IOCS bytes
  //   34 input bytes
  //   1 IOPS byte
  //   = 43 bytes
  // =========================================================================
 
  std::vector<rt::IODataObject> inputObjects;
 
  int frameOffset = 0;
 
  // First reserve IOCS positions for every submodule that has
  // no input process data.
  for (const auto& s : slots)
  {
    if (s.inputLength == 0)
    {
      inputObjects.push_back(
          {
              s.slot,
              s.subslot,
              frameOffset, // no process data
              0,           // dataLength
              -1,          // no IOPS
              frameOffset  // IOCS
          });
 
      ++frameOffset;
    }
  }
 
  // Then append the actual input process data.
  for (const auto& s : slots)
  {
    if (s.inputLength > 0)
    {
      const int dataOffset = frameOffset;
 
      frameOffset += s.inputLength;
 
      const int iopsOffset = frameOffset++;
 
      inputObjects.push_back(
          {
              s.slot,
              s.subslot,
              dataOffset,
              s.inputLength,
              iopsOffset,
              -1 // no IOCS
          });
    }
  }
 
  rt::IOCRConfig inputIocr;
  inputIocr.typeIOCR = rt::IOCR_TYPE_INPUT;
  inputIocr.referenceIOCR = 1;
  inputIocr.frameId = inputFrameId;
  inputIocr.sendClockFactor = sendClockFactor;
  inputIocr.reductionRatio = reductionRatio;
  inputIocr.watchdogFactor = watchdogFactor;
  inputIocr.dataLength = frameOffset;
  inputIocr.objects = std::move(inputObjects);
 
  // =========================================================================
  // OUTPUT IOCR: Controller -> Device
  //
  // C_SDU layout:
  //
  //   IOCS for every submodule without output data
  //   output process data
  //   IOPS for every output-data submodule
  //
  // For this AUMA device:
  //
  //   8 IOCS bytes
  //   16 output bytes
  //   1 IOPS byte
  //   = 25 bytes
  // =========================================================================
 
  std::vector<rt::IODataObject> outputObjects;
 
  frameOffset = 0;
 
  // First reserve IOCS positions for every submodule that has
  // no output process data.
  for (const auto& s : slots)
  {
    if (s.outputLength == 0)
    {
      outputObjects.push_back(
          {
              s.slot,
              s.subslot,
              frameOffset, // no process data
              0,           // dataLength
              -1,          // no IOPS
              frameOffset  // IOCS
          });
 
      ++frameOffset;
    }
  }
 
  // Then append the actual output process data.
  for (const auto& s : slots)
  {
    if (s.outputLength > 0)
    {
      const int dataOffset = frameOffset;
 
      frameOffset += s.outputLength;
 
      const int iopsOffset = frameOffset++;
 
      outputObjects.push_back(
          {
              s.slot,
              s.subslot,
              dataOffset,
              s.outputLength,
              iopsOffset,
              -1 // no IOCS
          });
    }
  }
 
  rt::IOCRConfig outputIocr;
  outputIocr.typeIOCR = rt::IOCR_TYPE_OUTPUT;
  outputIocr.referenceIOCR = 2;
  outputIocr.frameId = outputFrameId;
  outputIocr.sendClockFactor = sendClockFactor;
  outputIocr.reductionRatio = reductionRatio;
  outputIocr.watchdogFactor = watchdogFactor;
  outputIocr.dataLength = frameOffset;
  outputIocr.objects = std::move(outputObjects);
 
  return {std::move(inputIocr), std::move(outputIocr)};
}
*/
 
/* werkt prima maar ik wil wat generiekers
Bytes RPCCon::BuildExpectedSubmoduleBlock(const IOCRSetup& setup, blocks::ModuleType dataDescription)
{
  // ExpectedSubmoduleBlockReq (0x0104). Layout per IEC 61158-6-10:
  //   BlockHeader(6) + NumberOfAPIs(2) +
  //   [API(4) + NumberOfSubmodules(2) +
  //     [Slot(2)+ModuleIdent(4)+ModuleProperties(2)+Subslot(2)+
  //      SubmoduleIdent(4)+SubmoduleProperties(2)+DataDescription...]...]...
  //
  // We use a single API (0) with one module-per-slot, one submodule each
  // (matching the flattened slot model rpc.py's IOSlot/ExpectedSubmoduleBlockReq
  // builder uses).
  blocks::ExpectedSubmoduleBlockReq builder;
  Bytes apiEntries;
  for (const auto& slot : setup.slots)
  {
    const bool hasInput = slot.inputLength > 0;
    const bool hasOutput = slot.outputLength > 0;
 
    const blocks::ModuleType submoduleType = [&]()
    {
      if (hasInput && hasOutput)
      {
        return blocks::ModuleType::inputAndOutput;
      }
      if (hasInput)
      {
        return blocks::ModuleType::inputOnly;
      }
      if (hasOutput)
      {
        return blocks::ModuleType::outputOnly;
      }
      return blocks::ModuleType::none;
    }();
    if (dataDescription == submoduleType)
    {
      builder.AddSubmodule(
          0,
          slot.slot,
          slot.subslot,
          slot.moduleIdent,
          slot.submoduleIdent,
          static_cast<std::uint16_t>(submoduleType),
          slot.inputLength,
          slot.outputLength);
    }
    *
        Bytes entry;
        wire::PutU16(entry, slot.slot);           // Slot
        wire::PutU32(entry, slot.moduleIdent);    // ModuleIdentNumber
        wire::PutU16(entry, 0);                   // ModuleProperties
        wire::PutU16(entry, 1);                   // NumberOfSubmodules
        wire::PutU16(entry, slot.subslot);        // Subslot
        wire::PutU32(entry, slot.submoduleIdent); // SubmoduleIdentNumber
 
        wire::PutU16(entry, static_cast<std::uint16_t>(submoduleType)); // SubmoduleProperties (encodes I/O direction)
 
        if (hasInput)
        {
          PNExpectedSubmoduleDataDescription desc;
          desc.dataDescription = 1; // Input
          desc.submoduleDataLength = slot.inputLength;
          desc.lengthIocs = 1;
          desc.lengthIops = 1;
          Bytes d = desc.ToBytes();
          entry.insert(entry.end(), d.begin(), d.end());
        }
        if (hasOutput)
        {
          PNExpectedSubmoduleDataDescription desc;
          desc.dataDescription = 2; // Output
          desc.submoduleDataLength = slot.outputLength;
          desc.lengthIocs = 1;
          desc.lengthIops = 1;
          Bytes d = desc.ToBytes();
          entry.insert(entry.end(), d.begin(), d.end());
        }
        if (!hasInput && !hasOutput)
        {
          PNExpectedSubmoduleDataDescription desc; // NO_IO: single zero-length descriptor
          desc.dataDescription = 1;
          desc.submoduleDataLength = 0;
          desc.lengthIocs = 0;
          desc.lengthIops = 1;
          Bytes d = desc.ToBytes();
          entry.insert(entry.end(), d.begin(), d.end());
        }
 
        apiEntries.insert(apiEntries.end(), entry.begin(), entry.end());
    *
  }
  *
    Bytes body;
    wire::PutU16(body, 1);                                              // NumberOfAPIs
    wire::PutU32(body, 0);                                              // API
    wire::PutU16(body, static_cast<std::uint16_t>(setup.slots.size())); // NumberOfSubmodules (flattened)
    body.insert(body.end(), apiEntries.begin(), apiEntries.end());
 
    PNBlockHeader header;
    header.blockType = BLOCK_EXPECTED_SUBMODULE_REQ; // ExpectedSubmoduleBlockReq, 0x0104
    header.blockLength = static_cast<std::uint16_t>(2 + body.size());
    header.blockVersionHigh = VERSION_HIGH;
    header.blockVersionLow = VERSION_LOW;
 
    Bytes out = header.ToBytes();
    out.insert(out.end(), body.begin(), body.end());
  *
  Bytes out = builder.ToBytes();
  return out;
}
*/
Bytes RPCCon::BuildExpectedSubmoduleBlock(const IOCRSetup& setup)
{
  blocks::ExpectedSubmoduleBlockReq builder;
 
  for (const auto& slot : setup.slots)
  {
    const bool hasInput = slot.inputLength > 0;
    const bool hasOutput = slot.outputLength > 0;
 
    const blocks::ModuleType submoduleType =
        [&]()
    {
      if (hasInput && hasOutput)
      {
        return blocks::ModuleType::InputAndOutput;
      }
 
      if (hasInput)
      {
        return blocks::ModuleType::InputOnly;
      }
 
      if (hasOutput)
      {
        return blocks::ModuleType::OutputOnly;
      }
 
      return blocks::ModuleType::None;
    }();
 
    builder.AddSubmodule(
        0,
        slot.slot,
        slot.subslot,
        slot.moduleIdent,
        slot.submoduleIdent,
        static_cast<std::uint16_t>(submoduleType),
        slot.inputLength,
        slot.outputLength);
  }
 
  return builder.ToBytes();
}
Bytes RPCCon::BuildUnifiedExpectedSubmoduleBlock(const IOCRSetup& setup)
{
  blocks::ExpectedSubmoduleBlockReq builder;
 
  for (const auto& slot : setup.slots)
  {
    const bool hasInput = slot.inputLength > 0;
    const bool hasOutput = slot.outputLength > 0;
 
    std::uint16_t submoduleType = 0; // none
    if (hasInput && hasOutput)
    {
      submoduleType = 3; // inputAndOutput
    }
    else if (hasInput)
    {
      submoduleType = 1; // inputOnly
    }
    else if (hasOutput)
    {
      submoduleType = 2; // outputOnly
    }
 
    builder.AddSubmodule(
        0, // API
        slot.slot,
        slot.subslot,
        slot.moduleIdent,
        slot.submoduleIdent,
        submoduleType,
        slot.inputLength,
        slot.outputLength);
  }
 
  return builder.ToBytes();
}
 
std::uint16_t RPCCon::ParseIocrResponse(const Bytes& responseData, int iocrType)
{
  std::size_t offset = 0;
  while (offset + blockHeaderLenght <= responseData.size())
  {
    auto hdr = PeekBlockHeader(responseData, offset);
    if (hdr.blockType == PNIOCRBlockRes::BLOCK_TYPE)
    {
      const Bytes blockBytes(responseData.begin() + offset, responseData.end());
      try
      {
        auto res = PNIOCRBlockRes::Parse(blockBytes);
        if (res.iocrType == iocrType)
        {
          return res.frameId;
        }
      }
      // NOLINTNEXTLINE(bugprone-empty-catch)
      catch (const std::exception&)
      {
        // fall through and keep scanning
      }
    }
    offset += 4 + hdr.blockLength;
  }
  return 0;
}
 
PNRPCHeader RPCCon::SendReceive(const PNRPCHeader& request)
{
  Bytes rpcBytes = request.ToBytes();
  auto timeoutInMilliSeconds = std::chrono::floor<std::chrono::milliseconds>(std::chrono::duration<double>(timeout));
  PNRPCHeader resp;
  while (true)
  {
    const Bytes responseBytes =
        rpcTransport->SendReceive(
            rpcBytes,
            timeoutInMilliSeconds);
 
    if (responseBytes.size() < PNRPCHeader::kFixedSize)
    {
      throw RPCError("Failed to parse RPC response: data too short (" + std::to_string(responseBytes.size()) +
                     " bytes)");
    }
    try
    {
      resp = PNRPCHeader::Parse(responseBytes);
    }
    catch (const std::exception& e)
    {
      throw RPCError(std::string("Failed to parse RPC response: ") + e.what());
    }
 
    if (resp.packetType == PNRPCHeader::REQUEST)
    {
      continue;
    }
    break;
  }
  if (resp.packetType == PNRPCHeader::FAULT)
  {
    throw RPCFaultError("RPC fault from " + info.name, resp.operationNumber);
  }
  if (resp.packetType == PNRPCHeader::REJECT)
  {
    throw RPCError("RPC request rejected by " + info.name);
  }
  if (resp.packetType != PNRPCHeader::RESPONSE)
  {
    // Extract the complete formatted error message into a dedicated const variable
    const std::string errorMessage = std::format("Unexpected RPC packet type: 0x{:02X}", resp.packetType);
 
    throw RPCError(errorMessage);
  }
 
  live = true;
  liveMonotonic = std::chrono::steady_clock::now();
  return resp;
}
 
void RPCCon::CheckTimeout()
{
  if (live)
  {
    auto elapsed = std::chrono::duration<double>(std::chrono::steady_clock::now() - liveMonotonic).count();
    if (elapsed >= CONNECTION_TIMEOUT)
    {
      Connect();
    }
  }
}
 
std::optional<ConnectResult> RPCCon::Connect(std::optional<MacAddress> mac,
                                             bool withAlarmCr,
                                             std::optional<IOCRSetup> setup)
{
  if (!live)
  {
    if (!mac)
    {
      throw std::invalid_argument("srcMac required for initial connection");
    }
    this->srcMac = mac;
  }
  else
  {
    arUuid = RandomUuidBytes();
    activityUuid = RandomUuidBytes();
    sessionKey = RandomNonzeroU16();
    if (mac)
    {
      this->srcMac = mac;
    }
  }
  if (!this->srcMac)
  {
    throw std::invalid_argument("No source MAC address available");
  }
 
  // NOLINTNEXTLINE(performance-unnecessary-value-param)
  this->iocrSetup = std::move(setup);
 
  const std::uint32_t arProperties = this->iocrSetup ? 0x00000011U : 0x00000111U;
  std::string initiatorStationName = "rhodium-profinet-connector";
 
  PNBlockHeader block;
  block.blockType = BlockType::ApplicationRelationRequest; // ARBlockReq, 0x0101
  block.blockLength = static_cast<std::uint16_t>(PNARBlockRequest::kFixedSize - 2 + initiatorStationName.length() - 2);
  block.blockVersionHigh = VERSION_HIGH;
  block.blockVersionLow = VERSION_LOW;
 
  const std::uint16_t arType = this->iocrSetup ? 0x0001 : 0x0006;
 
  PNARBlockRequest ar;
  std::memcpy(ar.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
  ar.arType = arType;
  ar.arUuid = arUuid;
  ar.sessionKey = sessionKey;
  ar.cmInitiatorMacAddress = *mac;
  ar.cmInitiatorObjectUuid = localObjectUuid;
  ar.arProperties = arProperties;
  ar.cmInitiatorActivityTimeoutFactor = 100;
  ar.initiatorUdpRtport = PROFINET_ETHERTYPE;
  ar.stationNameLength = static_cast<std::uint16_t>(initiatorStationName.length());
  const Bytes initiatorStationNameInBytes(initiatorStationName.begin(), initiatorStationName.end());
  ar.cmInitiatorStationName = initiatorStationNameInBytes;
 
  Bytes nrdPayload = ar.ToBytes();
 
  if (this->iocrSetup)
  {
    inputIocrRef = iocrRefCounter++;
    Bytes inputIocr = BuildIocrBlock(1, inputIocrRef, *this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), inputIocr.begin(), inputIocr.end());
 
    outputIocrRef = iocrRefCounter++;
    Bytes outputIocr = BuildIocrBlock(2, outputIocrRef, *this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), outputIocr.begin(), outputIocr.end());
 
    Bytes alarmCrData = BuildAlarmCrBlock();
    nrdPayload.insert(nrdPayload.end(), alarmCrData.begin(), alarmCrData.end());
    withAlarmCr = true;
 
    Bytes expectedSubmodule = BuildExpectedSubmoduleBlock(*this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), expectedSubmodule.begin(), expectedSubmodule.end());
    /*
    Bytes expectedInputSubmodule = BuildExpectedSubmoduleBlock(*this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), expectedInputSubmodule.begin(), expectedInputSubmodule.end());
    Bytes expectedOutputSubmodule = BuildExpectedSubmoduleBlock(*this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), expectedOutputSubmodule.begin(), expectedOutputSubmodule.end());
    */
    // Build one single ExpectedSubmoduleBlockReq containing all slots (0, 1, and 2)
    // Bytes expectedSubmodules = BuildUnifiedExpectedSubmoduleBlock(*this->iocrSetup);
    // nrdPayload.insert(nrdPayload.end(), expectedSubmodules.begin(), expectedSubmodules.end());
  }
  else if (withAlarmCr)
  {
    Bytes alarmCrData = BuildAlarmCrBlock();
    nrdPayload.insert(nrdPayload.end(), alarmCrData.begin(), alarmCrData.end());
  }
 
  const PNNRDData nrd = CreateNrd(nrdPayload);
  const PNRPCHeader req = CreateRpc(PNRPCHeader::CONNECT, nrd.ToBytes());
 
  try
  {
    const PNRPCHeader resp = SendReceive(req);
    const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
 
    if (nrdResp.argsMaximumStatus != 0)
    {
      const PNIOError pnioErr = PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
      throw RPCConnectionError(std::string("Connect rejected by device: ") + pnioErr.what());
    }
 
    std::optional<ConnectResult> result;
    if (this->iocrSetup)
    {
      result = ConnectResult{};
      result->arUuid = arUuid;
      result->sessionKey = sessionKey;
      inputFrameId = ParseIocrResponse(nrdResp.payload, 1);
      result->inputFrameId = inputFrameId;
      outputFrameId = ParseIocrResponse(nrdResp.payload, 2);
      result->outputFrameId = outputFrameId;
    }
 
    if (withAlarmCr)
    {
      deviceAlarmRef = ParseAlarmCrResponse(nrdResp.payload);
      if (deviceAlarmRef >= 0)
      {
        alarmCrEnabled = true;
        if (result)
        {
          result->deviceAlarmRef = deviceAlarmRef;
        }
      }
    }
 
    return result;
  }
  catch (const RPCError& e)
  {
    throw RPCConnectionError(std::string("Failed to connect: ") + e.what());
  }
}
 
PNIODHeader RPCCon::Read(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx)
{
  CheckTimeout();
 
  PNBlockHeader block;
  block.blockType = PNBlockHeader::IODReadRequestHeader;
  block.blockLength = PNBlockHeader::DEFAULT_BLOCK_LENGTH;
  block.blockVersionHigh = VERSION_HIGH;
  block.blockVersionLow = VERSION_LOW;
 
  PNIODHeader iod;
  std::memcpy(iod.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
  iod.sequenceNumber = 0;
  iod.arUuid = arUuid;
  iod.api = api;
  iod.slot = slot;
  iod.subslot = subslot;
  iod.padding1 = 0;
  iod.index = idx;
  iod.length = 4096;
  iod.targetArUuid = {};
  iod.padding2 = {};
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::READ, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
 
  return PNIODHeader::Parse(nrdResp.payload);
}
 
PNIODHeader RPCCon::ReadImplicit(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx)
{
  PNBlockHeader block;
  block.blockType = PNBlockHeader::IODReadRequestHeader;
  block.blockLength = 60;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODHeader iod;
  std::memcpy(iod.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
  iod.sequenceNumber = 0;
  iod.arUuid = {}; // empty AR UUID for implicit read
  iod.api = api;
  iod.slot = slot;
  iod.subslot = subslot;
  iod.padding1 = 0;
  iod.index = idx;
  iod.length = 4096;
  iod.targetArUuid = {};
  iod.padding2 = {};
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::IMPLICIT_READ, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
 
  return PNIODHeader::Parse(nrdResp.payload);
}
 
void RPCCon::Write(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx,
                   const Bytes& data)
{
  CheckTimeout();
 
  PNBlockHeader block;
  block.blockType = BlockType::IoDataWriteRequest; // 0x0008; // IODWriteReqHeader
  block.blockLength = 60;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODHeader iod;
  std::memcpy(iod.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
  iod.sequenceNumber = 0;
  iod.arUuid = arUuid;
  iod.api = api;
  iod.slot = slot;
  iod.subslot = subslot;
  iod.padding1 = 0;
  iod.index = idx;
  iod.length = static_cast<std::uint32_t>(data.size());
  iod.targetArUuid = {};
  iod.padding2 = {};
  iod.payload = data;
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::WRITE, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
}
 
Bytes RPCCon::ReadRaw(std::uint16_t idx, std::uint16_t slot, std::uint16_t subslot)
{
  return Read(0, slot, subslot, idx).payload;
}
 
PNInM0 RPCCon::ReadIm0(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM0::Parse(Read(0, slot, subslot, PNInM0::IDX).payload);
}
PNInM1 RPCCon::ReadIm1(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM1::Parse(Read(0, slot, subslot, PNInM1::IDX).payload);
}
PNInM2 RPCCon::ReadIm2(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM2::Parse(Read(0, slot, subslot, PNInM2::IDX).payload);
}
PNInM3 RPCCon::ReadIm3(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM3::Parse(Read(0, slot, subslot, PNInM3::IDX).payload);
}
PNInM4 RPCCon::ReadIm4(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM4::Parse(Read(0, slot, subslot, PNInM4::IDX).payload);
}
PNInM5 RPCCon::ReadIm5(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM5::Parse(Read(0, slot, subslot, PNInM5::IDX).payload);
}
PNInM6 RPCCon::ReadIm6(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM6::Parse(Read(0, slot, subslot, PNInM6::IDX).payload);
}
PNInM7 RPCCon::ReadIm7(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM7::Parse(Read(0, slot, subslot, PNInM7::IDX).payload);
}
PNInM8 RPCCon::ReadIm8(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM8::Parse(Read(0, slot, subslot, PNInM8::IDX).payload);
}
PNInM9 RPCCon::ReadIm9(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM9::Parse(Read(0, slot, subslot, PNInM9::IDX).payload);
}
PNInM10 RPCCon::ReadIm10(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM10::Parse(Read(0, slot, subslot, PNInM10::IDX).payload);
}
PNInM11 RPCCon::ReadIm11(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM11::Parse(Read(0, slot, subslot, PNInM11::IDX).payload);
}
PNInM12 RPCCon::ReadIm12(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM12::Parse(Read(0, slot, subslot, PNInM12::IDX).payload);
}
PNInM13 RPCCon::ReadIm13(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM13::Parse(Read(0, slot, subslot, PNInM13::IDX).payload);
}
PNInM14 RPCCon::ReadIm14(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM14::Parse(Read(0, slot, subslot, PNInM14::IDX).payload);
}
PNInM15 RPCCon::ReadIm15(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM15::Parse(Read(0, slot, subslot, PNInM15::IDX).payload);
}
 
AllIM RPCCon::ReadAllIm(std::uint16_t slot, std::uint16_t subslot)
{
  AllIM result;
  result.im0 = ReadIm0(slot, subslot); // I&M0 is mandatory; propagate failure.
 
  auto tryRead = [&](auto& field, auto memberFn)
  {
    try
    {
      field = (this->*memberFn)(slot, subslot);
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const RPCError&)
    {
      // fall through and keep scanning
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const std::exception&)
    {
      // fall through and keep scanning
    }
  };
  tryRead(result.im1, &RPCCon::ReadIm1);
  tryRead(result.im2, &RPCCon::ReadIm2);
  tryRead(result.im3, &RPCCon::ReadIm3);
  tryRead(result.im4, &RPCCon::ReadIm4);
  tryRead(result.im5, &RPCCon::ReadIm5);
  tryRead(result.im6, &RPCCon::ReadIm6);
  tryRead(result.im7, &RPCCon::ReadIm7);
  tryRead(result.im8, &RPCCon::ReadIm8);
  tryRead(result.im9, &RPCCon::ReadIm9);
  tryRead(result.im10, &RPCCon::ReadIm10);
  tryRead(result.im11, &RPCCon::ReadIm11);
  tryRead(result.im12, &RPCCon::ReadIm12);
  tryRead(result.im13, &RPCCon::ReadIm13);
  tryRead(result.im14, &RPCCon::ReadIm14);
  tryRead(result.im15, &RPCCon::ReadIm15);
  return result;
}
 
// =============================================================================
// Configuration / diagnosis / topology
// =============================================================================
 
std::vector<blocks::WriteMultipleResult> RPCCon::WriteMultiple(const std::vector<WriteItem>& writes)
{
  CheckTimeout();
  if (writes.empty())
  {
    return {};
  }
 
  blocks::IODWriteMultipleBuilder builder(arUuid, /*SeqNum=*/0);
  for (const auto& w : writes)
  {
    builder.AddWrite(w.slot, w.subslot, w.index, w.data, w.api);
  }
  const Bytes payload = builder.Build();
 
  PNBlockHeader block;
  block.blockType = BlockType::IoDataWriteRequest; // 0x0008; // IODWriteReqHeader
  block.blockLength = 60;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODHeader iod;
  std::memcpy(iod.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
  iod.sequenceNumber = 0;
  iod.arUuid = arUuid;
  iod.api = 0xFFFFFFFF; // wildcard for multiple
  iod.slot = 0xFFFF;    // wildcard
  iod.subslot = 0xFFFF; // wildcard
  iod.padding1 = 0;
  iod.index = blocks::IODWriteMultipleBuilder::writeMultipleIndex; // 0xE040
  iod.length = static_cast<std::uint32_t>(payload.size());
  iod.targetArUuid = {};
  iod.padding2 = {};
  iod.payload = payload;
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::WRITE, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
 
  return blocks::ParseWriteMultipleResponse(nrdResp.payload);
}
 
blocks::ModuleDiffBlock RPCCon::ReadModuleDiff()
{
  const PNIODHeader iod = Read(0, 0, 0, MODULE_DIFF_BLOCK);
  return blocks::ParseModuleDiffBlock(iod.payload);
}
 
diagnosis::DiagnosisData RPCCon::ReadDiagnosis(std::uint16_t slot, std::uint16_t subslot, std::uint16_t index)
{
  try
  {
    const PNIODHeader iod = Read(0, slot, subslot, index);
    const Bytes& data = iod.payload;
 
    if (data.size() > 6)
    {
      diagnosis::DiagnosisData result = diagnosis::ParseDiagnosisBlock(data, 0, slot, subslot);
      if (result.entries.empty())
      {
        result = diagnosis::ParseDiagnosisSimple(data, 0, slot, subslot);
      }
      return result;
    }
    diagnosis::DiagnosisData empty;
    empty.api = 0;
    empty.slot = slot;
    empty.subslot = subslot;
    empty.rawData = data;
    return empty;
  }
  catch (const RPCError&)
  {
    diagnosis::DiagnosisData empty;
    empty.api = 0;
    empty.slot = slot;
    empty.subslot = subslot;
    return empty;
  }
}
 
std::map<std::uint16_t, diagnosis::DiagnosisData> RPCCon::ReadAllDiagnosis()
{
  static const std::vector<std::tuple<std::uint16_t, std::uint16_t, std::uint16_t>> kDiagnosisProbes = {
      {0x800A, 0, 0}, // Channel diagnosis for slot 0
      {0x800B, 0, 0}, // All diagnosis for slot 0
      {0x800C, 0, 1}, // Channel diagnosis for subslot 1
      {0xF000, 0, 0}, // All diagnosis data (device level)
      {0xF00A, 0, 0}, // Channel diagnosis (API level)
      {0xF00B, 0, 0}, // All diagnosis (API level)
  };
 
  std::map<std::uint16_t, diagnosis::DiagnosisData> results;
  for (const auto& [idx, Slot, Subslot] : kDiagnosisProbes)
  {
    try
    {
      const diagnosis::DiagnosisData diag = ReadDiagnosis(Slot, Subslot, idx);
      if (!diag.entries.empty())
      {
        results[idx] = diag;
      }
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const RPCError&)
    {
    }
  }
  return results;
}
 
blocks::PDRealData RPCCon::ReadPdRealData()
{
  const PNIODHeader iod = Read(0, 0, 1, PD_REAL_DATA);
  return blocks::ParsePdRealData(iod.payload);
}
 
blocks::RealIdentificationData RPCCon::ReadRealIdentificationData()
{
  const PNIODHeader iod = Read(0, 0, 1, REAL_ID_API);
  return blocks::ParseRealIdentificationData(iod.payload);
}
 
std::vector<blocks::SlotInfo> RPCCon::DiscoverSlots()
{
  return ReadRealIdentificationData().slots;
}
 
std::pair<blocks::PDRealData, blocks::RealIdentificationData> RPCCon::DiscoverTopology()
{
  return {ReadPdRealData(), ReadRealIdentificationData()};
}
 
std::map<std::uint16_t, rpc::IndexProbeResult> RPCCon::EnumerateIndices(
    std::uint16_t slot, std::uint16_t subslot, std::optional<std::vector<std::uint16_t>> customIndices)
{
  std::vector<std::pair<std::uint16_t, std::string>> probeList;
 
  if (customIndices)
  {
    for (auto idx : *customIndices)
    {
      probeList.emplace_back(idx, GetIndexName(idx));
    }
  }
  else
  {
    auto extend = [&](const IndexNamePairs& src)
    {
      probeList.insert(probeList.end(), src.begin(), src.end());
    };
    extend(ImIndices());
    extend(DiagnosisIndices("subslot"));
    extend(DiagnosisIndices("device"));
    extend(PortIndices());
    extend(InterfaceIndices());
    extend(DeviceIndices());
    probeList.emplace_back(EXPECTED_ID_SUBSLOT, "ExpectedIdentificationData");
    probeList.emplace_back(REAL_ID_SUBSLOT, "RealIdentificationData");
    probeList.emplace_back(MODULE_DIFF_BLOCK, "ModuleDiffBlock");
    probeList.emplace_back(RECORD_INPUT_DATA, "RecordInputData");
    probeList.emplace_back(RECORD_OUTPUT_DATA, "RecordOutputData");
  }
 
  std::map<std::uint16_t, IndexProbeResult> results;
  std::vector<std::uint16_t> seen;
  for (const auto& [idx, Name] : probeList)
  {
    if (std::ranges::find(seen, idx) != seen.end())
    {
      continue;
    }
    seen.push_back(idx);
 
    IndexProbeResult r;
    r.name = Name;
    try
    {
      const PNIODHeader iod = Read(0, slot, subslot, idx);
      if (!iod.payload.empty())
      {
        r.status = "readable";
        r.size = iod.payload.size();
      }
      else
      {
        r.status = "empty";
      }
    }
    catch (const PNIOError& e)
    {
      r.status = "error";
      r.error = e.what();
      r.errorCode1 = e.errorCode1;
      r.errorCode2 = e.errorCode2;
    }
    catch (const RPCError& e)
    {
      r.status = "error";
      r.error = e.what();
    }
    results[idx] = r;
  }
 
  return results;
}
 
Bytes RPCCon::SendControl(BlockType blockType, ControlCommand controlCommand, bool waitResponse,
                          const Bytes& subBlocks)
{
  if (!live)
  {
    throw RPCError("Not connected");
  }
 
  PNBlockHeader block;
  block.blockType = blockType;
  block.blockLength = 28;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODReleaseBlock controlBlock;
  std::memcpy(controlBlock.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
  controlBlock.padding1 = 0;
  controlBlock.arUuid = arUuid;
  controlBlock.sessionKey = sessionKey;
  controlBlock.padding2 = 0;
  controlBlock.controlCommand = controlCommand;
  controlBlock.controlBlockProperties = 0;
 
  Bytes nrdPayload = controlBlock.ToBytes();
  nrdPayload.insert(nrdPayload.end(), subBlocks.begin(), subBlocks.end());
 
  const PNNRDData nrd = CreateNrd(nrdPayload);
  const PNRPCHeader req = CreateRpc(PNRPCHeader::CONTROL, nrd.ToBytes());
 
  if (!waitResponse)
  {
    Bytes rpcBytes = req.ToBytes();
    rpcTransport->Send(rpcBytes);
    return {};
  }
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
  return nrdResp.payload;
}
 
Bytes RPCCon::PrmBegin()
{
  return SendControl(BlockType::ParameterizationBeginRequest, ControlCommand::PrmBegin);
}
Bytes RPCCon::PrmEnd()
{
  return SendControl(BlockType::ControlPrmEndRequest, ControlCommand::PrmEnd);
}
Bytes RPCCon::ReadyForRtClass3()
{
  return SendControl(BlockType::ControlRtClass3Request, ControlCommand::ReadyForRtClass3);
}
 
namespace
{
 
struct RawRpcHeader
{
  std::uint8_t version{}, packetType{}, flags1{}, flags2{}, serialHigh{};
  std::array<std::uint8_t, 4> drep{};
  std::array<std::uint8_t, uuidLenght> objectUuid{}, interfaceUuid{}, activityUuid{};
  std::uint32_t interfaceVersion{}, sequenceNumber{};
  std::uint16_t operationNumber{};
  std::uint8_t serialLow{};
  bool isLittleEndian{};
  Bytes payload;
};
 
std::optional<RawRpcHeader> ParseRawRpcHeader(const Bytes& data)
{
  if (data.size() < PNRPCHeader::kFixedSize)
  {
    return std::nullopt;
  }
  RawRpcHeader h;
  h.version = data[0];    // 0x04
  h.packetType = data[1]; // 0x00 = Request, 0x02 = Response
  h.flags1 = data[2];
  h.flags2 = data[3];
  // drep is 4 bytes (indices 4, 5, 6, 7), drep[0] = 0x10 = Little-Endian, drep[0] = 0x00 = Big-Endian
  h.drep = {data[4], data[5], data[6], data[7]};
 
  std::memcpy(h.objectUuid.data(), &data[8], uuidLenght);
  std::memcpy(h.interfaceUuid.data(), &data[24], uuidLenght);
  std::memcpy(h.activityUuid.data(), &data[40], uuidLenght);
  h.isLittleEndian = (h.drep[0] & 0x10) != 0;
 
  auto u32 = [&](std::size_t off)
  {
    return h.isLittleEndian ? ReadU32Le(&data[off])
                            : static_cast<std::uint32_t>((data[off] << ThreeOctetsShift) | (data[off + 1] << uuidLenght) |
                                                         (data[off + 2] << OneOctetShift) | data[off + 3]);
  };
  auto u16 = [&](std::size_t off)
  {
    return h.isLittleEndian ? ReadU16Le(&data[off])
                            : static_cast<std::uint16_t>((data[off] << OneOctetShift) | data[off + 1]);
  };
 
  // Field offsets per DCE/RPC v4 specification:
  // Bytes 56-59: server_boot_time
  h.interfaceVersion = u32(60);
  h.sequenceNumber = u32(64);
  h.operationNumber = u16(68);
  // Bytes 70-71: interface_hint
  // Bytes 72-73: activity_hint
  // Bytes 74-75: len (args_len)
  // Bytes 76-77: fragnum
  // Byte  78:    auth_proto
  h.serialLow = data[79];
 
  h.payload = Bytes(data.begin() + PNRPCHeader::kFixedSize, data.end());
  return h;
}
 
} // namespace
 
Bytes RPCCon::ApplicationReady(double timeoutSec)
{
  if (!live)
  {
    throw RPCError("Not connected");
  }
 
  auto timeoutInMilliSeconds = std::chrono::floor<std::chrono::milliseconds>(std::chrono::duration<double>(timeoutSec));
  Bytes result;
  try
  {
    while (true)
    {
      Bytes respBytes;
      // This maybe wrong... i am too tired to validate
      // Receive incoming UDP request (and capture sender endpoint if transport supports it)
 
      asio::ip::udp::endpoint senderEndpoint;
      Bytes buf = ccontrolTransport->Receive(timeoutInMilliSeconds, senderEndpoint);
      auto hdr = ParseRawRpcHeader(buf);
      if (!hdr)
      {
        continue;
      }
      if (hdr->packetType != PNRPCHeader::REQUEST)
      {
        continue;
      }
      if (hdr->operationNumber != PNRPCHeader::CONTROL)
      {
        continue;
      }
 
      const Bytes& nrdPayload = hdr->payload;
      if (nrdPayload.size() < 20)
      {
        continue;
      }
      bool le = hdr->isLittleEndian;
      const std::uint32_t nrdActual =
          le ? ReadU32Le(&nrdPayload[16])
             : static_cast<std::uint32_t>((nrdPayload[16] << ThreeOctetsShift) | (nrdPayload[17] << TwoOctetsShift) |
                                          (nrdPayload[18] << OneOctetShift) | nrdPayload[19]);
      (void)nrdActual;
      Bytes nrdBody(nrdPayload.begin() + 20, nrdPayload.end());
      if (nrdBody.size() < 32)
      {
        continue;
      }
      /*
            const std::uint16_t blockType =
 
                le ? ReadU16Le(nrdBody.data()) : static_cast<std::uint16_t>((nrdBody[0] << OneOctetShift) | nrdBody[1]);
            auto controlCmd = static_cast<std::uint16_t>((nrdBody[28] << OneOctetShift) | nrdBody[29]);
 
            if (blockType != BLOCK_IOD_CONTROL_APP_READY_REQ)
            {
              continue;
            }
      */
      // 1. BlockType is ALWAYS Big-Endian (0x0112 = IODControlReq / ApplicationReady)
      const std::uint16_t blockType = (static_cast<std::uint16_t>(nrdBody[0]) << 8) | nrdBody[1];
 
      // 2. ControlCommand is located at offset 28 inside PNIODControlBlockReq
      // (Block Header: 6 bytes + ARUUID: 16 bytes + SessionKey: 2 bytes + Reserved: 4 bytes = 28 bytes)
      const std::uint16_t controlCmd = (static_cast<std::uint16_t>(nrdBody[28]) << 8) | nrdBody[29];
 
      std::cout << "Parsed BlockType: 0x" << std::hex << blockType
                << ", ControlCmd: 0x" << controlCmd << std::dec << "\n";
 
      if (blockType != BLOCK_IOD_CONTROL_APP_READY_REQ) // 0x0112
      {
        std::cerr << "Ignoring non-AppReady block: 0x" << std::hex << blockType << "\n";
        continue;
      }
      // (control_cmd expected to be CONTROL_CMD_APP_READY; devices that
      // deviate are still accepted, mirroring rpc.py's warn-and-continue.)
      //(void)controlCmd;
 
      // Build CControl response: block 0x8112, cmd=DONE.
      PNBlockHeader respBlock;
      respBlock.blockType = BlockType::ControlApplicationReadyResponse;
      respBlock.blockLength = 28;
      respBlock.blockVersionHigh = 0x01;
      respBlock.blockVersionLow = 0x00;
 
      PNIODReleaseBlock respControl;
      std::memcpy(respControl.blockHeader.data(), respBlock.ToBytes().data(), blockHeaderLenght);
      respControl.padding1 = 0;
      respControl.arUuid = arUuid;
      respControl.sessionKey = sessionKey;
      respControl.padding2 = 0;
      respControl.controlCommand = ControlCommand::Done;
      respControl.controlBlockProperties = 0;
 
      Bytes respNrdPayload = respControl.ToBytes();
      auto respNrdLen = static_cast<std::uint32_t>(respNrdPayload.size());
 
      Bytes respNrd;
      if (le)
      {
        WriteU32Le(respNrd, 0);          // pnio_status = OK
        WriteU32Le(respNrd, respNrdLen); // args_length
        WriteU32Le(respNrd, respNrdLen); // maximum_count
        WriteU32Le(respNrd, 0);          // offset
        WriteU32Le(respNrd, respNrdLen); // actual_count
      }
      else
      {
        wire::PutU32(respNrd, 0);
        wire::PutU32(respNrd, respNrdLen);
        wire::PutU32(respNrd, respNrdLen);
        wire::PutU32(respNrd, 0);
        wire::PutU32(respNrd, respNrdLen);
      }
      respNrd.insert(respNrd.end(), respNrdPayload.begin(), respNrdPayload.end());
 
      respBytes.push_back(hdr->version);
      respBytes.push_back(PNRPCHeader::RESPONSE);
      respBytes.push_back(0x00);
      respBytes.push_back(0x00);
      respBytes.insert(respBytes.end(), hdr->drep.begin(), hdr->drep.end());
      // respBytes.push_back(hdr->serialHigh);
      respBytes.insert(respBytes.end(), hdr->objectUuid.begin(), hdr->objectUuid.end());
      respBytes.insert(respBytes.end(), hdr->interfaceUuid.begin(), hdr->interfaceUuid.end());
      respBytes.insert(respBytes.end(), hdr->activityUuid.begin(), hdr->activityUuid.end());
 
      auto putFieldU32 = [&](std::uint32_t v)
      {
        if (le)
        {
          WriteU32Le(respBytes, v);
        }
        else
        {
          wire::PutU32(respBytes, v);
        }
      };
      auto putFieldU16 = [&](std::uint16_t v)
      {
        if (le)
        {
          WriteU16Le(respBytes, v);
        }
        else
        {
          wire::PutU16(respBytes, v);
        }
      };
 
      putFieldU32(0); // server_boot_time
      putFieldU32(hdr->interfaceVersion);
      putFieldU32(hdr->sequenceNumber);
      putFieldU16(hdr->operationNumber);
      putFieldU16(0xFFFF); // interface_hint
      putFieldU16(0xFFFF); // activity_hint
      putFieldU16(static_cast<std::uint16_t>(respNrd.size()));
      putFieldU16(0); // fragment_number
      respBytes.push_back(0);
      respBytes.push_back(hdr->serialLow);
      respBytes.insert(respBytes.end(), respNrd.begin(), respNrd.end());
 
      ccontrolTransport->SendTo(respBytes, senderEndpoint);
 
      live = true;
      liveMonotonic = std::chrono::steady_clock::now();
      result = nrdBody;
      break;
    }
  }
  catch (...)
  {
    throw;
  }
  return result;
}
 
void RPCCon::Disconnect()
{
  if (!live)
  {
    return;
  }
 
  try
  {
    PNBlockHeader block;
    block.blockType = BlockType::ReleaseRequest;
    block.blockLength = 28;
    block.blockVersionHigh = 0x01;
    block.blockVersionLow = 0x00;
 
    PNIODReleaseBlock release;
    std::memcpy(release.blockHeader.data(), block.ToBytes().data(), blockHeaderLenght);
    release.padding1 = 0;
    release.arUuid = arUuid;
    release.sessionKey = sessionKey;
    release.padding2 = 0;
    release.controlCommand = ControlCommand::Release;
    release.controlBlockProperties = 0;
 
    const PNNRDData nrd = CreateNrd(release.ToBytes());
    const PNRPCHeader req = CreateRpc(PNRPCHeader::RELEASE, nrd.ToBytes());
    Bytes rpcBytes = req.ToBytes();
    rpcTransport->Send(rpcBytes);
  }
  // NOLINTNEXTLINE(bugprone-empty-catch)
  catch (...)
  {
    // best-effort, matching rpc.py's disconnect()
  }
 
  live = false;
}
 
void RPCCon::Close() noexcept
{
  Disconnect();
  rpcTransport->Close();
  ccontrolTransport->Close();
}
 
} // namespace profinet::rpc