NavidromeApp/Shared/Storage/PlaybackStateStore.swift

import Foundation

/// Persists the current playback queue and position to UserDefaults so the app
/// can restore them after being terminated by iOS (memory pressure, system kill).
///
/// Restoration is intentionally conservative:
/// - Only offline/downloaded songs are auto-resumed (streams need live URLs)
/// - Playback restarts paused at the saved position — the user taps Play
/// - If the saved songs no longer exist in the library the state is discarded
struct PlaybackStateStore {

    static let shared = PlaybackStateStore()

    private let queueKey    = "playback_saved_queue"
    private let indexKey    = "playback_saved_index"
    private let timeKey     = "playback_saved_time"
    private let songIdKey   = "playback_saved_song_id"
    private let encoder     = JSONEncoder()

    // MARK: - Save

    /// Save the full queue structure — call when queue content or index changes
    /// (play, next, reorder, add/remove). Heavy: encodes entire [Song] array.
    func save(queue: [Song], index: Int, currentTime: TimeInterval, currentSongId: String?) {
        guard !queue.isEmpty else { return }

        if let data = try? encoder.encode(queue) {
            UserDefaults.standard.set(data, forKey: queueKey)
        }
        UserDefaults.standard.set(index,         forKey: indexKey)
        UserDefaults.standard.set(currentTime,   forKey: timeKey)
        UserDefaults.standard.set(currentSongId, forKey: songIdKey)
    }

    /// Save only the playback position — call from the periodic time observer.
    /// Lightweight: writes a single Double, no JSON encoding.
    func savePosition(_ currentTime: TimeInterval) {
        UserDefaults.standard.set(currentTime, forKey: timeKey)
    }

    // MARK: - Load

    struct RestoredState {
        let queue:       [Song]
        let index:       Int
        let currentTime: TimeInterval
        let currentSong: Song
    }

    /// Returns saved state if valid, nil if nothing was saved or data is stale.
    func load() -> RestoredState? {
        guard let data  = UserDefaults.standard.data(forKey: queueKey),
              let queue = try? JSONDecoder().decode([Song].self, from: data),
              !queue.isEmpty else { return nil }

        let index = UserDefaults.standard.integer(forKey: indexKey)
        let time  = UserDefaults.standard.double(forKey: timeKey)

        guard queue.indices.contains(index) else { return nil }

        return RestoredState(
            queue:       queue,
            index:       index,
            currentTime: time,
            currentSong: queue[index]
        )
    }

    // MARK: - Clear

    /// Call after the user explicitly stops playback or clears the queue.
    func clear() {
        UserDefaults.standard.removeObject(forKey: queueKey)
        UserDefaults.standard.removeObject(forKey: indexKey)
        UserDefaults.standard.removeObject(forKey: timeKey)
        UserDefaults.standard.removeObject(forKey: songIdKey)
    }
    
    // MARK: - Backup Export/Import
    
    /// Export playback state as JSON data for the backup system.
    func exportData() -> Data? {
        guard let queueData = UserDefaults.standard.data(forKey: queueKey) else { return nil }
        let dict: [String: Any] = [
            "queue": queueData.base64EncodedString(),
            "index": UserDefaults.standard.integer(forKey: indexKey),
            "time": UserDefaults.standard.double(forKey: timeKey),
            "songId": UserDefaults.standard.string(forKey: songIdKey) ?? ""
        ]
        return try? JSONSerialization.data(withJSONObject: dict)
    }
    
    /// Import playback state from backup data.
    func importData(_ data: Data) {
        guard let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return }
        if let b64 = dict["queue"] as? String, let queueData = Data(base64Encoded: b64) {
            UserDefaults.standard.set(queueData, forKey: queueKey)
        }
        if let idx = dict["index"] as? Int {
            UserDefaults.standard.set(idx, forKey: indexKey)
        }
        if let time = dict["time"] as? Double {
            UserDefaults.standard.set(time, forKey: timeKey)
        }
        if let songId = dict["songId"] as? String {
            UserDefaults.standard.set(songId, forKey: songIdKey)
        }
    }
}