How to Build a Fasting Tracker App in SwiftUI

// FastingTrackerApp.swift
import SwiftUI
import SwiftData

@main
struct FastingTrackerApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: FastingSession.self)
    }
}

// Models/FastingSession.swift
import SwiftData
import Foundation

@Model
final class FastingSession {
    var startDate: Date
    var targetDuration: TimeInterval   // seconds — 57_600 = 16 h
    var endDate: Date?
    var completed: Bool

    init(
        startDate: Date = .now,
        targetDuration: TimeInterval = 57_600
    ) {
        self.startDate = startDate
        self.targetDuration = targetDuration
        self.endDate = nil
        self.completed = false
    }

    /// Real elapsed time, computed from the clock — not a tick counter.
    var elapsed: TimeInterval {
        (endDate ?? .now).timeIntervalSince(startDate)
    }

    var progress: Double {
        min(elapsed / targetDuration, 1.0)
    }

    var durationHours: Int {
        Int(targetDuration / 3600)
    }
}

// Views/ContentView.swift
import SwiftUI

struct ContentView: View {
    var body: some View {
        TabView {
            TimerView()
                .tabItem { Label("Fast", systemImage: "timer") }
            HistoryView()
                .tabItem { Label("History", systemImage: "list.bullet") }
        }
    }
}

// Views/TimerView.swift
import SwiftUI
import SwiftData

struct TimerView: View {
    @Environment(\.modelContext) private var context
    @State private var timerVM = FastingTimer()

    var body: some View {
        NavigationStack {
            VStack(spacing: 32) {
                Text(timerVM.isActive ? "Currently Fasting" : "Ready to Fast")
                    .font(.title2.weight(.semibold))
                    .foregroundStyle(timerVM.isActive ? .green : .secondary)

                // Circular progress ring
                ZStack {
                    Circle()
                        .stroke(Color.secondary.opacity(0.15), lineWidth: 14)
                    Circle()
                        .trim(from: 0, to: timerVM.progress)
                        .stroke(
                            timerVM.progress >= 1 ? Color.yellow : Color.green,
                            style: StrokeStyle(lineWidth: 14, lineCap: .round)
                        )
                        .rotationEffect(.degrees(-90))
                        .animation(.linear(duration: 1), value: timerVM.progress)

                    VStack(spacing: 6) {
                        Text(timerVM.timeString)
                            .font(.system(size: 46, weight: .bold, design: .monospaced))
                        Text("of \(timerVM.targetLabel)")
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                    }
                }
                .frame(width: 270, height: 270)

                Button(timerVM.isActive ? "End Fast" : "Start Fast") {
                    if timerVM.isActive {
                        timerVM.stop(context: context)
                    } else {
                        timerVM.start(context: context)
                    }
                }
                .buttonStyle(.borderedProminent)
                .tint(timerVM.isActive ? .red : .green)
                .font(.headline)
                .controlSize(.large)
            }
            .padding()
            .navigationTitle("Fasting Tracker")
        }
    }
}

#Preview {
    TimerView()
        .modelContainer(for: FastingSession.self, inMemory: true)
}

// ViewModels/FastingTimer.swift
import SwiftUI
import SwiftData
import UserNotifications

@Observable
final class FastingTimer {
    var elapsed: TimeInterval = 0
    var targetDuration: TimeInterval = 57_600   // 16 h default
    var isActive: Bool = false

    private var ticker: Timer?
    private var sessionID: PersistentIdentifier?

    // MARK: - Derived state

    var progress: Double {
        isActive ? min(elapsed / targetDuration, 1.0) : 0
    }

    var timeString: String {
        let t = Int(elapsed)
        return String(format: "%02d:%02d:%02d",
                      t / 3600, (t % 3600) / 60, t % 60)
    }

    var targetLabel: String {
        "\(Int(targetDuration / 3600))h fast"
    }

    // MARK: - Controls

    func start(context: ModelContext) {
        let session = FastingSession(startDate: .now,
                                     targetDuration: targetDuration)
        context.insert(session)
        try? context.save()
        sessionID = session.persistentModelID
        elapsed = 0
        isActive = true

        // Tick every second; derive elapsed from real clock to survive suspension.
        let start = session.startDate
        ticker = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
            guard let self else { return }
            self.elapsed = Date.now.timeIntervalSince(start)
            if self.elapsed >= self.targetDuration {
                self.finish(context: context, completed: true)
            }
        }

        scheduleNotification()
    }

    func stop(context: ModelContext) {
        finish(context: context, completed: elapsed >= targetDuration)
        cancelNotification()
    }

    // MARK: - Private helpers

    private func finish(context: ModelContext, completed: Bool) {
        ticker?.invalidate()
        ticker = nil
        if let id = sessionID,
           let session = context.model(for: id) as? FastingSession {
            session.endDate = .now
            session.completed = completed
            try? context.save()
        }
        isActive = false
    }

    private func scheduleNotification() {
        let remaining = max(targetDuration - elapsed, 1)
        UNUserNotificationCenter.current()
            .requestAuthorization(options: [.alert, .sound, .badge]) { granted, _ in
                guard granted else { return }
                let content = UNMutableNotificationContent()
                content.title = "Fast complete! 🎉"
                content.body = "You finished your \(Int(self.targetDuration / 3600))-hour fast. Time to break the fast."
                content.sound = .default
                let trigger = UNTimeIntervalNotificationTrigger(
                    timeInterval: remaining,
                    repeats: false
                )
                let request = UNNotificationRequest(
                    identifier: "fast-complete",
                    content: content,
                    trigger: trigger
                )
                UNUserNotificationCenter.current().add(request)
            }
    }

    private func cancelNotification() {
        UNUserNotificationCenter.current()
            .removePendingNotificationRequests(withIdentifiers: ["fast-complete"])
    }
}

<!-- PrivacyInfo.xcprivacy -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>NSPrivacyTracking</key>
    <false/>
    <key>NSPrivacyTrackingDomains</key>
    <array/>
    <key>NSPrivacyCollectedDataTypes</key>
    <array/>
    <key>NSPrivacyAccessedAPITypes</key>
    <array>
        <dict>
            <key>NSPrivacyAccessedAPIType</key>
            <string>NSPrivacyAccessedAPICategoryUserDefaults</string>
            <key>NSPrivacyAccessedAPITypeReasons</key>
            <array>
                <string>CA92.1</string>
            </array>
        </dict>
    </array>
</dict>
</plist>