Never Silent While Waiting, and a Still Keeps Its Truth

enum OutboxWaiting {
    /// Registered in Info.plist (`BGTaskSchedulerPermittedIdentifiers`).
    static let refreshTask = "com.cwk.spark.mobile.outbox"
    static let notificationId = "spark-outbox-waiting"
    /// A capture still on the phone this long after it was kept is waiting,
    /// not on its way: a copy over slow LTE takes a minute or two.
    static let waitingAfter: TimeInterval = 15 * 60

    /// The words for what waits, oldest first; nil when nothing does.
    static func notice(_ entries: [QueuedMoment]) -> (title: String, body: String)? {
        let waiting = entries.filter { !$0.state.isSettled }.sorted { $0.createdAt < $1.createdAt }
        guard let oldest = waiting.first else { return nil }
        let parked = waiting.filter { $0.state == .failedNeedsAttention }
        let taken = takenLine(oldest.payload)
        let title = waiting.count == 1 ? "A capture has not reached Pippa" : "\(waiting.count) captures have not reached Pippa"
        var body = waiting.count == 1
            ? "Taken \(taken), it is still on this phone."
            : "The oldest, taken \(taken), is still on this phone."
        if !parked.isEmpty {
            body += parked.count == waiting.count
                ? " The engine refused it; open Spark to send it again or discard it."
                : " \(parked.count) of them the engine refused; open Spark to see why."
        } else {
            body += " Open Spark to send \(waiting.count == 1 ? "it" : "them")."
        }
        return (title, body)
    }

/// A camera still keeps what the photo knows about itself (todo #590; Dad's
/// rule: every metadatum stays on private surfaces, stripped only at
/// publication). The picker hands the app a decoded image whose JPEG carries
/// no EXIF at all, so the moment's own truth fills what is missing: when it was
/// taken, with its offset, and where. A field the photo already has (a library
/// pick, a share) is never overwritten. Lossless: the image data is copied, not
/// re-encoded; anything ImageIO cannot write back returns the bytes unchanged.
enum PhotoMetadata {
    static func filled(_ data: Data, capturedAt: String, place: PlaceSample?) -> Data {
        guard let source = CGImageSourceCreateWithData(data as CFData, nil),
              let type = CGImageSourceGetType(source),
              let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any]
        else { return data }
        let exif = properties[kCGImagePropertyExifDictionary] as? [CFString: Any] ?? [:]
        let metadata = CGImageMetadataCreateMutable()
        var changed = false
        func set(_ dictionary: CFString, _ key: CFString, _ value: Any) {
            changed = CGImageMetadataSetValueMatchingImageProperty(metadata, dictionary, key, value as CFTypeRef) || changed
        }
        // A photo with a time of its own was taken elsewhere, earlier (a
        // library pick): where Dad is now is not where it was, so only a
        // photo without one takes the moment's place.
        let ownsTime = exif[kCGImagePropertyExifDateTimeOriginal] != nil
        if !ownsTime, let stamp = stampParts(capturedAt) {
            set(kCGImagePropertyExifDictionary, kCGImagePropertyExifDateTimeOriginal, stamp.clock)
            set(kCGImagePropertyExifDictionary, kCGImagePropertyExifDateTimeDigitized, stamp.clock)
            set(kCGImagePropertyExifDictionary, kCGImagePropertyExifOffsetTimeOriginal, stamp.offset)
            set(kCGImagePropertyExifDictionary, kCGImagePropertyExifOffsetTimeDigitized, stamp.offset)
        }
        if !ownsTime, properties[kCGImagePropertyGPSDictionary] == nil, let place {
            let gps = kCGImagePropertyGPSDictionary
            set(gps, kCGImagePropertyGPSLatitude, abs(place.lat))
            set(gps, kCGImagePropertyGPSLatitudeRef, place.lat >= 0 ? "N" : "S")
            set(gps, kCGImagePropertyGPSLongitude, abs(place.lon))
            set(gps, kCGImagePropertyGPSLongitudeRef, place.lon >= 0 ? "E" : "W")
            if let accuracy = place.accuracyM { set(gps, kCGImagePropertyGPSHPositioningError, accuracy) }
        }
        guard changed else { return data }
        let output = NSMutableData()
        guard let destination = CGImageDestinationCreateWithData(output, type, 1, nil) else { return data }
        let options: [CFString: Any] = [kCGImageDestinationMetadata: metadata, kCGImageDestinationMergeMetadata: true]
        guard CGImageDestinationCopyImageSource(destination, source, options as CFDictionary, nil) else { return data }
        return output as Data
    }

    var body: some Scene {
        WindowGroup {
            if Self.hostingTests {
                Color.clear
            } else {
                RootView()
                    .id(model.client.endpoint)
                    .environment(model)
                    .tint(Palette.ember)
                    .preferredColorScheme(.dark)
                    .onOpenURL { model.receive($0) }
                    .task(id: "\(phase)-\(model.client.endpoint)") {
                        // Leaving the app: what still waits is counted on the
                        // icon, notified, and iOS is asked to wake Spark to
                        // send it (todo #590).
                        guard phase == .active else {
                            if phase == .background { await model.noteWaiting() }
                            return
                        }
                        while !Task.isCancelled {
                            await model.syncOffline()
                            do { try await Task.sleep(for: .seconds(60)) } catch { return }
                        }
                    }
            }
        }
        .backgroundTask(.appRefresh(OutboxWaiting.refreshTask)) {
            await model.drainWhileAway()
        }
    }