HealthStatsDialog: show per-weekday typical sleep values

Mirrors the typical-steps debug section added on fix/typical-steps,
showing the four values the watch reads from each <weekday>_sleepData
blob's typical tail: duration / deep duration / bedtime → wakeup.
Weekdays below the 2-day minimum-history threshold show "--".

WeekdaySleepTypicals visibility bumped from internal to public so the
new HealthDebugStats field can expose it across modules. The data
class is just four Ints and was always going to be reachable by the
debug dialog by design.

Author: aveao

libpebble3/src/commonMain/kotlin/io/rebble/libpebblecommon/connection/FakeLibPebble.kt

@@ -381,6 +381,7 @@ class FakeLibPebble : LibPebble {
             latestDataTimestamp = null,
             daysOfData = 0,
             weekdayTypicalSteps = emptyMap(),
+            weekdayTypicalSleep = emptyMap(),
         )
     }
 

libpebble3/src/commonMain/kotlin/io/rebble/libpebblecommon/health/Health.kt

@@ -19,6 +19,7 @@ import io.rebble.libpebblecommon.datalogging.HealthDataProcessor
 import io.rebble.libpebblecommon.di.LibPebbleCoroutineScope
 import io.rebble.libpebblecommon.services.DailySleep
 import io.rebble.libpebblecommon.services.calculateHealthAverages
+import io.rebble.libpebblecommon.services.computeAllWeekdayTypicalSleep
 import io.rebble.libpebblecommon.services.computeAllWeekdayTypicalSteps
 import io.rebble.libpebblecommon.services.decodeTypicalStepTotal
 import io.rebble.libpebblecommon.services.groupSleepSessions
@@ -98,6 +99,7 @@ class Health(
 
         val weekdayTypicalSteps = computeAllWeekdayTypicalSteps(healthDao, today, timeZone)
             .mapValues { (_, payload) -> decodeTypicalStepTotal(payload) }
+        val weekdayTypicalSleep = computeAllWeekdayTypicalSleep(healthDao, today, timeZone)
 
         return HealthDebugStats(
             totalSteps30Days = averages.totalSteps,
@@ -109,6 +111,7 @@ class Health(
             latestDataTimestamp = latestTimestamp,
             daysOfData = daysOfData,
             weekdayTypicalSteps = weekdayTypicalSteps,
+            weekdayTypicalSleep = weekdayTypicalSleep,
         )
     }
 

libpebble3/src/commonMain/kotlin/io/rebble/libpebblecommon/health/HealthRecords.kt

@@ -81,6 +81,10 @@ class RawOverlayRecord : StructMappable() {
  * [weekdayTypicalSteps] carries the per-weekday typical-step totals computed for the
  * `<weekday>_steps` BlobDB rows; absent keys are weekdays where the user has insufficient
  * same-weekday history (we don't write a row for them, so the watch shows no comparison).
+ *
+ * [weekdayTypicalSleep] carries the four typical sleep values per weekday written into the
+ * tail of each `<weekday>_sleepData` BlobDB row; absent keys are weekdays below the same
+ * minimum-history threshold.
  */
 data class HealthDebugStats(
     val totalSteps30Days: Long,
@@ -92,4 +96,5 @@ data class HealthDebugStats(
     val latestDataTimestamp: Long?,
     val daysOfData: Int,
     val weekdayTypicalSteps: Map<kotlinx.datetime.DayOfWeek, Int> = emptyMap(),
+    val weekdayTypicalSleep: Map<kotlinx.datetime.DayOfWeek, io.rebble.libpebblecommon.services.WeekdaySleepTypicals> = emptyMap(),
 )

libpebble3/src/commonMain/kotlin/io/rebble/libpebblecommon/services/HealthStatsSync.kt

@@ -493,7 +493,7 @@ private val STEP_TYPICAL_KEYS = mapOf(
     DayOfWeek.SUNDAY to "sunday_steps",
 )
 
-internal data class WeekdaySleepTypicals(
+data class WeekdaySleepTypicals(
     val sleepDurationSeconds: Int,
     val deepSleepDurationSeconds: Int,
     val fallAsleepSecondsOfDay: Int,

pebble/src/commonMain/kotlin/coredevices/pebble/ui/HealthStatsDialog.kt

@@ -201,6 +201,37 @@ fun HealthStatsDialog(libPebble: LibPebble, onDismissRequest: () -> Unit) {
                                 )
                             }
                         }
+
+                        Spacer(Modifier.height(4.dp))
+
+                        Text(
+                            "Typical sleep by weekday",
+                            style = MaterialTheme.typography.bodyMedium,
+                        )
+                        for (wd in DayOfWeek.entries) {
+                            val typ = s.weekdayTypicalSleep[wd]
+                            Row(
+                                modifier = Modifier.fillMaxWidth(),
+                                horizontalArrangement = Arrangement.SpaceBetween
+                            ) {
+                                Text(
+                                    wd.name.lowercase().replaceFirstChar { it.uppercase() },
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                )
+                                Text(
+                                    typ?.let {
+                                        "${formatHm(it.sleepDurationSeconds)} / ${formatHm(it.deepSleepDurationSeconds)}  ${formatClock(it.fallAsleepSecondsOfDay)}→${formatClock(it.wakeupSecondsOfDay)}"
+                                    } ?: "--",
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = if (typ != null) {
+                                        MaterialTheme.colorScheme.onSurface
+                                    } else {
+                                        MaterialTheme.colorScheme.onSurfaceVariant
+                                    },
+                                )
+                            }
+                        }
                     }
                 } else {
                     Text(
@@ -215,4 +246,16 @@ fun HealthStatsDialog(libPebble: LibPebble, onDismissRequest: () -> Unit) {
 }
 
 expect fun Double.format(digits: Int): String
-fun Float.format(digits: Int): String = toDouble().format(digits)
+fun Float.format(digits: Int): String = toDouble().format(digits)
+
+private fun formatHm(totalSeconds: Int): String {
+    val h = totalSeconds / 3600
+    val m = (totalSeconds % 3600) / 60
+    return "${h}h${m.toString().padStart(2, '0')}m"
+}
+
+private fun formatClock(secondsOfDay: Int): String {
+    val h = secondsOfDay / 3600
+    val m = (secondsOfDay % 3600) / 60
+    return "${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}"
+}

pebble/src/iosMain/kotlin/coredevices/pebble/actions/watch/HealthStats.kt

@@ -10,5 +10,8 @@ fun healthDebugStatsToJson(stats: HealthDebugStats): String {
     val latestTs = stats.latestDataTimestamp?.toString() ?: "null"
     val typicalSteps = stats.weekdayTypicalSteps.entries
         .joinToString(prefix = "{", postfix = "}") { (wd, total) -> "\"$wd\":$total" }
-    return """{"totalSteps30Days":${stats.totalSteps30Days},"averageStepsPerDay":${stats.averageStepsPerDay},"totalSleepSeconds30Days":${stats.totalSleepSeconds30Days},"averageSleepSecondsPerDay":${stats.averageSleepSecondsPerDay},"todaySteps":${stats.todaySteps},"lastNightSleepHours":$lastNight,"latestDataTimestamp":$latestTs,"daysOfData":${stats.daysOfData},"weekdayTypicalSteps":$typicalSteps}"""
+    val typicalSleep = stats.weekdayTypicalSleep.entries.joinToString(prefix = "{", postfix = "}") { (wd, v) ->
+        "\"$wd\":{\"sleepDurationSeconds\":${v.sleepDurationSeconds},\"deepSleepDurationSeconds\":${v.deepSleepDurationSeconds},\"fallAsleepSecondsOfDay\":${v.fallAsleepSecondsOfDay},\"wakeupSecondsOfDay\":${v.wakeupSecondsOfDay}}"
+    }
+    return """{"totalSteps30Days":${stats.totalSteps30Days},"averageStepsPerDay":${stats.averageStepsPerDay},"totalSleepSeconds30Days":${stats.totalSleepSeconds30Days},"averageSleepSecondsPerDay":${stats.averageSleepSecondsPerDay},"todaySteps":${stats.todaySteps},"lastNightSleepHours":$lastNight,"latestDataTimestamp":$latestTs,"daysOfData":${stats.daysOfData},"weekdayTypicalSteps":$typicalSteps,"weekdayTypicalSleep":$typicalSleep}"""
 }