import Foundation

}

final class DataTypesViewModel {

    var filter: DiffFilter = .all

    var comparisonMode: ComparisonMode = .previous

    var observationRowsError: String?

    var archiveDiffError: String?

        observationRows

            .sorted { $0.observedAt > $1.observedAt }

            .map {

                DataTypeSnapshotContext(

                    observationID: $0.observationID,

                    observedAt: $0.observedAt

                )

            }

    }

        guard let archiveDiffs else { return [] }

        return apply(filter: filter, to: archiveDiffs)

    }

    func clearArchiveDiffs() {

        archiveDiffs = nil

        archiveDiffError = nil

    }

    func loadArchiveRows(limit: Int = 200) async {

        do {

            let cache = try CoreDataArchiveCacheStore()

            observationRows = try cache.observationRows(limit: limit)

            observationRowsError = nil

        } catch {

            observationRows = []

            observationRowsError = error.localizedDescription

        }

    }

            return

        }

        do {

            let cache = try CoreDataArchiveCacheStore()

            let baselineSummaries = try cache.typeSummaries(observationID: baseline.observationID)

            let baselineByType = Dictionary(uniqueKeysWithValues: baselineSummaries.map { ($0.sampleTypeIdentifier, $0) })

            let allTypeIdentifiers = Set(currentByType.keys).union(baselineByType.keys)

            var archiveRows: [TypeDiff] = []

            archiveRows.reserveCapacity(allTypeIdentifiers.count)

            for typeIdentifier in allTypeIdentifiers {

                let summary = currentByType[typeIdentifier]

                let baselineSummary = baselineByType[typeIdentifier]

                let diff = try await SQLiteHealthArchiveStore.shared.diffSummary(HealthArchiveDiffRequest(

                    toObservationID: current.observationID,

                ))

                archiveRows.append(TypeDiff(

                    id: typeIdentifier,

                    typeIdentifier: typeIdentifier,

                    displayName: summary?.displayName ?? baselineSummary?.displayName ?? typeIdentifier,

                    currentCount: summary?.visibleRecordCount ?? 0,

                    previousCount: baselineSummary?.visibleRecordCount ?? 0,

                    previousTracked: baselineSummary != nil,

                    appearedCount: diff.appearedCount,

                    disappearedCount: diff.disappearedCount,

                    representationChangedCount: diff.representationChangedCount

                ))

            }

            archiveDiffs = archiveRows.sorted {

                $0.displayName.localizedCompare($1.displayName) == .orderedAscending

            }

            archiveDiffError = nil

        } catch {

            archiveDiffs = nil

            archiveDiffError = error.localizedDescription

        }

    }

        for snapshot: DataTypeSnapshotContext,

        in snapshots: [DataTypeSnapshotContext]

    ) -> DataTypeSnapshotContext? {

        let sorted = snapshots.sorted { $0.observedAt > $1.observedAt }

        case .previous:

            return nil  // DataTypesView uses .previous by default; selection lives in SnapshotsTab

        case .relativeTime(let interval):

            return snapshots

                .filter { $0.observedAt <= target }

                .max { $0.observedAt < $1.observedAt }

        }

    }

    private func apply(filter: DiffFilter, to diffs: [TypeDiff]) -> [TypeDiff] {

        switch filter {

        case .all:       return diffs

        case .changed:   return diffs.filter { $0.previousTracked && $0.hasChanges }

        case .increased: return diffs.filter { $0.previousTracked && $0.delta > 0 }

        case .decreased: return diffs.filter { $0.previousTracked && $0.delta < 0 }

    }

}