Add resolver recommendation summaries

Author: AmirrezaFarnamTaheri

app/src/main/java/shop/whitedns/client/scan/ResolverScanResult.kt

@@ -24,6 +24,15 @@ data class ResolverScanResult(
         get() = resolverScanScore(this)
 }
 
+data class ResolverScanRecommendation(
+    val resolver: String,
+    val score: Int,
+    val observationCount: Int,
+    val successfulServerCount: Int,
+    val bestLatencyMillis: Int?,
+    val lastObservedAtMillis: Long,
+)
+
 fun resolverScanScore(result: ResolverScanResult): Int {
     if (!result.isValid) {
         return 0
@@ -61,6 +70,39 @@ fun rankResolverScanResults(results: Iterable<ResolverScanResult>): List<Resolve
         )
 }
 
+fun summarizeResolverScanRecommendations(
+    results: Iterable<ResolverScanResult>,
+): List<ResolverScanRecommendation> {
+    return results
+        .filter { it.isValid && it.resolver.isNotBlank() }
+        .groupBy { it.resolver }
+        .map { (resolver, resolverResults) ->
+            val successfulServerCount = resolverResults
+                .mapNotNull { it.serverDomain.takeIf(String::isNotBlank) }
+                .distinct()
+                .size
+            val bestScore = resolverResults.maxOf { it.score }
+            val stabilityBonus = ((resolverResults.size - 1).coerceAtMost(4) * 2) +
+                (successfulServerCount.coerceAtMost(4) * 3)
+            ResolverScanRecommendation(
+                resolver = resolver,
+                score = (bestScore + stabilityBonus).coerceIn(1, 100),
+                observationCount = resolverResults.size,
+                successfulServerCount = successfulServerCount,
+                bestLatencyMillis = resolverResults.mapNotNull { it.latencyMillis }.minOrNull(),
+                lastObservedAtMillis = resolverResults.maxOf { it.observedAtMillis },
+            )
+        }
+        .sortedWith(
+            compareByDescending<ResolverScanRecommendation> { it.score }
+                .thenBy { it.bestLatencyMillis ?: Int.MAX_VALUE }
+                .thenByDescending { it.successfulServerCount }
+                .thenByDescending { it.observationCount }
+                .thenByDescending { it.lastObservedAtMillis }
+                .thenBy { it.resolver },
+        )
+}
+
 fun ResolverScanResult.toJsonObject(): JSONObject {
     return JSONObject()
         .put("resolver", resolver)

app/src/main/java/shop/whitedns/client/scan/WhiteDnsScannerResultStore.kt

@@ -27,11 +27,19 @@ object WhiteDnsScannerResultStore {
         if (structuredResults.isEmpty()) {
             return readValidResolvers(context).take(limit)
         }
-        return rankResolverScanResults(structuredResults)
+        return summarizeResolverScanRecommendations(structuredResults)
             .map { it.resolver }
             .take(limit.coerceAtLeast(1))
     }
 
+    fun readResolverRecommendations(
+        context: Context,
+        limit: Int = 64,
+    ): List<ResolverScanRecommendation> {
+        return summarizeResolverScanRecommendations(readStructuredResults(context))
+            .take(limit.coerceAtLeast(1))
+    }
+
     fun readStructuredResults(context: Context): List<ResolverScanResult> {
         return runCatching {
             val file = structuredResultFile(context)

app/src/test/java/shop/whitedns/client/scan/ResolverScanResultTest.kt

@@ -75,4 +75,42 @@ class ResolverScanResultTest {
 
         assertEquals(result, resolverScanResultFromJson(result.toJsonObject()))
     }
+
+    @Test
+    fun summarizeResolverScanRecommendationsRewardsRepeatedServerSuccess() {
+        val recommendations = summarizeResolverScanRecommendations(
+            listOf(
+                ResolverScanResult(
+                    resolver = "8.8.8.8",
+                    status = ResolverScanResultStatus.Valid,
+                    serverDomain = "server-a.example.com",
+                    latencyMillis = 95,
+                    attempts = 1,
+                    observedAtMillis = 10L,
+                ),
+                ResolverScanResult(
+                    resolver = "8.8.8.8",
+                    status = ResolverScanResultStatus.Valid,
+                    serverDomain = "server-b.example.com",
+                    latencyMillis = 110,
+                    attempts = 1,
+                    observedAtMillis = 20L,
+                ),
+                ResolverScanResult(
+                    resolver = "1.1.1.1",
+                    status = ResolverScanResultStatus.Valid,
+                    serverDomain = "server-a.example.com",
+                    latencyMillis = 95,
+                    attempts = 1,
+                    observedAtMillis = 30L,
+                ),
+            ),
+        )
+
+        assertEquals("8.8.8.8", recommendations.first().resolver)
+        assertEquals(2, recommendations.first().observationCount)
+        assertEquals(2, recommendations.first().successfulServerCount)
+        assertEquals(95, recommendations.first().bestLatencyMillis)
+        assertTrue(recommendations.first().score > recommendations.last().score)
+    }
 }