Sources/OrgstarMobile/ClockScreens.swift

  1#if os(iOS)
  2import OrgApp
  3import OrgCore
  4import SwiftUI
  5
  6/// Clock commands that ask questions, and their answers in `ClockPromptSheet`.
  7@MainActor
  8@Observable
  9final class ClockPrompter {
 10    struct Pending: Identifiable {
 11        let id = UUID()
 12        let prompt: Prompt
 13        let reply: (String?) -> Void
 14    }
 15
 16    var pending: Pending?
 17
 18    var ask: ClockModel.Ask {
 19        { [self] prompt in
 20            await withCheckedContinuation { continuation in
 21                pending = Pending(prompt: prompt) { continuation.resume(returning: $0) }
 22            }
 23        }
 24    }
 25
 26    func answer(_ text: String?) {
 27        guard let request = pending else { return }
 28        pending = nil
 29        request.reply(text)
 30    }
 31}
 32
 33/// The clock commands both the editor and the clock accessory run.
 34@MainActor
 35enum MobileClock {
 36    /// Runs a clock command; false for other ids. Messages go to `show`; entries to show open.
 37    static func run(_ id: String, model: MobileModel, workspace: WorkspaceModel, show: @escaping (String) -> Void) -> Bool {
 38        let clock = model.clock
 39        let session = model.session
 40        let ask = model.clockPrompts.ask
 41        let paths = workspace.files.filter { $0.kind == .org }.map(\.path)
 42        func open(_ location: (path: String, offset: Int)?) {
 43            if let location { model.openRequest = .offset(location.path, location.offset) }
 44        }
 45        func report(_ outcome: ClockModel.Outcome) {
 46            open(outcome.jump)
 47            if let message = outcome.messages.last(where: { !$0.isEmpty }) { show(message) }
 48        }
 49        func clockIn(_ target: ClockModel.Target) {
 50            Task { report(await clock.clockIn(session, target: target, paths: paths, ask: ask)) }
 51        }
 52        switch id {
 53        case "app.clock.in": clockIn(.caret)
 54        case "app.clock.in-recent": clockIn(.select)
 55        case "app.clock.in-last": clockIn(.last)
 56        case let id where id.hasPrefix("app.clock.history."):
 57            guard let index = Int(id.dropFirst("app.clock.history.".count)), index < clock.history.count else { return true }
 58            clockIn(.task(clock.history[index]))
 59        case "app.clock.out": show(clock.clockOut(session))
 60        case "app.clock.cancel": show(clock.clockOut(session, cancel: true))
 61        case "app.clock.goto":
 62            let found = clock.goto(session)
 63            open(found.location)
 64            if let message = found.message { show(message) }
 65        case "app.clock.goto-recent":
 66            Task {
 67                let found = await clock.gotoRecent(session, ask: ask)
 68                open(found.location)
 69                if let message = found.message { show(message) }
 70            }
 71        case "app.clock.default": show(clock.markDefault(session))
 72        case "app.clock.resolve":
 73            Task { report(await clock.resolveOpenClocks(session, paths: paths, ask: ask)) }
 74        default:
 75            return false
 76        }
 77        return true
 78    }
 79}
 80
 81/// Recent entries to clock in to, and the commands that choose among them.
 82struct RecentClockMenu: View {
 83    let clock: ClockModel
 84    let perform: (String) -> Void
 85
 86    var body: some View {
 87        Menu("Recent Entries", systemImage: "clock.arrow.circlepath") {
 88            ForEach(Array(clock.history.enumerated()), id: \.offset) { index, task in
 89                Button(task.title) { perform("app.clock.history.\(index)") }
 90            }
 91            Divider()
 92            Button("Clock In to Recent Entry…") { perform("app.clock.in-recent") }
 93            Button("Go to Recent Clocked Entry…") { perform("app.clock.goto-recent") }
 94        }
 95        .disabled(clock.history.isEmpty)
 96    }
 97}
 98
 99/// A clock question: keys to choose from under their sections, or a number or date to type.
100struct ClockPromptSheet: View {
101    let prompt: Prompt
102    let answer: (String?) -> Void
103    @State private var text = ""
104
105    var body: some View {
106        NavigationStack {
107            Form {
108                if let fast = prompt.fast {
109                    ForEach(Array(sections(fast).enumerated()), id: \.offset) { _, section in
110                        Section(section.title) {
111                            ForEach(Array(section.options.enumerated()), id: \.offset) { _, option in
112                                Button {
113                                    answer(String(option.key))
114                                } label: {
115                                    HStack(alignment: .firstTextBaseline) {
116                                        Text(String(option.key)).font(.body.monospaced()).foregroundStyle(.tint)
117                                        Text(option.name).foregroundStyle(.primary)
118                                    }
119                                }
120                            }
121                        }
122                    }
123                } else {
124                    Section {
125                        TextField(prompt.message, text: $text)
126                            .autocorrectionDisabled()
127                            .textInputAutocapitalization(.never)
128                            .keyboardType(prompt.date == nil ? .numbersAndPunctuation : .default)
129                            .onSubmit { answer(text) }
130                    } footer: {
131                        Text(prompt.date == nil ? "Empty takes the default." : "Org's date syntax: 14:00, -1h, today 9:30")
132                    }
133                }
134            }
135            .navigationTitle(prompt.message.trimmingCharacters(in: CharacterSet(charactersIn: ":?[] ")))
136            .navigationBarTitleDisplayMode(.inline)
137            .toolbar {
138                ToolbarItem(placement: .cancellationAction) { Button("Cancel") { answer(nil) } }
139                if prompt.fast == nil {
140                    ToolbarItem(placement: .confirmationAction) { Button("Done") { answer(text) } }
141                }
142            }
143        }
144        .onAppear { text = prompt.initial }
145        .interactiveDismissDisabled()
146    }
147
148    private struct Group {
149        var title: String
150        var options: [(key: Character, name: String)]
151    }
152
153    /// Options under the labels before them.
154    private func sections(_ fast: FastSelection) -> [Group] {
155        var groups: [Group] = []
156        for item in fast.items {
157            switch item {
158            case .label(let title): groups.append(Group(title: title, options: []))
159            case .option(let key, let name):
160                if groups.isEmpty { groups.append(Group(title: "", options: [])) }
161                groups[groups.count - 1].options.append((key, name))
162            default: break
163            }
164        }
165        return groups
166    }
167}
168
169/// The running clock over the tab bar: the entry and time so far, and clocking out.
170struct ClockAccessory: View {
171    let running: ClockModel.Running
172    let clock: ClockModel
173    let perform: (String) -> Void
174
175    var body: some View {
176        Menu {
177            Button("Clock Out", systemImage: "stop.circle") { perform("app.clock.out") }
178            Button("Cancel Clock", systemImage: "xmark.circle") { perform("app.clock.cancel") }
179            Button("Go to Clocked Entry", systemImage: "arrow.right.circle") { perform("app.clock.goto") }
180            RecentClockMenu(clock: clock, perform: perform)
181            Button("Clock Report", systemImage: "list.bullet.rectangle") { perform("app.clock.report") }
182        } label: {
183            HStack {
184                Image(systemName: "stopwatch")
185                Text(running.heading).lineLimit(1)
186                Spacer()
187                TimelineView(.periodic(from: .now, by: 30)) { context in
188                    Text(Self.elapsed(running, now: context.date)).monospacedDigit()
189                }
190            }
191            .padding(.horizontal)
192        }
193        .accessibilityLabel("Clocked in on \(running.heading)")
194    }
195
196    /// Elapsed time of the running clock, `H:MM`.
197    static func elapsed(_ running: ClockModel.Running, now: Date) -> String {
198        let minutes = max(0, Int(now.timeIntervalSince(running.startedAt) / 60))
199        return String(format: "%d:%02d", minutes / 60, minutes % 60)
200    }
201}
202
203extension View {
204    /// The running clock over the tab bar, while there is one.
205    @ViewBuilder
206    func clockAccessory(_ clock: ClockModel, perform: @escaping (String) -> Void) -> some View {
207        if #available(iOS 26.1, *) {
208            tabViewBottomAccessory(isEnabled: clock.running != nil) {
209                if let running = clock.running { ClockAccessory(running: running, clock: clock, perform: perform) }
210            }
211        } else {
212            safeAreaInset(edge: .bottom) {
213                if let running = clock.running { ClockAccessory(running: running, clock: clock, perform: perform).padding(.vertical, 8).background(.bar) }
214            }
215        }
216    }
217}
218
219/// Time per day and heading, as `tr/generate-report` writes it, for chosen files and dates.
220struct ClockReportScreen: View {
221    let workspace: WorkspaceModel
222    @State private var start = Calendar.current.date(byAdding: .day, value: -6, to: Date()) ?? Date()
223    @State private var end = Date()
224    @State private var limit = false
225    @State private var selected: Set<String> = []
226    @State private var report = ""
227    @Environment(\.dismiss) private var dismiss
228
229    private var candidates: [FileEntry] { workspace.files.filter { $0.kind == .org } }
230
231    var body: some View {
232        NavigationStack {
233            Form {
234                Section("Files") {
235                    ForEach(candidates) { file in
236                        Toggle(file.relativePath, isOn: Binding {
237                            selected.contains(file.path)
238                        } set: { on in
239                            if on { selected.insert(file.path) } else { selected.remove(file.path) }
240                        })
241                    }
242                }
243                Section {
244                    Toggle("Limit dates", isOn: $limit)
245                    if limit {
246                        DatePicker("From", selection: $start, displayedComponents: .date)
247                        DatePicker("To", selection: $end, displayedComponents: .date)
248                    }
249                }
250                Section("Report") {
251                    ScrollView(.horizontal) {
252                        Text(report.isEmpty ? "Choose files with clocked time." : report)
253                            .font(.footnote.monospaced())
254                            .textSelection(.enabled)
255                            .fixedSize()
256                    }
257                }
258            }
259            .navigationTitle("Clock Report")
260            .navigationBarTitleDisplayMode(.inline)
261            .toolbar {
262                ToolbarItem(placement: .cancellationAction) { Button("Close") { dismiss() } }
263                ToolbarItem(placement: .primaryAction) {
264                    ShareLink(item: report, preview: SharePreview("Time report")).disabled(report.isEmpty)
265                }
266            }
267        }
268        .onAppear {
269            if selected.isEmpty {
270                selected = Set(candidates.filter { (try? String(contentsOfFile: $0.path, encoding: .utf8))?.contains("CLOCK: [") ?? false }.map(\.path))
271            }
272            compute()
273        }
274        .onChange(of: selected) { compute() }
275        .onChange(of: start) { compute() }
276        .onChange(of: end) { compute() }
277        .onChange(of: limit) { compute() }
278    }
279
280    private func day(_ date: Date) -> String {
281        let c = Calendar.current.dateComponents([.year, .month, .day], from: date)
282        return String(format: "%04d-%02d-%02d", c.year!, c.month!, c.day!)
283    }
284
285    private func compute() {
286        var entries: [ClockReport.Entry] = []
287        for path in selected.sorted() {
288            guard let text = try? String(contentsOfFile: path, encoding: .utf8) else { continue }
289            entries += ClockReport.entries(text, settings: workspace.settings.org)
290        }
291        report = selected.isEmpty ? "" : ClockReport.timeReport(entries, start: limit ? day(start) : nil, end: limit ? day(end) : nil)
292    }
293}
294#endif