Added codecs for whole WSPRMessage and sequence of WSPRMessages

Author: Dr. Brandon Wiley

Codex/src/main/java/org/operatorfoundation/codex/symbols/WSPRMessage.kt

@@ -0,0 +1,71 @@
+package org.operatorfoundation.codex.symbols
+
+import java.math.BigInteger
+import org.operatorfoundation.codex.Encoder
+
+/**
+ * A single WSPR message symbol that encodes/decodes one complete WSPR transmission.
+ *
+ * Format: Q + 6-char callsign + 4-char grid + power level = 12 bytes total
+ */
+class WSPRMessage : Symbol {
+    /**
+     * WSPR symbol configuration matching the standard WSPR message format.
+     *
+     * Symbol breakdown:
+     * - Required('Q'): Fixed prefix (1 byte, size=1, contributes 0 bits)
+     * - CallLetterNumber (6x): Callsign characters (A-Z, 0-9 = 36 values each)
+     * - GridLetter (2x): First two grid characters (A-R = 18 values each)
+     * - Number (2x): Last two grid characters (0-9 = 10 values each)
+     * - Power: Power level (19 discrete values: 0, 3, 7, 10... 60 dBm)
+     */
+    private val WSPR_SYMBOLS: List<Symbol> = listOf(
+        Required('Q'.code.toByte()),  // Fixed prefix
+        CallLetterNumber(),            // Callsign char 1
+        CallLetterNumber(),            // Callsign char 2
+        CallLetterNumber(),            // Callsign char 3
+        CallLetterNumber(),            // Callsign char 4
+        CallLetterNumber(),            // Callsign char 5
+        CallLetterNumber(),            // Callsign char 6 (often space)
+        GridLetter(),                  // Grid char 1
+        GridLetter(),                  // Grid char 2
+        Number(),                      // Grid char 3
+        Number(),                      // Grid char 4
+        Power()                        // Power level
+    )
+
+    private val encoder = Encoder(WSPR_SYMBOLS)
+    private val decoder = encoder.decoder()
+
+    override fun size(): Int = WSPR_SYMBOLS.sumOf { it.size() }
+
+    override fun toString(): String = "WSPRMessage"
+
+    override fun decode(encodedValue: ByteArray): BigInteger {
+        require(encodedValue.size == size()) {
+            "Encoded value must be ${size()} bytes, got ${encodedValue.size}"
+        }
+
+        // Split the encoded byte array into parts for each symbol
+        val parts = mutableListOf<ByteArray>()
+        var offset = 0
+
+        for (symbol in WSPR_SYMBOLS) {
+            val symbolSize = symbol.size()
+            val symbolBytes = encodedValue.sliceArray(offset until offset + symbolSize)
+            parts.add(symbolBytes)
+            offset += symbolSize
+        }
+
+        // Use the decoder to convert the parts back to an integer
+        return decoder.decode(parts)
+    }
+
+    override fun encode(numericValue: BigInteger): ByteArray {
+        // Use the encoder to convert the integer to a list of byte arrays
+        val parts = encoder.encode(numericValue)
+
+        // Concatenate all parts into a single byte array
+        return parts.flatMap { it.toList() }.toByteArray()
+    }
+}

Codex/src/main/java/org/operatorfoundation/codex/symbols/WSRPMessageSequence.kt

@@ -0,0 +1,59 @@
+package org.operatorfoundation.codex.symbols
+
+import java.math.BigInteger
+import org.operatorfoundation.codex.Encoder
+
+/**
+ * A sequence of WSPR messages that can encode arbitrarily large integers
+ * by splitting them across multiple WSPR transmissions.
+ *
+ * This enables the Tidbit protocol to send messages larger than a single
+ * WSPR message can contain by chaining multiple messages together.
+ *
+ * @param count Number of WSPR messages in the sequence
+ */
+class WSPRMessageSequence(private val count: Int) : Symbol {
+    init {
+        require(count > 0) { "Sequence must contain at least one WSPR message" }
+    }
+
+    private val wsrpMessages: List<Symbol> = List(count) { WSPRMessage() }
+    private val encoder = Encoder(wsrpMessages)
+    private val decoder = encoder.decoder()
+
+    override fun size(): Int = wsrpMessages.sumOf { it.size() }
+
+    override fun toString(): String = "WSPRMessageSequence($count)"
+
+    override fun decode(encodedValue: ByteArray): BigInteger {
+        require(encodedValue.size == size()) {
+            "Encoded value must be ${size()} bytes for $count messages, got ${encodedValue.size}"
+        }
+
+        // Split the encoded byte array into parts for each WSPR message
+        val parts = mutableListOf<ByteArray>()
+        var offset = 0
+
+        for (message in wsrpMessages) {
+            val messageSize = message.size()
+            val messageBytes = encodedValue.sliceArray(offset until offset + messageSize)
+            parts.add(messageBytes)
+            offset += messageSize
+        }
+
+        // Use the decoder to convert the parts back to an integer
+        return decoder.decode(parts)
+    }
+
+    override fun encode(numericValue: BigInteger): ByteArray {
+        // Use the encoder to convert the integer to a list of byte arrays
+        val parts = encoder.encode(numericValue)
+
+        require(parts.size == count) {
+            "Encoder produced ${parts.size} parts but expected $count"
+        }
+
+        // Concatenate all parts into a single byte array
+        return parts.flatMap { it.toList() }.toByteArray()
+    }
+}

Codex/src/test/java/org/operatorfoundation/codex/EncoderDecoderTest.kt

@@ -12,6 +12,8 @@ import org.operatorfoundation.codex.symbols.CallLetterSpace
 import org.operatorfoundation.codex.symbols.GridLetter
 import org.operatorfoundation.codex.symbols.Power
 import org.operatorfoundation.codex.symbols.Trinary
+import org.operatorfoundation.codex.symbols.WSPRMessage
+import org.operatorfoundation.codex.symbols.WSPRMessageSequence
 
 import java.math.BigInteger
 
@@ -174,5 +176,204 @@ class EncoderDecoderTest
             assertEquals(bigIntValue, decoded, "Round-trip failed for value $value")
         }
     }
+}
+
+@Test
+fun testWSPRMessageRoundTrip() {
+    val wsprMessage = WSPRMessage()
+
+    // Test various values within WSPR message capacity
+    val testValues = listOf(
+        BigInteger.ZERO,
+        BigInteger.ONE,
+        BigInteger.valueOf(1415934836), // "Test" as integer
+        BigInteger.valueOf(123456789),
+        BigInteger.valueOf(999999999),
+        BigInteger("10000000000") // Larger value
+    )
+
+    testValues.forEach { value ->
+        val encoded = wsprMessage.encode(value)
+
+        // Verify size
+        assertEquals(wsprMessage.size(), encoded.size,
+            "Encoded size mismatch for value $value")
+
+        // Decode and verify
+        val decoded = wsprMessage.decode(encoded)
+        assertEquals(value, decoded, "Round-trip failed for value $value")
+
+        println("WSPRMessage round-trip: $value -> ${encoded.size} bytes -> $decoded")
+    }
+}
+
+@Test
+fun testWSPRMessageFormat() {
+    val wsprMessage = WSPRMessage()
+    val testInteger = BigInteger.valueOf(1415934836) // "Test"
+
+    val encoded = wsprMessage.encode(testInteger)
+
+    // Verify the message starts with 'Q'
+    assertEquals('Q'.code.toByte(), encoded[0], "WSPR message should start with 'Q'")
+
+    // Decode and display the message components
+    val parts = mutableListOf<String>()
+    parts.add(encoded[0].toInt().toChar().toString()) // Required 'Q'
+    parts.add((1..6).map { encoded[it].toInt().toChar() }.joinToString("")) // Callsign
+    parts.add((7..8).map { encoded[it].toInt().toChar() }.joinToString("")) // Grid letters
+    parts.add((9..10).map { encoded[it].toInt().toChar() }.joinToString("")) // Grid numbers
+    parts.add(encoded[11].toInt().toChar().toString()) // Power
+
+    println("WSPR Message components: ${parts.joinToString(" ")}")
+
+    // Verify decoding
+    val decoded = wsprMessage.decode(encoded)
+    assertEquals(testInteger, decoded)
+}
+
+@Test
+fun testWSPRMessageSequenceSingleMessage() {
+    // Test with a sequence of 1 message (should behave like WSPRMessage)
+    val sequence = WSPRMessageSequence(1)
+    val singleMessage = WSPRMessage()
+
+    val testValue = BigInteger.valueOf(1415934836)
+
+    val seqEncoded = sequence.encode(testValue)
+    val msgEncoded = singleMessage.encode(testValue)
+
+    // Should produce identical results
+    assertArrayEquals(msgEncoded, seqEncoded)
+
+    // Verify decoding
+    val decoded = sequence.decode(seqEncoded)
+    assertEquals(testValue, decoded)
+}
+
+@Test
+fun testWSPRMessageSequenceMultipleMessages() {
+    // Test with 3 messages
+    val sequence = WSPRMessageSequence(3)
+
+    val testValues = listOf(
+        BigInteger.ZERO,
+        BigInteger.ONE,
+        BigInteger.valueOf(1415934836),
+        BigInteger("100000000000000"), // Large value requiring multiple messages
+        BigInteger("999999999999999999")
+    )
+
+    testValues.forEach { value ->
+        val encoded = sequence.encode(value)
+
+        // Verify total size is 3 × single message size
+        val singleMessageSize = WSPRMessage().size()
+        assertEquals(singleMessageSize * 3, encoded.size,
+            "Sequence size should be 3 × single message size")
+
+        // Decode and verify
+        val decoded = sequence.decode(encoded)
+        assertEquals(value, decoded, "Round-trip failed for value $value")
+
+        println("WSPRMessageSequence(3) round-trip: $value -> ${encoded.size} bytes -> $decoded")
+    }
+}
+
+@Test
+fun testWSPRMessageSequenceCapacity() {
+    // Test that larger sequences can handle larger numbers
+    val sequence2 = WSPRMessageSequence(2)
+    val sequence5 = WSPRMessageSequence(5)
+
+    // A very large number that would overflow a single message
+    val largeValue = BigInteger("123456789012345678901234567890")
+
+    try {
+        val encoded2 = sequence2.encode(largeValue)
+        val decoded2 = sequence2.decode(encoded2)
+        assertEquals(largeValue, decoded2, "Sequence of 2 failed for large value")
+        println("WSPRMessageSequence(2) handled large value successfully")
+    } catch (e: Exception) {
+        println("WSPRMessageSequence(2) cannot handle value (expected if too large)")
+    }
 
+    try {
+        val encoded5 = sequence5.encode(largeValue)
+        val decoded5 = sequence5.decode(encoded5)
+        assertEquals(largeValue, decoded5, "Sequence of 5 failed for large value")
+        println("WSPRMessageSequence(5) handled large value: $largeValue")
+    } catch (e: Exception) {
+        println("WSPRMessageSequence(5) cannot handle value (too large even for 5 messages)")
+    }
+}
+
+@Test
+fun testWSPRMessageSequenceIndependence() {
+    // Verify that each message in the sequence contributes independently
+    val sequence = WSPRMessageSequence(2)
+    val singleMessageSize = WSPRMessage().size()
+
+    val testValue = BigInteger.valueOf(1000000)
+    val encoded = sequence.encode(testValue)
+
+    // Split into two messages
+    val message1 = encoded.sliceArray(0 until singleMessageSize)
+    val message2 = encoded.sliceArray(singleMessageSize until encoded.size)
+
+    println("Message 1 bytes: ${message1.map { (it.toInt() and 0xFF).toString(16) }}")
+    println("Message 2 bytes: ${message2.map { (it.toInt() and 0xFF).toString(16) }}")
+
+    // Both should start with 'Q'
+    assertEquals('Q'.code.toByte(), message1[0], "First message should start with Q")
+    assertEquals('Q'.code.toByte(), message2[0], "Second message should start with Q")
+
+    // Verify full round-trip still works
+    val decoded = sequence.decode(encoded)
+    assertEquals(testValue, decoded)
+}
+
+@Test
+fun testWSPRMessageVsSequenceComparison() {
+    // Compare the capacity and behavior of single vs multiple messages
+    val single = WSPRMessage()
+    val double = WSPRMessageSequence(2)
+
+    // Find a value that fits in single message
+    val smallValue = BigInteger.valueOf(1000)
+    val singleEncoded = single.encode(smallValue)
+    val doubleEncoded = double.encode(smallValue)
+
+    println("Single message size: ${singleEncoded.size} bytes")
+    println("Double sequence size: ${doubleEncoded.size} bytes")
+
+    assertEquals(single.size(), singleEncoded.size)
+    assertEquals(single.size() * 2, doubleEncoded.size)
+
+    // Both should decode correctly
+    assertEquals(smallValue, single.decode(singleEncoded))
+    assertEquals(smallValue, double.decode(doubleEncoded))
+}
+
+@Test
+fun testWSPRMessageSequenceEdgeCases() {
+    // Test edge cases
+    val sequence = WSPRMessageSequence(1)
+
+    // Test zero
+    val zeroEncoded = sequence.encode(BigInteger.ZERO)
+    assertEquals(BigInteger.ZERO, sequence.decode(zeroEncoded))
+
+    // Test one
+    val oneEncoded = sequence.encode(BigInteger.ONE)
+    assertEquals(BigInteger.ONE, sequence.decode(oneEncoded))
+
+    // Test that invalid count throws
+    assertThrows(IllegalArgumentException::class.java) {
+        WSPRMessageSequence(0)
+    }
+
+    assertThrows(IllegalArgumentException::class.java) {
+        WSPRMessageSequence(-1)
+    }
 }