feat(map,lotw): multi-grid station locations (台址) in roamed stripes and operated-grid selector

A LoTW station location (台址) can span several grid squares: the report
emits <MY_VUCC_GRIDS> (comma-separated, MY_GRIDSQUARE often absent) on
those records, but the app parsed only <MY_GRIDSQUARE>, so every extra
grid of a multi-grid 台址 silently vanished from both the blue roamed
stripes and the operated-grid (VUCC) selector.

- GridQso gains myGrids (full own-grid set), myCallsign and stationKey
  (MY_* station snapshot); myGrid stays as the first grid for back-compat.
- parseConfirmedGridQsos parses MY_VUCC_GRIDS + the MY_* snapshot fields;
  parseRoamedGrids parses MY_VUCC_GRIDS too and uppercases (lowercase
  grids never matched the overlay labels).
- SettingsRepo persists mgs/mc/sk; old data falls back to single-grid sets.
- MapScreen groups the selector's 台址名单 by the 台址's full grid set:
  a multi-grid 台址 is one entry listing all its grids (e.g. 'OM60,PM01'),
  and selecting it fills every worked grid worked from any of them.
  Identical grid sets merge (VUCC-equivalent), so partial MY_* snapshots
  can't split one 台址 into duplicate entries. Own grid still never
  striped.

Verified against real reports: BH6RJD (807 SAT QSOs) yields 7 台址
including 4 multi-grid ones; BA7OPF's own data stays a single 'OL62'
entry. 28 LoTW parser tests pass (5 new).

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/LoTWRepository.kt

@@ -252,17 +252,40 @@ class LoTWRepository : ILoTWRepository {
         var country: String? = null
         var cqz: Int? = null
         var state: String? = null
-        var myGrid: String? = null
+        // Own-station (台址) fields: MY_GRIDSQUARE + MY_VUCC_GRIDS give the
+        // full grid set of the station location; the remaining MY_* fields
+        // together identify the station location (one callsign can own
+        // several locations, and one location can span several grids).
+        var myGrids = mutableSetOf<String>()
+        var myCallsign: String? = null
+        var myDxcc: String? = null
+        var myState: String? = null
+        var myCq: String? = null
+        var myItu: String? = null
+        var myIota: String? = null
+        var myCountry: String? = null
         val gridsInRecord = mutableListOf<String>()
 
         fun emitRecord() {
             if (propMode != "SAT" || gridsInRecord.isEmpty()) return
             val epochMs = adifTimestampToEpoch(qsoDate, timeOn)
+            val stationKey = buildString {
+                append(myCallsign ?: "")
+                append('|').append(myDxcc ?: "")
+                append('|').append(myState ?: "")
+                append('|').append(myCq ?: "")
+                append('|').append(myItu ?: "")
+                append('|').append(myIota ?: "")
+                append('|').append(myCountry ?: "")
+            }.ifBlank { null }
             val qso = com.rtbishop.look4sat.core.domain.model.GridQso(
                 call = call, epochMs = epochMs, satName = satName,
                 mode = mode, bandUp = bandUp, bandDown = bandDown,
                 dxcc = dxcc, country = country, cqz = cqz, state = state,
-                myGrid = myGrid
+                myGrid = myGrids.firstOrNull(),
+                myGrids = myGrids,
+                myCallsign = myCallsign,
+                stationKey = stationKey
             )
             for (grid in gridsInRecord) {
                 result.getOrPut(grid) { mutableListOf() }.add(qso)
@@ -273,7 +296,9 @@ class LoTWRepository : ILoTWRepository {
             propMode = null; call = ""; qsoDate = ""; timeOn = ""
             satName = ""; mode = ""; bandUp = ""; bandDown = ""
             dxcc = null; country = null; cqz = null; state = null
-            myGrid = null
+            myGrids = mutableSetOf()
+            myCallsign = null; myDxcc = null; myState = null
+            myCq = null; myItu = null; myIota = null; myCountry = null
             gridsInRecord.clear()
         }
 
@@ -311,10 +336,40 @@ class LoTWRepository : ILoTWRepository {
                 line.startsWith("<MY_GRIDSQUARE:") -> {
                     // Own-station grid (must not be confused with GRIDSQUARE —
                     // the opposite station's grid). Recorded per QSO so awards
-                    // can be counted per operated grid.
+                    // can be counted per operated grid. A station location may
+                    // also carry MY_VUCC_GRIDS (below) for multi-grid roaming.
                     val value = adifValue(line)
-                    if (value.length >= 4) myGrid = value.take(4).uppercase()
+                    if (value.length >= 4) myGrids.add(value.take(4).uppercase())
                 }
+                line.startsWith("<MY_VUCC_GRIDS:") -> {
+                    // Own-station VUCC grids: a comma-separated list LoTW emits
+                    // when one station location spans several grid squares
+                    // (e.g. "OM60,OM50" with MY_GRIDSQUARE absent). Without
+                    // this field the extra grids of a multi-grid 台址 silently
+                    // vanished from both the blue stripes and the per-台址 VUCC
+                    // count. Same split/truncate as VUCC_GRIDS below.
+                    adifValue(line).split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) myGrids.add(field.take(4))
+                    }
+                }
+                // Remaining MY_* fields identify the station location (台址):
+                // grouped together they form the stationKey used by the map's
+                // operated-grid selector. One callsign can own several 台址.
+                line.startsWith("<STATION_CALLSIGN:") ->
+                    myCallsign = adifValue(line).trim().uppercase().ifBlank { null }
+                line.startsWith("<MY_DXCC:") ->
+                    myDxcc = adifValue(line).trim().ifBlank { null }
+                line.startsWith("<MY_STATE:") ->
+                    myState = adifValue(line).trim().ifBlank { null }?.let { normalizeState(it) }
+                line.startsWith("<MY_CQ_ZONE:") ->
+                    myCq = adifValue(line).trim().ifBlank { null }
+                line.startsWith("<MY_ITU_ZONE:") ->
+                    myItu = adifValue(line).trim().ifBlank { null }
+                line.startsWith("<MY_IOTA:") ->
+                    myIota = adifValue(line).trim().uppercase().ifBlank { null }
+                line.startsWith("<MY_COUNTRY:") ->
+                    myCountry = adifValue(line).trim().ifBlank { null }
                 line.startsWith("<GRIDSQUARE:") || line.startsWith("<VUCC_GRIDS:") -> {
                     // VUCC_GRIDS holds a comma-separated list of grids
                     // ("EN52en,EN53fa"), up to four for contacts spanning
@@ -420,23 +475,30 @@ class LoTWRepository : ILoTWRepository {
         // would silently drop every own grid on real reports; buffer the record
         // and decide at <EOR> instead.
         var propMode: String? = null
-        var myGrid: String? = null
+        var myGrids = mutableSetOf<String>()
         for (raw in body.lineSequence()) {
             val line = raw.trim()
             when {
                 line.equals("<EOR>", ignoreCase = true) -> {
-                    if (propMode == "SAT" && myGrid != null) grids.add(myGrid)
+                    if (propMode == "SAT" && myGrids.isNotEmpty()) grids.addAll(myGrids)
                     propMode = null
-                    myGrid = null
+                    myGrids = mutableSetOf()
                 }
                 line.startsWith("<PROP_MODE:") -> {
                     propMode = adifValue(line).uppercase()
                 }
                 line.startsWith("<MY_GRIDSQUARE:") -> {
-                    // MY_GRIDSQUARE must not be mistaken for GRIDSQUARE (the
-                    // opposite station's grid) — only own-station grids count.
                     val value = adifValue(line)
-                    if (value.length >= 4) myGrid = value.take(4)
+                    if (value.length >= 4) myGrids.add(value.take(4).uppercase())
+                }
+                line.startsWith("<MY_VUCC_GRIDS:") -> {
+                    // Multi-grid 台址: each field of MY_VUCC_GRIDS is a grid the
+                    // station location covered; without this the extra grids
+                    // never reached the blue stripes.
+                    adifValue(line).split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) myGrids.add(field.take(4))
+                    }
                 }
             }
         }

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SettingsRepo.kt

@@ -210,7 +210,20 @@ class SettingsRepo(
                         cqz = o.optInt("cq", 0).takeIf { it > 0 },
                         state = o.optString("st").ifBlank { null },
                         // Own-grid field: absent in pre-myGrid data -> null.
-                        myGrid = o.optString("mg").ifBlank { null }
+                        myGrid = o.optString("mg").ifBlank { null },
+                        // Multi-grid 台址 fields (v4.4.7-ba7opf.16+): "mgs" is
+                        // the full grid set (MY_GRIDSQUARE + MY_VUCC_GRIDS);
+                        // pre-multi-grid data has only "mg" and falls back to a
+                        // single-element set so every consumer sees myGrids.
+                        myGrids = o.optJSONArray("mgs")?.let { arr ->
+                            (0 until arr.length()).mapNotNull { i ->
+                                arr.optString(i).takeIf { it.isNotBlank() }
+                            }.toSet()
+                        }?.takeIf { it.isNotEmpty() }
+                            ?: o.optString("mg").ifBlank { null }?.let { setOf(it) }
+                            ?: emptySet(),
+                        myCallsign = o.optString("mc").ifBlank { null },
+                        stationKey = o.optString("sk").ifBlank { null }
                     )
                 }
                 if (list.isNotEmpty()) result[grid] = list
@@ -239,6 +252,9 @@ class SettingsRepo(
                         .put("cq", q.cqz ?: 0)
                         .put("st", q.state ?: "")
                         .put("mg", q.myGrid ?: "")
+                        .put("mgs", org.json.JSONArray(q.myGrids.sorted()))
+                        .put("mc", q.myCallsign ?: "")
+                        .put("sk", q.stationKey ?: "")
                 )
             }
             root.put(grid, array)

core/data/src/test/java/com/rtbishop/look4sat/core/data/repository/LoTWRepositoryTest.kt

@@ -169,6 +169,53 @@ class LoTWRepositoryTest {
         assertTrue(repo.parseConfirmedGridQsos(report(qso1, ground))!!.values.all { it.all { q -> q.myGrid == "OL62" } })
     }
 
+    @Test
+    fun parseQsosCapturesMyVuccGridsMultiGridStation() {
+        // A station location (台址) can span several grids: LoTW emits
+        // <MY_VUCC_GRIDS> (comma-separated) with MY_GRIDSQUARE absent. Both
+        // grids must land in myGrids, and myGrid (back-compat) = the first.
+        val qso = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n<MODE:2>CW\n" +
+            "<MY_VUCC_GRIDS:11>OM60,OM50\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        val parsed = result["NL47"]!!.first()
+        assertEquals(setOf("OM60", "OM50"), parsed.myGrids)
+        assertEquals("OM60", parsed.myGrid)
+        // 6-char fields are truncated to 4 like every other grid path.
+        val six = "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<MY_VUCC_GRIDS:17>OM60IL70,OM50MA20\n<GRIDSQUARE:4>OK48\n<EOR>\n"
+        assertEquals(setOf("OM60", "OM50"), repo.parseConfirmedGridQsos(report(six))!!["OK48"]!!.first().myGrids)
+    }
+
+    @Test
+    fun parseQsosBuildsStationKeyFromMyFields() {
+        // 台址 identity = the MY_* station snapshot (callsign + dxcc + state +
+        // CQ/ITU + IOTA + country). A record with the full snapshot yields the
+        // stable key the operated-grid selector groups by.
+        val qso = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<STATION_CALLSIGN:6>BH6RJD\n<MY_DXCC:3>318\n<MY_STATE:11>JS // Jiangsu\n" +
+            "<MY_CQ_ZONE:2>24\n<MY_ITU_ZONE:2>44\n<MY_COUNTRY:5>CHINA\n" +
+            "<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val parsed = repo.parseConfirmedGridQsos(report(qso))!!["NL47"]!!.first()
+        assertEquals("BH6RJD", parsed.myCallsign)
+        assertEquals("BH6RJD|318|JS|24|44||CHINA", parsed.stationKey)
+    }
+
+    @Test
+    fun parseQsosStationKeyDistinguishesLocationsUnderSameCallsign() {
+        // One callsign can own several 台址 (e.g. BH6RJD with a Hubei location
+        // and a Zhejiang location); different MY_STATE -> different stationKey.
+        val hb = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<STATION_CALLSIGN:6>BH6RJD\n<MY_STATE:11>HB // Hubei\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val zj = "<CALL:5>BG7ZFK\n<QSO_DATE:8>20260819\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n" +
+            "<STATION_CALLSIGN:6>BH6RJD\n<MY_STATE:11>ZJ // Zhejiang\n<GRIDSQUARE:4>OK48\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(hb, zj))!!
+        assertTrue(result["NL47"]!!.first().stationKey != result["OK48"]!!.first().stationKey)
+    }
+
     // endregion
 
     // region parseRoamedGrids (MY_GRIDSQUARE = grids the account operated from)
@@ -224,6 +271,30 @@ class LoTWRepositoryTest {
         assertNull(repo.parseRoamedGrids("<HTML>Username/password incorrect</HTML>"))
     }
 
+    @Test
+    fun parseRoamedGridsCollectsMyVuccGrids() {
+        // Multi-grid 台址: MY_VUCC_GRIDS carries the extra grids (MY_GRIDSQUARE
+        // may be absent); every field must reach the roamed set for the stripes.
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<MY_VUCC_GRIDS:11>OM60,OM50\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        assertEquals(setOf("OM60", "OM50"), repo.parseRoamedGrids(report(qso)))
+        // Combined with MY_GRIDSQUARE the union is kept.
+        val both = "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n" +
+            "<MY_GRIDSQUARE:4>OL62\n<MY_VUCC_GRIDS:11>OM60,OM50\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        assertEquals(setOf("OL62", "OM60", "OM50"), repo.parseRoamedGrids(report(both)))
+    }
+
+    @Test
+    fun parseRoamedGridsUppercasesLowercaseMyGrid() {
+        // LoTW emits the <eor> tag lowercase, so field CASE is not guaranteed:
+        // a lowercase MY_GRIDSQUARE must still match the overlay's uppercase
+        // labels (regression: take(4) without .uppercase() silently dropped
+        // stripes for lowercase grids).
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>IO-86\n" +
+            "<MY_GRIDSQUARE:4>ol62\n<GRIDSQUARE:4>PM95\n<EOR>\n"
+        assertEquals(setOf("OL62"), repo.parseRoamedGrids(report(qso)))
+    }
+
     // endregion
 
     // region failure classification (fetchReportBody -> LoTWResult mapping)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/model/GridQso.kt

@@ -49,8 +49,27 @@ data class GridQso(
     val country: String? = null,
     val cqz: Int? = null,
     val state: String? = null,
-    /** 4-char grid the station itself operated from (ADIF MY_GRIDSQUARE). */
-    val myGrid: String? = null
+    /** 4-char grid the station itself operated from (ADIF MY_GRIDSQUARE).
+     *  Kept as the first entry of [myGrids] for backward compatibility with
+     *  consumers that predate multi-grid station locations. */
+    val myGrid: String? = null,
+    /** Every 4-char grid the station operated from for this QSO — ADIF
+     *  <MY_GRIDSQUARE> plus every field of <MY_VUCC_GRIDS> (a comma-separated
+     *  list LoTW emits when one station location roams across several grid
+     *  squares; MY_GRIDSQUARE may be absent on those records). A station
+     *  location (台址) can legitimately span multiple grids, and the map's
+     *  stripes and the operated-grid selector must show all of them. */
+    val myGrids: Set<String> = emptySet(),
+    /** Callsign of the station location this QSO was logged under (ADIF
+     *  <STATION_CALLSIGN>; e.g. "BH6RJD", "BH6RJD/P"). NOT the 台址 identity
+     *  on its own — one callsign can have several station locations. */
+    val myCallsign: String? = null,
+    /** Stable key of the station location (台址) this QSO was logged under,
+     *  derived from the MY_* station fields (STATION_CALLSIGN + MY_DXCC +
+     *  MY_STATE + MY_CQ_ZONE + MY_ITU_ZONE + MY_IOTA + MY_COUNTRY), so the
+     *  operated-grid selector can group QSOs per 台址 and show each 台址 with
+     *  its full grid set. Null for data synced before this field existed. */
+    val stationKey: String? = null
 ) {
     /** Short uplink/downlink band label ("U/V", "V/A"), or "" when unknown. */
     val bandLabel: String