Flaro/Packages/FlixyKit/Sources/PlexKit/Endpoints/PlexServer+Playback.swift

import Foundation

extension PlexServer {
    // MARK: - Transcoding

    /// Die Adresse des HLS-Stroms für diese Wiedergabe.
    ///
    /// HLS ist genau die Kost, für die AVPlayer gebaut ist: er wechselt die
    /// Bitrate während der Wiedergabe von selbst, je nachdem was die Leitung
    /// hergibt. Genau das ist die zugesagte automatische Qualitätsanpassung —
    /// sie wird nicht selbst gerechnet, sondern kommt mit dem Format.
    public nonisolated func transcodeURL(for request: TranscodeRequest) -> URL? {
        guard let baseURL = connection.url,
              var components = URLComponents(
                url: baseURL.appending(path: "/video/:/transcode/universal/start.m3u8"),
                resolvingAgainstBaseURL: false
              )
        else { return nil }

        components.queryItems = request.queryItems + [
            URLQueryItem(name: "X-Plex-Token", value: token),
        ] + clientProfileItems
        return components.url
    }

    /// Fragt den Server, ob er diese Wiedergabe zulässt.
    public func transcodeDecision(for request: TranscodeRequest) async throws(PlexError) -> TranscodeDecision {
        try await client.send(
            PlexRequest(
                path: "/video/:/transcode/universal/decision",
                query: request.queryItems + clientProfileItems
            ),
            as: TranscodeDecision.self
        )
    }

    /// Hält den Transcoder an.
    ///
    /// Muss beim Verlassen des Players laufen. Ohne dieses Signal rechnet der
    /// Server weiter, bis er von selbst merkt, dass niemand mehr abruft — das
    /// dauert Minuten und kostet die ganze Zeit über Rechenleistung.
    public func stopTranscode(sessionIdentifier: String) async {
        _ = try? await client.send(
            PlexRequest(
                path: "/video/:/transcode/universal/stop",
                query: [URLQueryItem(name: "session", value: sessionIdentifier)],
                timeout: .seconds(5)
            )
        )
    }

    /// Was dieses Gerät abspielen kann, in der Schreibweise von Plex.
    ///
    /// Der Server richtet seine Entscheidung danach aus. Die Angaben stammen
    /// aus `DeviceCapabilities` — wären sie großzügiger als das, was iOS
    /// wirklich kann, schickte Plex einen Strom, der hier stumm bliebe oder
    /// schwarz.
    private nonisolated var clientProfileItems: [URLQueryItem] {
        [
            URLQueryItem(
                name: "X-Plex-Client-Profile-Extra",
                value: [
                    // Was ohne Umrechnung durchgereicht werden darf.
                    "add-transcode-target(type=videoProfile&context=streaming&protocol=hls&container=mpegts&videoCodec=h264&audioCodec=aac)",
                    // DTS und TrueHD kann iOS nicht — für sie ausdrücklich
                    // eine Umrechnung nach AAC verlangen, statt zu hoffen,
                    // dass Plex es von selbst merkt.
                    "add-transcode-target-audio-codec(type=videoProfile&context=streaming&protocol=hls&audioCodec=aac)",
                    "add-limitation(scope=videoCodec&scopeName=h264&type=upperBound&name=video.level&value=52)",
                ].joined(separator: "+")
            ),
        ]
    }

    // MARK: - Fortschritt melden

    /// Meldet die aktuelle Stelle an den Server.
    ///
    /// Grundlage für das geräteübergreifende Weiterschauen: was hier
    /// ankommt, sieht der Fernseher im Wohnzimmer. Fehler werden verschluckt —
    /// eine Fehlermeldung mitten im Film wäre störender als ein verlorener
    /// Fortschrittswert, und der nächste Bericht kommt in Sekunden.
    public func reportProgress(
        ratingKey: String,
        state: PlaybackReportState,
        time: Duration,
        duration: Duration
    ) async {
        _ = try? await client.send(
            PlexRequest(
                path: "/:/timeline",
                query: [
                    URLQueryItem(name: "ratingKey", value: ratingKey),
                    URLQueryItem(name: "key", value: "/library/metadata/\(ratingKey)"),
                    URLQueryItem(name: "state", value: state.rawValue),
                    URLQueryItem(name: "time", value: String(time.milliseconds)),
                    URLQueryItem(name: "duration", value: String(duration.milliseconds)),
                ],
                timeout: .seconds(10)
            )
        )
    }

    /// Markiert einen Titel als gesehen.
    public func markWatched(ratingKey: String) async throws(PlexError) {
        _ = try await client.send(scrobbleRequest(path: "/:/scrobble", ratingKey: ratingKey))
    }

    /// Nimmt die Markierung zurück.
    public func markUnwatched(ratingKey: String) async throws(PlexError) {
        _ = try await client.send(scrobbleRequest(path: "/:/unscrobble", ratingKey: ratingKey))
    }

    /// Setzt eine Bewertung. `rating` von 0 bis 10; 0 entfernt sie.
    public func rate(ratingKey: String, rating: Int) async throws(PlexError) {
        _ = try await client.send(
            PlexRequest(path: "/:/rate", query: [
                URLQueryItem(name: "key", value: ratingKey),
                URLQueryItem(name: "identifier", value: "com.plexapp.plugins.library"),
                URLQueryItem(name: "rating", value: String(max(0, min(10, rating)))),
            ])
        )
    }

    /// Stößt einen Suchlauf in einer Mediathek an.
    public func refreshLibrary(_ library: PlexLibrary) async throws(PlexError) {
        _ = try await client.send(PlexRequest(path: "/library/sections/\(library.key)/refresh"))
    }

    private nonisolated func scrobbleRequest(path: String, ratingKey: String) -> PlexRequest {
        PlexRequest(path: path, query: [
            URLQueryItem(name: "key", value: ratingKey),
            // Ohne diese Kennung antwortet Plex mit 400. Sie benennt die
            // Bibliotheks-Erweiterung, an die sich die Meldung richtet.
            URLQueryItem(name: "identifier", value: "com.plexapp.plugins.library"),
        ])
    }
}

/// In welchem Zustand sich die Wiedergabe beim Melden befindet.
public enum PlaybackReportState: String, Sendable {
    case playing
    case paused
    /// Beim Verlassen des Players. Erst dieser Wert lässt Plex den Eintrag aus
    /// „wird gerade abgespielt" entfernen.
    case stopped
    case buffering
}

extension Duration {
    /// Die Dauer in ganzen Millisekunden — die Einheit, in der Plex rechnet.
    public var milliseconds: Int {
        Int(components.seconds * 1000 + components.attoseconds / 1_000_000_000_000_000)
    }
}

extension PlexServer {
    /// Die nächste Folge nach der angegebenen.
    ///
    /// Plex kennt keinen Endpunkt dafür. Der Weg führt über die Geschwister:
    /// die Folgen derselben Staffel holen und die mit der nächsthöheren Nummer
    /// nehmen. Ist die Staffel zu Ende, wird in der folgenden weitergesucht —
    /// sonst bräche das Weiterschauen jedes Mal am Staffelende ab.
    public func nextEpisode(after episode: PlexItem) async throws(PlexError) -> PlexItem? {
        guard episode.kind == .episode,
              let seasonKey = episode.parentRatingKey,
              let currentIndex = episode.index
        else { return nil }

        let siblings = try await children(of: seasonKey)
        if let next = siblings
            .filter({ ($0.index ?? 0) > currentIndex })
            .min(by: { ($0.index ?? 0) < ($1.index ?? 0) }) {
            return next
        }

        // Staffelende: in der nächsten Staffel weitersuchen.
        guard let showKey = episode.grandparentRatingKey,
              let seasonNumber = episode.parentIndex
        else { return nil }

        let seasons = try await children(of: showKey)
        guard let nextSeason = seasons
            .filter({ ($0.index ?? 0) > seasonNumber })
            .min(by: { ($0.index ?? 0) < ($1.index ?? 0) })
        else { return nil }

        return try await children(of: nextSeason.ratingKey)
            .min(by: { ($0.index ?? 0) < ($1.index ?? 0) })
    }
}