import { userDayKey } from "@/lib/tz/resolver"; import type { DayBand, TargetConsistency } from "./types"; const DAY_MS = 24 * 60 * 60 * 1000; const EMPTY_STRIP = [null, null, null, null, null, null, null] as const; const EMPTY_CONSISTENCY: TargetConsistency = { daysInRange7d: 0, daysLogged7d: 0, daysInRange30d: 0, daysLogged30d: 0, lastMetGoalAt: null, streakDays: 0, insufficientData: true, consistency7d: EMPTY_STRIP, }; interface ConsistencyClock { timezone: string; now: Date; } interface RollupConsistencyInput extends ConsistencyClock { events: ReadonlyArray<{ measuredAt: Date; value: number }>; classify: (mean: number) => DayBand | null; totalReadingsThreshold?: number; } interface RollupDayMapInput extends ConsistencyClock { dayBandByKey: ReadonlyMap; totalDaysThreshold?: number; } function dayKeyAtOffset(now: Date, timezone: string, daysAgo: number): string { return userDayKey(new Date(now.getTime() - daysAgo * DAY_MS), timezone); } function last7DayKeys(now: Date, timezone: string): string[] { const keys: string[] = []; for (let daysAgo = 6; daysAgo >= 0; daysAgo--) { keys.push(dayKeyAtOffset(now, timezone, daysAgo)); } return keys; } /** A day's readings folded to their sum and count, keyed by local day. */ export type DaySums = ReadonlyMap; function sumByDay( events: ReadonlyArray<{ measuredAt: Date; value: number }>, timezone: string, ): Map { const byDay = new Map(); for (const event of events) { const key = userDayKey(event.measuredAt, timezone); const bucket = byDay.get(key) ?? { sum: 0, count: 0 }; bucket.sum += event.value; bucket.count += 1; byDay.set(key, bucket); } return byDay; } function computeStrip( byDay: DaySums, classify: (mean: number) => DayBand | null, timezone: string, now: Date, ) { const consistency7d: Array = []; let daysInRange7d = 0; let daysLogged7d = 0; for (const key of last7DayKeys(now, timezone)) { const bucket = byDay.get(key); if (!bucket) { consistency7d.push(null); continue; } daysLogged7d += 1; const band = classify(bucket.sum / bucket.count); consistency7d.push(band); if (band === "in") daysInRange7d += 1; } return { consistency7d, daysInRange7d, daysLogged7d }; } export function rollupConsistency({ events, ...rest }: RollupConsistencyInput): TargetConsistency { return rollupConsistencyFromDays({ ...rest, byDay: sumByDay(events, rest.timezone), readingCount: events.length, }); } interface RollupDaySumsInput extends ConsistencyClock { /** Each local day's readings as sum and count. */ byDay: DaySums; /** Readings behind `byDay`, for the thin-data threshold. */ readingCount: number; classify: (mean: number) => DayBand | null; totalReadingsThreshold?: number; } /** * The same consistency as {@link rollupConsistency}, from readings already * folded per local day. Every figure here is a function of each day's mean * and of the reading count, so a reader that folds in SQL hands over one row * per day instead of every reading and gets the same answer. */ export function rollupConsistencyFromDays({ byDay, readingCount, classify, timezone, now, totalReadingsThreshold = 3, }: RollupDaySumsInput): TargetConsistency { if (readingCount < totalReadingsThreshold) { const partial = computeStrip(byDay, classify, timezone, now); return { ...EMPTY_CONSISTENCY, ...partial, insufficientData: true, }; } const strip = computeStrip(byDay, classify, timezone, now); let daysInRange30d = 0; let daysLogged30d = 0; for (let daysAgo = 29; daysAgo >= 0; daysAgo--) { const bucket = byDay.get(dayKeyAtOffset(now, timezone, daysAgo)); if (!bucket) continue; daysLogged30d += 1; if (classify(bucket.sum / bucket.count) === "in") daysInRange30d += 1; } let lastMetGoalAt: string | null = null; for (let daysAgo = 0; daysAgo < 30; daysAgo++) { const key = dayKeyAtOffset(now, timezone, daysAgo); const bucket = byDay.get(key); if (!bucket) continue; if (classify(bucket.sum / bucket.count) === "in") { lastMetGoalAt = key; break; } } let streakDays = 0; for (let daysAgo = 0; daysAgo < 365; daysAgo++) { const bucket = byDay.get(dayKeyAtOffset(now, timezone, daysAgo)); if (!bucket || classify(bucket.sum / bucket.count) !== "in") break; streakDays += 1; } return { daysInRange7d: strip.daysInRange7d, daysLogged7d: strip.daysLogged7d, daysInRange30d, daysLogged30d, lastMetGoalAt, streakDays, insufficientData: readingCount < totalReadingsThreshold || strip.daysLogged7d < 1, consistency7d: strip.consistency7d, }; } export function rollupFromDayMap({ dayBandByKey, timezone, now, totalDaysThreshold = 3, }: RollupDayMapInput): TargetConsistency { const loggedKeys = Array.from(dayBandByKey.values()).filter( (band) => band !== null, ); const strip = last7DayKeys(now, timezone).map( (key) => dayBandByKey.get(key) ?? null, ); const daysLogged7d = strip.filter((band) => band !== null).length; const daysInRange7d = strip.filter((band) => band === "in").length; if (loggedKeys.length < totalDaysThreshold) { return { ...EMPTY_CONSISTENCY, consistency7d: strip, daysLogged7d, daysInRange7d, insufficientData: true, }; } let daysInRange30d = 0; let daysLogged30d = 0; for (let daysAgo = 29; daysAgo >= 0; daysAgo--) { const band = dayBandByKey.get(dayKeyAtOffset(now, timezone, daysAgo)); if (!band) continue; daysLogged30d += 1; if (band === "in") daysInRange30d += 1; } let lastMetGoalAt: string | null = null; for (let daysAgo = 0; daysAgo < 30; daysAgo++) { const key = dayKeyAtOffset(now, timezone, daysAgo); if (dayBandByKey.get(key) === "in") { lastMetGoalAt = key; break; } } let streakDays = 0; for (let daysAgo = 0; daysAgo < 365; daysAgo++) { const band = dayBandByKey.get(dayKeyAtOffset(now, timezone, daysAgo)); if (band === undefined || band === null || band !== "in") break; streakDays += 1; } return { daysInRange7d, daysLogged7d, daysInRange30d, daysLogged30d, lastMetGoalAt, streakDays, insufficientData: loggedKeys.length < totalDaysThreshold, consistency7d: strip, }; } export function makeRangeClassifier( range: { min: number; max: number } | null, options?: { orangeMin?: number; orangeMax?: number }, ): (mean: number) => DayBand | null { if (!range) return () => null; const span = range.max - range.min; const orangeMin = options?.orangeMin ?? range.min - span * 0.3; const orangeMax = options?.orangeMax ?? range.max + span * 0.3; return (mean) => { if (mean >= range.min && mean <= range.max) return "in"; if (mean >= orangeMin && mean <= orangeMax) return "near"; return "out"; }; }