Use archive cache in snapshot detail · 6209aee

Use archive cache in snapshot detail
Browse files

bogdan committed 2 weeks ago

main

1 parent 95e0e8a

commit 6209aee

Showing 3 changed files with 238 additions and 15 deletions

+4 -3

HealthProbe/Doc/04-project/IMPLEMENTATION_STATUS.md

@@ -28,7 +28,7 @@ There are no real deployments, only test installations. Existing prototype datab
 | SQLite archive | Archive v2 schema, snapshot-level observation grouping, differential write path, v2 verification/delete bookkeeping, daily aggregate rebuilds, integrity report, v2 record reads, SQL diff/count/aggregate/provenance/consolidation-evidence APIs, large synthetic diff pagination coverage, formal timing/memory metrics, and XCTest coverage are in place; the legacy `archive_samples` mirror has been removed | Move Snapshots/Data Types from SwiftData previews to archive/cache DTOs |
 | Core Data cache | Initial programmatic Core Data model, full-cache rebuild service, read DTOs for observation/type/health rows, and Dashboard archive-cache status wiring are in place | Move Snapshots/Data Types to cache DTOs and add targeted partial invalidation |
 | SwiftData cache | Exists; test builds now reset legacy prototype UI/archive/cache stores once for archive v2 so old SwiftData-only snapshots are not treated as backed-up observations | Treat as disposable prototype data; reset/ignore during v2 transition |
-| UI | Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Snapshots timeline and Data Types list prefer Core Data cache rows when archive observation ids exist; data type detail/drill-down uses SQLite `diffSummary`/`diffRecords`, with SwiftData detail cache as transition fallback | Move observation/detail screens to cached summaries plus paged SQLite DTOs |
+| UI | Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Snapshots timeline, snapshot detail summaries/type rows, and Data Types list prefer Core Data cache rows when archive observation ids exist; data type detail/drill-down uses SQLite `diffSummary`/`diffRecords`, with SwiftData detail cache as transition fallback | Finish remaining detail charts/export previews on paged SQLite DTOs |
 | Diff/change explanation | Prototype/legacy anomaly logic exists | Move heavy diffing into SQLite and use neutral change classifications |
 | Export | Prototype scoped JSON export exists | Add recovery-compatible manifests and streaming/paged export |
 | Legacy device support | Not implemented | Remove SwiftData dependency and simplify heavy views for low-memory devices |
@@ -49,8 +49,8 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
 - SwiftData currently blocks iOS 15-era device support.
 - Existing `Anomaly*` model/service names are legacy language.
 - Some screens still imply snapshot-count monitoring rather than Time Machine inspection.
-- Current UI/cache layers still depend on SwiftData prototype models for navigation handles and detail screens.
-- Snapshots timeline, Data Types list rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist, but observation/detail navigation still uses SwiftData snapshot handles during the transition.
+- Current UI/cache layers still depend on SwiftData prototype models for navigation handles, some charts, and export/PDF paths.
+- Snapshots timeline, snapshot detail summary/type rows, Data Types list rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist, but navigation still uses SwiftData snapshot handles during the transition.
 - Legacy SwiftData-only snapshots can show diffs without archive-backed values; they are now reset for archive v2 test installs rather than migrated.
 - Existing implementation may decode or cache too much data for low-end devices.
 - Old prototype database compatibility is no longer required.
@@ -63,6 +63,7 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
 - [ ] No recurring complete snapshot copies are written for high-volume types.
 - [x] SQL diff between two observations runs without loading full datasets into Swift arrays.
 - [x] Snapshots timeline rows use Core Data cached observation counts/change summaries when cache rows are available.
+- [x] Snapshot detail summary/type rows use Core Data cached summaries plus SQLite diff summaries when archive observation ids are available.
 - [x] Data Types list rows use Core Data cached counts plus SQLite diff summaries when archive observation ids are available.
 - [x] Data type added/disappeared drill-down pages records from SQLite diff queries when archive observation ids are available.
 - [x] Expensive counts used by reports/UI are cached and rebuildable.


+1 -1

HealthProbe/Doc/04-project/Refactoring-Plan.md

View

@@ -223,7 +223,7 @@ Checklist:
 - [ ] Replace direct SwiftData `@Query` dependencies for target screens.
 - [ ] Dashboard reads Core Data cache.
 - [x] Observation timeline rows read Core Data cache when available, while retaining SwiftData handles for detail navigation during transition.
-- [ ] Observation detail uses cached summaries plus paged SQLite DTOs.
+- [x] Observation detail uses cached summary/type rows plus SQLite diff summaries when archive observation ids exist.
 - [x] Data Types list rows prefer Core Data cached counts plus SQLite `diffSummary` when archive observation ids exist.
 - [x] Data type detail uses SQLite `diffSummary` when archive observation ids exist.
 - [x] Data type added/disappeared drill-down pages through SQLite `diffRecords` when archive observation ids exist.


+233 -11

HealthProbe/Views/Snapshots/SnapshotDetailView.swift

View

+                         @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]
+                         @Query private var allDeltas: [SnapshotDelta]
+                         @State private var displayedSnapshot: HealthSnapshot?
+                    +    @State private var archiveTypeRows: [SnapshotArchiveTypeRow]?
+                    +    @State private var archiveTypeError: String?
+                         private var currentSnapshot: HealthSnapshot {
+                             displayedSnapshot ?? snapshot
+                                 .sorted { $0.displayName.localizedCompare($1.displayName) == .orderedAscending }
+                    +    private var archiveReloadID: String {
+                    +        [
+                    +            currentSnapshot.id.uuidString,
+                    +            String(currentSnapshot.archiveObservationID ?? -1),
+                    +            String(baseline?.archiveObservationID ?? -1)
+                    +        ].joined(separator: "|")
+                    +    }
+                    +    private var summaryTypeCount: Int? {
+                    +        if let archiveTypeRows {
+                    +            return archiveTypeRows.count
+                    +        }
+                    +        guard currentSnapshot.hasCurrentCachedSummary else { return nil }
+                    +        return currentSnapshot.cachedTypeCount
+                    +    }
+                    +    private var summaryRecordCount: Int? {
+                    +        if let archiveTypeRows {
+                    +            return archiveTypeRows.reduce(0) { $0 + $1.currentCount }
+                    +        }
+                    +        guard currentSnapshot.hasCurrentCachedSummary else { return nil }
+                    +        return currentSnapshot.cachedRecordCount
+                    +    }
+                    +    private var summaryEarliestRecordDate: Date? {
+                    +        archiveTypeRows?.compactMap(\.earliestStartDate).min() ?? currentSnapshot.cachedEarliestRecordDate
+                    +    }
+                    +    private var summaryLatestRecordDate: Date? {
+                    +        archiveTypeRows?.compactMap(\.latestEndDate).max() ?? currentSnapshot.cachedLatestRecordDate
+                    +    }
+                    +    private var archiveRecordChangeCount: Int? {
+                    +        archiveTypeRows?.reduce(0) { $0 + $1.recordChangeCount }
+                    +    }
+                    +    private var archiveAffectedMetricCount: Int? {
+                    +        archiveTypeRows?.filter(\.hasChanges).count
+                    +    }
+                         private var deviceDisplayName: String {
+                             if let name = profile?.name, !name.isEmpty { return name }
+                             return currentSnapshot.deviceName.isEmpty ? "Unknown device" : currentSnapshot.deviceName
+                                         .ignoresSafeArea()
+                    +        .task(id: archiveReloadID) {
+                    +            await loadArchiveTypeRows()
+                    +        }
+                         private func exportAsPDF() {
+                    +    @MainActor
+                    +    private func loadArchiveTypeRows() async {
+                    +        guard let currentObservationID = currentSnapshot.archiveObservationID else {
+                    +            archiveTypeRows = nil
+                    +            archiveTypeError = nil
+                    +            return
+                    +        }
+                    +        do {
+                    +            let cache = try CoreDataArchiveCacheStore()
+                    +            let currentSummaries = try cache.typeSummaries(observationID: currentObservationID)
+                    +            let baselineObservationID = baseline?.archiveObservationID
+                    +            let baselineSummaries = try baselineObservationID.map {
+                    +                try cache.typeSummaries(observationID: $0)
+                    +            } ?? []
+                    +            let currentByType = Dictionary(uniqueKeysWithValues: currentSummaries.map { ($0.sampleTypeIdentifier, $0) })
+                    +            let baselineByType = Dictionary(uniqueKeysWithValues: baselineSummaries.map { ($0.sampleTypeIdentifier, $0) })
+                    +            let allTypeIdentifiers = Set(currentByType.keys).union(baselineByType.keys)
+                    +            var rows: [SnapshotArchiveTypeRow] = []
+                    +            rows.reserveCapacity(allTypeIdentifiers.count)
+                    +            for typeIdentifier in allTypeIdentifiers {
+                    +                let current = currentByType[typeIdentifier]
+                    +                let baselineSummary = baselineByType[typeIdentifier]
+                    +                let diff: HealthArchiveDiffSummary
+                    +                if let baselineObservationID {
+                    +                    diff = try await SQLiteHealthArchiveStore.shared.diffSummary(HealthArchiveDiffRequest(
+                    +                        fromObservationID: baselineObservationID,
+                    +                        toObservationID: currentObservationID,
+                    +                        sampleTypeIdentifier: typeIdentifier
+                    +                    ))
+                    +                } else {
+                    +                    diff = HealthArchiveDiffSummary(
+                    +                        fromObservationID: currentObservationID,
+                    +                        toObservationID: currentObservationID,
+                    +                        sampleTypeIdentifier: typeIdentifier,
+                    +                        appearedCount: 0,
+                    +                        disappearedCount: 0,
+                    +                        representationChangedCount: 0
+                    +                    )
+                    +                }
+                    +                rows.append(SnapshotArchiveTypeRow(
+                    +                    typeIdentifier: typeIdentifier,
+                    +                    displayName: current?.displayName ?? baselineSummary?.displayName ?? typeIdentifier,
+                    +                    currentCount: current?.visibleRecordCount ?? 0,
+                    +                    previousCount: baselineSummary?.visibleRecordCount,
+                    +                    appearedCount: diff.appearedCount,
+                    +                    disappearedCount: diff.disappearedCount,
+                    +                    representationChangedCount: diff.representationChangedCount,
+                    +                    earliestStartDate: current?.earliestStartDate,
+                    +                    latestEndDate: current?.latestEndDate
+                    +                ))
+                    +            }
+                    +            archiveTypeRows = rows.sorted {
+                    +                $0.displayName.localizedCompare($1.displayName) == .orderedAscending
+                    +            }
+                    +            archiveTypeError = nil
+                    +        } catch {
+                    +            archiveTypeRows = nil
+                    +            archiveTypeError = error.localizedDescription
+                    +        }
+                    +    }
+                         @ViewBuilder
+                         private var snapshotToolbarTitle: some View {
+                             if #available(iOS 26.0, *) {
+                                         // Data Range
+                                         SnapshotDataRangeIndicator(
+                    -                        oldestRecordDate: currentSnapshot.cachedEarliestRecordDate,
+                    -                        newestRecordDate: currentSnapshot.cachedLatestRecordDate,
+                    +                        oldestRecordDate: summaryEarliestRecordDate,
+                    +                        newestRecordDate: summaryLatestRecordDate,
+                                             quality: currentSnapshot.snapshotQuality
+                                         // Summary Stats (compact)
+                                         VStack(spacing: 12) {
+                    -                        if currentSnapshot.hasCurrentCachedSummary {
+                    +                        if let summaryTypeCount,
+                    +                           let summaryRecordCount {
+                                                 HStack(spacing: 16) {
+                    -                                statCompact(label: "Types", value: "\(currentSnapshot.cachedTypeCount)")
+                    +                                statCompact(label: "Types", value: "\(summaryTypeCount)")
+                                                     Divider()
+                    -                                statCompact(label: "Records", value: "\(currentSnapshot.cachedRecordCount)")
+                    +                                statCompact(label: "Records", value: "\(summaryRecordCount)")
+                                                 .font(.caption)
+                                                 .foregroundStyle(.secondary)
+                         @ViewBuilder
+                         private func comparisonSection(baseline: HealthSnapshot) -> some View {
+                    -        let delta = currentDeltaSummary?.absoluteRecordChangeCount ?? 0
+                    +        let delta = archiveRecordChangeCount ?? currentDeltaSummary?.absoluteRecordChangeCount ?? 0
+                             let deltaPercent = computeDeltaPercent(delta: delta, baseline: baseline)
+                    -        let affectedMetricCount = currentDeltaSummary?.affectedMetricCount ?? 0
+                    +        let affectedMetricCount = archiveAffectedMetricCount ?? currentDeltaSummary?.affectedMetricCount ?? 0
+                             let isSignificant = delta > 0 || affectedMetricCount > 0 || (deltaPercent > 10)
+                             DisclosureGroup {
+                                         Text(days == 0 ? "Same day" : "\(days) days")
+                                             .foregroundStyle(.secondary)
+                    -                if let summary = currentDeltaSummary {
+                    +                if archiveTypeRows != nil || currentDeltaSummary != nil {
+                                         Divider()
+                                         DetailRow(label: "Changed Metrics") {
+                    -                        Text("\(summary.affectedMetricCount)")
+                    +                        Text("\(affectedMetricCount)")
+                                                 .foregroundStyle(.secondary)
+                                         Divider()
+                                         DetailRow(label: "Record Changes") {
+                    -                        Text("\(summary.absoluteRecordChangeCount)")
+                    +                        Text("\(delta)")
+                                                 .foregroundStyle(.secondary)
+                         private func computeDeltaPercent(delta: Int, baseline: HealthSnapshot) -> Double {
+                    +        if let archiveTypeRows {
+                    +            let baselineTotal = archiveTypeRows.reduce(0) { $0 + ($1.previousCount ?? 0) }
+                    +            return baselineTotal > 0 ? Double(delta) / Double(baselineTotal) * 100 : 0
+                    +        }
+                             let baselineTotal = baseline.hasCurrentCachedSummary ? baseline.cachedRecordCount : 0
+                             return baselineTotal > 0 ? Double(delta) / Double(baselineTotal) * 100 : 0
+                         private var evolutionSection: some View {
+                             Section("Data Types") {
+                    -            if baseline == nil {
+                    +            if let archiveTypeRows {
+                    +                if archiveTypeRows.isEmpty {
+                    +                    Text("No data types are available for this snapshot.")
+                    +                        .foregroundStyle(.secondary)
+                    +                } else {
+                    +                    ForEach(archiveTypeRows) { row in
+                    +                        NavigationLink {
+                    +                            DataTypeSnapshotDetailView(
+                    +                                snapshot: currentSnapshot,
+                    +                                typeIdentifier: row.typeIdentifier,
+                    +                                displayName: row.displayName
+                    +                            )
+                    +                        } label: {
+                    +                            SnapshotArchiveTypeRowView(row: row, hasBaseline: baseline != nil)
+                    +                        }
+                    +                    }
+                    +                }
+                    +            } else if baseline == nil {
+                                     Text("This snapshot starts the chain, so no baseline comparison is available.")
+                                         .foregroundStyle(.secondary)
+                                 } else if currentDelta == nil {
+                    +private struct SnapshotArchiveTypeRow: Identifiable {
+                    +    let typeIdentifier: String
+                    +    let displayName: String
+                    +    let currentCount: Int
+                    +    let previousCount: Int?
+                    +    let appearedCount: Int
+                    +    let disappearedCount: Int
+                    +    let representationChangedCount: Int
+                    +    let earliestStartDate: Date?
+                    +    let latestEndDate: Date?
+                    +    var id: String { typeIdentifier }
+                    +    var recordChangeCount: Int {
+                    +        appearedCount + disappearedCount + representationChangedCount
+                    +    }
+                    +    var hasChanges: Bool {
+                    +        currentDelta != 0 || recordChangeCount > 0
+                    +    }
+                    +    var currentDelta: Int {
+                    +        guard let previousCount else { return currentCount }
+                    +        return currentCount - previousCount
+                    +    }
+                    +}
+                    +private struct SnapshotArchiveTypeRowView: View {
+                    +    let row: SnapshotArchiveTypeRow
+                    +    let hasBaseline: Bool
+                    +    private var countText: String {
+                    +        "\(row.currentCount)"
+                    +    }
+                    +    private var changeLabel: String {
+                    +        guard hasBaseline else { return "Stored" }
+                    +        if row.disappearedCount > 0 {
+                    +            return "\(row.disappearedCount) disappeared"
+                    +        }
+                    +        if row.appearedCount > 0 {
+                    +            return "\(row.appearedCount) added"
+                    +        }
+                    +        if row.representationChangedCount > 0 {
+                    +            return "\(row.representationChangedCount) changed"
+                    +        }
+                    +        if row.currentDelta != 0 {
+                    +            let prefix = row.currentDelta > 0 ? "+" : ""
+                    +            return "\(prefix)\(row.currentDelta) records"
+                    +        }
+                    +        return "No changes"
+                    +    }
+                    +    private var changeColor: Color {
+                    +        guard hasBaseline else { return .secondary }
+                    +        if row.disappearedCount > 0 { return .criticalRed }
+                    +        if row.hasChanges { return .warningAmber }
+                    +        return .secondary
+                    +    }
+                    +    var body: some View {
+                    +        HStack(spacing: 12) {
+                    +            VStack(alignment: .leading, spacing: 3) {
+                    +                Text(row.displayName)
+                    +                    .font(.subheadline)
+                    +                Text(row.typeIdentifier)
+                    +                    .font(.caption2)
+                    +                    .foregroundStyle(.secondary)
+                    +                    .lineLimit(1)
+                    +                    .truncationMode(.middle)
+                    +            }
+                    +            Spacer()
+                    +            VStack(alignment: .trailing, spacing: 4) {
+                    +                Text(countText)
+                    +                    .font(.subheadline.monospacedDigit())
+                    +                    .foregroundStyle(.primary)
+                    +                Text(changeLabel)
+                    +                    .font(.caption.weight(.semibold))
+                    +                    .foregroundStyle(changeColor)
+                    +            }
+                    +        }
+                    +        .accessibilityElement(children: .combine)
+                    +    }
+                    +}
+                     private struct SnapshotTypeDeltaRow: View {
+                         let typeDelta: TypeDelta

	@@ -223,7 +223,7 @@ Checklist:
223	223	- [ ] Replace direct SwiftData `@Query` dependencies for target screens.
224	224	- [ ] Dashboard reads Core Data cache.
225	225	- [x] Observation timeline rows read Core Data cache when available, while retaining SwiftData handles for detail navigation during transition.
226		-- [ ] Observation detail uses cached summaries plus paged SQLite DTOs.
	226	+- [x] Observation detail uses cached summary/type rows plus SQLite diff summaries when archive observation ids exist.
227	227	- [x] Data Types list rows prefer Core Data cached counts plus SQLite `diffSummary` when archive observation ids exist.
228	228	- [x] Data type detail uses SQLite `diffSummary` when archive observation ids exist.
229	229	- [x] Data type added/disappeared drill-down pages through SQLite `diffRecords` when archive observation ids exist.

	@@ -28,7 +28,7 @@ There are no real deployments, only test installations. Existing prototype datab
28	28	\| SQLite archive \| Archive v2 schema, snapshot-level observation grouping, differential write path, v2 verification/delete bookkeeping, daily aggregate rebuilds, integrity report, v2 record reads, SQL diff/count/aggregate/provenance/consolidation-evidence APIs, large synthetic diff pagination coverage, formal timing/memory metrics, and XCTest coverage are in place; the legacy `archive_samples` mirror has been removed \| Move Snapshots/Data Types from SwiftData previews to archive/cache DTOs \|
29	29	\| Core Data cache \| Initial programmatic Core Data model, full-cache rebuild service, read DTOs for observation/type/health rows, and Dashboard archive-cache status wiring are in place \| Move Snapshots/Data Types to cache DTOs and add targeted partial invalidation \|
30	30	\| SwiftData cache \| Exists; test builds now reset legacy prototype UI/archive/cache stores once for archive v2 so old SwiftData-only snapshots are not treated as backed-up observations \| Treat as disposable prototype data; reset/ignore during v2 transition \|
31		-\| UI \| Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Snapshots timeline and Data Types list prefer Core Data cache rows when archive observation ids exist; data type detail/drill-down uses SQLite `diffSummary`/`diffRecords`, with SwiftData detail cache as transition fallback \| Move observation/detail screens to cached summaries plus paged SQLite DTOs \|
	31	+\| UI \| Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Snapshots timeline, snapshot detail summaries/type rows, and Data Types list prefer Core Data cache rows when archive observation ids exist; data type detail/drill-down uses SQLite `diffSummary`/`diffRecords`, with SwiftData detail cache as transition fallback \| Finish remaining detail charts/export previews on paged SQLite DTOs \|
32	32	\| Diff/change explanation \| Prototype/legacy anomaly logic exists \| Move heavy diffing into SQLite and use neutral change classifications \|
33	33	\| Export \| Prototype scoped JSON export exists \| Add recovery-compatible manifests and streaming/paged export \|
34	34	\| Legacy device support \| Not implemented \| Remove SwiftData dependency and simplify heavy views for low-memory devices \|
	@@ -49,8 +49,8 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
49	49	- SwiftData currently blocks iOS 15-era device support.
50	50	- Existing `Anomaly*` model/service names are legacy language.
51	51	- Some screens still imply snapshot-count monitoring rather than Time Machine inspection.
52		-- Current UI/cache layers still depend on SwiftData prototype models for navigation handles and detail screens.
53		-- Snapshots timeline, Data Types list rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist, but observation/detail navigation still uses SwiftData snapshot handles during the transition.
	52	+- Current UI/cache layers still depend on SwiftData prototype models for navigation handles, some charts, and export/PDF paths.
	53	+- Snapshots timeline, snapshot detail summary/type rows, Data Types list rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist, but navigation still uses SwiftData snapshot handles during the transition.
54	54	- Legacy SwiftData-only snapshots can show diffs without archive-backed values; they are now reset for archive v2 test installs rather than migrated.
55	55	- Existing implementation may decode or cache too much data for low-end devices.
56	56	- Old prototype database compatibility is no longer required.
	@@ -63,6 +63,7 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
63	63	- [ ] No recurring complete snapshot copies are written for high-volume types.
64	64	- [x] SQL diff between two observations runs without loading full datasets into Swift arrays.
65	65	- [x] Snapshots timeline rows use Core Data cached observation counts/change summaries when cache rows are available.
	66	+- [x] Snapshot detail summary/type rows use Core Data cached summaries plus SQLite diff summaries when archive observation ids are available.
66	67	- [x] Data Types list rows use Core Data cached counts plus SQLite diff summaries when archive observation ids are available.
67	68	- [x] Data type added/disappeared drill-down pages records from SQLite diff queries when archive observation ids are available.
68	69	- [x] Expensive counts used by reports/UI are cached and rebuildable.