Flaro/Flixy/Session/FlixySession.swift

import Foundation
import JellyfinKit
import MediaKit
import Observation
import PlexKit

/// Der Zustand der Verbindung zum Server.
///
/// Alles, was die App über „bin ich angemeldet und mit wem spreche ich" weiß,
/// steht hier. Die Views lesen nur `phase` — dadurch gibt es genau einen Ort,
/// an dem sich entscheidet, was auf dem Bildschirm erscheint.
///
/// Seit es zwei Serverarten gibt, hält diese Klasse **einen** aktiven Server,
/// nicht zwei. Zwei gleichzeitig hießen: zwei Startseiten, zwei Mediatheken,
/// zwei Suchergebnisse — und bei jedem Titel die Frage, woher er stammt.
/// Umschalten ja, nebeneinander nein.
@MainActor
@Observable
final class FlixySession {
    /// Welche Art von Server gerade bedient wird.
    enum ServerKind: String, Sendable, CaseIterable {
        case plex
        case jellyfin
    }

    enum Phase: Equatable {
        /// Beim Start: liegt ein Token im Schlüsselbund?
        case launching
        case signedOut
        /// Das Anmeldefenster von Plex ist offen.
        case authenticating
        /// Mehrere Server am Konto — einer muss gewählt werden.
        case choosingServer([PlexResource])
        /// Ein Weg zum Server wird gesucht.
        case connecting(serverName: String)
        case ready
        case failed(message: String)

        static func == (lhs: Phase, rhs: Phase) -> Bool {
            switch (lhs, rhs) {
            case (.launching, .launching), (.signedOut, .signedOut), (.ready, .ready):
                true
            case (.authenticating, .authenticating):
                true
            case (.choosingServer(let l), .choosingServer(let r)):
                l.map(\.clientIdentifier) == r.map(\.clientIdentifier)
            case (.connecting(let l), .connecting(let r)):
                l == r
            case (.failed(let l), .failed(let r)):
                l == r
            default:
                false
            }
        }
    }

    private enum Key {
        /// Welche Serverart zuletzt aktiv war.
        ///
        /// Fehlt der Eintrag, aber es liegt ein Plex-Token bereit, war es
        /// Plex — so kam die App bis hierher, und niemand soll durch ein
        /// Update abgemeldet werden.
        static let serverKind = "flixy.backend.kind"
        static let preferredServer = "flixy.server.clientIdentifier"
        static let cachedConnectionURI = "flixy.server.connectionURI"
        static let cachedServerName = "flixy.server.name"
        static let cachedConnectionIsLocal = "flixy.server.connectionIsLocal"
        static let jellyfinAddress = "flixy.jellyfin.address"
        static let jellyfinUserID = "flixy.jellyfin.userID"
        static let jellyfinUserName = "flixy.jellyfin.userName"
        static let jellyfinServerName = "flixy.jellyfin.serverName"
        static let jellyfinIsAdministrator = "flixy.jellyfin.isAdministrator"
    }

    /// Unter welchem Namen die Server-Token im Schlüsselbund liegen.
    ///
    /// Nicht in den Voreinstellungen: sie geben vollen Zugriff auf die
    /// Mediathek. Getrennte Konten je Serverart, damit ein späteres Umschalten
    /// zwischen beiden nicht jedes Mal eine neue Anmeldung kostet. Das
    /// ausdrückliche Abmelden räumt trotzdem beide ab — siehe `signOut()`.
    private static let plexTokenAccount = "plex.server"
    private static let jellyfinTokenAccount = "jellyfin.server"

    /// Wird für die Anmelde-Adresse gebraucht: plex.tv ordnet den
    /// bestätigten Code darüber diesem Gerät zu.
    var clientIdentifier: String { identity.clientIdentifier }

    /// Der Code der laufenden Anmeldung.
    ///
    /// Wird nach kurzer Zeit im Anmeldebildschirm eingeblendet — als Ausweg,
    /// falls die Browser-Seite den Code nicht verknüpft. Das passiert, wenn
    /// man dort schon angemeldet ist, und ohne diesen Ausweg säße man fest.
    private(set) var pendingCode: String?
    private(set) var showsManualCode = false

    private(set) var phase: Phase = .launching
    /// Welche Serverart gerade bedient wird — `nil`, solange niemand
    /// angemeldet ist.
    private(set) var kind: ServerKind?

    /// Der aktive Server hinter dem neutralen Vertrag.
    ///
    /// Die Ansichten sprechen ausschließlich hierüber. Ob dahinter Plex oder
    /// Jellyfin steckt, sehen sie nicht — und genau deshalb musste für
    /// Jellyfin keine einzige Ansicht neu geschrieben werden.
    private(set) var backend: (any MediaBackend)?

    /// Der Plex-Server, solange Plex aktiv ist.
    ///
    /// Player, Live-TV und die Diagnose sprechen noch unmittelbar mit ihm.
    /// Bei Jellyfin ist er `nil` — diese drei Bereiche wandern als Nächstes
    /// auf den neutralen Vertrag.
    private(set) var server: PlexServer?

    /// Das angemeldete Jellyfin-Konto, solange Jellyfin aktiv ist.
    private(set) var jellyfinAccount: JellyfinAccount?

    /// Wer angemeldet ist — sofern der Server einen Namen dafür kennt.
    ///
    /// Plex führt den Kontonamen am Konto, nicht am Server; dort steht er hier
    /// noch nicht zur Verfügung, und deshalb bleibt die Zeile leer, statt
    /// etwas Falsches zu behaupten.
    var accountName: String? { jellyfinAccount?.userName }

    /// Die Mediatheken, die Flixy darstellen kann — Musik und Fotos
    /// erscheinen gar nicht erst.
    private(set) var libraries: [MediaLibrary] = []

    /// Wie der Server heißt, so wie er sich selbst nennt.
    var serverName: String { backend?.serverName ?? "" }

    /// Unter welcher Adresse er erreicht wird.
    var serverAddress: String? {
        switch kind {
        case .plex: server?.connection.uri
        case .jellyfin: defaults.string(forKey: Key.jellyfinAddress)
        case nil: nil
        }
    }

    /// Wie die Verbindung zum Server zu beschreiben ist.
    ///
    /// Für die Diagnose, und deshalb hier: welcher Weg zum Server führt, weiß
    /// die Sitzung. Bei Plex ist es die entscheidende Angabe — über die
    /// Vermittlung von plex.tv ist alles gedrosselt, und das erklärt die
    /// Hälfte aller Ruckler, bevor man weitersucht.
    var connectionDescription: String? {
        switch kind {
        case .plex:
            guard let connection = server?.connection else { return nil }
            if connection.local { return "Lokal · \(connection.uri)" }
            if connection.relay { return "Plex-Vermittlung (gedrosselt)" }
            return "Direkt von außen · \(connection.uri)"
        case .jellyfin:
            return serverAddress
        case nil:
            return nil
        }
    }

    /// Ob der aktive Server Live-TV anbietet, **so wie die App es heute kann**.
    ///
    /// Nicht `capabilities.contains(.liveTV)`: Jellyfin kann es, der
    /// Programmführer der App spricht aber noch unmittelbar mit Plex. Einen
    /// Eintrag zu zeigen, der zu einem leeren Bildschirm führt, wäre eine
    /// Zusage, die niemand einlöst.
    var supportsLiveTV: Bool { server != nil }

    /// Warum gerade nicht abgespielt werden kann.
    ///
    /// Bei Jellyfin ist die Anmeldung fertig, die Wiedergabe noch nicht — sie
    /// ist der nächste Schritt. „Server nicht erreichbar" wäre an dieser
    /// Stelle schlicht gelogen: er ist erreichbar, die App kann nur noch
    /// nichts von ihm abspielen.
    var playbackUnavailableMessage: String {
        kind == .jellyfin
            ? String(localized: "player.jellyfinPending")
            : String(localized: "error.serverUnreachable")
    }

    private let identity: PlexClientIdentity
    private let jellyfinIdentity: JellyfinIdentity
    private let tokenStore: any TokenStoring
    private let authenticator: PlexAuthenticator
    private let webAuthenticator = PlexWebAuthenticator()
    private let defaults: UserDefaults
    private var authorizationTask: Task<Void, Never>?

    init(
        identity: PlexClientIdentity,
        jellyfinIdentity: JellyfinIdentity,
        tokenStore: any TokenStoring,
        defaults: UserDefaults = .standard
    ) {
        self.identity = identity
        self.jellyfinIdentity = jellyfinIdentity
        self.tokenStore = tokenStore
        self.defaults = defaults
        self.authenticator = PlexAuthenticator(identity: identity, tokenStore: tokenStore)
    }

    // MARK: - Start

    /// Versucht, mit einem bereits gespeicherten Token weiterzumachen.
    func restore() async {
        switch storedKind {
        case .jellyfin:
            if await restoreJellyfin() { return }
            phase = .signedOut

        case .plex, nil:
            guard let token = authenticator.storedToken else {
                phase = .signedOut
                return
            }
            // Wer vor dieser Version angemeldet war, hat keinen Eintrag über
            // die Serverart — nachtragen, damit „nicht eingetragen" von hier
            // an eindeutig „abgemeldet" heißt.
            defaults.set(ServerKind.plex.rawValue, forKey: Key.serverKind)

            // Erst der kurze Weg: die Verbindung, die beim letzten Mal
            // funktioniert hat. Ohne ihn kostet jeder Start eine Anfrage an
            // plex.tv plus eine neue Verbindungssuche — zusammen mehrere
            // Sekunden, in denen nur ein Ladekreis zu sehen ist.
            if await restoreFromRememberedConnection() { return }

            await connect(accountToken: token)
        }
    }

    private var storedKind: ServerKind? {
        defaults.string(forKey: Key.serverKind).flatMap(ServerKind.init(rawValue:))
    }

    /// Nimmt die zuletzt funktionierende Verbindung wieder auf.
    ///
    /// Gibt `false` zurück, wenn nichts gespeichert ist oder der Server nicht
    /// mehr darüber erreichbar ist — dann übernimmt die vollständige Suche.
    /// Das ist der Fall, wenn man von zuhause weggeht: die lokale Adresse
    /// antwortet nicht mehr, und der direkte Weg muss neu gefunden werden.
    private func restoreFromRememberedConnection() async -> Bool {
        guard let identifier = defaults.string(forKey: Key.preferredServer),
              let uri = defaults.string(forKey: Key.cachedConnectionURI),
              let serverToken = tokenStore.token(for: Self.plexTokenAccount)
        else { return false }

        let name = defaults.string(forKey: Key.cachedServerName) ?? ""
        phase = .connecting(serverName: name)

        let connection = PlexConnection(
            uri: uri,
            local: defaults.bool(forKey: Key.cachedConnectionIsLocal)
        )
        let resource = PlexResource(
            name: name,
            clientIdentifier: identifier,
            accessToken: serverToken,
            connections: [connection]
        )

        // Kurze Zeitgrenze: wenn die gemerkte Adresse nicht sofort antwortet,
        // ist die vollständige Suche schneller als weiteres Warten.
        let selector = PlexConnectionSelector(identity: identity, probeTimeout: .seconds(2))
        guard await selector.selectConnection(for: resource) != nil,
              let server = PlexServer(resource: resource, connection: connection, identity: identity)
        else { return false }

        adopt(server: server)
        do {
            libraries = try await server.libraries().filter(\.isSupported).map(\.asMediaLibrary)
            phase = .ready
            return true
        } catch {
            clearActiveServer()
            return false
        }
    }

    // MARK: - Anmeldung bei Plex

    /// Öffnet die Anmeldeseite von Plex.
    ///
    /// Der PIN steckt weiterhin darunter — er ist der einzige Weg, auf dem
    /// Plex einen Token herausgibt. Sichtbar ist er nicht mehr.
    ///
    /// Das Fenster wird geöffnet, aber **nicht abgewartet**: Plex führt den
    /// Rücksprung über `forwardUrl` nicht zuverlässig aus. Auf dem iPad landet
    /// der Browser nach dem Anmelden auf watch.plex.tv und bleibt dort stehen
    /// — der Token liegt längst bereit, aber die App wartete auf einen
    /// Rückruf, der nie kam. Stattdessen wird hier im Sekundentakt beim Server
    /// nachgefragt und nebenbei geprüft, ob das Fenster geschlossen wurde.
    func beginSignIn() async {
        phase = .authenticating

        let pin: PlexPin
        do {
            pin = try await authenticator.requestPin()
        } catch {
            phase = .failed(message: ErrorText.describe(error))
            return
        }

        guard let url = pin.linkURL else {
            phase = .failed(message: String(localized: "signIn.windowFailed"))
            return
        }

        pendingCode = pin.code
        showsManualCode = false
        webAuthenticator.present(url: url, callbackScheme: Branding.urlScheme)

        // Die Frist entspricht der Gültigkeit des Codes bei Plex.
        for second in 0..<900 {
            try? await Task.sleep(for: .seconds(1))

            // Nach einer Viertelminute den Code zeigen. Wer bis dahin nicht
            // durch ist, hat vermutlich den Fall erwischt, in dem die Seite
            // nicht verknüpft — dann hilft nur noch das Abtippen.
            if second == 15 { showsManualCode = true }

            if let token = try? await authenticator.token(for: pin) {
                webAuthenticator.dismiss()
                clearPendingCode()
                await connect(accountToken: token)
                return
            }

            // Fenster geschlossen, ohne dass ein Token da ist.
            if webAuthenticator.didReturn {
                switch webAuthenticator.outcome {
                case .cancelled, nil:
                    // Abgebrochen oder zurückgesprungen, ohne dass der Token
                    // schon bereitlag. Noch ein paar Sekunden nachfragen,
                    // bevor aufgegeben wird — zwischen Rücksprung und Eintrag
                    // bei Plex liegt manchmal eine Sekunde.
                    if let token = try? await graceTokenLookup(pin: pin) {
                        clearPendingCode()
                        await connect(accountToken: token)
                        return
                    }
                    // Fenster zu, kein Token: nicht abmelden, sondern den Code
                    // stehen lassen. Er gilt weiter, und das Abtippen bei
                    // plex.tv/link ist jetzt der schnellste Weg.
                    showsManualCode = true
                case .presentationFailed(let description):
                    phase = .failed(message: description)
                }
                return
            }
        }

        webAuthenticator.dismiss()
        clearPendingCode()
        phase = .failed(message: String(localized: "signIn.timedOut"))
    }

    private func clearPendingCode() {
        pendingCode = nil
        showsManualCode = false
    }

    /// Fragt nach dem Schließen des Fensters noch ein paar Sekunden nach.
    private func graceTokenLookup(pin: PlexPin) async throws -> String? {
        for _ in 0..<5 {
            if let token = try? await authenticator.token(for: pin) { return token }
            try? await Task.sleep(for: .milliseconds(700))
        }
        return nil
    }

    func cancelSignIn() {
        authorizationTask?.cancel()
        authorizationTask = nil
        webAuthenticator.dismiss()
        clearPendingCode()
        phase = .signedOut
    }

    /// Meldet ab — von allen Servern, nicht nur vom gerade aktiven.
    ///
    /// Der Knopf heißt „Abmelden" und nicht „diesen Server verlassen". Nur den
    /// aktiven zu vergessen hieße, dass nach dem Abmelden beim nächsten Start
    /// wieder eine Mediathek dasteht — die des anderen Servers.
    func signOut() {
        authorizationTask?.cancel()
        authenticator.signOut()
        forgetRememberedConnection()
        forgetJellyfin()
        defaults.removeObject(forKey: Key.serverKind)
        clearActiveServer()
        phase = .signedOut
    }

    // MARK: - Verbinden mit Plex

    private func connect(accountToken: String) async {
        phase = .connecting(serverName: "")

        let directory = PlexServerDirectory(identity: identity, token: accountToken)
        let servers: [PlexResource]
        do {
            servers = try await directory.servers()
        } catch PlexError.unauthorized {
            // Der Token wurde am Konto zurückgezogen. Ihn zu behalten würde
            // bei jedem Start denselben Fehler erzeugen.
            authenticator.signOut()
            phase = .signedOut
            return
        } catch {
            phase = .failed(message: ErrorText.describe(error))
            return
        }

        guard !servers.isEmpty else {
            phase = .failed(message: String(localized: "error.noServers"))
            return
        }

        // Beim zweiten Start soll niemand erneut wählen müssen.
        let remembered = defaults.string(forKey: Key.preferredServer)
        if let chosen = servers.first(where: { $0.clientIdentifier == remembered }) ?? servers.singleElement {
            await connect(to: chosen)
        } else {
            phase = .choosingServer(servers)
        }
    }

    func connect(to resource: PlexResource) async {
        phase = .connecting(serverName: resource.name)

        let selector = PlexConnectionSelector(identity: identity)
        guard let connection = await selector.selectConnection(for: resource) else {
            phase = .failed(message: String(localized: "error.serverUnreachable"))
            return
        }

        guard let server = PlexServer(
            resource: resource,
            connection: connection,
            identity: identity
        ) else {
            phase = .failed(message: String(localized: "error.serverUnreachable"))
            return
        }

        adopt(server: server)
        remember(resource: resource, connection: connection)

        do {
            libraries = try await server.libraries().filter(\.isSupported).map(\.asMediaLibrary)
            phase = .ready
        } catch {
            phase = .failed(message: ErrorText.describe(error))
        }
    }

    /// Merkt sich, worüber es funktioniert hat.
    private func remember(resource: PlexResource, connection: PlexConnection) {
        defaults.set(ServerKind.plex.rawValue, forKey: Key.serverKind)
        defaults.set(resource.clientIdentifier, forKey: Key.preferredServer)
        defaults.set(connection.uri, forKey: Key.cachedConnectionURI)
        defaults.set(connection.local, forKey: Key.cachedConnectionIsLocal)
        defaults.set(resource.name, forKey: Key.cachedServerName)
        if let token = resource.accessToken {
            try? tokenStore.store(token, for: Self.plexTokenAccount)
        }
    }

    /// Vergisst die gemerkte Verbindung.
    private func forgetRememberedConnection() {
        for key in [Key.preferredServer, Key.cachedConnectionURI,
                    Key.cachedConnectionIsLocal, Key.cachedServerName] {
            defaults.removeObject(forKey: key)
        }
        tokenStore.remove(for: Self.plexTokenAccount)
    }

    // MARK: - Verbinden mit Jellyfin

    /// Übernimmt eine fertige Jellyfin-Anmeldung.
    ///
    /// Die Anmeldung selbst führt `JellyfinSignInModel` — sie besteht aus
    /// mehreren Schritten mit eigener Bedienung (Adresse, Code, Rückfall auf
    /// Passwort) und gehört deshalb in ein eigenes Modell. Hier kommt nur das
    /// Ergebnis an: ein Konto und ein Weg dorthin.
    func adoptJellyfin(
        client: JellyfinClient,
        account: JellyfinAccount,
        serverName: String
    ) async {
        phase = .connecting(serverName: serverName)

        let backend = JellyfinBackend(client: client, account: account, serverName: serverName)
        clearActiveServer()
        kind = .jellyfin
        jellyfinAccount = account
        self.backend = backend

        do {
            libraries = try await backend.libraries().filter(\.isSupported)
        } catch {
            self.backend = nil
            jellyfinAccount = nil
            kind = nil
            phase = .failed(message: ErrorText.describe(error))
            return
        }

        rememberJellyfin(account: account, serverName: serverName, baseURL: client.baseURL)
        phase = .ready
    }

    /// Nimmt eine gespeicherte Jellyfin-Anmeldung wieder auf.
    ///
    /// Gibt `false` zurück, wenn nichts gespeichert ist oder der Token nicht
    /// mehr gilt — dann steht die Anmeldung wieder am Anfang. Ist der Server
    /// bloß gerade nicht erreichbar, bleibt die Anmeldung dagegen bestehen und
    /// es gibt einen Fehler mit „Erneut versuchen": auf dem Weg zur Arbeit ist
    /// jeder Server unerreichbar, und das ist kein Grund, jemanden abzumelden.
    private func restoreJellyfin() async -> Bool {
        guard let address = defaults.string(forKey: Key.jellyfinAddress),
              let baseURL = URL(string: address),
              let userID = defaults.string(forKey: Key.jellyfinUserID),
              let token = tokenStore.token(for: Self.jellyfinTokenAccount)
        else { return false }

        let serverName = defaults.string(forKey: Key.jellyfinServerName) ?? ""
        phase = .connecting(serverName: serverName)

        let account = JellyfinAccount(
            userID: userID,
            userName: defaults.string(forKey: Key.jellyfinUserName) ?? "",
            token: token,
            isAdministrator: defaults.bool(forKey: Key.jellyfinIsAdministrator)
        )
        let client = JellyfinClient(baseURL: baseURL, identity: jellyfinIdentity, token: token)
        let backend = JellyfinBackend(client: client, account: account, serverName: serverName)

        clearActiveServer()
        kind = .jellyfin
        jellyfinAccount = account
        self.backend = backend

        do {
            libraries = try await backend.libraries().filter(\.isSupported)
            phase = .ready
            return true
        } catch MediaBackendError.unauthorized {
            // Der Token wurde am Server zurückgezogen. Ihn zu behalten würde
            // bei jedem Start denselben Fehler erzeugen.
            forgetJellyfin()
            clearActiveServer()
            return false
        } catch {
            phase = .failed(message: ErrorText.describe(error))
            return true
        }
    }

    private func rememberJellyfin(account: JellyfinAccount, serverName: String, baseURL: URL) {
        defaults.set(ServerKind.jellyfin.rawValue, forKey: Key.serverKind)
        defaults.set(baseURL.absoluteString, forKey: Key.jellyfinAddress)
        defaults.set(account.userID, forKey: Key.jellyfinUserID)
        defaults.set(account.userName, forKey: Key.jellyfinUserName)
        defaults.set(serverName, forKey: Key.jellyfinServerName)
        defaults.set(account.isAdministrator, forKey: Key.jellyfinIsAdministrator)
        try? tokenStore.store(account.token, for: Self.jellyfinTokenAccount)
    }

    private func forgetJellyfin() {
        for key in [Key.jellyfinAddress, Key.jellyfinUserID, Key.jellyfinUserName,
                    Key.jellyfinServerName, Key.jellyfinIsAdministrator] {
            defaults.removeObject(forKey: key)
        }
        tokenStore.remove(for: Self.jellyfinTokenAccount)
    }

    // MARK: - Der aktive Server

    /// Setzt Plex als aktiven Server.
    private func adopt(server: PlexServer) {
        kind = .plex
        self.server = server
        backend = PlexBackend(server: server)
        jellyfinAccount = nil
    }

    private func clearActiveServer() {
        server = nil
        backend = nil
        jellyfinAccount = nil
        kind = nil
        libraries = []
    }

    /// Nach einem Fehler noch einmal versuchen, ohne die Anmeldung zu verlieren.
    func retry() async {
        switch storedKind {
        case .jellyfin:
            if await restoreJellyfin() { return }
            phase = .signedOut
        case .plex, nil:
            if let token = authenticator.storedToken {
                await connect(accountToken: token)
            } else {
                phase = .signedOut
            }
        }
    }

    /// Die Kennung für Jellyfin-Anmeldungen.
    ///
    /// Der Anmeldebildschirm baut sich seinen eigenen Client, bevor es eine
    /// Sitzung gibt — er braucht dieselbe Gerätekennung, sonst steht die App
    /// nach dem Anmelden ein zweites Mal in der Geräteliste des Servers.
    var jellyfinDeviceIdentity: JellyfinIdentity { jellyfinIdentity }
}

extension Array {
    /// Das einzige Element — oder `nil`, wenn es keines oder mehrere gibt.
    var singleElement: Element? { count == 1 ? first : nil }
}