import Foundation
import Testing
@testable import PlexKit

private func hub(_ identifier: String) -> PlexHub {
    PlexHub(hubIdentifier: identifier, title: identifier.capitalized)
}

@Suite("Anordnung der Startseiten-Reihen")
struct HubArrangementTests {
    private let serverHubs = [hub("continue"), hub("recent"), hub("watchlist"), hub("collections")]

    @Test("Ohne Einstellungen bleibt die Reihenfolge des Servers")
    func defaultKeepsServerOrder() {
        let result = HubArrangement().apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["continue", "recent", "watchlist", "collections"])
    }

    @Test("Ausgeblendete Reihen verschwinden")
    func hiddenRowsAreRemoved() {
        let arrangement = HubArrangement(hidden: ["watchlist", "collections"])
        let result = arrangement.apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["continue", "recent"])
    }

    @Test("Die gespeicherte Reihenfolge wird angewendet")
    func storedOrderIsApplied() {
        let arrangement = HubArrangement(order: ["watchlist", "continue", "recent", "collections"])
        let result = arrangement.apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["watchlist", "continue", "recent", "collections"])
    }

    @Test("Neue Reihen vom Server landen am Ende statt zu verschwinden")
    func unknownRowsAppearAtTheEnd() {
        // Der Fall, der die einfachere Regel — nur Bekanntes anzeigen — zur
        // Falle macht: ein neu angelegtes Regal auf dem Server wäre in der App
        // nie aufgetaucht, ohne dass jemand den Grund gesehen hätte.
        let arrangement = HubArrangement(order: ["recent", "continue"])
        let result = arrangement.apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["recent", "continue", "watchlist", "collections"])
    }

    @Test("Mehrere neue Reihen behalten die Reihenfolge des Servers")
    func multipleUnknownRowsKeepServerOrder() {
        // Ohne stabile Rückfalllinie wäre ihre Anordnung zufällig — und
        // änderte sich bei jedem Start.
        let arrangement = HubArrangement(order: ["collections"])
        let result = arrangement.apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["collections", "continue", "recent", "watchlist"])
    }

    @Test("Gespeicherte Reihen, die es nicht mehr gibt, stören nicht")
    func staleOrderEntriesAreIgnored() {
        // Entsteht beim Löschen einer Mediathek auf dem Server.
        let arrangement = HubArrangement(order: ["geloescht", "recent", "continue"])
        let result = arrangement.apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["recent", "continue", "watchlist", "collections"])
    }

    @Test("Ein doppelter Eintrag in der Reihenfolge stürzt nicht ab")
    func duplicateOrderEntriesAreTolerated() {
        // Kann nach einem abgebrochenen Schreibvorgang entstehen. Ein
        // Dictionary aus doppelten Schlüsseln wäre ein harter Absturz.
        let arrangement = HubArrangement(order: ["recent", "recent", "continue"])
        let result = arrangement.apply(to: serverHubs)
        #expect(result.first?.hubIdentifier == "recent")
        #expect(result.count == 4)
    }

    @Test("Ausblenden und Sortieren greifen zusammen")
    func hidingAndOrderingCombine() {
        let arrangement = HubArrangement(
            hidden: ["recent"],
            order: ["collections", "recent", "continue"]
        )
        let result = arrangement.apply(to: serverHubs)
        #expect(result.map(\.hubIdentifier) == ["collections", "continue", "watchlist"])
    }

    // MARK: - Die Liste für die Einstellungen

    @Test("Der Einstellungsbildschirm zeigt Gespeichertes zuerst")
    func settingsListPutsStoredFirst() {
        let arrangement = HubArrangement(order: ["watchlist", "continue"])
        let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
        #expect(identifiers == ["watchlist", "continue", "recent", "collections"])
    }

    @Test("Der Einstellungsbildschirm zeigt auch ausgeblendete Reihen")
    func settingsListIncludesHidden() {
        // Sonst ließe sich eine einmal ausgeblendete Reihe nie wieder
        // einschalten — eine Einbahnstraße.
        let arrangement = HubArrangement(hidden: ["recent"])
        let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
        #expect(identifiers.contains("recent"))
    }

    @Test("Verschwundene Reihen erscheinen nicht in den Einstellungen")
    func settingsListDropsStaleEntries() {
        let arrangement = HubArrangement(order: ["geloescht", "recent"])
        let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
        #expect(!identifiers.contains("geloescht"))
    }
}