Flaro/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift

import Foundation
import PlexKit

/// Entscheidet, wie ein Titel abgespielt wird.
///
/// Reine Rechnung ohne Netz und ohne Zustand — deshalb vollständig testbar.
/// Die zugehörige Testtabelle in `PlaybackDeciderTests` ist die wichtigste im
/// Projekt: sie hält fest, welche Datei auf welchem Weg landet, und schlägt
/// an, sobald jemand die Fähigkeitenliste anfasst.
public struct PlaybackDecider: Sendable {
    private let capabilities: DeviceCapabilities

    public init(capabilities: DeviceCapabilities = .avFoundation) {
        self.capabilities = capabilities
    }

    public func decide(
        media: PlexMedia,
        part: PlexPart,
        policy: PlaybackPolicy
    ) -> PlaybackDecision {
        var rationale: [PlaybackDecision.Rationale] = []

        // 1. Reicht die Leitung? Das kommt zuerst, weil es unabhängig vom
        //    Format ist: eine 80-Mbit-Datei über Mobilfunk ist auch dann keine
        //    gute Idee, wenn AVPlayer sie problemlos öffnen könnte.
        if let limit = policy.maximumBitrate, let bitrate = media.bitrate, bitrate > limit {
            rationale.append(.bitrateExceedsLimit(mediaBitrate: bitrate, limit: limit))
            if policy.allowsTranscoding {
                return PlaybackDecision(method: .transcode(maximumBitrate: limit), rationale: rationale)
            }
            // Ohne Transcoder bleibt nur, es trotzdem zu versuchen. Das ist
            // ehrlicher als eine Fehlermeldung: im WLAN klappt es meistens,
            // und der Grund steht in der Begründung.
            rationale.append(.transcodingUnavailable)
        }

        // 2. Kennt der Server die Datei überhaupt?
        let container = normalized(part.container ?? media.container)
        guard !part.streams.isEmpty, let videoCodec = normalized(media.videoCodec ?? part.videoStream?.codec) else {
            rationale.append(.streamsUnknown)
            return fallback(policy: policy, rationale: rationale)
        }

        // 3. Kann AVPlayer das?
        var blockers: [PlaybackDecision.Rationale] = []
        if let container, !capabilities.containers.contains(container) {
            blockers.append(.containerUnsupported(container))
        }
        if !capabilities.videoCodecs.contains(videoCodec) {
            blockers.append(.videoCodecUnsupported(videoCodec))
        }
        // Geprüft wird die Spur, die tatsächlich klingen soll. Eine Datei mit
        // deutschem AAC und englischem DTS ist für AVPlayer in Ordnung,
        // solange Deutsch gewählt ist.
        if let audioCodec = normalized(part.selectedAudioStream?.codec ?? media.audioCodec),
           !capabilities.audioCodecs.contains(audioCodec) {
            blockers.append(.audioCodecUnsupported(audioCodec))
        }

        guard blockers.isEmpty else {
            rationale.append(contentsOf: blockers)
            return fallback(policy: policy, rationale: rationale)
        }

        rationale.append(.nativelySupported)
        return PlaybackDecision(method: .directPlay(engine: .avPlayer), rationale: rationale)
    }

    /// Was passiert, wenn AVPlayer nicht kann.
    ///
    /// VLCKit hat Vorrang vor dem Transcoder: die Datei geht unverändert über
    /// die Leitung, der Server muss nicht rechnen, und die Bildqualität bleibt
    /// die des Originals. Umgerechnet wird erst, wenn auch VLC ausscheidet.
    private func fallback(
        policy: PlaybackPolicy,
        rationale: [PlaybackDecision.Rationale]
    ) -> PlaybackDecision {
        if policy.allowsFallbackEngine {
            return PlaybackDecision(method: .directPlay(engine: .vlc), rationale: rationale)
        }
        if policy.allowsTranscoding {
            return PlaybackDecision(
                method: .transcode(maximumBitrate: policy.maximumBitrate),
                rationale: rationale
            )
        }
        var rationale = rationale
        rationale.append(.transcodingUnavailable)
        return PlaybackDecision(method: .directPlay(engine: .avPlayer), rationale: rationale)
    }

    /// Plex schreibt Codecs mal groß, mal klein, und hängt bei Containern
    /// gelegentlich Punkte an. Ein Vergleich ohne diese Angleichung geht
    /// sporadisch schief — und zwar nur bei manchen Dateien, was die Suche
    /// nach dem Grund unangenehm macht.
    private func normalized(_ value: String?) -> String? {
        guard let value, !value.isEmpty else { return nil }
        return value.lowercased().trimmingCharacters(in: CharacterSet(charactersIn: ". "))
    }
}