Begin WSPRCodex

Author: consuelita

Codex/src/main/java/org/operatorfoundation/codex/WSPRCodex.kt

@@ -1,7 +1,5 @@
-package org.operatorfoundation.Codex
+package org.operatorfoundation.codex
 
-import org.operatorfoundation.codex.Decoder
-import org.operatorfoundation.codex.Encoder
 import org.operatorfoundation.codex.symbols.Number
 import org.operatorfoundation.codex.symbols.*
 import java.math.BigInteger
@@ -72,15 +70,38 @@ class WSPRCodex
          */
         fun getMaxPayloadBytes(): Int
         {
-            // Calculate total capacity in bits
+            // DEBUG: Print out what symbols we have and their sizes
+            println("=== Symbol Configuration Debug ===")
+            WSPR_SYMBOLS.forEachIndexed { index, symbol ->
+                println("Symbol $index: $symbol, size: ${symbol.size()}")
+            }
+
+            // Calculate the product of all symbol sizes
+            // e.g. if we have symbols with sizes [36, 36, 18, 10, 19]
+            // total capacity = 36 x 36 x 18 x 10 x 19 (total number of unique calculations)
+
+            // Convert list of symbols to list of their sizes
             val symbolSizes = WSPR_SYMBOLS.map { it.size().toBigInteger() }
-            val totalCapacity = symbolSizes.fold(BigInteger.ONE) { acc, size -> acc * size }
+            // Multiply all  sizes together
+            val totalCapacity = symbolSizes.fold(BigInteger.ONE) { acc, size -> acc * size}
+
+            // The max integer we can encode is (totalCapacity - 1)
+            val maxEncodableValue = totalCapacity - BigInteger.ONE
+
+            // Convert maxEncodableValue to bytes so we know how many bytes we need (how many bytes  it takes to store this number)
+            val byteArray = maxEncodableValue.toByteArray()
 
-            // Convert to bits (log2 of total capacity)
-            val capacityBits = totalCapacity.bitLength() - 1
+            // BigInteger sometimes adds an extra leading zero byte for the sign
+            // Remove the extra byte if it exists
+            return if (byteArray.isNotEmpty() && byteArray[0] == 0.toByte())
+            {
+                byteArray.size - 1
+            }
+            else
+            {
+                byteArray.size
+            }
 
-            // Convert to bytes (divide by 8)
-            return capacityBits / 8
         }
 
         /**

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

@@ -0,0 +1,50 @@
+package org.operatorfoundation.codex
+
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeEach
+import org.operatorfoundation.codex.WSPRCodex
+import java.math.BigInteger
+
+class WSPRCodexTest
+{
+    private lateinit var codex: WSPRCodex
+
+    @BeforeEach
+    fun setup()
+    {
+        codex = WSPRCodex()
+    }
+
+    @Test
+    fun testMaxPayload()
+    {
+        // Verify the calculated maximum payload is reasonable
+        val maxBytes = WSPRCodex.getMaxPayloadBytes()
+
+        println("Maximum WSPR payload capacity: $maxBytes bytes")
+
+        // Should be around 28 bytes based on symbol sizes
+        assertTrue(maxBytes in 20..35, "Expected capacity around 28 bytes, got $maxBytes")
+    }
+
+    @Test
+    fun testActualCapacity() {
+        // Try encoding increasingly large byte arrays until we find the limit
+        var workingSize = 0
+
+        for (size in 1..50) {
+            val testData = ByteArray(size) { 0xFF.toByte() }
+            try {
+                codex.encode(testData)
+                workingSize = size
+                println("Size $size: SUCCESS")
+            } catch (e: Exception) {
+                println("Size $size: FAILED - ${e.message}")
+                break
+            }
+        }
+
+        println("Actual working capacity: $workingSize bytes")
+    }
+}