import Foundation
import Testing
@testable import MediaKit

/// Ein Server, der auf Ansage annimmt oder nicht.
private final class Briefkasten: Fortschrittsempfaenger, @unchecked Sendable {
    nonisolated let identity: String
    /// Ob Meldungen angenommen werden.
    var nimmtAn: Bool
    private(set) var angekommen: [PlaybackReport] = []

    init(identity: String = "server-a", nimmtAn: Bool = true) {
        self.identity = identity
        self.nimmtAn = nimmtAn
    }

    func reportProgress(_ report: PlaybackReport) async -> Bool {
        guard nimmtAn else { return false }
        angekommen.append(report)
        return true
    }
}

private func bericht(_ titel: String, sekunden: Double) -> PlaybackReport {
    PlaybackReport(
        itemID: titel,
        state: .stopped,
        time: .seconds(sekunden),
        duration: .seconds(3600)
    )
}

@Suite("Nachgereichter Fortschritt")
@MainActor
struct FortschrittspostTests {
    /// Eine eigene Datei je Prüfung — sonst sähe die zweite, was die erste
    /// liegen gelassen hat.
    private func ablage() -> URL {
        FileManager.default.temporaryDirectory
            .appending(path: "post-\(UUID().uuidString).json")
    }

    @Test("Was ankam, wird nicht aufgehoben")
    func nichtsLiegenLassen() async {
        let post = Fortschrittspost(ablage: ablage())
        let server = Briefkasten()

        post.zuruecklegen(bericht("film", sekunden: 600), server: server.identity)
        #expect(post.wartend == 1)

        await post.zustellen(über: server)
        #expect(post.wartend == 0)
        #expect(server.angekommen.count == 1)
        #expect(server.angekommen.first?.itemID == "film")
    }

    @Test("Was nicht ankommt, bleibt liegen")
    func liegenbleiben() async {
        let post = Fortschrittspost(ablage: ablage())
        let server = Briefkasten(nimmtAn: false)

        post.zuruecklegen(bericht("film", sekunden: 600), server: server.identity)
        await post.zustellen(über: server)
        #expect(post.wartend == 1)

        server.nimmtAn = true
        await post.zustellen(über: server)
        #expect(post.wartend == 0)
    }

    @Test("Je Titel nur der letzte Stand")
    func nurDerLetzteStand() async {
        let post = Fortschrittspost(ablage: ablage())
        let server = Briefkasten()

        post.zuruecklegen(bericht("film", sekunden: 60), server: server.identity)
        post.zuruecklegen(bericht("film", sekunden: 1800), server: server.identity)
        #expect(post.wartend == 1)

        await post.zustellen(über: server)
        #expect(server.angekommen.count == 1)
        #expect(server.angekommen.first?.time == .seconds(1800))
    }

    @Test("Ein fremder Server bekommt nichts")
    func nichtAnDenFalschen() async {
        let post = Fortschrittspost(ablage: ablage())
        post.zuruecklegen(bericht("film", sekunden: 600), server: "server-a")

        let anderer = Briefkasten(identity: "server-b")
        await post.zustellen(über: anderer)
        #expect(anderer.angekommen.isEmpty)
        #expect(post.wartend == 1)
    }

    @Test("Der Briefkasten überlebt den Neustart")
    func aufDerPlatte() async {
        let datei = ablage()
        let erste = Fortschrittspost(ablage: datei)
        erste.zuruecklegen(bericht("folge", sekunden: 900), server: "server-a")

        let zweite = Fortschrittspost(ablage: datei)
        #expect(zweite.wartend == 1)

        let server = Briefkasten()
        await zweite.zustellen(über: server)
        #expect(server.angekommen.first?.time == .seconds(900))
    }

    @Test("Leeren wirft alles weg")
    func leeren() async {
        let post = Fortschrittspost(ablage: ablage())
        post.zuruecklegen(bericht("film", sekunden: 600), server: "server-a")
        post.leeren()
        #expect(post.wartend == 0)
    }
}