Sources/OrgstarMobile/CaptureScreen.swift

  1#if os(iOS)
  2import OrgApp
  3import OrgCore
  4import SwiftUI
  5
  6/// Capture with a template: its questions (`%^{…}`, `%^g`, `%^t`…), then its text to edit,
  7/// filed where the template says, as `org-capture` does.
  8struct CaptureScreen: View {
  9    let workspace: WorkspaceModel
 10    let session: DocumentSession
 11    let request: CaptureRequest
 12    @Environment(\.dismiss) private var dismiss
 13    @Environment(ClockModel.self) private var clock
 14    @Environment(MobileModel.self) private var model
 15    @State private var templates: [CaptureTemplate] = []
 16    @State private var key: String?
 17    @State private var context = CaptureContext()
 18    @State private var questions: [Capture.Question] = []
 19    @State private var answers: [String] = []
 20    @State private var editing = false
 21    @State private var text = ""
 22    @State private var selection: TextSelection?
 23    @State private var problem: String?
 24    @FocusState private var focused: Bool
 25
 26    private var template: CaptureTemplate? { templates.first { $0.key == key } }
 27
 28    var body: some View {
 29        NavigationStack {
 30            Form {
 31                Picker("Template", selection: $key) {
 32                    ForEach(templates) { Text($0.name).tag(Optional($0.key)) }
 33                }
 34                if editing {
 35                    Section {
 36                        TextEditor(text: $text, selection: $selection)
 37                            .font(.body.monospaced())
 38                            .frame(minHeight: 200)
 39                            .focused($focused)
 40                    } footer: {
 41                        if let problem { Text(problem).foregroundStyle(.red) }
 42                    }
 43                } else {
 44                    ForEach(questions.indices, id: \.self) { index in
 45                        QuestionField(question: questions[index], answer: $answers[index], defaultDate: request.day.map(Self.date))
 46                    }
 47                    if let problem { Text(problem).foregroundStyle(.red) }
 48                }
 49            }
 50            .navigationTitle("Capture")
 51            .navigationBarTitleDisplayMode(.inline)
 52            .toolbar {
 53                ToolbarItem(placement: .cancellationAction) { Button("Cancel") { dismiss() } }
 54                ToolbarItem(placement: .confirmationAction) {
 55                    if editing {
 56                        Button("File", action: file).disabled(template == nil)
 57                    } else {
 58                        Button("Continue", action: fill)
 59                    }
 60                }
 61            }
 62        }
 63        .onAppear {
 64            let loaded = CaptureTemplates.load()
 65            templates = loaded.templates
 66            problem = loaded.problems.first
 67            key = request.template.flatMap { wanted in templates.first { $0.key == wanted }?.key } ?? templates.first?.key
 68            if let wanted = request.template, !templates.contains(where: { $0.key == wanted }) { problem = "No capture template \"\(wanted)\"" }
 69        }
 70        .onChange(of: key, initial: true) { choose() }
 71    }
 72
 73    /// The template's questions, asked before its text; none, and the text shows at once.
 74    private func choose() {
 75        guard let template else { return }
 76        context = CaptureContext(
 77            initial: request.properties["initial"] ?? "", annotation: request.properties["annotation"] ?? "",
 78            allTags: (try? workspace.index.tags()) ?? []
 79        )
 80        context.linkProperties = request.properties
 81        // `%^g` offers the target file's tags.
 82        let path = DocumentSession.resolve(template.target.file, root: workspace.rootPaths.first)
 83        if !template.target.file.isEmpty,
 84           let source = session.openTexts[path] ?? (try? String(contentsOfFile: path, encoding: .utf8)) {
 85            var tags: [String] = []
 86            for heading in DocumentModel(tree: OrgParser.parse(source)).headings { for tag in heading.localTags where !tags.contains(tag) { tags.append(tag) } }
 87            context.fileTags = tags
 88        }
 89        questions = Capture.questions(template.template, context: context)
 90        answers = questions.map { _ in "" }
 91        editing = false
 92        if questions.isEmpty { fill() }
 93    }
 94
 95    /// The template expanded with the answers; the caret where `%?` was.
 96    private func fill() {
 97        guard let template else { return }
 98        context.now = request.day.map(Self.date) ?? Date()
 99        switch Capture.fill(template.template, context: context, answers: answers) {
100        case .success(let filled):
101            let (filledText, cursor) = request.day.map { Capture.scheduling(filled.text, cursor: filled.cursor, on: $0) } ?? (filled.text, filled.cursor)
102            text = filledText
103            selection = TextSelection(insertionPoint: String.Index(utf16Offset: cursor, in: filledText))
104            problem = nil
105            editing = true
106            focused = true
107            if template.options.immediateFinish { file() }
108        case .failure(.message(let message)):
109            problem = message
110        }
111    }
112
113    /// Now's time of day on `day` (a `Days` number): the default time of an agenda day's
114    /// capture, as `org-agenda-capture` sets `org-overriding-default-time`.
115    static func date(_ day: Int) -> Date {
116        let calendar = Calendar.current
117        let d = Days.date(day)
118        var parts = calendar.dateComponents([.hour, .minute, .second], from: Date())
119        (parts.year, parts.month, parts.day) = (d.year, d.month, d.day)
120        return calendar.date(from: parts) ?? Date()
121    }
122
123    private func file() {
124        guard let template else { return }
125        let now = Date()
126        let placed = template.resolved(workspace: workspace, session: session, clock: clock).flatMap { resolved in
127            session.capture(text, template: resolved.template, root: workspace.rootPaths.first, file: resolved.file, now: request.day.map(Self.date) ?? now)
128        }
129        switch placed {
130        case .failure(let error):
131            problem = error.message
132            editing = true
133        case .success(let entry):
134            // Clocked from when capture began.
135            let paths = workspace.files.filter { $0.kind == .org }.map(\.path)
136            Task { [clock, session, opened = context.now] in
137                _ = await clock.captured(entry, options: template.options, session: session, paths: paths, ask: model.clockPrompts.ask, opened: opened, now: now)
138            }
139            if template.options.jumpToCaptured { model.openRequest = .offset(entry.path, entry.offset) }
140            dismiss()
141        }
142    }
143}
144
145/// One of a template's questions: text with its choices, tags, or a date.
146struct QuestionField: View {
147    let question: Capture.Question
148    @Binding var answer: String
149    /// What an empty date answer means: now, or the agenda day capture started from.
150    let defaultDate: Date?
151    @State private var date: Date
152
153    init(question: Capture.Question, answer: Binding<String>, defaultDate: Date? = nil) {
154        self.question = question
155        _answer = answer
156        self.defaultDate = defaultDate
157        _date = State(initialValue: defaultDate ?? Date())
158    }
159
160    var body: some View {
161        Section {
162            TextField(placeholder, text: $answer)
163                .autocorrectionDisabled()
164                .textInputAutocapitalization(.never)
165            if case .date(let withTime, _) = question.kind {
166                DatePicker("Date", selection: $date, displayedComponents: withTime ? [.date, .hourAndMinute] : [.date])
167                    .onChange(of: date) { answer = Self.stamp(date, withTime: withTime) }
168            }
169            if !question.choices.isEmpty {
170                ScrollView(.horizontal, showsIndicators: false) {
171                    HStack {
172                        ForEach(question.choices.prefix(30), id: \.self) { choice in
173                            Button(choice) { pick(choice) }.buttonStyle(.bordered)
174                        }
175                    }
176                }
177            }
178        } header: {
179            Text(question.prompt)
180        }
181    }
182
183    /// What an empty answer means.
184    private var placeholder: String {
185        switch question.kind {
186        case .text, .property, .clipboard: question.defaultValue
187        case .tags: "tag:tag"
188        case .date(let withTime, _):
189            defaultDate.map { Self.stamp($0, withTime: withTime) + "; or +2d, fri" }
190                ?? (withTime ? "now; or +2d, fri 14:00" : "today; or +2d, fri")
191        }
192    }
193
194    /// Tags add to what's typed; other choices replace it.
195    private func pick(_ choice: String) {
196        guard question.kind == .tags else { return answer = choice }
197        let tags = answer.split(separator: ":").map(String.init)
198        if !tags.contains(choice) { answer = (tags + [choice]).joined(separator: ":") }
199    }
200
201    static func stamp(_ date: Date, withTime: Bool) -> String {
202        let formatter = DateFormatter()
203        formatter.locale = Locale(identifier: "en_US_POSIX")
204        formatter.dateFormat = withTime ? "yyyy-MM-dd HH:mm" : "yyyy-MM-dd"
205        return formatter.string(from: date)
206    }
207}
208#endif