import CryptoKit
import Foundation
import XCTest
import VelodyDomain
import VelodyNetworking
import VelodyPersistence
@testable import VelodySync

final class RemoteLibrarySyncServiceTests: XCTestCase {
    func testBootstrapFirstSyncPersistsRemoteTracksAndCursor() async throws {
        let store = InMemoryRemoteLibraryStore()
        let cursorStore = InMemoryRemoteLibrarySyncCursorStore()
        let track = makeRemoteTrack(trackId: "track-123")
        let service = makeSyncService(
            apiClient: MockVelodyAPIClient(
                bootstrapResponse: SyncBootstrapResponse(
                    nextCursor: SyncCursor(value: "4"),
                    tracks: [track],
                    serverTime: "2026-06-15T12:00:00.000Z"
                )
            ),
            store: store,
            cursorStore: cursorStore
        )

        let tracks = try await service.syncRemoteLibrary(deviceId: "device-123")
        let cachedTracks = try await service.loadCachedRemoteTracks()
        let storedCursor = try await cursorStore.loadCursor()
        let downloadStates = try await service.loadDownloadStates()

        XCTAssertEqual(tracks, [track])
        XCTAssertEqual(cachedTracks, [track])
        XCTAssertEqual(storedCursor, SyncCursor(value: "4"))
        XCTAssertEqual(downloadStates.first?.downloadStatus, RemoteTrackDownloadStatus.notDownloaded)
    }

    func testChangesForExistingCursorApplyWithoutDuplicateTracks() async throws {
        let originalTrack = makeRemoteTrack(trackId: "track-123", title: "Old Title")
        let updatedTrack = makeRemoteTrack(trackId: "track-123", title: "New Title")
        let secondTrack = makeRemoteTrack(
            trackId: "track-456",
            title: "Second Track",
            createdAt: "2026-06-15T12:01:00.000Z"
        )
        let store = InMemoryRemoteLibraryStore(tracks: [originalTrack])
        let cursorStore = InMemoryRemoteLibrarySyncCursorStore(
            cursor: SyncCursor(value: "4")
        )
        let apiClient = MockVelodyAPIClient(
            changeResponses: [
                SyncChangesResponse(
                    nextCursor: SyncCursor(value: "6"),
                    hasMore: false,
                    requiresBootstrap: false,
                    events: [
                        SyncEvent(
                            cursor: SyncCursor(value: "5"),
                            entityType: "TRACK",
                            entityId: updatedTrack.trackId,
                            action: "UPDATED",
                            track: updatedTrack,
                            createdAt: "2026-06-15T12:00:30.000Z"
                        ),
                        SyncEvent(
                            cursor: SyncCursor(value: "6"),
                            entityType: "AUDIO_ASSET",
                            entityId: secondTrack.assetId,
                            action: "CREATED",
                            track: secondTrack,
                            createdAt: "2026-06-15T12:01:00.000Z"
                        ),
                    ],
                    serverTime: "2026-06-15T12:01:00.000Z"
                ),
            ]
        )
        let service = makeSyncService(
            apiClient: apiClient,
            store: store,
            cursorStore: cursorStore
        )

        let tracks = try await service.syncRemoteLibrary(deviceId: "device-123")
        let storedCursor = try await cursorStore.loadCursor()

        XCTAssertEqual(tracks, [updatedTrack, secondTrack])
        XCTAssertEqual(Set(tracks.map(\.trackId)), ["track-123", "track-456"])
        XCTAssertEqual(storedCursor, SyncCursor(value: "6"))
        let changeCursors = await apiClient.recordedChangeCursors()
        XCTAssertEqual(changeCursors, ["4"])
    }

    func testPaginationAndReplayEventsDoNotDuplicateTracks() async throws {
        let originalTrack = makeRemoteTrack(trackId: "track-123", title: "Old Title")
        let updatedTrack = makeRemoteTrack(trackId: "track-123", title: "Updated Once")
        let secondUpdate = makeRemoteTrack(trackId: "track-123", title: "Updated Twice")
        let secondTrack = makeRemoteTrack(
            trackId: "track-456",
            title: "Another Track",
            createdAt: "2026-06-15T12:02:00.000Z"
        )
        let store = InMemoryRemoteLibraryStore(tracks: [originalTrack])
        let cursorStore = InMemoryRemoteLibrarySyncCursorStore(
            cursor: SyncCursor(value: "3")
        )
        let apiClient = MockVelodyAPIClient(
            changeResponses: [
                SyncChangesResponse(
                    nextCursor: SyncCursor(value: "5"),
                    hasMore: true,
                    requiresBootstrap: false,
                    events: [
                        SyncEvent(
                            cursor: SyncCursor(value: "4"),
                            entityType: "TRACK",
                            entityId: updatedTrack.trackId,
                            action: "UPDATED",
                            track: updatedTrack,
                            createdAt: "2026-06-15T12:00:30.000Z"
                        ),
                        SyncEvent(
                            cursor: SyncCursor(value: "5"),
                            entityType: "TRACK",
                            entityId: secondUpdate.trackId,
                            action: "UPDATED",
                            track: secondUpdate,
                            createdAt: "2026-06-15T12:01:00.000Z"
                        ),
                    ],
                    serverTime: "2026-06-15T12:01:00.000Z"
                ),
                SyncChangesResponse(
                    nextCursor: SyncCursor(value: "6"),
                    hasMore: false,
                    requiresBootstrap: false,
                    events: [
                        SyncEvent(
                            cursor: SyncCursor(value: "6"),
                            entityType: "TRACK",
                            entityId: secondTrack.trackId,
                            action: "CREATED",
                            track: secondTrack,
                            createdAt: "2026-06-15T12:02:00.000Z"
                        ),
                    ],
                    serverTime: "2026-06-15T12:02:00.000Z"
                ),
            ]
        )
        let service = makeSyncService(
            apiClient: apiClient,
            store: store,
            cursorStore: cursorStore
        )

        let tracks = try await service.syncRemoteLibrary(deviceId: "device-123")

        XCTAssertEqual(tracks, [secondUpdate, secondTrack])
        XCTAssertEqual(Set(tracks.map(\.trackId)).count, 2)
        let changeCursors = await apiClient.recordedChangeCursors()
        XCTAssertEqual(changeCursors, ["3", "5"])
    }

    func testRequiresBootstrapFallbackReplacesCachedLibraryAndCursor() async throws {
        let staleTrack = makeRemoteTrack(trackId: "track-stale", title: "Stale")
        let freshTrack = makeRemoteTrack(trackId: "track-fresh", title: "Fresh")
        let store = InMemoryRemoteLibraryStore(tracks: [staleTrack])
        let cursorStore = InMemoryRemoteLibrarySyncCursorStore(
            cursor: SyncCursor(value: "2")
        )
        let apiClient = MockVelodyAPIClient(
            bootstrapResponse: SyncBootstrapResponse(
                nextCursor: SyncCursor(value: "9"),
                tracks: [freshTrack],
                serverTime: "2026-06-15T12:05:00.000Z"
            ),
            changeResponses: [
                SyncChangesResponse(
                    nextCursor: SyncCursor(value: "2"),
                    hasMore: false,
                    requiresBootstrap: true,
                    reason: "cursor_too_old",
                    events: [],
                    serverTime: "2026-06-15T12:04:00.000Z"
                ),
            ]
        )
        let service = makeSyncService(
            apiClient: apiClient,
            store: store,
            cursorStore: cursorStore
        )

        let tracks = try await service.syncRemoteLibrary(deviceId: "device-123")
        let storedCursor = try await cursorStore.loadCursor()

        XCTAssertEqual(tracks, [freshTrack])
        XCTAssertEqual(storedCursor, SyncCursor(value: "9"))
        let changeCursors = await apiClient.recordedChangeCursors()
        XCTAssertEqual(changeCursors, ["2"])
    }

    func testCursorPersistsAcrossRepositoryInstances() async throws {
        let fileManager = FileManager.default
        let tempDirectory = fileManager.temporaryDirectory.appendingPathComponent(
            UUID().uuidString,
            isDirectory: true
        )
        let remoteLibraryFileURL = tempDirectory.appendingPathComponent("remote-library.json")
        let syncCursorFileURL = tempDirectory.appendingPathComponent("remote-library-sync-cursor.json")
        let bootstrapTrack = makeRemoteTrack(trackId: "track-bootstrap")
        let changedTrack = makeRemoteTrack(trackId: "track-bootstrap", title: "Track Bootstrap Updated")

        defer {
            try? fileManager.removeItem(at: tempDirectory)
        }

        let firstClient = MockVelodyAPIClient(
            bootstrapResponse: SyncBootstrapResponse(
                nextCursor: SyncCursor(value: "2"),
                tracks: [bootstrapTrack],
                serverTime: "2026-06-15T12:00:00.000Z"
            )
        )
        let firstService = makeSyncService(
            apiClient: firstClient,
            store: try FileRemoteLibraryStore(fileURL: remoteLibraryFileURL),
            cursorStore: try FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
        )

        _ = try await firstService.syncRemoteLibrary(deviceId: "device-123")

        let secondClient = MockVelodyAPIClient(
            changeResponses: [
                SyncChangesResponse(
                    nextCursor: SyncCursor(value: "3"),
                    hasMore: false,
                    requiresBootstrap: false,
                    events: [
                        SyncEvent(
                            cursor: SyncCursor(value: "3"),
                            entityType: "TRACK",
                            entityId: changedTrack.trackId,
                            action: "UPDATED",
                            track: changedTrack,
                            createdAt: "2026-06-15T12:01:00.000Z"
                        ),
                    ],
                    serverTime: "2026-06-15T12:01:00.000Z"
                ),
            ]
        )
        let secondService = makeSyncService(
            apiClient: secondClient,
            store: try FileRemoteLibraryStore(fileURL: remoteLibraryFileURL),
            cursorStore: try FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
        )

        let tracks = try await secondService.syncRemoteLibrary(deviceId: "device-123")
        let storedCursor = try await FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
            .loadCursor()

        XCTAssertEqual(tracks, [changedTrack])
        XCTAssertEqual(storedCursor, SyncCursor(value: "3"))
        let changeCursors = await secondClient.recordedChangeCursors()
        XCTAssertEqual(changeCursors, ["2"])
    }

    func testNetworkFailureLeavesCachedLibraryAndCursorIntact() async throws {
        let cachedTrack = makeRemoteTrack(trackId: "track-123", title: "Cached")
        let store = InMemoryRemoteLibraryStore(tracks: [cachedTrack])
        let cursorStore = InMemoryRemoteLibrarySyncCursorStore(
            cursor: SyncCursor(value: "7")
        )
        let service = makeSyncService(
            apiClient: MockVelodyAPIClient(
                changeError: VelodyAPIError.requestFailed("Offline")
            ),
            store: store,
            cursorStore: cursorStore
        )

        await XCTAssertThrowsErrorAsync {
            _ = try await service.syncRemoteLibrary(deviceId: "device-123")
        }

        let cachedTracks = try await service.loadCachedRemoteTracks()
        let storedCursor = try await cursorStore.loadCursor()
        XCTAssertEqual(cachedTracks, [cachedTrack])
        XCTAssertEqual(storedCursor, SyncCursor(value: "7"))
    }

    func testPersistedCursorSurvivesRelaunchFailureAndLaterRecovery() async throws {
        let fileManager = FileManager.default
        let tempDirectory = fileManager.temporaryDirectory.appendingPathComponent(
            UUID().uuidString,
            isDirectory: true
        )
        let remoteLibraryFileURL = tempDirectory.appendingPathComponent("remote-library.json")
        let syncCursorFileURL = tempDirectory.appendingPathComponent("remote-library-sync-cursor.json")
        let bootstrapTrack = makeRemoteTrack(trackId: "track-cursor-persist")
        let updatedTrack = makeRemoteTrack(
            trackId: bootstrapTrack.trackId,
            title: "Track Cursor Updated"
        )

        defer {
            try? fileManager.removeItem(at: tempDirectory)
        }

        let firstService = makeSyncService(
            apiClient: MockVelodyAPIClient(
                bootstrapResponse: SyncBootstrapResponse(
                    nextCursor: SyncCursor(value: "1"),
                    tracks: [bootstrapTrack],
                    serverTime: "2026-06-15T12:00:00.000Z"
                )
            ),
            store: try FileRemoteLibraryStore(fileURL: remoteLibraryFileURL),
            cursorStore: try FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
        )

        _ = try await firstService.syncRemoteLibrary(deviceId: "device-123")

        let offlineService = makeSyncService(
            apiClient: MockVelodyAPIClient(
                changeError: VelodyAPIError.requestFailed("Offline")
            ),
            store: try FileRemoteLibraryStore(fileURL: remoteLibraryFileURL),
            cursorStore: try FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
        )

        await XCTAssertThrowsErrorAsync {
            _ = try await offlineService.syncRemoteLibrary(deviceId: "device-123")
        }

        let recoveryClient = MockVelodyAPIClient(
            changeResponses: [
                SyncChangesResponse(
                    nextCursor: SyncCursor(value: "2"),
                    hasMore: false,
                    requiresBootstrap: false,
                    events: [
                        SyncEvent(
                            cursor: SyncCursor(value: "2"),
                            entityType: "TRACK",
                            entityId: updatedTrack.trackId,
                            action: "UPDATED",
                            track: updatedTrack,
                            createdAt: "2026-06-15T12:05:00.000Z"
                        ),
                    ],
                    serverTime: "2026-06-15T12:05:00.000Z"
                ),
            ]
        )
        let recoveredService = makeSyncService(
            apiClient: recoveryClient,
            store: try FileRemoteLibraryStore(fileURL: remoteLibraryFileURL),
            cursorStore: try FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
        )

        let recoveredTracks = try await recoveredService.syncRemoteLibrary(deviceId: "device-123")
        let recoveredCursor = try await FileRemoteLibrarySyncCursorStore(fileURL: syncCursorFileURL)
            .loadCursor()

        XCTAssertEqual(recoveredTracks, [updatedTrack])
        XCTAssertEqual(recoveredCursor, SyncCursor(value: "2"))
        let recordedChangeCursors = await recoveryClient.recordedChangeCursors()
        XCTAssertEqual(recordedChangeCursors, ["1"])
    }

    func testSyncFailurePreservesDownloadedStateAndLocalFile() async throws {
        let track = makeRemoteTrack(trackId: "track-offline", assetId: "asset-offline")
        let localFilePath = "/in-memory/\(track.assetId).mp3"
        let downloadStateStore = InMemoryRemoteTrackDownloadStateStore(states: [
            RemoteTrackDownloadState(
                remoteTrackId: track.trackId,
                assetId: track.assetId,
                localFilePath: localFilePath,
                downloadedAt: Date(timeIntervalSince1970: 3_000),
                downloadStatus: .downloaded
            ),
        ])
        let audioFileStore = InMemoryOfflineAudioFileStore(files: [
            localFilePath: sampleMp3Data(seed: "network-safe"),
        ])
        let service = makeSyncService(
            apiClient: MockVelodyAPIClient(
                changeError: VelodyAPIError.requestFailed("Offline")
            ),
            store: InMemoryRemoteLibraryStore(tracks: [track]),
            cursorStore: InMemoryRemoteLibrarySyncCursorStore(
                cursor: SyncCursor(value: "7")
            ),
            downloadStateStore: downloadStateStore,
            audioFileStore: audioFileStore
        )

        await XCTAssertThrowsErrorAsync {
            _ = try await service.syncRemoteLibrary(deviceId: "device-123")
        }

        let recoveredState = try await service.loadDownloadStates().first
        let fileExists = await audioFileStore.fileExists(at: localFilePath)

        XCTAssertEqual(recoveredState?.downloadStatus, .downloaded)
        XCTAssertEqual(recoveredState?.localFilePath, localFilePath)
        XCTAssertTrue(fileExists)
    }

    func testDownloadTrackPersistsDownloadedStateAndFile() async throws {
        let downloadStateStore = InMemoryRemoteTrackDownloadStateStore()
        let audioFileStore = InMemoryOfflineAudioFileStore()
        let service = RemoteLibrarySyncService(
            repository: DefaultRemoteLibraryRepository(
                apiClient: MockVelodyAPIClient(
                    audioAssetData: sampleMp3Data(seed: "download-success")
                ),
                store: InMemoryRemoteLibraryStore(),
                syncCursorStore: InMemoryRemoteLibrarySyncCursorStore()
            ),
            downloadStateStore: downloadStateStore,
            audioFileStore: audioFileStore,
            artworkStore: InMemoryArtworkStore()
        )
        let track = makeRemoteTrack(
            trackId: "track-123",
            sha256: sha256Hex(sampleMp3Data(seed: "download-success")),
            assetId: "asset-456"
        )

        let state = try await service.downloadTrack(track, deviceId: "device-123")
        let storedStates = try await service.loadDownloadStates()
        let fileExists = await audioFileStore.fileExists(at: state.localFilePath)

        XCTAssertEqual(state.downloadStatus, RemoteTrackDownloadStatus.downloaded)
        XCTAssertEqual(state.assetId, "asset-456")
        XCTAssertFalse(state.localFilePath.isEmpty)
        XCTAssertEqual(storedStates.first?.downloadStatus, RemoteTrackDownloadStatus.downloaded)
        XCTAssertTrue(fileExists)
    }

    func testDownloadTrackPersistsFailureState() async throws {
        let service = RemoteLibrarySyncService(
            repository: DefaultRemoteLibraryRepository(
                apiClient: MockVelodyAPIClient(
                    downloadError: VelodyAPIError.server(statusCode: 404, message: "Missing")
                ),
                store: InMemoryRemoteLibraryStore(),
                syncCursorStore: InMemoryRemoteLibrarySyncCursorStore()
            ),
            downloadStateStore: InMemoryRemoteTrackDownloadStateStore(),
            audioFileStore: InMemoryOfflineAudioFileStore(),
            artworkStore: InMemoryArtworkStore()
        )
        let track = makeRemoteTrack(trackId: "track-123", assetId: "asset-456")

        await XCTAssertThrowsErrorAsync {
            _ = try await service.downloadTrack(track, deviceId: "device-123")
        }

        let storedStates = try await service.loadDownloadStates()
        XCTAssertEqual(storedStates.first?.downloadStatus, RemoteTrackDownloadStatus.failed)
        XCTAssertEqual(storedStates.first?.remoteTrackId, "track-123")
    }

    func testRetryAfterFailureCanSucceedAndPersistDownloadedState() async throws {
        let audioData = sampleMp3Data(seed: "retry-success")
        let track = makeRemoteTrack(
            trackId: "track-retry",
            sha256: sha256Hex(audioData),
            assetId: "asset-retry"
        )
        let downloadStateStore = InMemoryRemoteTrackDownloadStateStore()
        let audioFileStore = InMemoryOfflineAudioFileStore()
        let service = RemoteLibrarySyncService(
            repository: SequencedDownloadRepository(
                downloadResults: [
                    .failure(VelodyAPIError.server(statusCode: 503, message: "Try Again")),
                    .success(audioData),
                ]
            ),
            downloadStateStore: downloadStateStore,
            audioFileStore: audioFileStore,
            artworkStore: InMemoryArtworkStore()
        )

        await XCTAssertThrowsErrorAsync {
            _ = try await service.downloadTrack(track, deviceId: "device-123")
        }

        let failedState = try await service.loadDownloadStates().first
        XCTAssertEqual(failedState?.downloadStatus, .failed)

        let recoveredState = try await service.downloadTrack(track, deviceId: "device-123")
        let persistedState = try await downloadStateStore.loadDownloadStates().first
        let fileExists = await audioFileStore.fileExists(at: recoveredState.localFilePath)

        XCTAssertEqual(recoveredState.downloadStatus, .downloaded)
        XCTAssertEqual(persistedState?.downloadStatus, .downloaded)
        XCTAssertFalse(recoveredState.localFilePath.isEmpty)
        XCTAssertTrue(fileExists)
    }

    func testLoadDownloadStatesRecoversInterruptedDownloadToFailedRetryStateWhenFileIsMissing() async throws {
        let interruptedState = RemoteTrackDownloadState(
            remoteTrackId: "track-123",
            assetId: "asset-456",
            localFilePath: "/in-memory/asset-456.mp3",
            downloadedAt: Date(timeIntervalSince1970: 1_000),
            downloadStatus: .downloading
        )
        let downloadStateStore = InMemoryRemoteTrackDownloadStateStore(states: [interruptedState])
        let service = makeSyncService(
            apiClient: MockVelodyAPIClient(),
            store: InMemoryRemoteLibraryStore(),
            cursorStore: InMemoryRemoteLibrarySyncCursorStore(),
            downloadStateStore: downloadStateStore,
            audioFileStore: InMemoryOfflineAudioFileStore()
        )

        let recoveredStates = try await service.loadDownloadStates()
        let recoveredState = try XCTUnwrap(recoveredStates.first)
        let persistedState = try await downloadStateStore.loadDownloadStates().first

        XCTAssertEqual(recoveredState.downloadStatus, .failed)
        XCTAssertEqual(
            recoveredState.lastDownloadError,
            "The previous download did not finish. Try again."
        )
        XCTAssertEqual(recoveredState.localFilePath, "")
        XCTAssertNil(recoveredState.downloadedAt)
        XCTAssertEqual(persistedState, recoveredState)
    }

    func testLoadDownloadStatesRecoversInterruptedDownloadToDownloadedWhenFileExists() async throws {
        let recoveredFilePath = "/in-memory/asset-456.mp3"
        let recoveredDate = Date(timeIntervalSince1970: 2_000)
        let interruptedState = RemoteTrackDownloadState(
            remoteTrackId: "track-123",
            assetId: "asset-456",
            localFilePath: "",
            downloadedAt: recoveredDate,
            downloadStatus: .downloading,
            lastDownloadError: "Interrupted"
        )
        let downloadStateStore = InMemoryRemoteTrackDownloadStateStore(states: [interruptedState])
        let audioFileStore = InMemoryOfflineAudioFileStore(files: [
            recoveredFilePath: sampleMp3Data(seed: "interrupted-file"),
        ])
        let service = makeSyncService(
            apiClient: MockVelodyAPIClient(),
            store: InMemoryRemoteLibraryStore(),
            cursorStore: InMemoryRemoteLibrarySyncCursorStore(),
            downloadStateStore: downloadStateStore,
            audioFileStore: audioFileStore
        )

        let recoveredStates = try await service.loadDownloadStates()
        let recoveredState = try XCTUnwrap(recoveredStates.first)
        let persistedState = try await downloadStateStore.loadDownloadStates().first

        XCTAssertEqual(recoveredState.downloadStatus, .downloaded)
        XCTAssertEqual(recoveredState.localFilePath, recoveredFilePath)
        XCTAssertEqual(recoveredState.downloadedAt, recoveredDate)
        XCTAssertNil(recoveredState.lastDownloadError)
        XCTAssertEqual(persistedState, recoveredState)
    }

    func testLoadDownloadStatesRepairsStaleLocalFilePathAfterStoreRecreation() async throws {
        let fileManager = FileManager.default
        let tempDirectory = fileManager.temporaryDirectory.appendingPathComponent(
            UUID().uuidString,
            isDirectory: true
        )
        let firstAudioDirectory = tempDirectory.appendingPathComponent("audio-v1", isDirectory: true)
        let secondAudioDirectory = tempDirectory.appendingPathComponent("audio-v2", isDirectory: true)
        let stateFileURL = tempDirectory.appendingPathComponent("remote-download-states.json")
        let audioData = sampleMp3Data(seed: "relaunch-repair")
        let track = makeRemoteTrack(
            trackId: "track-123",
            title: "1 Mai 2026",
            sha256: sha256Hex(audioData),
            assetId: "asset-456"
        )

        defer {
            try? fileManager.removeItem(at: tempDirectory)
        }

        let firstService = RemoteLibrarySyncService(
            repository: DefaultRemoteLibraryRepository(
                apiClient: MockVelodyAPIClient(audioAssetData: audioData),
                store: InMemoryRemoteLibraryStore(),
                syncCursorStore: InMemoryRemoteLibrarySyncCursorStore()
            ),
            downloadStateStore: try FileRemoteTrackDownloadStateStore(fileURL: stateFileURL),
            audioFileStore: try FileOfflineAudioFileStore(baseDirectoryURL: firstAudioDirectory),
            artworkStore: InMemoryArtworkStore()
        )

        let originalState = try await firstService.downloadTrack(track, deviceId: "device-123")
        let originalFileURL = URL(fileURLWithPath: originalState.localFilePath)
        let recreatedStoreFileURL = secondAudioDirectory.appendingPathComponent("asset-456.mp3")
        try fileManager.createDirectory(at: secondAudioDirectory, withIntermediateDirectories: true)
        try fileManager.moveItem(at: originalFileURL, to: recreatedStoreFileURL)

        let relaunchedAudioStore = try FileOfflineAudioFileStore(baseDirectoryURL: secondAudioDirectory)
        let relaunchedService = RemoteLibrarySyncService(
            repository: DefaultRemoteLibraryRepository(
                apiClient: MockVelodyAPIClient(),
                store: InMemoryRemoteLibraryStore(),
                syncCursorStore: InMemoryRemoteLibrarySyncCursorStore()
            ),
            downloadStateStore: try FileRemoteTrackDownloadStateStore(fileURL: stateFileURL),
            audioFileStore: relaunchedAudioStore,
            artworkStore: InMemoryArtworkStore()
        )

        let restoredStates = try await relaunchedService.loadDownloadStates()
        let restoredState = try XCTUnwrap(restoredStates.first)
        let restoredBytes = try await relaunchedAudioStore.readAudioFile(at: restoredState.localFilePath)
        let persistedRestoredState = try await FileRemoteTrackDownloadStateStore(fileURL: stateFileURL)
            .loadDownloadStates()
            .first

        XCTAssertEqual(restoredState.downloadStatus, RemoteTrackDownloadStatus.downloaded)
        XCTAssertEqual(restoredState.localFilePath, recreatedStoreFileURL.standardizedFileURL.path)
        XCTAssertEqual(persistedRestoredState?.localFilePath, recreatedStoreFileURL.standardizedFileURL.path)
        XCTAssertTrue(fileManager.fileExists(atPath: restoredState.localFilePath))
        XCTAssertEqual(restoredBytes, audioData)
    }

    func testSyncCachesArtworkIndependentlyFromAudioDownloads() async throws {
        let artwork = RemoteArtwork(
            artworkId: "artwork-123",
            sha256: String(repeating: "d", count: 64),
            mimeType: "image/png",
            width: 1,
            height: 1
        )
        let track = makeRemoteTrack(
            trackId: "track-123",
            artwork: artwork
        )
        let artworkStore = InMemoryArtworkStore()
        let service = makeSyncService(
            apiClient: MockVelodyAPIClient(
                bootstrapResponse: SyncBootstrapResponse(
                    nextCursor: SyncCursor(value: "1"),
                    tracks: [track],
                    serverTime: "2026-06-15T12:00:00.000Z"
                ),
                artworkData: sampleArtworkData()
            ),
            store: InMemoryRemoteLibraryStore(),
            cursorStore: InMemoryRemoteLibrarySyncCursorStore(),
            artworkStore: artworkStore
        )

        let tracks = try await service.syncRemoteLibrary(deviceId: "device-123")
        let cachedArtworkPath = await artworkStore.cachedFilePath(for: artwork)
        let cachedArtworkBytes = try await artworkStore.readArtwork(
            at: try XCTUnwrap(cachedArtworkPath)
        )

        XCTAssertEqual(tracks.first?.artwork, artwork)
        XCTAssertEqual(cachedArtworkBytes, sampleArtworkData())
    }
}

private func makeSyncService(
    apiClient: any VelodyAPIClient,
    store: any RemoteLibraryStore,
    cursorStore: any RemoteLibrarySyncCursorStore,
    downloadStateStore: any RemoteTrackDownloadStateStore = InMemoryRemoteTrackDownloadStateStore(),
    audioFileStore: any OfflineAudioFileStore = InMemoryOfflineAudioFileStore(),
    artworkStore: any ArtworkStore = InMemoryArtworkStore()
) -> RemoteLibrarySyncService {
    RemoteLibrarySyncService(
        repository: DefaultRemoteLibraryRepository(
            apiClient: apiClient,
            store: store,
            syncCursorStore: cursorStore
        ),
        downloadStateStore: downloadStateStore,
        audioFileStore: audioFileStore,
        artworkStore: artworkStore
    )
}

private actor MockVelodyAPIClient: VelodyAPIClient {
    private let bootstrapResponse: SyncBootstrapResponse
    private let changeResponses: [SyncChangesResponse]
    private let changeError: VelodyAPIError?
    private let audioAssetData: Data?
    private let downloadError: VelodyAPIError?
    private let artworkData: Data?
    private let artworkDownloadError: VelodyAPIError?
    private var changeResponseIndex = 0
    private var changeCursors: [String] = []

    init(
        bootstrapResponse: SyncBootstrapResponse = SyncBootstrapResponse(
            nextCursor: SyncCursor(value: "0"),
            tracks: [],
            serverTime: "2026-06-15T12:00:00.000Z"
        ),
        changeResponses: [SyncChangesResponse] = [],
        changeError: VelodyAPIError? = nil,
        audioAssetData: Data? = nil,
        downloadError: VelodyAPIError? = nil,
        artworkData: Data? = nil,
        artworkDownloadError: VelodyAPIError? = nil
    ) {
        self.bootstrapResponse = bootstrapResponse
        self.changeResponses = changeResponses
        self.changeError = changeError
        self.audioAssetData = audioAssetData
        self.downloadError = downloadError
        self.artworkData = artworkData
        self.artworkDownloadError = artworkDownloadError
    }

    func registerDevice(
        _ payload: DeviceRegistrationPayload
    ) async throws -> DeviceRegistrationResponse {
        _ = payload
        return DeviceRegistrationResponse(
            deviceId: UUID().uuidString,
            deviceAccessToken: UUID().uuidString,
            bootstrapToken: UUID().uuidString,
            serverTime: "2026-06-15T12:00:00.000Z"
        )
    }

    func sendHeartbeat(
        _ payload: DeviceHeartbeatPayload
    ) async throws -> DeviceHeartbeatResponse {
        _ = payload
        return DeviceHeartbeatResponse(
            ok: true,
            serverTime: "2026-06-15T12:00:00.000Z"
        )
    }

    func fetchSyncBootstrap() async throws -> SyncBootstrapResponse {
        bootstrapResponse
    }

    func fetchSyncChanges(
        cursor: SyncCursor
    ) async throws -> SyncChangesResponse {
        changeCursors.append(cursor.value)

        if let changeError {
            throw changeError
        }

        guard !changeResponses.isEmpty else {
            return SyncChangesResponse(
                nextCursor: cursor,
                hasMore: false,
                requiresBootstrap: false,
                events: [],
                serverTime: "2026-06-15T12:00:00.000Z"
            )
        }

        let response = changeResponses[min(changeResponseIndex, changeResponses.count - 1)]
        changeResponseIndex += 1
        return response
    }

    func fetchRemoteLibrary(
        deviceId: String
    ) async throws -> RemoteLibraryResponseDTO {
        _ = deviceId
        return RemoteLibraryResponseDTO(tracks: [])
    }

    func downloadAudioAsset(
        assetId: String,
        deviceId: String
    ) async throws -> Data {
        _ = assetId
        _ = deviceId

        if let downloadError {
            throw downloadError
        }

        return audioAssetData ?? Data()
    }

    func downloadArtwork(
        artworkId: String,
        deviceId: String
    ) async throws -> Data {
        _ = artworkId
        _ = deviceId

        if let artworkDownloadError {
            throw artworkDownloadError
        }

        return artworkData ?? Data()
    }

    func prepareUpload(
        _ payload: UploadPrepareRequest
    ) async throws -> UploadPrepareResponse {
        _ = payload
        return UploadPrepareResponse(status: .uploadRequired, uploadId: UUID().uuidString, nextOffset: 0)
    }

    func fetchUploadStatus(
        uploadId: String
    ) async throws -> UploadSessionStatusResponse {
        UploadSessionStatusResponse(
            uploadId: uploadId,
            status: .completed,
            receivedBytes: "0",
            expectedSizeBytes: "0",
            nextOffset: "0"
        )
    }

    func uploadFile(
        uploadId: String,
        fileURL: URL,
        mimeType: String
    ) async throws -> UploadSessionStatusResponse {
        _ = fileURL
        _ = mimeType
        return UploadSessionStatusResponse(
            uploadId: uploadId,
            status: .completed,
            receivedBytes: "0",
            expectedSizeBytes: "0",
            nextOffset: "0"
        )
    }

    func finalizeUpload(
        uploadId: String,
        payload: UploadFinalizeRequest
    ) async throws -> UploadFinalizeResponse {
        _ = uploadId
        _ = payload
        return UploadFinalizeResponse(
            trackId: UUID().uuidString,
            assetId: UUID().uuidString
        )
    }

    func recordedChangeCursors() -> [String] {
        changeCursors
    }
}

private actor SequencedDownloadRepository: RemoteLibraryRepository {
    private var downloadResults: [Result<Data, VelodyAPIError>]
    private let tracks: [RemoteTrack]

    init(
        downloadResults: [Result<Data, VelodyAPIError>],
        tracks: [RemoteTrack] = []
    ) {
        self.downloadResults = downloadResults
        self.tracks = tracks
    }

    func loadCachedRemoteTracks() async throws -> [RemoteTrack] {
        tracks
    }

    func syncRemoteTracks(deviceId: String) async throws -> [RemoteTrack] {
        _ = deviceId
        return tracks
    }

    func downloadAudioAsset(assetId: String, deviceId: String) async throws -> Data {
        _ = assetId
        _ = deviceId

        guard !downloadResults.isEmpty else {
            return Data()
        }

        let result = downloadResults.removeFirst()
        switch result {
        case let .success(data):
            return data
        case let .failure(error):
            throw error
        }
    }

    func downloadArtwork(artworkId: String, deviceId: String) async throws -> Data {
        _ = artworkId
        _ = deviceId
        return Data()
    }
}

private func makeRemoteTrack(
    trackId: String,
    title: String = "Remote Title",
    artist: String = "Remote Artist",
    durationSeconds: Int = 245,
    sha256: String = String(repeating: "a", count: 64),
    assetId: String? = nil,
    createdAt: String = "2026-06-15T12:00:00.000Z",
    updatedAt: String = "2026-06-15T12:05:00.000Z",
    artwork: RemoteArtwork? = nil
) -> RemoteTrack {
    RemoteTrack(
        trackId: trackId,
        title: title,
        artist: artist,
        durationSeconds: durationSeconds,
        sha256: sha256,
        assetId: assetId ?? "asset-\(trackId)",
        createdAt: createdAt,
        updatedAt: updatedAt,
        artwork: artwork
    )
}

private func sampleMp3Data(seed: String) -> Data {
    Data([
        0x49, 0x44, 0x33, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21,
    ] + Array(seed.utf8))
}

private func sampleArtworkData() -> Data {
    Data(
        base64Encoded:
            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P8z8DwHwAFgwJ/lBi4NwAAAABJRU5ErkJggg=="
    )!
}

private func sha256Hex(_ data: Data) -> String {
    SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
}

private func XCTAssertThrowsErrorAsync(
    _ expression: @escaping () async throws -> Void,
    file: StaticString = #filePath,
    line: UInt = #line
) async {
    do {
        try await expression()
        XCTFail("Expected expression to throw an error.", file: file, line: line)
    } catch {
        XCTAssertTrue(true)
    }
}