///|
fn print_usage() -> Unit {
  println("profinet-master CLI")
  println("")
  println("Usage:")
  println(
    "  moon run cmd/main -- identify  [xid] [destination-mac]",
  )
  println(
    "  moon run cmd/main -- get   [selectors] [xid]",
  )
  println(
    "  moon run cmd/main -- get --iface   [selectors] [timeout-ms] [xid]",
  )
  println(
    "  moon run cmd/main -- set-name    [xid]",
  )
  println(
    "  moon run cmd/main -- set-name --iface    [timeout-ms] [xid]",
  )
  println(
    "  moon run cmd/main -- set-ip      [xid]",
  )
  println(
    "  moon run cmd/main -- set-ip --iface      [timeout-ms] [xid]",
  )
  println(
    "  moon run cmd/main -- observe-set-name --iface    [timeout-ms] [observe-window-ms] [xid]",
  )
  println(
    "  moon run cmd/main -- observe-set-ip --iface      [timeout-ms] [observe-window-ms] [xid]",
  )
  println("  moon run cmd/main -- list-ifaces")
  println("  moon run cmd/main -- scan --iface  [timeout-ms]")
  println("  moon run cmd/main -- scan --fixture ")
  println(
    "  moon run cmd/main -- scan --fixtures  ...",
  )
  println(
    "  moon run cmd/main -- rpc-connect --iface   [station-name] [timeout-ms] [ar-uuid] [activity-uuid] [object-uuid]",
  )
  println(
    "  moon run cmd/main -- rpc-release --iface   [station-name] [timeout-ms] [ar-uuid] [activity-uuid] [object-uuid]",
  )
  println(
    "  moon run cmd/main -- rpc-read-iam0 --iface   [station-name] [timeout-ms] [slot subslot] [ar-uuid] [activity-uuid] [object-uuid]",
  )
  println(
    "  moon run cmd/main -- rpc-read-record --iface      [station-name] [timeout-ms] [ar-uuid] [activity-uuid] [object-uuid]",
  )
  println(
    "  moon run cmd/main -- rpc-write-iam1 --iface   [station-name] [timeout-ms] [function-tag] [location-tag] [slot subslot] [ar-uuid] [activity-uuid] [object-uuid]",
  )
  println(
    "  moon run cmd/main -- modify-iam1 --iface     [station-name] [timeout-ms]",
  )
  println(
    "  moon run cmd/main -- snmp-get  [community] [timeout-ms]",
  )
  println(
    "  moon run cmd/main -- lldp-capture --iface  [timeout-ms] [source-mac]",
  )
  println(
    "  moon run cmd/main -- dhcp-discover-live --iface  [timeout-ms] [hostname] [xid] [bind-ip]",
  )
  println(
    "  moon run cmd/main -- pcap-baseline --iface    [timeout-ms] [device-ip] [station-name] [cycle-count] [--clock highres|monotonic-ms|receive-paced(deprecated)] [--period-us ] [--rt-period-us ] [--data-hold-factor <3..0x1E00>] [--data-hold-ms ] [--rt-output-vlan-pcp <0..7>|--rt-output-vlan-tci <0..0xFFFF>] [--win-rt ...]",
  )
  println(
    "  moon run cmd/main -- alarm-listen --iface  [timeout-ms] [source-mac] [--ack]",
  )
  println(
    "  moon run cmd/main -- rpc-b4 --iface   [station-name] [timeout-ms] [finite-cycle-count] [ar-uuid] [activity-uuid] [object-uuid] [--clock highres|monotonic-ms|receive-paced(deprecated)] [--period-us ] [--rt-period-us ] [--data-hold-factor <3..0x1E00>] [--data-hold-ms ] [--rt-output-vlan-pcp <0..7>|--rt-output-vlan-tci <0..0xFFFF>] [--win-rt --win-rt-mask  --win-rt-thread-priority <16..31>]",
  )
  println(
    "  moon run cmd/main -- rpc-b4-update-io --iface     [station-name] [timeout-ms] [finite-cycle-count] [change-cycle] [--clock highres|monotonic-ms|receive-paced(deprecated)] [--period-us ] [--rt-period-us ] [--data-hold-factor <3..0x1E00>] [--data-hold-ms ] [--rt-output-vlan-pcp <0..7>|--rt-output-vlan-tci <0..0xFFFF>] [--win-rt --win-rt-mask  --win-rt-thread-priority <16..31>]",
  )
  println(
    "  moon run cmd/main -- rpc-b4-io-write --iface    [station-name] [timeout-ms] [finite-cycle-count] [--clock highres|monotonic-ms|receive-paced(deprecated)] [--period-us ] [--rt-period-us ] [--data-hold-factor <3..0x1E00>] [--data-hold-ms ] [--rt-output-vlan-pcp <0..7>|--rt-output-vlan-tci <0..0xFFFF>] [--win-rt --win-rt-mask  --win-rt-thread-priority <16..31>]",
  )
  println(
    "  moon run cmd/main -- rpc-b4-read-io --iface   [station-name] [timeout-ms] [finite-cycle-count] [sample-every] [--clock highres|monotonic-ms|receive-paced(deprecated)] [--period-us ] [--rt-period-us ] [--data-hold-factor <3..0x1E00>] [--data-hold-ms ] [--rt-output-vlan-pcp <0..7>|--rt-output-vlan-tci <0..0xFFFF>] [--win-rt --win-rt-mask  --win-rt-thread-priority <16..31>]",
  )
  println(
    "  moon run cmd/main -- rpc-b4-alarm --iface   [station-name] [timeout-ms] [finite-cycle-count] [ar-uuid] [activity-uuid] [object-uuid] [--clock highres|monotonic-ms|receive-paced(deprecated)] [--period-us ] [--rt-period-us ] [--data-hold-factor <3..0x1E00>] [--data-hold-ms ] [--rt-output-vlan-pcp <0..7>|--rt-output-vlan-tci <0..0xFFFF>] [--win-rt --win-rt-mask  --win-rt-thread-priority <16..31>]",
  )
  println("  moon run cmd/main -- gsd-info ")
  println("  moon run cmd/main -- gsd-info-text ")
  println(
    "  moon run cmd/main -- read-pd-port (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pd-port-mrp (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pd-port-mrplc (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pd-interface (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pd-interface-mrp (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pd-port-statistic (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pdev (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- read-pd-real (--file  | --text )",
  )
  println(
    "  moon run cmd/main -- baseline-report [--probe-matrix] [--grouped] [--markdown] [--extensions]",
  )
  println(
    "  moon run cmd/main -- validate-device --fixture   [set-usage-ms] [ip-startup-ms] [reset-to-factory-ms] [ar-release-ms] [autoneg-ms]",
  )
  println(
    "  moon run cmd/main -- validate-device --iface   [timeout-ms] [set-usage-ms] [ip-startup-ms] [reset-to-factory-ms] [ar-release-ms] [autoneg-ms]",
  )
  println(
    "  moon run cmd/main -- validate-device --set-name --iface     [timeout-ms] [observe-window-ms] [xid]",
  )
  println(
    "  moon run cmd/main -- validate-device --set-ip --iface       [timeout-ms] [observe-window-ms] [xid]",
  )
  println("  moon run cmd/main -- gsd-detail ")
  println("  moon run cmd/main -- gsd-detail-text ")
  println("  moon run cmd/main -- profidrive-state ")
  println("  moon run cmd/main -- security-info")
  println("  moon run cmd/main -- decode-alarm ")
  println("  moon run cmd/main -- decode-rpc ")
  println("  moon run cmd/main -- ar-info [station-name]")
  println("  moon run cmd/main -- iocr-info [frame-id]")
  println("  moon run cmd/main -- decode-io ")
  println("  moon run cmd/main -- decode-iam0 ")
  println("  moon run cmd/main -- encode-record-read   ")
  println(
    "  moon run cmd/main -- encode-record-write    ",
  )
  println(
    "  moon run cmd/main -- encode-record-control   [properties]",
  )
  println("  moon run cmd/main -- encode-snmp-get  [community]")
  println("  moon run cmd/main -- decode-lldp ")
  println("  moon run cmd/main -- decode-dhcp ")
  println("  moon run cmd/main -- encode-dhcp-discover  [hostname]")
  println("")
  println("Implemented now:")
  println(
    "  identify   Encode a DCP Identify request and print its raw frame bytes.",
  )
  println(
    "  get        Encode a DCP Get request and print its raw frame bytes.",
  )
  println(
    "             Supported named selectors: all, vendor, name, identity, role, options, alias, instance, oem, ip, mac, full-ip, initiative.",
  )
  println(
    "             Raw selectors may also be passed as : hex bytes, for example 02:02.",
  )
  println(
    "             `get --iface  ...` now prints the provider harness handoff for DCP live get.",
  )
  println(
    "  set-name   Encode a DCP Set NameOfStation request and print its raw frame bytes.",
  )
  println(
    "             `set-name --iface  ...` now prints the provider harness handoff for DCP live set-name.",
  )
  println(
    "             Standard default timeout: 1000 ms; standard default Set/Get retry limit: 2.",
  )
  println(
    "  set-ip     Encode a DCP Set IPParameter request and print its raw frame bytes.",
  )
  println(
    "             `set-ip --iface  ...` now prints the provider harness handoff for DCP live set-ip.",
  )
  println(
    "             Standard default timeout: 1000 ms; standard default Set/Get retry limit: 2.",
  )
  println(
    "  observe-set-name Print the provider harness handoff for DCP live set-name observe flow.",
  )
  println(
    "  observe-set-ip Print the provider harness handoff for DCP live set-ip observe flow.",
  )
  println(
    "  list-ifaces Print the provider harness handoff for native interface discovery.",
  )
  println(
    "  scan       Parse a fixture DCP response and print a device summary.",
  )
  println(
    "             Use `scan --fixtures ...` to aggregate multiple fixture responses with the same de-duplication path as live scan.",
  )
  println(
    "             `scan --iface ` now prints the provider harness handoff for DCP live identify.",
  )
  println(
    "             Standard default timeout: 400 ms; default destination uses pruning MAC 01:0E:CF:00:00:00.",
  )
  println(
    "  gsd-info   Read a GSDML file and print its extracted identity summary.",
  )
  println(
    "  read-pd-port Read a PDPortDataReal fixture and print the normalized record summary.",
  )
  println(
    "  read-pd-port-mrp Read a PDPortMRPDataReal fixture and print the normalized port-binding summary.",
  )
  println(
    "  read-pd-port-mrplc Read a PDPortMRPLCDataReal fixture and print the normalized MRP interconnection summary.",
  )
  println(
    "             Use --file  for fixture files or --text  for inline input.",
  )
  println(
    "  read-pd-interface Read a PDInterfaceDataReal fixture and print the normalized record summary.",
  )
  println(
    "  read-pd-interface-mrp Read a PDInterfaceMRPDataReal fixture and print the normalized redundancy summary.",
  )
  println(
    "  read-pd-port-statistic Read a PDPortStatistic fixture and print the normalized counter summary.",
  )
  println(
    "  read-pdev   Read a PDevData fixture and print the normalized component summary.",
  )
  println(
    "  read-pd-real Read a PDRealData fixture and print the aggregated submodule summary.",
  )
  println(
    "  baseline-report Print the current offline standards baseline covered by the facade.",
  )
  println(
    "             Use `baseline-report --probe-matrix` to print the current probeability matrix.",
  )
  println(
    "             Use `baseline-report --grouped` for sectioned text, `--markdown` for Markdown, and `--extensions` for planned acquisition channel skeletons.",
  )
  println(
    "  validate-device Compare a DCP response fixture or print the provider harness handoff for DCP live validation.",
  )
  println(
    "             Live handoff mode preserves the standard 400 ms identify timeout by default.",
  )
  println(
    "             Output now includes non-bumpless address change flags plus Set_Usage_Time/IP_Startup_Time/Reset_to_Factory_Time limits.",
  )
  println(
    "             Optional observed timing inputs are accepted in ms and classified as within_recommended/within_mandatory/out_of_spec.",
  )
  println(
    "             Current observed timing coverage includes Set_Usage_Time, IP_Startup_Time, Reset_to_Factory_Time, AR_Resource_Release_Timeout, and Autonegotiation timeout.",
  )
  println(
    "             Live set validation modes can auto-send DCP set requests, wait for observed convergence, then emit a combined validation report.",
  )
  println("  decode-alarm Decode a PROFINET alarm notification from hex bytes.")
  println("  decode-rpc Decode a DCE/RPC header from hex bytes.")
  println(
    "  ar-info    Print a default AR block request for the given station name.",
  )
  println(
    "  iocr-info  Print a default IOCR block request for the given frame id.",
  )
  println("  decode-io  Decode a PROFINET IO cyclic frame from hex bytes.")
  println("  decode-iam0 Decode an I&M0 record from hex bytes.")
  println(
    "  encode-record-read Encode an IODReadReqHeader and print hex + summary.",
  )
  println(
    "  encode-record-write Encode an IODWriteReqHeader and print hex + summary.",
  )
  println(
    "  encode-record-control Encode an IODControlReq for prmend, application-ready, release, done, or a raw command value.",
  )
  println("  encode-snmp-get Encode a SNMP GetRequest for the given OID.")
  println(
    "  snmp-get  Print the provider harness handoff for SNMP live helper requests.",
  )
  println(
    "  decode-lldp Decode LLDP TLVs from hex bytes and print neighbor info.",
  )
  println(
    "  lldp-capture Print the provider harness handoff for LLDP raw capture.",
  )
  println("  decode-dhcp Decode a DHCP message from hex bytes.")
  println(
    "  encode-dhcp-discover Encode a DHCP discover message and print hex.",
  )
  println(
    "  dhcp-discover-live Print the provider harness handoff for DHCP live helper traffic.",
  )
  println(
    "  pcap-baseline Print the provider harness handoff for Lockwire-owned pcap baseline recording.",
  )
  println(
    "  alarm-listen Print the provider harness handoff for alarm listener traffic.",
  )
  println(
    "  rpc-connect Print the provider harness handoff for CA400 Connect live traffic.",
  )
  println(
    "  rpc-release Print the provider harness handoff for Release live traffic.",
  )
  println(
    "  rpc-read-iam0 Print the provider harness handoff for I&M0 record read traffic.",
  )
  println(
    "  rpc-read-record Print the provider harness handoff for record read traffic.",
  )
  println(
    "  rpc-write-iam1 Print the provider harness handoff for I&M1 record write traffic.",
  )
  println(
    "  modify-iam1 Print the provider harness handoff for I&M1 Function/Location tag update traffic.",
  )
  println(
    "  rpc-b4     Print the provider harness handoff for CA400 RT cyclic exchange.",
  )
  println(
    "             Omit finite-cycle-count for continuous RT exchange; Ctrl+C stops the process.",
  )
  println(
    "             Optional --clock selects the pacing loop; default is highres (deadline-paced). monotonic-ms is comparison-only and logs its 32-bit ms wrap risk; receive-paced is deprecated.",
  )
  println(
    "             Optional --period-us sets both IOCR send_clock_factor/reduction_ratio and the local RT send period; --rt-period-us is local-loop only.",
  )
  println(
    "             Optional --data-hold-factor / --data-hold-ms override Data-RTC DHF explicitly; automatic DHF stays in the mandatory 0x0003..0x00FF range.",
  )
  println(
    "             Optional --win-rt enables the Windows IoT realtime priority path; pass --win-rt-mask  for reserved-core affinity.",
  )
  println(
    "  rpc-b4-io-write Print the provider harness handoff for RT output writes.",
  )
  println(
    "  rpc-b4-read-io Print the provider harness handoff for RT input sampling.",
  )
  println(
    "  rpc-b4-alarm Print the provider harness handoff for RT-cycle alarm handling.",
  )
}

///|
fn parse_optional_int_arg(
  args : Array[String],
  index : Int,
  label : String,
) -> Int? {
  if args.length() <= index {
    None
  } else {
    try @string.parse_int(args[index][:]) catch {
      _ => {
        println("Invalid \{label}. Expected a decimal integer.")
        return None
      }
    } noraise {
      value => Some(value)
    }
  }
}

///|
fn parse_xid_or_default(args : Array[String], index : Int) -> Int? {
  if args.length() > index {
    try @string.parse_int(args[index][:]) catch {
      _ => None
    } noraise {
      value => Some(value)
    }
  } else {
    Some(16909060)
  }
}

///|
fn run_identify(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    print_usage()
    return
  }
  let source_mac = args[0]
  let xid = if args.length() >= 2 {
    @string.parse_int(args[1][:]) catch {
      _ => {
        println("Invalid xid. Expected a decimal integer.")
        return
      }
    }
  } else {
    16909060
  }
  let destination_mac = if args.length() >= 3 {
    args[2][:]
  } else {
    "01:0E:CF:00:00:00"
  }
  try {
    let encoded = @lib.encode_dcp_identify_request_hex(
      source_mac[:],
      destination_mac~,
      xid~,
    )
    println(encoded)
  } catch {
    err => println("Failed to encode identify request: \{to_repr(err)}")
  }
}

///|
fn run_get(args : Array[String]) -> Unit {
  if args.length() >= 3 && args[0] == "--iface" {
    let selectors = if args.length() >= 4 { args[3][:] } else { "all" }
    let timeout_ms = if args.length() >= 5 {
      @string.parse_int(args[4][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let xid = if args.length() >= 6 {
      @string.parse_int(args[5][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "get",
        "@lib.live_get_dcp_response -> @rawnet.RawSocket",
        [
          "interface=" + args[1],
          "destination_mac=" + args[2],
          "selectors=" + selectors.to_owned(),
          "timeout_ms=" + timeout_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  guard args.length() >= 2 else {
    print_usage()
    return
  }
  let selectors = if args.length() >= 3 { args[2][:] } else { "all" }
  let xid = if args.length() >= 4 {
    @string.parse_int(args[3][:]) catch {
      _ => {
        println("Invalid xid. Expected a decimal integer.")
        return
      }
    }
  } else {
    16909060
  }
  try {
    let encoded = @lib.encode_dcp_get_request_hex(
      args[0][:],
      args[1][:],
      selectors~,
      xid~,
    )
    println(encoded)
  } catch {
    err => println("Failed to encode get request: \{to_repr(err)}")
  }
}

///|
fn run_set_name(args : Array[String]) -> Unit {
  if args.length() >= 4 && args[0] == "--iface" {
    let timeout_ms = if args.length() >= 5 {
      @string.parse_int(args[4][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let xid = if args.length() >= 6 {
      @string.parse_int(args[5][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "set-name",
        "@lib.live_set_station_name -> @rawnet.RawSocket",
        [
          "interface=" + args[1],
          "destination_mac=" + args[2],
          "station_name=" + args[3],
          "timeout_ms=" + timeout_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  guard args.length() >= 3 else {
    print_usage()
    return
  }
  let xid = match parse_xid_or_default(args, 3) {
    Some(value) => value
    None => {
      println("Invalid xid. Expected a decimal integer.")
      return
    }
  }
  try {
    let encoded = @lib.encode_dcp_set_name_request_hex(
      args[0][:],
      args[1][:],
      args[2],
      xid~,
    )
    println(encoded)
  } catch {
    err => println("Failed to encode set-name request: \{to_repr(err)}")
  }
}

///|
fn run_set_ip(args : Array[String]) -> Unit {
  if args.length() >= 6 && args[0] == "--iface" {
    let timeout_ms = if args.length() >= 7 {
      @string.parse_int(args[6][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let xid = if args.length() >= 8 {
      @string.parse_int(args[7][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "set-ip",
        "@lib.live_set_ip_parameters -> @rawnet.RawSocket",
        [
          "interface=" + args[1],
          "destination_mac=" + args[2],
          "ip=" + args[3],
          "mask=" + args[4],
          "gateway=" + args[5],
          "timeout_ms=" + timeout_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  guard args.length() >= 5 else {
    print_usage()
    return
  }
  let xid = match parse_xid_or_default(args, 5) {
    Some(value) => value
    None => {
      println("Invalid xid. Expected a decimal integer.")
      return
    }
  }
  try {
    let encoded = @lib.encode_dcp_set_ip_request_hex(
      args[0][:],
      args[1][:],
      args[2][:],
      args[3][:],
      args[4][:],
      xid~,
    )
    println(encoded)
  } catch {
    err => println("Failed to encode set-ip request: \{to_repr(err)}")
  }
}

///|
fn run_observe_set_name(args : Array[String]) -> Unit {
  if args.length() >= 4 && args[0] == "--iface" {
    let timeout_ms = if args.length() >= 5 {
      @string.parse_int(args[4][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let observe_window_ms = if args.length() >= 6 {
      @string.parse_int(args[5][:]) catch {
        _ => {
          println("Invalid observe window. Expected a decimal integer.")
          return
        }
      }
    } else {
      2000
    }
    let xid = if args.length() >= 7 {
      @string.parse_int(args[6][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "observe-set-name",
        "@lib.observe_live_set_station_name -> @rawnet.RawSocket",
        [
          "interface=" + args[1],
          "destination_mac=" + args[2],
          "station_name=" + args[3],
          "timeout_ms=" + timeout_ms.to_string(),
          "observe_window_ms=" + observe_window_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  println(
    "observe-set-name supports: --iface    [timeout-ms] [observe-window-ms] [xid]",
  )
}

///|
fn run_observe_set_ip(args : Array[String]) -> Unit {
  if args.length() >= 6 && args[0] == "--iface" {
    let timeout_ms = if args.length() >= 7 {
      @string.parse_int(args[6][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let observe_window_ms = if args.length() >= 8 {
      @string.parse_int(args[7][:]) catch {
        _ => {
          println("Invalid observe window. Expected a decimal integer.")
          return
        }
      }
    } else {
      2000
    }
    let xid = if args.length() >= 9 {
      @string.parse_int(args[8][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "observe-set-ip",
        "@lib.observe_live_set_ip_parameters -> @rawnet.RawSocket",
        [
          "interface=" + args[1],
          "destination_mac=" + args[2],
          "ip=" + args[3],
          "mask=" + args[4],
          "gateway=" + args[5],
          "timeout_ms=" + timeout_ms.to_string(),
          "observe_window_ms=" + observe_window_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  println(
    "observe-set-ip supports: --iface      [timeout-ms] [observe-window-ms] [xid]",
  )
}

///|
fn run_scan(args : Array[String]) -> Unit {
  if args.length() == 2 && args[0] == "--fixture" {
    println(@lib.summarize_dcp_response_hex(args[1][:])) catch {
      err => println("Failed to parse response fixture: \{to_repr(err)}")
    }
    return
  }
  if args.length() >= 2 && args[0] == "--fixtures" {
    println(@lib.summarize_dcp_response_hexes(args[1:].to_owned())) catch {
      err => println("Failed to parse response fixtures: \{to_repr(err)}")
    }
    return
  }
  if args.length() >= 2 && args[0] == "--iface" {
    let timeout_ms = if args.length() >= 3 {
      @string.parse_int(args[2][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_identify_timeout_ms()
    }
    println(
      provider_harness_dcp_handoff_text(
        "scan",
        "@lib.scan_dcp_devices_text -> @rawnet.RawSocket",
        ["interface=" + args[1], "timeout_ms=" + timeout_ms.to_string()],
      ),
    )
    return
  }
  println(
    "scan supports: --fixture , --fixtures  ..., or --iface  [timeout-ms]",
  )
}

///|
/// Probe the device's CL-RPC (DCE/RPC over UDP) endpoint to verify the UDP
/// transport reaches the wire. This is the b1 transport slice for live AR:
/// AR Connect/Release ride UDP to port 34964, unlike DCP's raw Ethernet. A full
/// Connect.req (with AR/IOCR/ExpectedSubmodule/AlarmCR blocks) comes in a later
/// slice; for now the device will not reply to this minimal probe.
fn run_rpc_probe(args : Array[String]) -> Unit {
  if args.length() < 1 {
    println("rpc-probe  [port] [timeout-ms]")
    return
  }
  let device_ip = @frame.IPv4Address::from_text(args[0][:]) catch {
    err => {
      println("Invalid device IP: \{to_repr(err)}")
      return
    }
  }
  let port = if args.length() >= 2 {
    @string.parse_int(args[1][:]) catch {
      _ => {
        println("Invalid port. Expected a decimal integer.")
        return
      }
    }
  } else {
    @rpc.rpc_udp_port
  }
  let timeout_ms = if args.length() >= 3 {
    @string.parse_int(args[2][:]) catch {
      _ => {
        println("Invalid timeout. Expected a decimal integer.")
        return
      }
    }
  } else {
    1000
  }
  println(
    provider_harness_helper_handoff_text(
      "rpc-probe",
      "Endpoint Mapper helper",
      "@udpnet.UdpSocket::open",
      [
        "device_ip=" + device_ip.to_text(),
        "port=" + port.to_string(),
        "timeout_ms=" + timeout_ms.to_string(),
      ],
    ),
  )
}

///|
fn provider_harness_handoff_text(
  command : String,
  legacy_surface : String,
  next_task : String,
) -> String {
  [
    "status=moved_to_provider_harness",
    "command=" + command,
    "provider_harness=fieldbus_core/profinet_master_harness",
    "provider_stack=profinet_master",
    "legacy_surface=" + legacy_surface,
    "lockwire_dependency_in_profinet=false",
    "live_open_attempted=false",
    "next_task=" + next_task,
  ].join("\n")
}

///|
fn provider_harness_dcp_handoff_text(
  command : String,
  legacy_surface : String,
  fields : Array[String],
) -> String {
  let lines : Array[String] = [
    "status=moved_to_provider_harness",
    "command=" + command,
    "provider_harness=fieldbus_core/profinet_master_harness",
    "provider_stack=profinet_master",
    "provider_harness_entry=profinet_dcp_live_command_handoffs",
    "protocol_stage=DCP",
    "legacy_surface=" + legacy_surface,
    "lockwire_dependency_in_profinet=false",
    "live_open_attempted=false",
    "next_task=D63B3-PROFINET-CMD-HELPER-LIVE-HANDOFF",
  ]
  for field in fields {
    lines.push(field)
  }
  lines.join("\n")
}

///|
fn provider_harness_helper_handoff_text(
  command : String,
  protocol_stage : String,
  legacy_surface : String,
  fields : Array[String],
) -> String {
  let lines : Array[String] = [
    "status=moved_to_provider_harness",
    "command=" + command,
    "provider_harness=fieldbus_core/profinet_master_harness",
    "provider_stack=profinet_master",
    "provider_harness_entry=profinet_helper_live_command_handoffs",
    "protocol_stage=" + protocol_stage,
    "legacy_surface=" + legacy_surface,
    "lockwire_dependency_in_profinet=false",
    "live_open_attempted=false",
    "next_task=D63B4-PROFINET-CMD-RT-PCAP-HANDOFF",
  ]
  for field in fields {
    lines.push(field)
  }
  lines.join("\n")
}

///|
fn run_list_ifaces(args : Array[String]) -> Unit {
  if args.length() != 0 {
    println("list-ifaces takes no arguments")
    return
  }
  println(
    provider_harness_handoff_text(
      "list-ifaces", "@rawnet.list_interfaces", "D63B2-PROFINET-CMD-DCP-LIVE-HANDOFF",
    ),
  )
}

///|
fn run_gsd_info_text(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    print_usage()
    return
  }
  let xml_text = args.join(" ")
  println(@lib.parse_gsdml_summary_text(xml_text)) catch {
    err => println("Failed to parse GSDML text: \{to_repr(err)}")
  }
}

///|
fn run_gsd_info(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    print_usage()
    return
  }
  println(@lib.parse_gsdml_summary_file(args[0][:])) catch {
    err => println("Failed to parse GSDML file: \{to_repr(err)}")
  }
}

///|
fn read_fixture_input(args : Array[String], command : String) -> String? {
  if args.length() >= 2 && args[0] == "--text" {
    Some(args[1])
  } else if args.length() >= 2 && args[0] == "--file" {
    try @gsd.read_text_file(args[1][:]) catch {
      err => {
        println("Failed to read fixture file: \{to_repr(err)}")
        None
      }
    } noraise {
      content => Some(content)
    }
  } else {
    println("\{command} supports: --file  or --text ")
    None
  }
}

///|
fn run_read_pd_port(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-port") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_port_data_real(fixture))
}

///|
fn run_read_pd_port_mrp(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-port-mrp") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_port_mrp_data_real(fixture))
}

///|
fn run_read_pd_port_mrplc(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-port-mrplc") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_port_mrplc_data_real(fixture))
}

///|
fn run_read_pd_interface(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-interface") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_interface_data_real(fixture))
}

///|
fn run_read_pd_interface_mrp(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-interface-mrp") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_interface_mrp_data_real(fixture))
}

///|
fn run_read_pd_port_statistic(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-port-statistic") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_port_statistic(fixture))
}

///|
fn run_read_pdev(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pdev") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pdev_data(fixture))
}

///|
fn run_read_pd_real(args : Array[String]) -> Unit {
  let fixture = match read_fixture_input(args, "read-pd-real") {
    Some(content) => content
    None => return
  }
  println(@lib.read_pd_real_data(fixture))
}

///|
fn run_baseline_report(args : Array[String]) -> Unit {
  let probe_matrix = args.contains("--probe-matrix")
  let grouped = args.contains("--grouped")
  let markdown = args.contains("--markdown")
  let extensions = args.contains("--extensions")
  if extensions {
    if markdown {
      println(@lib.acquisition_channel_skeleton_markdown_report())
    } else {
      println(@lib.acquisition_channel_skeleton_report())
    }
  } else if probe_matrix {
    if markdown {
      println(@lib.probeability_matrix_markdown_report())
    } else {
      println(@lib.probeability_matrix_report())
    }
  } else if markdown {
    println(@lib.standard_baseline_markdown_report())
  } else if grouped {
    println(@lib.standard_baseline_grouped_report())
  } else {
    println(@lib.standard_baseline_report())
  }
}

///|
fn run_validate_device(args : Array[String]) -> Unit {
  if args.length() >= 6 && args[0] == "--set-name" && args[1] == "--iface" {
    let timeout_ms = if args.length() >= 7 {
      @string.parse_int(args[6][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let observe_window_ms = if args.length() >= 8 {
      @string.parse_int(args[7][:]) catch {
        _ => {
          println("Invalid observe window. Expected a decimal integer.")
          return
        }
      }
    } else {
      2000
    }
    let xid = if args.length() >= 9 {
      @string.parse_int(args[8][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "validate-device",
        "@lib.validate_live_set_name_against_gsd_file -> @rawnet.RawSocket",
        [
          "mode=set-name",
          "interface=" + args[2],
          "destination_mac=" + args[3],
          "station_name=" + args[4],
          "gsd_path=" + args[5],
          "timeout_ms=" + timeout_ms.to_string(),
          "observe_window_ms=" + observe_window_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  if args.length() >= 8 && args[0] == "--set-ip" && args[1] == "--iface" {
    let timeout_ms = if args.length() >= 9 {
      @string.parse_int(args[8][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_set_get_timeout_ms()
    }
    let observe_window_ms = if args.length() >= 10 {
      @string.parse_int(args[9][:]) catch {
        _ => {
          println("Invalid observe window. Expected a decimal integer.")
          return
        }
      }
    } else {
      2000
    }
    let xid = if args.length() >= 11 {
      @string.parse_int(args[10][:]) catch {
        _ => {
          println("Invalid xid. Expected a decimal integer.")
          return
        }
      }
    } else {
      16909060
    }
    println(
      provider_harness_dcp_handoff_text(
        "validate-device",
        "@lib.validate_live_set_ip_against_gsd_file -> @rawnet.RawSocket",
        [
          "mode=set-ip",
          "interface=" + args[2],
          "destination_mac=" + args[3],
          "ip=" + args[4],
          "mask=" + args[5],
          "gateway=" + args[6],
          "gsd_path=" + args[7],
          "timeout_ms=" + timeout_ms.to_string(),
          "observe_window_ms=" + observe_window_ms.to_string(),
          "xid=" + xid.to_string(),
        ],
      ),
    )
    return
  }
  if args.length() >= 3 && args[0] == "--fixture" {
    let observed_set_usage_ms = parse_optional_int_arg(args, 3, "set-usage-ms")
    if args.length() > 3 && observed_set_usage_ms is None {
      return
    }
    let observed_ip_startup_ms = parse_optional_int_arg(
      args, 4, "ip-startup-ms",
    )
    if args.length() > 4 && observed_ip_startup_ms is None {
      return
    }
    let observed_reset_to_factory_ms = parse_optional_int_arg(
      args, 5, "reset-to-factory-ms",
    )
    if args.length() > 5 && observed_reset_to_factory_ms is None {
      return
    }
    let observed_ar_release_ms = parse_optional_int_arg(
      args, 6, "ar-release-ms",
    )
    if args.length() > 6 && observed_ar_release_ms is None {
      return
    }
    let observed_autoneg_ms = parse_optional_int_arg(args, 7, "autoneg-ms")
    if args.length() > 7 && observed_autoneg_ms is None {
      return
    }
    println(
      @lib.validate_device_fixture_against_gsd_file_with_timings(
        args[1][:],
        args[2][:],
        observed_set_usage_ms~,
        observed_ip_startup_ms~,
        observed_reset_to_factory_ms~,
        observed_ar_resource_release_ms=observed_ar_release_ms,
        observed_autonegotiation_ms=observed_autoneg_ms,
      ),
    ) catch {
      err => println("Failed to validate device fixture: \{to_repr(err)}")
    }
    return
  }
  if args.length() >= 3 && args[0] == "--iface" {
    let timeout_ms = if args.length() >= 4 {
      @string.parse_int(args[3][:]) catch {
        _ => {
          println("Invalid timeout. Expected a decimal integer.")
          return
        }
      }
    } else {
      @lib.default_dcp_identify_timeout_ms()
    }
    let observed_set_usage_ms = parse_optional_int_arg(args, 4, "set-usage-ms")
    if args.length() > 4 && observed_set_usage_ms is None {
      return
    }
    let observed_ip_startup_ms = parse_optional_int_arg(
      args, 5, "ip-startup-ms",
    )
    if args.length() > 5 && observed_ip_startup_ms is None {
      return
    }
    let observed_reset_to_factory_ms = parse_optional_int_arg(
      args, 6, "reset-to-factory-ms",
    )
    if args.length() > 6 && observed_reset_to_factory_ms is None {
      return
    }
    let observed_ar_release_ms = parse_optional_int_arg(
      args, 7, "ar-release-ms",
    )
    if args.length() > 7 && observed_ar_release_ms is None {
      return
    }
    let observed_autoneg_ms = parse_optional_int_arg(args, 8, "autoneg-ms")
    if args.length() > 8 && observed_autoneg_ms is None {
      return
    }
    let fields : Array[String] = [
      "mode=scan",
      "interface=" + args[1],
      "gsd_path=" + args[2],
      "timeout_ms=" + timeout_ms.to_string(),
    ]
    match observed_set_usage_ms {
      Some(value) => fields.push("set_usage_ms=" + value.to_string())
      None => ()
    }
    match observed_ip_startup_ms {
      Some(value) => fields.push("ip_startup_ms=" + value.to_string())
      None => ()
    }
    match observed_reset_to_factory_ms {
      Some(value) => fields.push("reset_to_factory_ms=" + value.to_string())
      None => ()
    }
    match observed_ar_release_ms {
      Some(value) => fields.push("ar_release_ms=" + value.to_string())
      None => ()
    }
    match observed_autoneg_ms {
      Some(value) => fields.push("autoneg_ms=" + value.to_string())
      None => ()
    }
    println(
      provider_harness_dcp_handoff_text(
        "validate-device", "@lib.validate_scanned_devices_against_gsd_file_with_timings -> @rawnet.RawSocket",
        fields,
      ),
    )
    return
  }
  println(
    "validate-device supports: --fixture   [set-usage-ms] [ip-startup-ms] [reset-to-factory-ms] [ar-release-ms] [autoneg-ms] or --iface   [timeout-ms] [set-usage-ms] [ip-startup-ms] [reset-to-factory-ms] [ar-release-ms] [autoneg-ms] or --set-name --iface     [timeout-ms] [observe-window-ms] [xid] or --set-ip --iface       [timeout-ms] [observe-window-ms] [xid]",
  )
}

///|
fn run_gsd_detail(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: gsd-detail ")
    return
  }
  let xml = @gsd.read_text_file(args[0][:]) catch {
    err => {
      println("Failed to read file: \{to_repr(err)}")
      return
    }
  }
  let detail = @gsd.parse_gsdml_detail(xml) catch {
    e => {
      println("Error: \{to_repr(e)}")
      return
    }
  }
  println(@gsd.format_gsd_detail(detail))
}

///|
fn run_gsd_detail_text(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: gsd-detail-text ")
    return
  }
  let text = @lib.parse_gsdml_detail_text(args[0]) catch {
    e => {
      println("Error: \{to_repr(e)}")
      return
    }
  }
  println(text)
}

///|
fn run_profidrive_state(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: profidrive-state ")
    println("  Example: profidrive-state 0x0007")
    return
  }
  let zsw1_str = args[0]
  let zsw1 = if zsw1_str.has_prefix("0x") || zsw1_str.has_prefix("0X") {
    parse_hex(zsw1_str.view(start_offset=2))
  } else {
    @string.parse_int(zsw1_str[:]) catch {
      _ => 0
    }
  }
  println(@lib.profidrive_state_from_zsw1(zsw1))
}

///|
fn run_security_info(_args : Array[String]) -> Unit {
  println("=== PROFINET Security Profiles ===")
  println(
    "ANY:       " +
    @lib.security_format_info(
      @security.SecurityMode::Any,
      @security.AeadAlgorithm::AES_256_GCM,
    ),
  )
  println(
    "PROTECTED: " +
    @lib.security_format_info(
      @security.SecurityMode::Protected,
      @security.AeadAlgorithm::AES_256_GCM,
    ),
  )
  println("")
  println("Supported algorithms:")
  println(
    "  " +
    @lib.security_format_info(
      @security.SecurityMode::Any,
      @security.AeadAlgorithm::AES_128_GCM,
    ),
  )
  println(
    "  " +
    @lib.security_format_info(
      @security.SecurityMode::Any,
      @security.AeadAlgorithm::AES_256_GCM,
    ),
  )
  println(
    "  " +
    @lib.security_format_info(
      @security.SecurityMode::Any,
      @security.AeadAlgorithm::ChaCha20_Poly1305,
    ),
  )
  println("")
  println("Secure Frame IDs: AlarmHigh=0xFC41, AlarmLow=0xFE41")
}

///|
fn run_decode_alarm(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: decode-alarm ")
    return
  }
  println(@lib.decode_alarm_notification_hex(args[0][:])) catch {
    err => println("Failed to decode alarm: \{to_repr(err)}")
  }
}

///|
fn run_decode_rpc(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: decode-rpc ")
    return
  }
  println(@lib.decode_rpc_header_hex(args[0][:])) catch {
    err => println("Failed to decode RPC header: \{to_repr(err)}")
  }
}

///|
fn run_format_ar(args : Array[String]) -> Unit {
  let station_name = if args.length() >= 1 { args[0] } else { "controller" }
  println(@lib.format_ar_block_req_default(station_name))
}

///|
fn run_format_iocr(args : Array[String]) -> Unit {
  let frame_id = if args.length() >= 1 {
    if args[0].has_prefix("0x") || args[0].has_prefix("0X") {
      parse_hex(args[0].view(start_offset=2))
    } else {
      @string.parse_int(args[0][:]) catch {
        _ => 0x8000
      }
    }
  } else {
    0x8000
  }
  println(@lib.format_iocr_block_req_default(frame_id))
}

///|
fn run_decode_io(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: decode-io ")
    return
  }
  println(@lib.decode_io_cyclic_frame_hex(args[0][:])) catch {
    err => println("Failed to decode IO frame: \{to_repr(err)}")
  }
}

///|
fn run_decode_iam0(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: decode-iam0 ")
    return
  }
  println(@lib.decode_iam0_hex(args[0][:])) catch {
    err => println("Failed to decode I&M0: \{to_repr(err)}")
  }
}

///|
fn parse_number_arg(text : String, label : String) -> Int? {
  if text.has_prefix("0x") || text.has_prefix("0X") {
    Some(parse_hex(text.view(start_offset=2)))
  } else {
    try @string.parse_int(text[:]) catch {
      _ => {
        println(
          "Invalid \{label}. Expected a decimal integer or 0x-prefixed hex.",
        )
        return None
      }
    } noraise {
      value => Some(value)
    }
  }
}

///|
fn format_record_write_req(req : @record.IODWriteReqHeader) -> String {
  let lines : Array[String] = []
  lines.push("seq=" + req.seq_number.to_string())
  lines.push("ar_uuid=" + req.ar_uuid.to_hex())
  lines.push("api=" + req.api.to_string())
  lines.push("slot=" + req.slot_number.to_string())
  lines.push("subslot=" + req.subslot_number.to_string())
  lines.push("index=0x" + @frame.uint16_to_hex(req.index))
  lines.push("record_data_length=" + req.record_data_length.to_string())
  lines.join("\n")
}

///|
fn parse_record_control_command(text : String) -> Int? {
  match text {
    "prmend" | "PrmEnd" => Some(@record.control_command_prmend)
    "application-ready" | "application_ready" | "ApplicationReady" =>
      Some(@record.control_command_application_ready)
    "release" | "Release" => Some(@record.control_command_release)
    "done" | "Done" => Some(@record.control_command_done)
    _ => parse_number_arg(text, "control command")
  }
}

///|
fn run_encode_record_read(args : Array[String]) -> Unit {
  guard args.length() >= 3 else {
    println("Usage: encode-record-read   ")
    println("  Example: encode-record-read 0 1 0xF820")
    return
  }
  let slot = @string.parse_int(args[0][:]) catch {
    _ => {
      println("Invalid slot number.")
      return
    }
  }
  let subslot = @string.parse_int(args[1][:]) catch {
    _ => {
      println("Invalid subslot number.")
      return
    }
  }
  let index = if args[2].has_prefix("0x") || args[2].has_prefix("0X") {
    parse_hex(args[2].view(start_offset=2))
  } else {
    @string.parse_int(args[2][:]) catch {
      _ => {
        println("Invalid index.")
        return
      }
    }
  }
  println(@lib.format_record_read_req(slot, subslot, index))
  println("hex: " + @lib.encode_record_read_hex(slot, subslot, index))
}

///|
fn run_encode_record_write(args : Array[String]) -> Unit {
  guard args.length() >= 4 else {
    println(
      "Usage: encode-record-write    ",
    )
    println("  Example: encode-record-write 0 1 0xAFF1 32")
    return
  }
  let slot = match parse_number_arg(args[0], "slot number") {
    Some(value) => value
    None => return
  }
  let subslot = match parse_number_arg(args[1], "subslot number") {
    Some(value) => value
    None => return
  }
  let index = match parse_number_arg(args[2], "index") {
    Some(value) => value
    None => return
  }
  let record_data_length = match
    parse_number_arg(args[3], "record data length") {
    Some(value) => value
    None => return
  }
  let req = @record.IODWriteReqHeader::{
    seq_number: 0,
    ar_uuid: @rpc.Uuid::empty(),
    api: 0,
    slot_number: slot,
    subslot_number: subslot,
    index,
    record_data_length,
  }
  println(format_record_write_req(req))
  println(
    "hex: " +
    @frame.bytes_to_hex(@record.encode_iod_write_req_header(req), separator=""),
  )
}

///|
fn run_encode_record_control(args : Array[String]) -> Unit {
  guard args.length() >= 2 else {
    println("Usage: encode-record-control   [properties]")
    println(
      "  Commands: prmend, application-ready, release, done, or a raw value",
    )
    println("  Example: encode-record-control 1 prmend")
    return
  }
  let session_key = match parse_number_arg(args[0], "session key") {
    Some(value) => value
    None => return
  }
  let control_command = match parse_record_control_command(args[1]) {
    Some(value) => value
    None => return
  }
  let control_block_properties = if args.length() >= 3 {
    match parse_number_arg(args[2], "control block properties") {
      Some(value) => value
      None => return
    }
  } else {
    0
  }
  let req = @record.IODControlReq::{
    ar_uuid: @rpc.Uuid::empty(),
    session_key,
    control_command,
    control_block_properties,
  }
  println(@record.format_iod_control(req))
  println(
    "hex: " +
    @frame.bytes_to_hex(@record.encode_iod_control_req(req), separator=""),
  )
}

///|
fn run_encode_snmp_get(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: encode-snmp-get  [community]")
    println("  Example: encode-snmp-get 1.3.6.1.2.1.1.1")
    return
  }
  let oid = args[0]
  let community = if args.length() >= 2 { args[1] } else { "public" }
  println("hex: " + @lib.encode_snmp_get_hex(oid, community))
}

///|
fn run_decode_lldp(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: decode-lldp ")
    return
  }
  println(@lib.decode_lldp_hex(args[0][:])) catch {
    err => println("Failed to decode LLDP: \{to_repr(err)}")
  }
}

///|
fn run_decode_dhcp(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: decode-dhcp ")
    return
  }
  println(@lib.decode_dhcp_hex(args[0][:])) catch {
    err => println("Failed to decode DHCP: \{to_repr(err)}")
  }
}

///|
fn run_encode_dhcp_discover(args : Array[String]) -> Unit {
  guard args.length() >= 1 else {
    println("Usage: encode-dhcp-discover  [hostname]")
    println("  Example: encode-dhcp-discover 00:11:22:33:44:55 myhost")
    return
  }
  let hostname = if args.length() >= 2 { args[1] } else { "" }
  println(@lib.encode_dhcp_discover_hex(args[0][:], hostname)) catch {
    err => println("Failed to encode DHCP discover: \{to_repr(err)}")
  }
}

///|
fn parse_hex(s : StringView) -> Int {
  let mut result = 0
  for ch in s {
    let d = if ch >= '0' && ch <= '9' {
      ch.to_int() - '0'.to_int()
    } else if ch >= 'a' && ch <= 'f' {
      ch.to_int() - 'a'.to_int() + 10
    } else if ch >= 'A' && ch <= 'F' {
      ch.to_int() - 'A'.to_int() + 10
    } else {
      0
    }
    result = (result << 4) | d
  }
  result
}

///|
fn main {
  let args = @env.args()
  guard args.length() >= 2 else {
    print_usage()
    return
  }
  match args[1] {
    "identify" => run_identify(args[2:].to_owned())
    "get" => run_get(args[2:].to_owned())
    "list-ifaces" => run_list_ifaces(args[2:].to_owned())
    "scan" => run_scan(args[2:].to_owned())
    "set-name" => run_set_name(args[2:].to_owned())
    "set-ip" => run_set_ip(args[2:].to_owned())
    "observe-set-name" => run_observe_set_name(args[2:].to_owned())
    "observe-set-ip" => run_observe_set_ip(args[2:].to_owned())
    "rpc-probe" => run_rpc_probe(args[2:].to_owned())
    "rpc-connect" => run_rpc_connect(args[2:].to_owned())
    "rpc-release" => run_rpc_release(args[2:].to_owned())
    "rpc-read-iam0" => run_rpc_read_iam0(args[2:].to_owned())
    "rpc-read-record" => run_rpc_read_record(args[2:].to_owned())
    "rpc-write-iam1" => run_rpc_write_iam1(args[2:].to_owned())
    "modify-iam1" => run_modify_iam1(args[2:].to_owned())
    "snmp-get" => run_snmp_get(args[2:].to_owned())
    "lldp-capture" => run_lldp_capture(args[2:].to_owned())
    "dhcp-discover-live" => run_dhcp_discover_live(args[2:].to_owned())
    "pcap-baseline" => run_pcap_baseline(args[2:].to_owned())
    "alarm-listen" => run_alarm_listen(args[2:].to_owned())
    "rpc-b4" => run_rpc_b4(args[2:].to_owned())
    "rpc-b4-update-io" => run_rpc_b4_update_io(args[2:].to_owned())
    "rpc-b4-io-write" => run_rpc_b4_io_write(args[2:].to_owned())
    "rpc-b4-read-io" => run_rpc_b4_read_io(args[2:].to_owned())
    "rpc-b4-alarm" => run_rpc_b4_alarm(args[2:].to_owned())
    "gsd-info" => run_gsd_info(args[2:].to_owned())
    "gsd-info-text" => run_gsd_info_text(args[2:].to_owned())
    "read-pd-port" => run_read_pd_port(args[2:].to_owned())
    "read-pd-port-mrp" => run_read_pd_port_mrp(args[2:].to_owned())
    "read-pd-port-mrplc" => run_read_pd_port_mrplc(args[2:].to_owned())
    "read-pd-interface" => run_read_pd_interface(args[2:].to_owned())
    "read-pd-interface-mrp" => run_read_pd_interface_mrp(args[2:].to_owned())
    "read-pd-port-statistic" => run_read_pd_port_statistic(args[2:].to_owned())
    "read-pdev" => run_read_pdev(args[2:].to_owned())
    "read-pd-real" => run_read_pd_real(args[2:].to_owned())
    "baseline-report" => run_baseline_report(args[2:].to_owned())
    "validate-device" => run_validate_device(args[2:].to_owned())
    "gsd-detail" => run_gsd_detail(args[2:].to_owned())
    "gsd-detail-text" => run_gsd_detail_text(args[2:].to_owned())
    "profidrive-state" => run_profidrive_state(args[2:].to_owned())
    "security-info" => run_security_info(args[2:].to_owned())
    "decode-alarm" => run_decode_alarm(args[2:].to_owned())
    "decode-rpc" => run_decode_rpc(args[2:].to_owned())
    "ar-info" => run_format_ar(args[2:].to_owned())
    "iocr-info" => run_format_iocr(args[2:].to_owned())
    "decode-io" => run_decode_io(args[2:].to_owned())
    "decode-iam0" => run_decode_iam0(args[2:].to_owned())
    "encode-record-read" => run_encode_record_read(args[2:].to_owned())
    "encode-record-write" => run_encode_record_write(args[2:].to_owned())
    "encode-record-control" => run_encode_record_control(args[2:].to_owned())
    "encode-snmp-get" => run_encode_snmp_get(args[2:].to_owned())
    "decode-lldp" => run_decode_lldp(args[2:].to_owned())
    "decode-dhcp" => run_decode_dhcp(args[2:].to_owned())
    "encode-dhcp-discover" => run_encode_dhcp_discover(args[2:].to_owned())
    "help" => print_usage()
    _ => print_usage()
  }
}