/macos/RoonKit/Sources/RoonKit/Sood.swift at 87a170f9d28ccdb128ca0552977163174cec30ee

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

import Foundation

enum SoodDecodeError: Error {
	case signatureMismatch
	case missingMessageKind
	case propertyKeySizeIsZero
	case incompletePropertyKey
	case missingPropertyValueSize
	case incompletePropertyValue
	case invalidPropertyKey
	case invalidPropertyValue
}

enum SoodMessageKind: Equatable, LosslessStringConvertible {
	/// Unknown, or unsupported message kind. Sorely exists for forward compatibility.
	case unknown(String)

	/// Discovery query. Client (Roon Extension) sends this via UDP multicast and/or broadcast.
	case query

	/// Response to a query. Roon Server sends this in response to a query SOOD message.
	case response

	var description: String {
		switch self {
		case .query:
			return "Q"
		case .response:
			return "R"
		case .unknown(let original):
			return original
		}
	}

	init(_ from: String) {
		switch from {
		case "R":
			self = .response
		case "Q":
			self = .query
		default:
			self = .unknown(from)
		}
	}

	func data() -> Data {
		return String(self).data(using: .utf8)!
	}
}

/// SOOD message is a binary data format used for Roon Server Discovery, a process for finding
/// Roon Servers in a network. SOOD messages are sent over UDP via multicast and broadcast.
struct Sood {
	private static let signature = "SOOD\u{2}"

	let kind: SoodMessageKind
	let properties: [String: String]

	init(kind: SoodMessageKind, properties: [String: String] = [:]) {
		self.kind = kind
		self.properties = properties
	}

	init?(_ from: String) {
		try? self.init(from: from.data(using: .utf8)!)
	}

	private enum PropertyParseState {
		case keySize
		case key(read: [UInt8], remainingBytes: UInt8)
		case valueSizeHi(key: String)
		case valueSizeLo(key: String, hi: UInt8)
		case value(key: String, read: [UInt8], remainingBytes: UInt16)
	}

	private enum ParseState {
		case signature(expecting: Character, remaining: Substring)
		case kind
		case properties(
			SoodMessageKind,
			parsing: PropertyParseState,
			parsed: [String: String]
		)
	}

	init(from: Data) throws(SoodDecodeError) {
		var state: ParseState = .signature(
			expecting: Sood.signature.first!,
			remaining: Sood.signature.dropFirst()
		)

		for byte in from {
			switch state {
			case .signature(let expecting, let remaining):
				if byte != expecting.asciiValue {
					throw .signatureMismatch
				}

				guard let next = remaining.first else {
					state = .kind
					break
				}

				state = .signature(expecting: next, remaining: remaining.dropFirst())
				break
			case .kind:
				guard let char = String(bytes: [byte], encoding: .ascii) else {
					throw .missingMessageKind
				}

				state = .properties(.init(char), parsing: .keySize, parsed: [:])
				break
			case .properties(let kind, let parsing, let parsed):
				switch parsing {
				case .keySize:
					if byte == 0 {
						throw .propertyKeySizeIsZero
					}

					state = .properties(
						kind,
						parsing: .key(read: [], remainingBytes: byte),
						parsed: parsed
					)
					break
				case .key(let read, let remainingBytes):
					let read = read + [byte]
					if remainingBytes > 1 {
						state = .properties(
							kind,
							parsing: .key(read: read, remainingBytes: remainingBytes - 1),
							parsed: parsed
						)
						break
					}

					guard let key = String(bytes: read, encoding: .utf8) else {
						throw .invalidPropertyKey
					}

					state = .properties(
						kind,
						parsing: .valueSizeHi(key: key),
						parsed: parsed
					)
					break
				case .valueSizeHi(let key):
					state = .properties(
						kind,
						parsing: .valueSizeLo(key: key, hi: byte),
						parsed: parsed
					)
					break
				case .valueSizeLo(let key, let hi):
					let hi = UInt16(hi)
					let lo = UInt16(byte)
					let size = UInt16(bigEndian: (hi.bigEndian << 8) | lo.bigEndian)

					state = .properties(
						kind,
						parsing: .value(key: key, read: [], remainingBytes: size),
						parsed: parsed
					)
					break
				case .value(let key, let read, let remainingBytes):
					let read = read + [byte]
					if remainingBytes > 1 {
						state = .properties(
							kind,
							parsing: .value(
								key: key,
								read: read,
								remainingBytes: remainingBytes - 1
							),
							parsed: parsed
						)
						break
					}

					guard let value = String(bytes: read, encoding: .utf8) else {
						throw .invalidPropertyValue
					}

					var parsed = parsed
					_ = parsed.updateValue(value, forKey: key)

					state = .properties(kind, parsing: .keySize, parsed: parsed)
					break
				}
			}
		}

		switch state {
		case .signature(_, _):
			throw .signatureMismatch
		case .kind:
			throw .missingMessageKind
		case .properties(let kind, parsing: .keySize, let parsed):
			self.kind = kind
			self.properties = parsed
			return
		case .properties(_, parsing: .key(_, _), parsed: _):
			throw .invalidPropertyKey
		case .properties(_, parsing: .valueSizeHi(_), parsed: _):
			throw .missingPropertyValueSize
		case .properties(_, parsing: .valueSizeLo(_, _), parsed: _):
			throw .missingPropertyValueSize
		case .properties(_, parsing: .value(_, _, _), parsed: _):
			throw .incompletePropertyValue
		}
	}

	func data() -> Data {
		var data = Sood.signature.data(using: .utf8)!
		data.append(self.kind.data())

		for (key, value) in self.properties {
			let key = key.data(using: .utf8)!
			data.append(contentsOf: [UInt8(key.count)])
			data.append(key)

			let value = value.data(using: .utf8)!
			let hi = UInt8((UInt16(value.count).bigEndian & 0b11111111).littleEndian)
			let lo = UInt8(
				((UInt16(value.count).bigEndian & 0b11111111_00000000) >> 8)
					.littleEndian
			)
			data.append(contentsOf: [hi, lo])
			data.append(value)
		}

		return data
	}
}