Flaro/Flixy/FlixyApp.swift

import SwiftData
import SwiftUI
import FlixyDesign
import FlixyDownloads
import FlixyPlayback
import PlexKit

@main
struct FlixyApp: App {
    /// Nimmt das Signal entgegen, mit dem iOS die App zum Abschluss von
    /// Hintergrund-Downloads aufweckt. Dafür gibt es in SwiftUI keinen
    /// eigenen Weg — nur den klassischen App-Delegaten.
    @UIApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate

    /// Leben hier, nicht in einer View: sie gelten für die gesamte App, und
    /// ein Neuaufbau der Wurzelansicht darf weder die Anmeldung noch laufende
    /// Downloads zurücksetzen.
    @State private var theme = FlixyTheme()
    @State private var session: FlixySession
    @State private var playback = PlaybackCoordinator()
    @State private var playbackSettings = PlaybackSettings()
    /// Beobachtet WLAN und Mobilfunk. Lebt hier, damit der Beobachter einmal
    /// läuft statt bei jedem Öffnen des Players neu zu starten.
    @State private var network = NetworkConditions()
    @State private var homeLayout = HomeLayoutSettings()
    @State private var diagnostics = PlaybackDiagnostics()
    @State private var downloads: DownloadCoordinator

    private let modelContainer: ModelContainer

    init() {
        let identity = PlexClientIdentity.current(
            product: Branding.plexProduct,
            version: Branding.version
        )
        _session = State(initialValue: FlixySession(
            identity: identity,
            tokenStore: KeychainTokenStore(service: Branding.keychainService)
        ))

        // Scheitert das Anlegen der Datenbank, ist die App nicht sinnvoll zu
        // benutzen — dann lieber hier abbrechen als später bei jedem Download
        // stillschweigend nichts tun.
        let container = try! ModelContainer(for: DownloadItem.self)
        self.modelContainer = container

        let fileStore = try! DownloadFileStore()
        _downloads = State(initialValue: DownloadCoordinator(
            container: container,
            fileStore: fileStore
        ))
    }

    var body: some Scene {
        WindowGroup {
            RootView()
                .environment(session)
                .environment(playback)
                .environment(playbackSettings)
                .environment(network)
                .environment(downloads)
                .environment(homeLayout)
                .environment(diagnostics)
                .environment(theme)
                // Akzentfarbe und Tönung setzt RootView, nicht diese Stelle.
                //
                // Scene-Bodies werten Änderungen an beobachteten Objekten
                // nicht zuverlässig neu aus. Stand `.tint` hier, blieb nach
                // einem Farbwechsel ein Teil der Oberfläche auf dem alten
                // Wert stehen — sichtbar etwa an Picker-Werten, die weiter in
                // der Standardfarbe leuchteten, während die Schalter schon
                // umgestellt waren.
                //
                // Der eigentliche Schalter für „nur dunkel" steht in der
                // Info.plist (UIUserInterfaceStyle). Diese Zeile ist die
                // Absicherung für SwiftUI-Vorschauen, die sie nicht lesen.
                .preferredColorScheme(.dark)
                .task {
                    appDelegate.downloads = downloads
                    await downloads.restore()
                    // Beim Start einmal prüfen: während die App weg war,
                    // können Folgen gesehen oder gelöscht worden sein.
                    await DownloadRefiller(
                        backend: session.backend,
                        coordinator: downloads
                    ).refill()
                }
        }
        .modelContainer(modelContainer)
    }
}

/// Der klassische App-Delegat, für das eine, was SwiftUI nicht abdeckt.
@MainActor
final class AppDelegate: NSObject, UIApplicationDelegate {
    weak var downloads: DownloadCoordinator?

    /// Nicht `@Sendable`: UIKit reicht den Block ohne diese Zusage herein,
    /// und er wird ohnehin nur auf dem Hauptakteur aufgerufen. Der Delegat
    /// selbst ist an den Hauptakteur gebunden.
    private var pendingCompletionHandler: (() -> Void)?

    /// Welche Ausrichtungen gerade erlaubt sind.
    ///
    /// Wird vom System bei jeder Drehung gefragt. Ohne diese Antwort dreht
    /// `requestGeometryUpdate` zwar kurz, das System dreht aber sofort zurück
    /// — genau das sah aus wie „wechselt nicht so richtig ins Querformat".
    func application(
        _ application: UIApplication,
        supportedInterfaceOrientationsFor window: UIWindow?
    ) -> UIInterfaceOrientationMask {
        MainActor.assumeIsolated { OrientationLock.shared.mask }
    }

    func application(
        _ application: UIApplication,
        handleEventsForBackgroundURLSession identifier: String,
        completionHandler: @escaping () -> Void
    ) {
        // iOS hat die App im Hintergrund gestartet, weil Downloads fertig
        // geworden sind. Der Abschlussblock muss aufgerufen werden, sobald
        // alles verarbeitet ist — sonst beendet das System die App hart und
        // merkt sich das für künftige Aufweckversuche negativ.
        guard identifier == DownloadCoordinator.sessionIdentifier else {
            completionHandler()
            return
        }
        pendingCompletionHandler = completionHandler

        Task { [weak self] in
            await self?.downloads?.restore()
            self?.pendingCompletionHandler?()
            self?.pendingCompletionHandler = nil
        }
    }
}