Trips, outside Trips

import WidgetKit
import SwiftUI

@main
struct TripsWidgetBundle: WidgetBundle {
    var body: some Widget {
        TripsWidget()
    }
}

import WidgetKitimport SwiftUI/// The entries of the widget's timeline: the trip to show, from a moment on.struct Provider: TimelineProvider {    func placeholder(in context: Context) -> SimpleEntry {        SimpleEntry(date: Date(), emoji: "😀")    func placeholder(in context: Context) -> TripEntry {        TripEntry(date: .now, trip: .seattle)    }    func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) {        let entry = SimpleEntry(date: Date(), emoji: "😀")        completion(entry)    func getSnapshot(in context: Context, completion: @escaping (TripEntry) -> ()) {        completion(TripEntry(date: .now, trip: nextTrip()))    }    func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {        var entries: [SimpleEntry] = []        // Generate a timeline consisting of five entries an hour apart, starting from the current date.        let currentDate = Date()        for hourOffset in 0 ..< 5 {            let entryDate = Calendar.current.date(byAdding: .hour, value: hourOffset, to: currentDate)!            let entry = SimpleEntry(date: entryDate, emoji: "😀")            entries.append(entry)        }        let timeline = Timeline(entries: entries, policy: .atEnd)        completion(timeline)    func getTimeline(in context: Context, completion: @escaping (Timeline<TripEntry>) -> ()) {        let entry = TripEntry(date: .now, trip: nextTrip())        let tomorrow = Calendar.current.startOfDay(for: .now.addingTimeInterval(24 * 60 * 60))        // ask again after midnight        completion(Timeline(entries: [entry], policy: .after(tomorrow)))    }//    func relevances() async -> WidgetRelevances<Void> {//        // Generate a list containing the contexts this widget is relevant in.//    }    /// The first trip that has not started yet.    private func nextTrip() -> Trip {        Trip.samples.filter { $0.start > .now }.min { $0.start < $1.start } ?? .seattle    }}struct SimpleEntry: TimelineEntry {struct TripEntry: TimelineEntry {    let date: Date    let emoji: String    let trip: Trip}struct TripsWidgetEntryView : View {    var entry: Provider.Entry    var body: some View {        VStack {            Text("Time:")            Text(entry.date, style: .time)            Text("Emoji:")            Text(entry.emoji)        VStack(alignment: .leading, spacing: 4) {            Text("Next trip")                .font(.caption)                .foregroundStyle(.secondary)            Text(entry.trip.city)                .font(.headline)            Text(entry.trip.start, style: .date)                .font(.caption)            Label("^[\(entry.trip.nights) night](inflect: true)", systemImage: "moon.stars")                .font(.caption2)        }    }}struct TripsWidget: Widget {    let kind: String = "TripsWidget"    var body: some WidgetConfiguration {        StaticConfiguration(kind: kind, provider: Provider()) { entry in            if #available(iOS 17.0, *) {                TripsWidgetEntryView(entry: entry)                    .containerBackground(.fill.tertiary, for: .widget)            } else {                TripsWidgetEntryView(entry: entry)                    .padding()                    .background()            }            TripsWidgetEntryView(entry: entry)                .containerBackground(.fill.tertiary, for: .widget)        }        .configurationDisplayName("My Widget")        .description("This is an example widget.")        .configurationDisplayName("Next trip")        .description("The next trip you have planned.")        .supportedFamilies([.systemSmall])    }}#Preview(as: .systemSmall) {    TripsWidget()} timeline: {    SimpleEntry(date: .now, emoji: "😀")    SimpleEntry(date: .now, emoji: "🤩")    TripEntry(date: .now, trip: .seattle)    TripEntry(date: .now, trip: .atacama)}

import WidgetKit
import SwiftUI

/// The entries of the widget's timeline: the trip to show, from a moment on.
struct Provider: TimelineProvider {
    func placeholder(in context: Context) -> TripEntry {
        TripEntry(date: .now, trip: .seattle)
    }

    func getSnapshot(in context: Context, completion: @escaping (TripEntry) -> ()) {
        completion(TripEntry(date: .now, trip: nextTrip()))
    }

    func getTimeline(in context: Context, completion: @escaping (Timeline<TripEntry>) -> ()) {
        let entry = TripEntry(date: .now, trip: nextTrip())
        let tomorrow = Calendar.current.startOfDay(for: .now.addingTimeInterval(24 * 60 * 60))
        // ask again after midnight
        completion(Timeline(entries: [entry], policy: .after(tomorrow)))
    }

    /// The first trip that has not started yet.
    private func nextTrip() -> Trip {
        Trip.samples.filter { $0.start > .now }.min { $0.start < $1.start } ?? .seattle
    }
}

struct TripEntry: TimelineEntry {
    let date: Date
    let trip: Trip
}

struct TripsWidgetEntryView : View {
    var entry: Provider.Entry

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text("Next trip")
                .font(.caption)
                .foregroundStyle(.secondary)
            Text(entry.trip.city)
                .font(.headline)
            Text(entry.trip.start, style: .date)
                .font(.caption)
            Label("^[\(entry.trip.nights) night](inflect: true)", systemImage: "moon.stars")
                .font(.caption2)
        }
    }
}

struct TripsWidget: Widget {
    let kind: String = "TripsWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            TripsWidgetEntryView(entry: entry)
                .containerBackground(.fill.tertiary, for: .widget)
        }
        .configurationDisplayName("Next trip")
        .description("The next trip you have planned.")
        .supportedFamilies([.systemSmall])
    }
}

#Preview(as: .systemSmall) {
    TripsWidget()
} timeline: {
    TripEntry(date: .now, trip: .seattle)
    TripEntry(date: .now, trip: .atacama)
}

import AppIntents

/// Says which trip comes next — from Spotlight, Siri or the Shortcuts app.
struct NextTripIntent: AppIntent {
    static let title: LocalizedStringResource = "Next trip"
    static let description = IntentDescription("Says which of your trips comes next.")

    @MainActor
    func perform() async throws -> some IntentResult & ProvidesDialog {
        let upcoming = TripStore().trips.filter { $0.start > .now }.sorted { $0.start < $1.start }
        guard let next = upcoming.first else {
            return .result(dialog: "No trips are planned.")
        }
        return .result(dialog: "\(next.city), on \(next.start.formatted(date: .long, time: .omitted)).")
    }
}

/// The phrases that run the intent, with nothing for anyone to set up first.
struct TripsShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(intent: NextTripIntent(), phrases: ["What is my next trip in \(.applicationName)"],
                    shortTitle: "Next trip", systemImageName: "airplane")
    }
}

import Foundation
import FoundationModels

/// Three things to pack for a trip, as the on-device model suggests them. `Sendable`: the model fills it in away
/// from the main actor, and it crosses back to the screen.
@Generable
struct PackingSuggestions: Sendable {
    @Guide(description: "Things to pack for this trip", .count(3))
    var items: [Idea]

    @Generable
    struct Idea: Sendable {
        @Guide(description: "A short name for the thing to pack, such as Rain jacket")
        var name: String
        @Guide(.anyOf(["Clothes", "Documents", "Gear"]))
        var category: String
    }
}

import SwiftUIimport SwiftDataimport FoundationModels/// What to pack for a trip, kept by SwiftData.struct PackingList: View {    let trip: Trip    @Environment(\.modelContext) private var context    @Environment(\.dismiss) private var dismiss    @Query(sort: \PackingItem.name, sectionBy: \PackingItem.category) private var sections: SectionedResults<PackingItem, String>    @State private var newName = ""    @State private var newCategory = "Clothes"    @State private var isSuggesting = false    /// The query is made here, because only here is the trip known.    init(trip: Trip) {        self.trip = trip        let id = trip.id        _sections = Query(filter: #Predicate<PackingItem> { $0.tripID == id }, sort: \.name, sectionBy: \.category)    }    var body: some View {        NavigationStack {            List {                Section {                    TextField("Something to pack", text: $newName)                    Picker("Category", selection: $newCategory) {                        ForEach(PackingItem.categories, id: \.self) { Text($0) }                    }                    Button("Add to the list", systemImage: "plus") {                        context.insert(PackingItem(name: newName, category: newCategory, tripID: trip.id))                        newName = ""                        save()                    }                    .disabled(newName.isEmpty)                    Button("Suggest three things", systemImage: "sparkles") {                        Task { await suggest() }                    }                    .disabled(isSuggesting || !canSuggest)                }                ForEach(sections) { section in                    Section(section.title) {                        ForEach(section) { item in                            Button {                                item.isPacked.toggle()                                save()                            } label: {                                Label(item.name, systemImage: item.isPacked ? "checkmark.circle.fill" : "circle")                            }                            .accessibilityValue(item.isPacked ? "Packed" : "Not packed")                        }                        .onDelete { offsets in                            for offset in offsets {                                context.delete(section[offset])                            }                            save()                        }                    }                }                if sections.isEmpty {                    ContentUnavailableView("Nothing to pack yet", systemImage: "suitcase",                                           description: Text("Add the first thing above."))                }            }            .navigationTitle("Packing for \(trip.city)")            .navigationBarTitleDisplayMode(.inline)            .toolbar {                ToolbarItem(placement: .confirmationAction) {                    Button("Done") { dismiss() }                }            }        }    }    /// Whether the on-device model can answer on this device, now.    private var canSuggest: Bool {        if case .available = SystemLanguageModel.default.availability { true } else { false }    }    /// Asks the on-device model for three things to pack, and adds them to the list.    private func suggest() async {        isSuggesting = true        defer { isSuggesting = false }        let session = LanguageModelSession(instructions: "You help travelers pack. Keep each name short.")        do {            let answer = try await session.respond(to: "Packing for \(trip.nights) nights in \(trip.city), \(trip.country).",                                                   generating: PackingSuggestions.self)            for idea in answer.content.items {                context.insert(PackingItem(name: idea.name, category: idea.category, tripID: trip.id))            }            save()            print("The model suggested \(answer.content.items.count) things")        } catch {            print("No suggestions:", error)        }    }    /// Writes the changes to disk now. Autosave would too — but at moments of its own choosing.    private func save() {        do {            try context.save()        } catch {            print("Could not save the packing list:", error)        }    }}#Preview {    PackingList(trip: .seattle)        .modelContainer(for: PackingItem.self, inMemory: true)}

import SwiftUI
import SwiftData
import FoundationModels

/// What to pack for a trip, kept by SwiftData.
struct PackingList: View {
    let trip: Trip
    @Environment(\.modelContext) private var context
    @Environment(\.dismiss) private var dismiss
    @Query(sort: \PackingItem.name, sectionBy: \PackingItem.category) private var sections: SectionedResults<PackingItem, String>
    @State private var newName = ""
    @State private var newCategory = "Clothes"
    @State private var isSuggesting = false

    /// The query is made here, because only here is the trip known.
    init(trip: Trip) {
        self.trip = trip
        let id = trip.id
        _sections = Query(filter: #Predicate<PackingItem> { $0.tripID == id }, sort: \.name, sectionBy: \.category)
    }

    var body: some View {
        NavigationStack {
            List {
                Section {
                    TextField("Something to pack", text: $newName)
                    Picker("Category", selection: $newCategory) {
                        ForEach(PackingItem.categories, id: \.self) { Text($0) }
                    }
                    Button("Add to the list", systemImage: "plus") {
                        context.insert(PackingItem(name: newName, category: newCategory, tripID: trip.id))
                        newName = ""
                        save()
                    }
                    .disabled(newName.isEmpty)
                    Button("Suggest three things", systemImage: "sparkles") {
                        Task { await suggest() }
                    }
                    .disabled(isSuggesting || !canSuggest)
                }
                ForEach(sections) { section in
                    Section(section.title) {
                        ForEach(section) { item in
                            Button {
                                item.isPacked.toggle()
                                save()
                            } label: {
                                Label(item.name, systemImage: item.isPacked ? "checkmark.circle.fill" : "circle")
                            }
                            .accessibilityValue(item.isPacked ? "Packed" : "Not packed")
                        }
                        .onDelete { offsets in
                            for offset in offsets {
                                context.delete(section[offset])
                            }
                            save()
                        }
                    }
                }
                if sections.isEmpty {
                    ContentUnavailableView("Nothing to pack yet", systemImage: "suitcase",
                                           description: Text("Add the first thing above."))
                }
            }
            .navigationTitle("Packing for \(trip.city)")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("Done") { dismiss() }
                }
            }
        }
    }

    /// Whether the on-device model can answer on this device, now.
    private var canSuggest: Bool {
        if case .available = SystemLanguageModel.default.availability { true } else { false }
    }

    /// Asks the on-device model for three things to pack, and adds them to the list.
    private func suggest() async {
        isSuggesting = true
        defer { isSuggesting = false }
        let session = LanguageModelSession(instructions: "You help travelers pack. Keep each name short.")
        do {
            let answer = try await session.respond(to: "Packing for \(trip.nights) nights in \(trip.city), \(trip.country).",
                                                   generating: PackingSuggestions.self)
            for idea in answer.content.items {
                context.insert(PackingItem(name: idea.name, category: idea.category, tripID: trip.id))
            }
            save()
            print("The model suggested \(answer.content.items.count) things")
        } catch {
            print("No suggestions:", error)
        }
    }

    /// Writes the changes to disk now. Autosave would too — but at moments of its own choosing.
    private func save() {
        do {
            try context.save()
        } catch {
            print("Could not save the packing list:", error)
        }
    }
}

#Preview {
    PackingList(trip: .seattle)
        .modelContainer(for: PackingItem.self, inMemory: true)
}