NavidromeApp/watchOS/App/WatchSessionManager.swift

import Foundation
import WatchConnectivity
import Combine

/// watchOS-side WatchConnectivity session manager
class WatchSessionManager: NSObject, ObservableObject {
    
    static let shared = WatchSessionManager()
    
    @Published var servers: [ServerConfig] = []
    @Published var activeServer: ServerConfig?
    @Published var isPhoneReachable = false
    @Published var isSyncing = false
    
    // Now playing from iPhone
    @Published var phoneNowPlaying: PhoneNowPlaying?
    
    struct PhoneNowPlaying {
        var title: String
        var artist: String
        var album: String
        var isPlaying: Bool
        var currentTime: TimeInterval
        var duration: TimeInterval
        var coverArtId: String?
    }
    
    private var session: WCSession?
    private let client = SubsonicClient()
    
    private override init() {
        super.init()
        if WCSession.isSupported() {
            session = WCSession.default
            session?.delegate = self
            session?.activate()
        }
        loadLocalServers()
    }
    
    // MARK: - Server Management
    
    func addServer(_ server: ServerConfig) {
        servers.append(server)
        saveLocalServers()
    }
    
    func setActive(_ server: ServerConfig) {
        activeServer = server
        client.currentServer = server
    }
    
    func testConnection(_ server: ServerConfig) async -> Bool {
        do {
            return try await client.ping(server: server)
        } catch {
            return false
        }
    }
    
    // MARK: - Request data from phone
    
    func requestServersFromPhone() {
        guard let session = session, session.isReachable else { return }
        session.sendMessage(["type": "requestServers"], replyHandler: { reply in
            if let data = reply["servers"] as? Data,
               let servers = try? JSONDecoder().decode([ServerConfig].self, from: data) {
                DispatchQueue.main.async {
                    self.servers = servers
                    self.activeServer = servers.first
                    if let first = servers.first {
                        self.client.currentServer = first
                    }
                    self.saveLocalServers()
                }
            }
        }, errorHandler: { error in
            print("Request servers failed: \(error)")
        })
    }
    
    func sendPlayCommand() {
        session?.sendMessage(["type": "playCommand"], replyHandler: nil, errorHandler: nil)
    }
    
    func sendNextCommand() {
        session?.sendMessage(["type": "nextCommand"], replyHandler: nil, errorHandler: nil)
    }
    
    func sendPreviousCommand() {
        session?.sendMessage(["type": "previousCommand"], replyHandler: nil, errorHandler: nil)
    }
    
    func requestDownload(songId: String) {
        session?.sendMessage(["type": "requestDownload", "songId": songId], replyHandler: nil, errorHandler: nil)
    }
    
    // MARK: - Direct API Access (watch can also talk to server directly)
    
    func getAlbumList(type: String = "newest", size: Int = 20) async throws -> [Album] {
        guard activeServer != nil else { return [] }
        return try await client.getAlbumList2(type: type, size: size)
    }
    
    func getAlbum(id: String) async throws -> AlbumWithSongs? {
        return try await client.getAlbum(id: id)
    }
    
    func getPlaylists() async throws -> [Playlist] {
        return try await client.getPlaylists()
    }
    
    func getPlaylist(id: String) async throws -> PlaylistWithSongs? {
        return try await client.getPlaylist(id: id)
    }
    
    func search(query: String) async throws -> SearchResult3? {
        return try await client.search3(query: query)
    }
    
    func streamURL(songId: String, maxBitRate: Int? = 192) -> URL? {
        return client.streamURL(songId: songId, format: maxBitRate != nil ? "mp3" : nil, maxBitRate: maxBitRate)
    }
    
    func coverArtURL(id: String, size: Int = 100) -> URL? {
        return client.coverArtURL(id: id, size: size)
    }
    
    /// Downloads a song at 192kbps MP3 for watch storage efficiency
    func downloadSong(id: String) async throws -> (Data, URLResponse) {
        let params = [
            URLQueryItem(name: "id", value: id),
            URLQueryItem(name: "format", value: "mp3"),
            URLQueryItem(name: "maxBitRate", value: "192")
        ]
        return try await client.requestData(endpoint: "stream", params: params)
    }
    
    // MARK: - Persistence
    
    private func saveLocalServers() {
        if let data = try? JSONEncoder().encode(servers) {
            UserDefaults.standard.set(data, forKey: "watch_servers")
        }
        if let data = try? JSONEncoder().encode(activeServer) {
            UserDefaults.standard.set(data, forKey: "watch_active_server")
        }
    }
    
    private func loadLocalServers() {
        if let data = UserDefaults.standard.data(forKey: "watch_servers"),
           let decoded = try? JSONDecoder().decode([ServerConfig].self, from: data) {
            servers = decoded
        }
        if let data = UserDefaults.standard.data(forKey: "watch_active_server"),
           let decoded = try? JSONDecoder().decode(ServerConfig.self, from: data) {
            activeServer = decoded
            client.currentServer = decoded
        } else if let first = servers.first {
            activeServer = first
            client.currentServer = first
        }
    }
}

// MARK: - WCSessionDelegate
extension WatchSessionManager: WCSessionDelegate {
    
    func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?) {
        DispatchQueue.main.async {
            self.isPhoneReachable = session.isReachable
        }
        
        if activationState == .activated {
            // Check existing application context (already sent before watch app opened)
            let existingContext = session.receivedApplicationContext
            if let data = existingContext["servers"] as? Data,
               let decoded = try? JSONDecoder().decode([ServerConfig].self, from: data) {
                DispatchQueue.main.async {
                    if self.servers.isEmpty {
                        self.servers = decoded
                        if self.activeServer == nil, let first = decoded.first {
                            self.activeServer = first
                            self.client.currentServer = first
                        }
                        self.saveLocalServers()
                    }
                }
            }
            
            // Also proactively request from phone if reachable
            if session.isReachable && self.servers.isEmpty {
                self.requestServersFromPhone()
            }
        }
    }
    
    func sessionReachabilityDidChange(_ session: WCSession) {
        DispatchQueue.main.async {
            self.isPhoneReachable = session.isReachable
        }
    }
    
    // Receive application context (server configs from iPhone)
    func session(_ session: WCSession, didReceiveApplicationContext applicationContext: [String: Any]) {
        if let data = applicationContext["servers"] as? Data,
           let servers = try? JSONDecoder().decode([ServerConfig].self, from: data) {
            DispatchQueue.main.async {
                self.servers = servers
                if self.activeServer == nil, let first = servers.first {
                    self.activeServer = first
                    self.client.currentServer = first
                }
                self.saveLocalServers()
            }
        }
        
        if let catalogData = applicationContext["offlineCatalog"] as? Data,
           let songs = try? JSONDecoder().decode([Song].self, from: catalogData) {
            DispatchQueue.main.async {
                // Update offline store with catalog
                WatchOfflineStore.shared.updateCatalog(songs)
            }
        }
    }
    
    // Receive messages (now playing info from iPhone)
    func session(_ session: WCSession, didReceiveMessage message: [String: Any]) {
        guard let type = message["type"] as? String else { return }
        
        if type == "nowPlaying" {
            DispatchQueue.main.async {
                self.phoneNowPlaying = PhoneNowPlaying(
                    title: message["title"] as? String ?? "",
                    artist: message["artist"] as? String ?? "",
                    album: message["album"] as? String ?? "",
                    isPlaying: message["isPlaying"] as? Bool ?? false,
                    currentTime: message["currentTime"] as? TimeInterval ?? 0,
                    duration: message["duration"] as? TimeInterval ?? 0,
                    coverArtId: message["coverArtId"] as? String
                )
            }
        }
    }
    
    // Messages that need a reply
    func session(_ session: WCSession, didReceiveMessage message: [String: Any], replyHandler: @escaping ([String: Any]) -> Void) {
        guard let type = message["type"] as? String else {
            replyHandler(["error": "no type"])
            return
        }
        
        switch type {
        case "requestSongList":
            let store = WatchOfflineStore.shared
            struct WatchSongInfoEnc: Codable {
                let id: String; let title: String; let artist: String; let album: String; let fileSize: Int64
            }
            let encoded = store.songs.map {
                WatchSongInfoEnc(id: $0.id, title: $0.song.title, artist: $0.song.artist ?? "Unknown", album: $0.song.album ?? "Unknown", fileSize: $0.fileSize)
            }
            if let data = try? JSONEncoder().encode(encoded) {
                replyHandler(["songs": data])
            } else {
                replyHandler(["songs": Data()])
            }
            print("[Watch] Sent song list: \(store.songs.count) songs")
            
        case "deleteSong":
            if let songId = message["songId"] as? String {
                DispatchQueue.main.async {
                    WatchOfflineStore.shared.removeSong(songId)
                }
                print("[Watch] Deleted song: \(songId)")
                replyHandler(["ok": true])
            } else {
                replyHandler(["error": "no songId"])
            }
            
        case "deleteAllSongs":
            DispatchQueue.main.async {
                WatchOfflineStore.shared.removeAll()
            }
            print("[Watch] Deleted all songs")
            replyHandler(["ok": true])
            
        default:
            replyHandler(["error": "unknown type"])
        }
    }
    
    // Receive user info (wake signals, queued data from phone)
    func session(_ session: WCSession, didReceiveUserInfo userInfo: [String: Any] = [:]) {
        if let type = userInfo["type"] as? String {
            print("[Watch] Received userInfo: \(type)")
            if type == "wake" {
                // Phone pinged us — we're alive now and ready to receive files
                print("[Watch] Wake signal received — app is active")
            }
        }
    }
    
    // Receive files (downloaded songs from iPhone)
    func session(_ session: WCSession, didReceive file: WCSessionFile) {
        let metadata = file.metadata ?? [:]
        print("[Watch] Received file transfer. Keys: \(metadata.keys.sorted())")
        
        // Support both "songId" and "id" keys for compatibility
        guard let songId = (metadata["songId"] as? String) ?? (metadata["id"] as? String),
              let suffix = metadata["suffix"] as? String else {
            print("[Watch] ERROR: Missing songId or suffix in metadata: \(metadata)")
            return
        }
        
        print("[Watch] Processing song: \(songId), suffix: \(suffix)")
        
        // Move file to permanent location
        let documentsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
        let musicDir = documentsDir.appendingPathComponent("OfflineMusic", isDirectory: true)
        try? FileManager.default.createDirectory(at: musicDir, withIntermediateDirectories: true)
        
        let destURL = musicDir.appendingPathComponent("\(songId).\(suffix)")
        
        do {
            if FileManager.default.fileExists(atPath: destURL.path) {
                try FileManager.default.removeItem(at: destURL)
            }
            try FileManager.default.moveItem(at: file.fileURL, to: destURL)
            
            let fileSize = (try? FileManager.default.attributesOfItem(atPath: destURL.path)[.size] as? Int64) ?? 0
            print("[Watch] Saved: \(destURL.lastPathComponent) (\(ByteCountFormatter.string(fromByteCount: fileSize, countStyle: .file)))")
            
            // Support both key naming conventions
            let coverArtId = (metadata["coverArtId"] as? String) ?? (metadata["coverArt"] as? String)
            
            let song = Song(
                id: songId,
                parent: nil, isDir: false,
                title: metadata["title"] as? String ?? "Unknown",
                album: metadata["album"] as? String,
                artist: metadata["artist"] as? String,
                track: nil, year: nil, genre: nil,
                coverArt: coverArtId,
                size: nil, contentType: nil,
                suffix: suffix,
                transcodedContentType: nil, transcodedSuffix: nil,
                duration: metadata["duration"] as? Int,
                bitRate: nil, path: nil, playCount: nil,
                discNumber: nil, created: nil,
                albumId: nil, artistId: nil,
                type: nil, starred: nil, bpm: nil, musicBrainzId: nil
            )
            
            DispatchQueue.main.async {
                WatchOfflineStore.shared.addSong(song, localPath: destURL.path)
                print("[Watch] Added to offline store: \(song.title)")
            }
        } catch {
            print("[Watch] ERROR saving file: \(error.localizedDescription)")
        }
    }
}