import Foundation
import Observation
import VelodyDomain
import VelodyNetworking
import VelodyPersistence
import VelodySync
import VelodyUtilities
#if canImport(UIKit)
import AVFoundation
import UIKit
#endif

@MainActor
protocol iPhoneLocalAudioPlaying: AnyObject {
    var onStateChange: ((iPhoneNowPlayingState) -> Void)? { get set }
    var state: iPhoneNowPlayingState { get }

    func play(
        trackID: String,
        title: String,
        artist: String,
        fileURL: URL
    ) throws
    func resume() throws
    func pause()
}

struct iPhoneNowPlayingState: Equatable {
    var trackID: String?
    var title: String?
    var artist: String?
    var isPlaying: Bool
    var errorMessage: String?
}

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

    private var audioPlayer: AVAudioPlayer?

    func play(
        trackID: String,
        title: String,
        artist: String,
        fileURL: URL
    ) throws {
        guard FileManager.default.fileExists(atPath: fileURL.path) else {
            state = iPhoneNowPlayingState(
                trackID: trackID,
                title: title,
                artist: artist,
                isPlaying: false,
                errorMessage: "The downloaded file could not be found."
            )
            throw NSError(
                domain: "VelodyiPhonePlayback",
                code: 1,
                userInfo: [NSLocalizedDescriptionKey: "The downloaded file could not be found."]
            )
        }

        do {
            try configureAudioSession()
            audioPlayer?.stop()
            let audioPlayer = try AVAudioPlayer(contentsOf: fileURL)
            audioPlayer.delegate = self
            audioPlayer.prepareToPlay()
            self.audioPlayer = audioPlayer

            guard audioPlayer.play() else {
                state = iPhoneNowPlayingState(
                    trackID: trackID,
                    title: title,
                    artist: artist,
                    isPlaying: false,
                    errorMessage: "Playback could not be started."
                )
                throw NSError(
                    domain: "VelodyiPhonePlayback",
                    code: 2,
                    userInfo: [NSLocalizedDescriptionKey: "Playback could not be started."]
                )
            }

            state = iPhoneNowPlayingState(
                trackID: trackID,
                title: title,
                artist: artist,
                isPlaying: true,
                errorMessage: nil
            )
        } catch {
            if state.trackID == nil {
                state = iPhoneNowPlayingState(
                    trackID: trackID,
                    title: title,
                    artist: artist,
                    isPlaying: false,
                    errorMessage: "The downloaded audio file could not be opened."
                )
            }
            throw error
        }
    }

    func resume() throws {
        guard let audioPlayer else {
            state.errorMessage = "No downloaded track is loaded."
            throw NSError(
                domain: "VelodyiPhonePlayback",
                code: 3,
                userInfo: [NSLocalizedDescriptionKey: "No downloaded track is loaded."]
            )
        }

        guard audioPlayer.play() else {
            state.errorMessage = "Playback could not be resumed."
            throw NSError(
                domain: "VelodyiPhonePlayback",
                code: 4,
                userInfo: [NSLocalizedDescriptionKey: "Playback could not be resumed."]
            )
        }

        state.isPlaying = true
        state.errorMessage = nil
    }

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

    nonisolated func audioPlayerDidFinishPlaying(
        _ player: AVAudioPlayer,
        successfully flag: Bool
    ) {
        guard flag else {
            return
        }

        Task { @MainActor [weak self] in
            self?.state.isPlaying = false
        }
    }

    private func configureAudioSession() throws {
        let session = AVAudioSession.sharedInstance()
        try session.setCategory(.playback, mode: .default)
        try session.setActive(true)
    }
}

@MainActor
@Observable
final class iPhoneLibraryViewModel {
    enum ViewState: Equatable {
        case idle
        case loading
        case success
        case empty
        case networkError(String)
    }

    var remoteTracks: [RemoteTrackRowViewData] = []
    var availableOfflineTracks: [AvailableOfflineTrackRowViewData] = []
    var searchText = "" {
        didSet {
            guard searchText != oldValue else {
                return
            }

            rebuildRows()
        }
    }
    var syncStatus = "Remote library not synced yet."
    var state: ViewState = .idle
    var nowPlaying = iPhoneNowPlayingState(
        trackID: nil,
        title: nil,
        artist: nil,
        isPlaying: false,
        errorMessage: nil
    )

    private let environment: ServerEnvironment
    private let apiClient: any VelodyAPIClient
    private let syncService: RemoteLibrarySyncService
    private let offlineLibraryService: OfflineLibraryService
    private let keychainService: any KeychainService
    private let player: any iPhoneLocalAudioPlaying
    private var cachedRemoteTracksByID: [String: RemoteTrack] = [:]
    private var cachedRemoteLibraryTracks: [OfflineLibraryRemoteTrack] = []
    private var cachedAvailableOfflineTracks: [OfflineLibraryTrack] = []
    private var hasLoaded = false

    var hasActiveSearch: Bool {
        !searchText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }

    var hasCachedRemoteTracks: Bool {
        !cachedRemoteLibraryTracks.isEmpty
    }

    init(
        player: (any iPhoneLocalAudioPlaying)? = nil,
        keychainService: any KeychainService = SystemKeychainService(
            service: "de.diyaa.velody.iphone"
        )
    ) {
        let environment = ServerEnvironment(
            baseURL: ServerEnvironment.defaultLocalBaseURL,
            appVersion: "0.1.0"
        )
        let apiClient = URLSessionVelodyAPIClient(environment: environment)
        let store = Self.makeRemoteLibraryStore()
        let downloadStateStore = Self.makeRemoteTrackDownloadStateStore()
        let audioFileStore = Self.makeOfflineAudioFileStore()
        let artworkStore = Self.makeArtworkStore()
        let repository = DefaultRemoteLibraryRepository(
            apiClient: apiClient,
            store: store
        )
        let syncService = RemoteLibrarySyncService(
            repository: repository,
            downloadStateStore: downloadStateStore,
            audioFileStore: audioFileStore,
            artworkStore: artworkStore
        )

        self.environment = environment
        self.apiClient = apiClient
        self.keychainService = keychainService
        self.player = player ?? iPhoneLocalAudioPlayer()
        self.syncService = syncService
        self.offlineLibraryService = OfflineLibraryService(
            syncService: syncService,
            audioFileStore: audioFileStore,
            artworkStore: artworkStore
        )
        self.player.onStateChange = { [weak self] state in
            self?.handleNowPlayingStateChange(state)
        }
    }

    func loadIfNeeded() async {
        guard !hasLoaded else { return }
        hasLoaded = true

        do {
            let snapshot = try await reloadOfflineLibrary()
            applyRestoredTracks(snapshot)
        } catch {
            state = .idle
            syncStatus = "Failed to load cached remote library: \(error.localizedDescription)"
        }
    }

    func refreshSync() async {
        state = .loading
        syncStatus = "Syncing remote library..."

        do {
            let deviceId = try await currentOrRegisterDeviceID()
            _ = try await syncService.syncRemoteLibrary(deviceId: deviceId)
            let snapshot = try await reloadOfflineLibrary()
            applySyncedTracks(snapshot)
        } catch {
            state = .networkError("Remote library sync failed.")
            syncStatus = "Remote library sync failed: \(error.localizedDescription)"
        }
    }

    func downloadTrack(trackID: String) async {
        guard let track = cachedRemoteTracksByID[trackID] else {
            return
        }

        updateRemoteTrack(trackID: trackID) { remoteTrack in
            var updatedTrack = remoteTrack
            updatedTrack.status = .downloading
            updatedTrack.lastDownloadError = nil
            return updatedTrack
        }
        rebuildRows()
        syncStatus = "Downloading \(track.title)..."

        do {
            let deviceId = try await currentOrRegisterDeviceID()
            _ = try await syncService.downloadTrack(track, deviceId: deviceId)
            _ = try await reloadOfflineLibrary()
            syncStatus = "Downloaded \(track.title)."
        } catch {
            _ = try? await reloadOfflineLibrary()
            syncStatus = "Download failed for \(track.title): \(error.localizedDescription)"
        }
    }

    func togglePlayback(trackID: String) {
        guard let track = cachedRemoteTracksByID[trackID] else {
            return
        }

        if nowPlaying.trackID == track.trackId, nowPlaying.isPlaying {
            player.pause()
            return
        }

        if nowPlaying.trackID == track.trackId, !nowPlaying.isPlaying {
            do {
                try player.resume()
            } catch {
                syncStatus = "Playback failed for \(track.title): \(error.localizedDescription)"
                refreshOfflineLibraryInBackground()
            }
            return
        }

        guard let offlineTrack = cachedAvailableOfflineTracks
            .first(where: { $0.remoteTrackId == track.trackId })
        else {
            if cachedRemoteLibraryTracks.first(where: { $0.remoteTrack.trackId == track.trackId })?.status == .missing {
                syncStatus = "The downloaded file for \(track.title) is missing."
            } else {
                syncStatus = "Download the track before playing it offline."
            }
            refreshOfflineLibraryInBackground()
            return
        }

        let fileURL = URL(fileURLWithPath: offlineTrack.localFilePath)
        do {
            try player.play(
                trackID: track.trackId,
                title: track.title,
                artist: track.artist,
                fileURL: fileURL
            )
        } catch {
            syncStatus = "Playback failed for \(track.title): \(error.localizedDescription)"
            refreshOfflineLibraryInBackground()
        }
    }

    private func currentOrRegisterDeviceID() async throws -> String {
        if let existingDeviceID = try await keychainService.loadValue(
            forKey: Self.deviceIDKey
        ), !existingDeviceID.isEmpty {
            return existingDeviceID
        }

        let response = try await apiClient.registerDevice(
            DeviceRegistrationPayload(
                platform: .iphone,
                deviceName: Self.currentDeviceName,
                appVersion: environment.appVersion
            )
        )

        try await keychainService.save(response.deviceId, forKey: Self.deviceIDKey)
        try await keychainService.save(
            response.bootstrapToken,
            forKey: Self.bootstrapTokenKey
        )

        return response.deviceId
    }

    private func applyRestoredTracks(_ snapshot: OfflineLibrarySnapshot) {
        if snapshot.remoteTracks.isEmpty {
            state = .idle
            syncStatus = "Tap Sync Remote Library to load remote metadata."
        } else {
            state = .success
            syncStatus = "Restored \(snapshot.remoteTracks.count) cached remote track(s). Offline available: \(snapshot.availableTracks.count)."
        }
    }

    private func applySyncedTracks(_ snapshot: OfflineLibrarySnapshot) {
        if snapshot.remoteTracks.isEmpty {
            state = .empty
            syncStatus = "Remote library is empty."
        } else {
            state = .success
            syncStatus = "Sync Remote Library completed. Remote tracks: \(snapshot.remoteTracks.count). Offline available: \(snapshot.availableTracks.count)."
        }
    }

    private static func makeRemoteLibraryStore() -> any RemoteLibraryStore {
        if let store = try? FileRemoteLibraryStore() {
            return store
        }

        return InMemoryRemoteLibraryStore()
    }

    private static func makeRemoteTrackDownloadStateStore() -> any RemoteTrackDownloadStateStore {
        if let store = try? FileRemoteTrackDownloadStateStore() {
            return store
        }

        return InMemoryRemoteTrackDownloadStateStore()
    }

    private static func makeOfflineAudioFileStore() -> any OfflineAudioFileStore {
        if let store = try? FileOfflineAudioFileStore() {
            return store
        }

        return InMemoryOfflineAudioFileStore()
    }

    private static func makeArtworkStore() -> any ArtworkStore {
        if let store = try? FileArtworkStore() {
            return store
        }

        return InMemoryArtworkStore()
    }

    private func reloadOfflineLibrary() async throws -> OfflineLibrarySnapshot {
        let snapshot = try await offlineLibraryService.loadSnapshot()

        cachedRemoteLibraryTracks = snapshot.remoteTracks
        cachedAvailableOfflineTracks = snapshot.availableTracks
        cachedRemoteTracksByID = Dictionary(
            uniqueKeysWithValues: snapshot.remoteTracks.map { ($0.remoteTrack.trackId, $0.remoteTrack) }
        )
        rebuildRows()

        return snapshot
    }

    private func rebuildRows() {
        let filteredSnapshot = OfflineLibrarySnapshot(
            remoteTracks: cachedRemoteLibraryTracks,
            availableTracks: cachedAvailableOfflineTracks
        ).filtered(searchText: searchText)

        remoteTracks = filteredSnapshot.remoteTracks.map { track in
            RemoteTrackRowViewData(
                track: track,
                nowPlaying: nowPlaying
            )
        }
        availableOfflineTracks = filteredSnapshot.availableTracks.map { track in
            AvailableOfflineTrackRowViewData(
                track: track,
                nowPlaying: nowPlaying
            )
        }
    }

    private func handleNowPlayingStateChange(_ state: iPhoneNowPlayingState) {
        nowPlaying = state
        rebuildRows()
    }

    private func updateRemoteTrack(
        trackID: String,
        transform: (OfflineLibraryRemoteTrack) -> OfflineLibraryRemoteTrack
    ) {
        guard let index = cachedRemoteLibraryTracks
            .firstIndex(where: { $0.remoteTrack.trackId == trackID })
        else {
            return
        }

        cachedRemoteLibraryTracks[index] = transform(cachedRemoteLibraryTracks[index])
    }

    private func refreshOfflineLibraryInBackground() {
        Task { @MainActor [weak self] in
            guard let self else {
                return
            }

            _ = try? await self.reloadOfflineLibrary()
        }
    }

    #if canImport(UIKit)
    private static var currentDeviceName: String {
        UIDevice.current.name
    }
    #else
    private static let currentDeviceName = "Velody iPhone"
    #endif

    private static let deviceIDKey = "velody.iphone.device-id"
    private static let bootstrapTokenKey = "velody.iphone.bootstrap-token"
}

struct RemoteTrackRowViewData: Identifiable, Equatable {
    let id: String
    let title: String
    let artist: String
    let durationText: String
    let remoteTrackID: String
    let assetID: String
    let status: OfflineLibraryRemoteTrackStatus
    let statusText: String
    let canDownload: Bool
    let downloadButtonTitle: String
    let canPlay: Bool
    let playButtonTitle: String
    let lastDownloadError: String?
    let artworkLocalFilePath: String?

    init(
        track: OfflineLibraryRemoteTrack,
        nowPlaying: iPhoneNowPlayingState
    ) {
        id = track.remoteTrack.trackId
        title = track.remoteTrack.title
        artist = track.remoteTrack.artist
        durationText = Self.formatDuration(seconds: track.remoteTrack.durationSeconds)
        remoteTrackID = track.remoteTrack.trackId
        assetID = track.remoteTrack.assetId
        status = track.status
        statusText = Self.statusText(for: track.status)
        canDownload = track.status == .notDownloaded || track.status == .failed || track.status == .missing
        downloadButtonTitle = Self.downloadButtonTitle(for: track.status)
        canPlay = track.isFileAvailable
        playButtonTitle = nowPlaying.trackID == track.remoteTrack.trackId && nowPlaying.isPlaying
            ? "Pause"
            : "Play"
        lastDownloadError = track.lastDownloadError
        artworkLocalFilePath = track.localArtworkFilePath
    }

    static func formatDuration(seconds: Int) -> String {
        let minutes = seconds / 60
        let remainingSeconds = seconds % 60
        return "\(minutes):\(String(format: "%02d", remainingSeconds))"
    }

    private static func statusText(for status: OfflineLibraryRemoteTrackStatus) -> String {
        switch status {
        case .notDownloaded:
            return "Not downloaded"
        case .downloading:
            return "Downloading"
        case .downloaded:
            return "Downloaded"
        case .missing:
            return "Missing"
        case .failed:
            return "Failed"
        }
    }

    private static func downloadButtonTitle(for status: OfflineLibraryRemoteTrackStatus) -> String {
        switch status {
        case .notDownloaded:
            return "Download"
        case .downloading, .downloaded:
            return "Download"
        case .missing:
            return "Re-download"
        case .failed:
            return "Retry"
        }
    }
}

struct AvailableOfflineTrackRowViewData: Identifiable, Equatable {
    let id: String
    let title: String
    let artist: String
    let durationText: String
    let remoteTrackID: String
    let assetID: String
    let playButtonTitle: String
    let artworkLocalFilePath: String?

    init(
        track: OfflineLibraryTrack,
        nowPlaying: iPhoneNowPlayingState
    ) {
        id = track.remoteTrackId
        title = track.title
        artist = track.artist
        durationText = RemoteTrackRowViewData.formatDuration(seconds: track.durationSeconds)
        remoteTrackID = track.remoteTrackId
        assetID = track.assetId
        playButtonTitle = nowPlaying.trackID == track.remoteTrackId && nowPlaying.isPlaying
            ? "Pause"
            : "Play"
        artworkLocalFilePath = track.localArtworkFilePath
    }
}