Push notifications

final class AppDelegate: NSObject, UIApplicationDelegate {
    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
        UNUserNotificationCenter.current().delegate = NotificationRouter.shared   // before launch finishes
        application.registerForRemoteNotifications()                              // every launch
        return true
    }

    func application(_ application: UIApplication,
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        let token = deviceToken.map { String(format: "%02x", $0) }.joined()
        Task { try? await DevicesAPI.shared.register(token: token) }               // upsert on the server
    }

    func application(_ application: UIApplication,
                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
        Logger.push.error("APNs registration failed: \(error)")                   // e.g. on a simulator without push
    }
}

// Called when the user taps "Notify me when it ships"
@MainActor
func enableShippingUpdates() async -> Bool {
    let center = UNUserNotificationCenter.current()
    switch await center.notificationSettings().authorizationStatus {
    case .authorized, .provisional, .ephemeral:
        return true
    case .notDetermined:
        return (try? await center.requestAuthorization(options: [.alert, .sound, .badge])) ?? false
    case .denied:
        showSettingsPrompt()            // "Notifications are off. Open Settings?"
        return false
    @unknown default:
        return false
    }
}

@MainActor
final class NotificationRouter: NSObject, UNUserNotificationCenterDelegate {
    static let shared = NotificationRouter()
    var navigation: AppNavigation?                       // set by the root view; pending links wait
    private var pendingLink: URL?

    // A notification arrives while the app is in the foreground
    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
                                            willPresent notification: UNNotification) async
        -> UNNotificationPresentationOptions {
        let chatId = notification.request.content.userInfo["chatId"] as? String
        let isOpen = await MainActor.run { NotificationRouter.shared.navigation?.openChatId == chatId }
        return isOpen && chatId != nil ? [] : [.banner, .sound, .list]   // don't banner the chat you're reading
    }

    // The user tapped the notification or one of its actions (also on cold launch)
    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
                                            didReceive response: UNNotificationResponse) async {
        let info = response.notification.request.content.userInfo
        guard let link = (info["link"] as? String).flatMap(URL.init(string:)) else { return }
        await MainActor.run { NotificationRouter.shared.open(link) }
    }

    func open(_ link: URL) {
        guard let navigation else { pendingLink = link; return }   // UI not ready yet: keep it
        navigation.handle(deepLink: link)                           // e.g. shop://orders/1042
    }

    func attach(_ navigation: AppNavigation) {
        self.navigation = navigation
        if let link = pendingLink { pendingLink = nil; navigation.handle(deepLink: link) }
    }
}

final class NotificationService: UNNotificationServiceExtension {
    private var contentHandler: ((UNNotificationContent) -> Void)?
    private var bestAttempt: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest,
                             withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        self.contentHandler = contentHandler
        let content = (request.content.mutableCopy() as? UNMutableNotificationContent) ?? UNMutableNotificationContent()
        bestAttempt = content

        guard let urlString = request.content.userInfo["imageUrl"] as? String,
              let url = URL(string: urlString) else {
            contentHandler(content)
            return
        }

        Task {
            if let attachment = try? await Self.downloadAttachment(from: url) {
                content.attachments = [attachment]
            }
            contentHandler(content)                    // always deliver, with or without the image
            self.contentHandler = nil
        }
    }

    override func serviceExtensionTimeWillExpire() {
        if let contentHandler, let bestAttempt { contentHandler(bestAttempt) }   // out of time: show what we have
        contentHandler = nil
    }

    private static func downloadAttachment(from url: URL) async throws -> UNNotificationAttachment {
        let (file, _) = try await URLSession.shared.download(from: url)
        let target = FileManager.default.temporaryDirectory.appendingPathComponent(url.lastPathComponent)
        try? FileManager.default.removeItem(at: target)
        try FileManager.default.moveItem(at: file, to: target)
        return try UNNotificationAttachment(identifier: "image", url: target)
    }
}