import XCTest
@testable import VelodyPlayback

final class PlaybackQueueTests: XCTestCase {
    func testQueueStartsWithoutCurrentTrackSelection() {
        let queue = PlaybackQueue(trackIDs: ["a", "b", "c"])

        XCTAssertEqual(queue.catalogTrackIDs, ["a", "b", "c"])
        XCTAssertEqual(queue.queuedTrackIDs, ["a", "b", "c"])
        XCTAssertNil(queue.currentTrackID)
        XCTAssertEqual(queue.nextTrackID(), "a")
    }

    func testSelectingTrackAndAdvancingUsesQueueOrder() {
        var queue = PlaybackQueue(trackIDs: ["a", "b", "c"])

        queue.selectTrack("b")

        XCTAssertEqual(queue.currentTrackID, "b")
        XCTAssertEqual(queue.nextTrackID(), "c")
        XCTAssertEqual(queue.previousTrackID(), "a")

        XCTAssertEqual(queue.advanceToNextTrack(), "c")
        XCTAssertEqual(queue.currentTrackID, "c")
    }

    func testShuffleCanUsePersistedQueueOrderWhileKeepingSameTrackSet() {
        var queue = PlaybackQueue(trackIDs: ["a", "b", "c", "d"])
        queue.selectTrack("c")

        queue.setShuffleEnabled(true, queuedTrackIDs: ["c", "a", "d", "b"])

        XCTAssertTrue(queue.isShuffleEnabled)
        XCTAssertEqual(queue.currentTrackID, "c")
        XCTAssertEqual(queue.queuedTrackIDs, ["c", "a", "d", "b"])

        queue.setShuffleEnabled(false)

        XCTAssertFalse(queue.isShuffleEnabled)
        XCTAssertEqual(queue.queuedTrackIDs, ["a", "b", "c", "d"])
        XCTAssertEqual(queue.currentTrackID, "c")
    }

    func testEnablingShuffleKeepsCurrentTrackSelectedAndAtQueueFront() {
        var queue = PlaybackQueue(trackIDs: ["a", "b", "c", "d"])
        queue.selectTrack("c")

        queue.setShuffleEnabled(true)

        XCTAssertTrue(queue.isShuffleEnabled)
        XCTAssertEqual(queue.currentTrackID, "c")
        XCTAssertEqual(queue.queuedTrackIDs.first, "c")
        XCTAssertEqual(Set(queue.queuedTrackIDs), Set(["a", "b", "c", "d"]))
        XCTAssertEqual(Set(queue.queuedTrackIDs).count, 4)
    }

    func testRepeatAllWrapsAroundQueueBoundaries() {
        var queue = PlaybackQueue(trackIDs: ["a", "b", "c"])
        queue.selectTrack("c")
        queue.setRepeatMode(.all)

        XCTAssertEqual(queue.nextTrackID(), "a")
        XCTAssertEqual(queue.advanceToNextTrack(), "a")
        XCTAssertEqual(queue.currentTrackID, "a")
        XCTAssertEqual(queue.previousTrackID(), "c")
    }

    func testRepeatOneKeepsCurrentTrackForNextAndPrevious() {
        var queue = PlaybackQueue(trackIDs: ["a", "b", "c"])
        queue.selectTrack("b")
        queue.setRepeatMode(.one)

        XCTAssertEqual(queue.nextTrackID(), "b")
        XCTAssertEqual(queue.previousTrackID(), "b")
        XCTAssertEqual(queue.advanceToNextTrack(), "b")
        XCTAssertEqual(queue.moveToPreviousTrack(), "b")
    }

    func testCycleRepeatModeUsesOffOneAllOrder() {
        var queue = PlaybackQueue(trackIDs: ["a", "b"])

        XCTAssertEqual(queue.repeatMode, .off)

        queue.cycleRepeatMode()
        XCTAssertEqual(queue.repeatMode, .one)

        queue.cycleRepeatMode()
        XCTAssertEqual(queue.repeatMode, .all)

        queue.cycleRepeatMode()
        XCTAssertEqual(queue.repeatMode, .off)
    }

    func testReplacingTrackIDsDropsRemovedTracksFromQueue() {
        var queue = PlaybackQueue(
            trackIDs: ["a", "b", "c"],
            currentTrackID: "b",
            queuedTrackIDs: ["b", "c", "a"],
            isShuffleEnabled: true,
            repeatMode: .all
        )

        queue.replaceTrackIDs(
            ["a", "c", "d"],
            currentTrackID: queue.currentTrackID,
            queuedTrackIDs: queue.queuedTrackIDs
        )

        XCTAssertEqual(queue.catalogTrackIDs, ["a", "c", "d"])
        XCTAssertEqual(queue.queuedTrackIDs, ["c", "a", "d"])
        XCTAssertNil(queue.currentTrackID)
        XCTAssertEqual(queue.nextTrackID(), "c")
    }
}