SwiftUI

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, Vitals")
            .font(.title)
            .padding()
    }
}

#Preview {
    ContentView()
}

struct StepCard: View {
    let title: String
    let value: String

    var body: some View {
        HStack {
            VStack(alignment: .leading, spacing: 4) {
                Text(title)
                    .font(.headline)
                Text(value)
                    .font(.largeTitle.bold())
            }
            Spacer()
            Image(systemName: "figure.walk")
                .font(.largeTitle)
        }
        .padding()
        .background(.regularMaterial, in: .rect(cornerRadius: 16))
    }
}

struct GlassCounter: View {
    @State private var count = 0

    var body: some View {
        VStack(spacing: 16) {
            Text("\(count) glasses of water")
                .font(.title2)
            Button("Add a glass") {
                count += 1
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

struct Reading: Identifiable {
    let id = UUID()
    let label: String
    let value: Int
}

struct ReadingsList: View {
    let readings: [Reading]

    var body: some View {
        List(readings) { reading in
            HStack {
                Text(reading.label)
                Spacer()
                Text("\(reading.value)")
                    .foregroundStyle(.secondary)
            }
        }
    }
}

import Observation
import SwiftUI

@Observable
final class HydrationModel {
    var glasses = 0
    var goal = 8

    var isGoalMet: Bool { glasses >= goal }

    func drink() { glasses += 1 }
}

struct HydrationView: View {
    @State private var model = HydrationModel()

    var body: some View {
        VStack(spacing: 12) {
            Text("\(model.glasses) / \(model.goal)")
                .font(.largeTitle.bold())
            if model.isGoalMet {
                Text("Goal met")
                    .foregroundStyle(.green)
            }
            Button("Drink") { model.drink() }
                .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

struct GoalStepper: View {
    @Binding var goal: Int

    var body: some View {
        Stepper("Daily goal: \(goal)", value: $goal, in: 1...20)
    }
}

struct SettingsView: View {
    @State private var goal = 8

    var body: some View {
        Form {
            GoalStepper(goal: $goal)        // pass the binding with $
            Text("You'll aim for \(goal) glasses")
        }
    }
}

struct AppView: View {
    @State private var path: [Reading] = []

    var body: some View {
        NavigationStack(path: $path) {
            List(sampleReadings) { reading in
                NavigationLink(reading.label, value: reading)
            }
            .navigationTitle("Vitals")
            .navigationDestination(for: Reading.self) { reading in
                ReadingDetail(reading: reading)
            }
        }
    }
}

@main
struct VitalsApp: App {
    @State private var model = HydrationModel()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(model)        // inject the instance
        }
    }
}

struct ContentView: View {
    @Environment(HydrationModel.self) private var model   // read it anywhere below

    var body: some View {
        Text("\(model.glasses) glasses today")
    }
}

@MainActor
@Observable
final class FeedModel {
    var readings: [Reading] = []
    var isLoading = false

    func load() async {
        isLoading = true
        defer { isLoading = false }
        readings = await VitalsService.fetchReadings()   // async call
    }
}

struct FeedView: View {
    @State private var model = FeedModel()

    var body: some View {
        List(model.readings) { Text($0.label) }
            .overlay { if model.isLoading { ProgressView() } }
            .task { await model.load() }   // runs on appear, cancels on disappear
    }
}

import HealthKit

let store = HKHealthStore()

func requestSteps() async throws {
    guard HKHealthStore.isHealthDataAvailable() else { return }
    let steps = HKQuantityType(.stepCount)
    try await store.requestAuthorization(toShare: [], read: [steps])
}

func todaysSteps() async throws -> Double {
    let type = HKQuantityType(.stepCount)
    let startOfDay = Calendar.current.startOfDay(for: .now)
    let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: .now)

    return try await withCheckedThrowingContinuation { continuation in
        let query = HKStatisticsQuery(
            quantityType: type, quantitySamplePredicate: predicate, options: .cumulativeSum
        ) { _, stats, error in
            if let error { continuation.resume(throwing: error); return }
            let count = stats?.sumQuantity()?.doubleValue(for: .count()) ?? 0
            continuation.resume(returning: count)
        }
        store.execute(query)
    }
}

import WidgetKit
import SwiftUI

struct StepsEntry: TimelineEntry {
    let date: Date
    let steps: Int
}

struct StepsProvider: TimelineProvider {
    func placeholder(in context: Context) -> StepsEntry { .init(date: .now, steps: 0) }

    func getSnapshot(in context: Context, completion: @escaping (StepsEntry) -> Void) {
        completion(.init(date: .now, steps: 4200))
    }

    func getTimeline(in context: Context, completion: @escaping (Timeline<StepsEntry>) -> Void) {
        let entry = StepsEntry(date: .now, steps: 4200)
        completion(Timeline(entries: [entry], policy: .atEnd))
    }
}

struct StepsWidget: Widget {
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: "StepsWidget", provider: StepsProvider()) { entry in
            VStack {
                Text("\(entry.steps)").font(.largeTitle.bold())
                Text("steps").font(.caption)
            }
            .containerBackground(.fill.tertiary, for: .widget)
        }
        .configurationDisplayName("Steps")
        .supportedFamilies([.systemSmall])
    }
}

struct GoalBadge: View {
    @State private var met = false

    var body: some View {
        VStack {
            if met {
                Text("Goal met")
                    .transition(.scale.combined(with: .opacity))
            }
            Button("Toggle") {
                withAnimation(.spring) { met.toggle() }
            }
        }
        .animation(.default, value: met)
    }
}

#Preview("Default") { GoalBadge() }

#Preview("Dark") {
    GoalBadge().preferredColorScheme(.dark)
}