import Foundation
import XCTest
import VelodyDomain
import VelodyNetworking
import VelodyPersistence
import VelodySync
import VelodyUtilities
@testable import VelodyiPhone

@MainActor
final class iPhoneLibraryViewModelFavoritesTests: XCTestCase {
    func testFavoritingTrackUpdatesRemoteOfflineAndNowPlayingState() async throws {
        let track = makeRemoteTrack(
            trackId: "remote-light-trap",
            assetId: "asset-light-trap",
            title: "Light Trap"
        )
        let player = TestPlayer()
        let viewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            audioFiles: [localFilePath(for: track): Data([0x1, 0x2, 0x3])],
            player: player
        )

        await viewModel.loadIfNeeded()
        viewModel.togglePlayback(trackID: track.trackId)

        XCTAssertEqual(viewModel.nowPlayingFavoriteTrackID, track.trackId)
        XCTAssertFalse(viewModel.isNowPlayingTrackFavorite)

        await viewModel.toggleFavorite(trackID: track.trackId)

        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: track.trackId)).isFavorite)
        XCTAssertTrue(try XCTUnwrap(offlineRow(in: viewModel, trackID: track.trackId)).isFavorite)
        XCTAssertEqual(viewModel.nowPlayingFavoriteTrackID, track.trackId)
        XCTAssertTrue(viewModel.isNowPlayingTrackFavorite)
    }

    func testUnfavoritingTrackRemovesFavoriteState() async throws {
        let track = makeRemoteTrack(
            trackId: "remote-harbor-lights",
            assetId: "asset-harbor-lights",
            title: "Harbor Lights"
        )
        let favoriteStore = InMemoryFavoriteTrackStore(tracks: [
            FavoriteTrackRecord(
                remoteTrackId: track.trackId,
                favoritedAt: Date(timeIntervalSince1970: 1_000)
            ),
        ])
        let viewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: favoriteStore,
            audioFiles: [localFilePath(for: track): Data([0x1])]
        )

        await viewModel.loadIfNeeded()
        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: track.trackId)).isFavorite)

        await viewModel.toggleFavorite(trackID: track.trackId)

        XCTAssertFalse(try XCTUnwrap(remoteRow(in: viewModel, trackID: track.trackId)).isFavorite)
        XCTAssertFalse(try XCTUnwrap(offlineRow(in: viewModel, trackID: track.trackId)).isFavorite)
        let savedFavorites = try await favoriteStore.loadFavoriteTracks()
        XCTAssertTrue(savedFavorites.isEmpty)
    }

    func testFavoritesPersistAcrossReload() async throws {
        let fileManager = FileManager.default
        let tempDirectory = fileManager.temporaryDirectory.appendingPathComponent(
            UUID().uuidString,
            isDirectory: true
        )
        let fileURL = tempDirectory.appendingPathComponent("favorite-tracks.json")
        let track = makeRemoteTrack(
            trackId: "remote-night-drive",
            assetId: "asset-night-drive",
            title: "Night Drive"
        )

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

        let firstViewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: try FileFavoriteTrackStore(fileURL: fileURL),
            audioFiles: [localFilePath(for: track): Data([0x2])]
        )
        await firstViewModel.loadIfNeeded()
        await firstViewModel.toggleFavorite(trackID: track.trackId)

        let relaunchedViewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: try FileFavoriteTrackStore(fileURL: fileURL),
            audioFiles: [localFilePath(for: track): Data([0x2])]
        )
        await relaunchedViewModel.loadIfNeeded()
        XCTAssertTrue(try XCTUnwrap(remoteRow(in: relaunchedViewModel, trackID: track.trackId)).isFavorite)

        await relaunchedViewModel.toggleFavorite(trackID: track.trackId)

        let secondRelaunchViewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: try FileFavoriteTrackStore(fileURL: fileURL),
            audioFiles: [localFilePath(for: track): Data([0x2])]
        )
        await secondRelaunchViewModel.loadIfNeeded()

        XCTAssertFalse(try XCTUnwrap(remoteRow(in: secondRelaunchViewModel, trackID: track.trackId)).isFavorite)
    }

    func testMultipleFavoritesAreTrackedIndependently() async throws {
        let firstTrack = makeRemoteTrack(
            trackId: "remote-first",
            assetId: "asset-first",
            title: "First Favorite"
        )
        let secondTrack = makeRemoteTrack(
            trackId: "remote-second",
            assetId: "asset-second",
            title: "Second Favorite"
        )
        let favoriteStore = InMemoryFavoriteTrackStore()
        let viewModel = makeViewModel(
            remoteTracks: [firstTrack, secondTrack],
            downloadStates: [
                makeDownloadedState(for: firstTrack),
                makeDownloadedState(for: secondTrack),
            ],
            favoriteTrackStore: favoriteStore,
            audioFiles: [
                localFilePath(for: firstTrack): Data([0x1]),
                localFilePath(for: secondTrack): Data([0x2]),
            ]
        )

        await viewModel.loadIfNeeded()
        await viewModel.toggleFavorite(trackID: firstTrack.trackId)
        await viewModel.toggleFavorite(trackID: secondTrack.trackId)

        let savedIDs = try await favoriteStore.loadFavoriteTracks()
            .map(\.remoteTrackId)
            .sorted()

        XCTAssertEqual(savedIDs, [firstTrack.trackId, secondTrack.trackId].sorted())
        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: firstTrack.trackId)).isFavorite)
        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: secondTrack.trackId)).isFavorite)
    }

    func testToggleFavoriteRepeatedlyLeavesSingleStableRecord() async throws {
        let track = makeRemoteTrack(
            trackId: "remote-repeat",
            assetId: "asset-repeat",
            title: "Repeat Toggle"
        )
        let favoriteStore = InMemoryFavoriteTrackStore()
        let viewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: favoriteStore,
            audioFiles: [localFilePath(for: track): Data([0x3])]
        )

        await viewModel.loadIfNeeded()
        for _ in 0..<5 {
            await viewModel.toggleFavorite(trackID: track.trackId)
        }

        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: track.trackId)).isFavorite)
        let savedFavorites = try await favoriteStore.loadFavoriteTracks()
        XCTAssertEqual(savedFavorites.count, 1)
    }

    func testFavoriteStateDerivesCorrectlyInRemoteLibrary() async throws {
        let track = makeRemoteTrack(
            trackId: "remote-only",
            assetId: "asset-only",
            title: "Remote Only"
        )
        let viewModel = makeViewModel(
            remoteTracks: [track],
            favoriteTrackStore: InMemoryFavoriteTrackStore(tracks: [
                FavoriteTrackRecord(
                    remoteTrackId: track.trackId,
                    favoritedAt: Date(timeIntervalSince1970: 4_000)
                ),
            ])
        )

        await viewModel.loadIfNeeded()

        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: track.trackId)).isFavorite)
        XCTAssertTrue(viewModel.availableOfflineTracks.isEmpty)
    }

    func testFavoriteStateDerivesCorrectlyInOfflineLibrary() async throws {
        let track = makeRemoteTrack(
            trackId: "offline-favorite",
            assetId: "asset-offline-favorite",
            title: "Offline Favorite"
        )
        let viewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: InMemoryFavoriteTrackStore(tracks: [
                FavoriteTrackRecord(
                    remoteTrackId: track.trackId,
                    favoritedAt: Date(timeIntervalSince1970: 5_000)
                ),
            ]),
            audioFiles: [localFilePath(for: track): Data([0x4])]
        )

        await viewModel.loadIfNeeded()

        XCTAssertTrue(try XCTUnwrap(offlineRow(in: viewModel, trackID: track.trackId)).isFavorite)
    }

    func testSearchDoesNotModifyFavoriteState() async throws {
        let favoriteTrack = makeRemoteTrack(
            trackId: "remote-search-favorite",
            assetId: "asset-search-favorite",
            title: "Northern Lights"
        )
        let otherTrack = makeRemoteTrack(
            trackId: "remote-search-other",
            assetId: "asset-search-other",
            title: "Quiet Harbor"
        )
        let favoriteStore = InMemoryFavoriteTrackStore()
        let viewModel = makeViewModel(
            remoteTracks: [favoriteTrack, otherTrack],
            downloadStates: [
                makeDownloadedState(for: favoriteTrack),
                makeDownloadedState(for: otherTrack),
            ],
            favoriteTrackStore: favoriteStore,
            audioFiles: [
                localFilePath(for: favoriteTrack): Data([0x5]),
                localFilePath(for: otherTrack): Data([0x6]),
            ]
        )

        await viewModel.loadIfNeeded()
        await viewModel.toggleFavorite(trackID: favoriteTrack.trackId)

        viewModel.searchText = otherTrack.title
        XCTAssertNil(remoteRow(in: viewModel, trackID: favoriteTrack.trackId))

        viewModel.searchText = favoriteTrack.title

        XCTAssertTrue(try XCTUnwrap(remoteRow(in: viewModel, trackID: favoriteTrack.trackId)).isFavorite)
        let savedFavoriteIDs = try await favoriteStore.loadFavoriteTracks().map(\.remoteTrackId)
        XCTAssertEqual(savedFavoriteIDs, [favoriteTrack.trackId])
    }

    func testMissingFileStateDoesNotRemoveFavorite() async throws {
        let track = makeRemoteTrack(
            trackId: "remote-missing",
            assetId: "asset-missing",
            title: "Missing Favorite"
        )
        let viewModel = makeViewModel(
            remoteTracks: [track],
            downloadStates: [makeDownloadedState(for: track)],
            favoriteTrackStore: InMemoryFavoriteTrackStore(tracks: [
                FavoriteTrackRecord(
                    remoteTrackId: track.trackId,
                    favoritedAt: Date(timeIntervalSince1970: 6_000)
                ),
            ])
        )

        await viewModel.loadIfNeeded()

        let remoteTrack = try XCTUnwrap(remoteRow(in: viewModel, trackID: track.trackId))

        XCTAssertEqual(remoteTrack.status, .missing)
        XCTAssertTrue(remoteTrack.isFavorite)
        XCTAssertTrue(viewModel.availableOfflineTracks.isEmpty)
    }
}

@MainActor
private final class TestPlayer: iPhoneLocalAudioPlaying {
    var onStateChange: ((iPhoneNowPlayingState) -> Void)?
    private(set) var state = iPhoneNowPlayingState(
        trackID: nil,
        title: nil,
        artist: nil,
        isPlaying: false,
        errorMessage: nil
    )

    func play(
        trackID: String,
        title: String,
        artist: String,
        fileURL: URL
    ) throws {
        _ = fileURL
        state = iPhoneNowPlayingState(
            trackID: trackID,
            title: title,
            artist: artist,
            isPlaying: true,
            errorMessage: nil
        )
        onStateChange?(state)
    }

    func resume() throws {
        state.isPlaying = true
        state.errorMessage = nil
        onStateChange?(state)
    }

    func pause() {
        state.isPlaying = false
        onStateChange?(state)
    }
}

private actor TestRemoteLibraryRepository: RemoteLibraryRepository {
    private let tracks: [RemoteTrack]

    init(tracks: [RemoteTrack]) {
        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
        throw TestRepositoryError.unexpectedDownload
    }

    func downloadArtwork(artworkId: String, deviceId: String) async throws -> Data {
        _ = artworkId
        _ = deviceId
        throw TestRepositoryError.unexpectedDownload
    }
}

private enum TestRepositoryError: Error {
    case unexpectedDownload
}

@MainActor
private func makeViewModel(
    remoteTracks: [RemoteTrack],
    downloadStates: [RemoteTrackDownloadState] = [],
    favoriteTrackStore: any FavoriteTrackStore = InMemoryFavoriteTrackStore(),
    audioFiles: [String: Data] = [:],
    player: (any iPhoneLocalAudioPlaying)? = nil
) -> iPhoneLibraryViewModel {
    let repository = TestRemoteLibraryRepository(tracks: remoteTracks)
    let downloadStateStore = InMemoryRemoteTrackDownloadStateStore(states: downloadStates)
    let audioFileStore = InMemoryOfflineAudioFileStore(files: audioFiles)
    let artworkStore = InMemoryArtworkStore()
    let syncService = RemoteLibrarySyncService(
        repository: repository,
        downloadStateStore: downloadStateStore,
        audioFileStore: audioFileStore,
        artworkStore: artworkStore
    )
    let offlineLibraryService = OfflineLibraryService(
        syncService: syncService,
        audioFileStore: audioFileStore,
        artworkStore: artworkStore
    )

    return iPhoneLibraryViewModel(
        environment: ServerEnvironment(
            baseURL: ServerEnvironment.defaultLocalBaseURL,
            appVersion: "Tests"
        ),
        apiClient: URLSessionVelodyAPIClient(
            environment: ServerEnvironment(
                baseURL: ServerEnvironment.defaultLocalBaseURL,
                appVersion: "Tests"
            )
        ),
        syncService: syncService,
        offlineLibraryService: offlineLibraryService,
        favoriteTrackStore: favoriteTrackStore,
        player: player ?? TestPlayer(),
        keychainService: MemoryKeychainService()
    )
}

private func makeRemoteTrack(
    trackId: String,
    assetId: String,
    title: String
) -> RemoteTrack {
    RemoteTrack(
        trackId: trackId,
        title: title,
        artist: "Velody Artist",
        durationSeconds: 245,
        sha256: String(repeating: "a", count: 64),
        assetId: assetId,
        createdAt: "2026-05-30T08:00:00.000Z",
        updatedAt: "2026-05-30T08:05:00.000Z"
    )
}

private func makeDownloadedState(for track: RemoteTrack) -> RemoteTrackDownloadState {
    RemoteTrackDownloadState(
        remoteTrackId: track.trackId,
        assetId: track.assetId,
        localFilePath: localFilePath(for: track),
        downloadedAt: Date(timeIntervalSince1970: 1_000),
        downloadStatus: .downloaded
    )
}

private func localFilePath(for track: RemoteTrack) -> String {
    "/in-memory/\(track.assetId).mp3"
}

@MainActor
private func remoteRow(
    in viewModel: iPhoneLibraryViewModel,
    trackID: String
) -> RemoteTrackRowViewData? {
    viewModel.remoteTracks.first(where: { $0.id == trackID })
}

@MainActor
private func offlineRow(
    in viewModel: iPhoneLibraryViewModel,
    trackID: String
) -> AvailableOfflineTrackRowViewData? {
    viewModel.availableOfflineTracks.first(where: { $0.id == trackID })
}