Flaro/Flixy/Session/PlaybackSettings.swift

import Foundation
#if canImport(FlixyVLC)
import FlixyVLC
#endif
import Observation
import FlixyPlayback

/// Was der Nutzer über die Wiedergabe eingestellt hat.
///
/// Getrennt nach WLAN und Mobilfunk, weil sich die Anforderungen dort
/// grundlegend unterscheiden: im Heimnetz ist die Originaldatei das Beste,
/// unterwegs zählt das Datenvolumen.
@MainActor
@Observable
final class PlaybackSettings {
    /// Die Stufen, die zur Auswahl stehen.
    ///
    /// Bewusst wenige und in Schritten, die man spürt. Eine freie Eingabe in
    /// Kilobit hilft niemandem bei der Frage „reicht das für heute Abend".
    enum Quality: Int, CaseIterable, Identifiable, Sendable {
        case original = 0
        case high = 12_000
        case medium = 8_000
        case low = 4_000
        case minimal = 2_000

        var id: Int { rawValue }

        /// `nil` heißt: keine Grenze, also die Originaldatei.
        var bitrateLimit: Int? { self == .original ? nil : rawValue }
    }

    private enum Key {
        static let wifiQuality = "flixy.playback.quality.wifi"
        static let cellularQuality = "flixy.playback.quality.cellular"
        static let autoSkipIntro = "flixy.playback.autoSkipIntro"
        static let autoSkipCredits = "flixy.playback.autoSkipCredits"
        static let autoPlayNext = "flixy.playback.autoPlayNext"
        static let locksLandscape = "flixy.playback.locksLandscape"
        static let rewindSeconds = "flixy.playback.rewindSeconds"
        static let forwardSeconds = "flixy.playback.forwardSeconds"
        static let defaultRate = "flixy.playback.defaultRate"
        static let remembersQuality = "flixy.playback.remembersQuality"
        static let rememberedQuality = "flixy.playback.rememberedQuality"
        static let showsBitrate = "flixy.playback.showsBitrate"
        static let lastPlaybackStruggled = "flixy.playback.struggled"
    }

    /// Die Sprünge, die es zur Auswahl gibt.
    ///
    /// Nicht frei einstellbar: ein Schieberegler für Sekunden lädt dazu ein,
    /// 23 einzustellen, und dafür gibt es kein Symbol. Diese fünf haben eins.
    static let skipChoices = [5, 10, 15, 30, 45]

    /// Die Geschwindigkeiten, mit denen eine Wiedergabe beginnen kann.
    static let rateChoices: [Double] = [0.75, 1.0, 1.25, 1.5, 1.75, 2.0]

    /// Ob ein zweiter Spieler zur Verfügung steht.
    ///
    /// VLC steckt in einem eigenen Paket, das nur für iOS gebaut wird — sein
    /// Binärpaket hat keinen Teil für Mac Catalyst. Wo es fehlt, übernimmt der
    /// Server: MKV und DTS werden dann umgerechnet statt unverändert
    /// übertragen. Das kostet ihn Rechenzeit und sieht man nicht, aber es
    /// spielt.
    static var hasFallbackEngine: Bool {
        #if canImport(FlixyVLC)
        true
        #else
        false
        #endif
    }

    private let defaults: UserDefaults

    var wifiQuality: Quality { didSet { defaults.set(wifiQuality.rawValue, forKey: Key.wifiQuality) } }
    var cellularQuality: Quality { didSet { defaults.set(cellularQuality.rawValue, forKey: Key.cellularQuality) } }
    var autoSkipIntro: Bool { didSet { defaults.set(autoSkipIntro, forKey: Key.autoSkipIntro) } }
    var autoSkipCredits: Bool { didSet { defaults.set(autoSkipCredits, forKey: Key.autoSkipCredits) } }
    var autoPlayNext: Bool { didSet { defaults.set(autoPlayNext, forKey: Key.autoPlayNext) } }
    /// ISO-Sprachcode, etwa `deu`. Leer heißt: nehmen, was der Server vorgibt.

    /// Ob der Player beim Öffnen ins Querformat dreht und dort bleibt.
    ///
    /// Für die allermeisten Filme richtig — und für den, der im Bett auf der
    /// Seite liegt, das Gegenteil davon. Deshalb abschaltbar.
    var locksLandscape: Bool { didSet { defaults.set(locksLandscape, forKey: Key.locksLandscape) } }
    /// Wie weit der Rücksprung geht, in Sekunden.
    var rewindSeconds: Int { didSet { defaults.set(rewindSeconds, forKey: Key.rewindSeconds) } }
    /// Wie weit der Vorsprung geht. Getrennt vom Rücksprung, weil die beiden
    /// verschiedene Zwecke haben: zurück, weil man etwas nicht verstanden hat;
    /// vor, weil man etwas überspringen will.
    var forwardSeconds: Int { didSet { defaults.set(forwardSeconds, forKey: Key.forwardSeconds) } }
    /// Mit welcher Geschwindigkeit eine Wiedergabe beginnt.
    var defaultRate: Double { didSet { defaults.set(defaultRate, forKey: Key.defaultRate) } }
    /// Ob die im Player gewählte Stufe für den nächsten Titel gilt.
    var remembersQuality: Bool { didSet { defaults.set(remembersQuality, forKey: Key.remembersQuality) } }
    /// Ob im Qualitätsmenü steht, was gerade tatsächlich ankommt.
    var showsBitrate: Bool { didSet { defaults.set(showsBitrate, forKey: Key.showsBitrate) } }

    /// Die zuletzt gewählte Stufe, als Zahl.
    ///
    /// Hier und nicht im Player: der lebt nur so lange wie ein Film. Was über
    /// mehrere Filme hinweg gelten soll, gehört in die Einstellungen.
    var rememberedQuality: Int? {
        get {
            guard remembersQuality else { return nil }
            let value = defaults.integer(forKey: Key.rememberedQuality)
            return value == 0 ? nil : value
        }
        set { defaults.set(newValue ?? 0, forKey: Key.rememberedQuality) }
    }

    /// Ob die letzte Wiedergabe von der Leitung nicht getragen wurde.
    ///
    /// **Ein Beleg, keine Vermutung.** Der Hinweis bei „ohne Grenze" soll nur
    /// erscheinen, wenn es tatsächlich gehakt hat — eine Warnung, die immer
    /// dasteht, liest nach dem zweiten Mal niemand mehr.
    ///
    /// Gesetzt vom Player, wenn im gleitenden Fenster ein Viertel der Zeit
    /// fürs Warten draufging oder ein einzelner Rückler über fünfzehn
    /// Sekunden dauerte.
    var lastPlaybackStruggled: Bool {
        get { defaults.bool(forKey: Key.lastPlaybackStruggled) }
        set { defaults.set(newValue, forKey: Key.lastPlaybackStruggled) }
    }

    init(defaults: UserDefaults = .standard) {
        self.defaults = defaults

        // Voreinstellung: im WLAN das Original, unterwegs 4 Mbit. Das ist die
        // Aufteilung, die im Alltag am seltensten stört — zuhause die beste
        // Qualität, unterwegs ein Wert, der auch bei mäßigem Empfang trägt.
        self.wifiQuality = Quality(rawValue: defaults.object(forKey: Key.wifiQuality) as? Int ?? 0) ?? .original
        self.cellularQuality = Quality(rawValue: defaults.object(forKey: Key.cellularQuality) as? Int ?? 4_000) ?? .low

        self.autoSkipIntro = defaults.object(forKey: Key.autoSkipIntro) as? Bool ?? false
        self.autoSkipCredits = defaults.object(forKey: Key.autoSkipCredits) as? Bool ?? false
        self.autoPlayNext = defaults.object(forKey: Key.autoPlayNext) as? Bool ?? true

        self.locksLandscape = defaults.object(forKey: Key.locksLandscape) as? Bool ?? true
        self.rewindSeconds = defaults.object(forKey: Key.rewindSeconds) as? Int ?? 10
        self.forwardSeconds = defaults.object(forKey: Key.forwardSeconds) as? Int ?? 10
        self.defaultRate = defaults.object(forKey: Key.defaultRate) as? Double ?? 1
        self.remembersQuality = defaults.object(forKey: Key.remembersQuality) as? Bool ?? false
        self.showsBitrate = defaults.object(forKey: Key.showsBitrate) as? Bool ?? true
    }

    /// Die Richtlinie für die aktuelle Lage.
    ///
    /// Das ist die Stelle, an der Phase 2 greift: `allowsTranscoding` steht
    /// jetzt auf `true`. Am Decider selbst musste dafür nichts geändert werden.
    func policy(for conditions: NetworkConditions) -> PlaybackPolicy {
        let quality = conditions.isExpensive || conditions.isConstrained
            ? cellularQuality
            : wifiQuality

        return PlaybackPolicy(
            allowsTranscoding: true,
            // Nur, wenn es ihn auf dieser Plattform gibt. Ohne VLC wählte die
            // Entscheidung sonst einen Spieler, den es nicht gibt — und die
            // Wiedergabe bliebe schwarz, statt dass der Server umrechnet.
            allowsFallbackEngine: Self.hasFallbackEngine,
            maximumBitrate: quality.bitrateLimit
        )
    }
}