Flaro/Packages/FlixyKit/Tests/PlexKitTests/LiveTVGuideTests.swift

import Foundation
import Testing
@testable import PlexKit

/// Woher die Senderliste kommt.
///
/// Drei Adressen, unter denen die Senderliste stehen sollte, antworteten auf
/// einem echten Server mit 404 — geraten war jede. Das Programmraster ist
/// keine Vermutung: die Weboberfläche von Plex zeichnet ihren Guide daraus,
/// und jeder Eintrag trägt den Sender mit sich. Diese Tests halten fest, dass
/// die Sender dort auch dann herauskommen, wenn sonst nichts antwortet.
@Suite("Senderliste aus dem Programmraster")
struct LiveTVGuideTests {

    private func server(routes: [String: String]) -> PlexServer {
        PlexServer(
            resource: PlexResource(
                name: "Test",
                clientIdentifier: "srv",
                accessToken: "token",
                connections: [PlexConnection(uri: "http://server:32400", local: true)]
            ),
            connection: PlexConnection(uri: "http://server:32400", local: true),
            identity: .test,
            transport: FakeTransport.routes(routes)
        )!
    }

    private func fixture(_ name: String) throws -> String {
        let url = try #require(Bundle.module.url(forResource: "Fixtures/\(name)", withExtension: "json"))
        return try String(contentsOf: url, encoding: .utf8)
    }

    private var dvr: PlexDVR {
        PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")
    }

    @Test("Jeder Sender kommt genau einmal, obwohl er in mehreren Sendungen steht")
    func derivesChannelsFromGrid() async throws {
        let server = server(routes: [
            "/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
        ])

        let guide = await server.liveTVGuide(dvr: dvr)

        #expect(guide.channels.count == 2)
        #expect(guide.channels.map(\.title) == ["SRF 1 HD", "SRF2"])
    }

    @Test("Fehlt der Sendername, trägt das Kürzel den Sender")
    func fallsBackToCallSign() async throws {
        let server = server(routes: [
            "/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
        ])

        let guide = await server.liveTVGuide(dvr: dvr)
        let second = try #require(guide.channels.last)

        #expect(second.title == "SRF2")
        // Die Sendernummer kommt mal als Zahl, mal als Zeichenkette — beides
        // muss lesbar sein, sonst fehlt sie bei der Hälfte der Sender.
        #expect(second.channelIdentifier == "2")
    }

    @Test("Sendungen landen beim richtigen Sender, nach Anfangszeit sortiert")
    func groupsProgramsByChannel() async throws {
        let server = server(routes: [
            "/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
        ])

        let guide = await server.liveTVGuide(dvr: dvr)
        let first = try #require(guide.channels.first)
        let programs = try #require(guide.programs[first.id])

        #expect(programs.map(\.title) == ["Tagesschau", "Meteo"])
        #expect(guide.programs.count == 2)
    }

    @Test("Ein Sender ohne Namen taucht nicht als Strich auf")
    func skipsNamelessChannels() async throws {
        let json = """
        {"MediaContainer":{"size":1,"Metadata":[
          {"ratingKey":"x","title":"Irgendwas","beginsAt":1757682000,"endsAt":1757685600,
           "Media":[{"channelIdentifier":"nur-eine-kennung","Part":[{"key":"/livetv/channels/9"}]}]}
        ]}}
        """
        let server = server(routes: ["/tv.plex.providers.epg.cloud:2/grid": json])

        let guide = await server.liveTVGuide(dvr: dvr)

        #expect(guide.channels.isEmpty)
    }

    @Test("Die Senderliste des Empfängers wird gefunden, ohne dass sie geraten wird")
    func sweepsUntilSomethingAnswers() async throws {
        // Der Fall, der viermal danebenging: die Senderliste steht weder beim
        // Programmanbieter noch unter dem Empfänger, sondern beim Gerät — und
        // sie schreibt den Namen in `name` statt in `title`.
        let device = """
        {"MediaContainer":{"size":2,"Channel":[
          {"name":"SRF 1 HD","vcn":1,"key":"/livetv/channels/11","enabled":"1"},
          {"name":"SRF zwei HD","vcn":2,"key":"/livetv/channels/12","enabled":"1"}
        ]}}
        """
        let server = server(routes: ["/media/grabbers/devices/tuner-7/channels": device])
        let withTuner = PlexDVR(
            key: "2",
            devices: [PlexTunerDevice(key: "tuner-7")],
            epgIdentifier: "tv.plex.providers.epg.cloud:2"
        )

        let lookup = await server.channels(inDVR: withTuner)

        #expect(lookup.channels.map(\.title) == ["SRF 1 HD", "SRF zwei HD"])
        #expect(lookup.channels.first?.channelIdentifier == "1")
    }

    @Test("Jede abgeklopfte Adresse steht mit ihrer Antwort in der Spur")
    func recordsWhatEveryPathAnswered() async throws {
        // Ohne diese Spur ist „keine Sender" eine Sackgasse: sie sagt nicht,
        // ob der Server nichts hergibt oder die App am falschen Ort sucht.
        let server = server(routes: [:])
        let withTuner = PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")

        let lookup = await server.channels(inDVR: withTuner)

        #expect(lookup.channels.isEmpty)
        #expect(lookup.trace.count >= 3)
        #expect(lookup.trace.allSatisfy { !$0.result.isEmpty })
        #expect(lookup.trace.contains { $0.path == "/livetv/dvrs/2/channels" })
    }

    @Test("Eine Liste aus Strichen zählt nicht als Senderliste")
    func rejectsNamelessChannels() async throws {
        // Genau das ist einmal durchgegangen: dreißig Einträge ohne Namen
        // sahen aus wie eine Senderliste und verdrängten die richtige Quelle.
        let nameless = """
        {"MediaContainer":{"size":2,"Channel":[
          {"channelKey":"a","enabled":"1"},{"channelKey":"b","enabled":"1"}
        ]}}
        """
        let server = server(routes: ["/livetv/dvrs/2/channels": nameless])
        let withTuner = PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")

        let lookup = await server.channels(inDVR: withTuner)

        #expect(lookup.channels.isEmpty)
        #expect(lookup.trace.contains { $0.path == "/livetv/dvrs/2/channels" && $0.result.contains("Channel: 2") })
    }

    @Test("Die Einschaltadresse reist mit dem Sender mit")
    func keepsTuneKey() async throws {
        let server = server(routes: [
            "/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
        ])

        let guide = await server.liveTVGuide(dvr: dvr)

        #expect(guide.channels.first?.key == "/livetv/channels/11")
    }
}