path: root/MusicConverter/Model/Napster.swift

//
//  Napster.swift
//  MusicConverter
//
//  Created by Finn Behrens on 02.04.21.
//

import Foundation
import MediaPlayer

class Napster: ObservableObject {
    var id: String
    var api: AppleMusicApi
    @Published var cachedNapsterSource: NANapsterPlaylist?
    @Published var tracks: [NANapsterPlaylist.Track]?
    
    var appleChoices: [AppleChoice] = []
    var finischedConvertingChoices = false
    @Published var applePlaylist: MPMediaPlaylist?
    // ToDo: error handling
    var error: Error?
    
    var musicPlayer = MPMusicPlayerController.systemMusicPlayer
    
    var name: String {
        cachedNapsterSource?.name ?? id
    }
    
    /*var synced: Bool {
        self.appleChoices.count == self.cachedNapsterSource?.trackCount ?? -1
    }*/
    var synced = false
    
    init(id: String, api: AppleMusicApi) {
        self.id = id
        self.api = api
        
        if self.id.isEmpty {
            return
        }
        // TODO: apikey
    }
    
    init(demo: String, api: AppleMusicApi = AppleMusicApi()) {
        self.id = demo
        self.api = api
    }
    
    public func update(completion: @escaping (Error?) -> Void) {
        self.cachedNapsterSource = NANapsterPlaylist(id: id)
        self.appleChoices = []; // TODO: keep choices, but update
        self.cachedNapsterSource?.update { result in
            switch result {
            case .failure(let e):
                self.error = e
            case .success(_):
                self.updateTracks() { result in
                    guard (try? result.get()) != nil else {
                        print("wtf? what did guard do?")
                        return
                    }
                    
                    self.resolveTracks(completion: { e in
                        if e != nil {
                            self.error = e
                        }
                        completion(e)
                        self.finischedConvertingChoices = true
                        DispatchQueue.main.async {
                            self.objectWillChange.send()
                        }
                    })
                }
            }
            DispatchQueue.main.async {
                self.objectWillChange.send()
            }
        }
    }
    
    public func updateChoice(choice: Napster.AppleChoice, song: Int) {
        self.appleChoices[choice.id].choice = song
        DispatchQueue.main.async {
            self.objectWillChange.send()
        }
    }
    
    public func updateTracks(completion: @escaping (Result<[NANapsterPlaylist.Track], Error>) -> Void = {_ in}) {
        self.cachedNapsterSource?.getTracks { result in
            switch result {
            case .failure(let e):
                self.error = e
                completion(.failure(e))
            case .success(let d):
                DispatchQueue.main.sync {
                    self.tracks = d;
                }
                completion(.success(d))
            }
            // error also changes self
            DispatchQueue.main.async {
                self.objectWillChange.send()
            }
        }
    }
    
    // TODO: do not add songs without playbackParams
    public func resolveTracks(completion: @escaping (Error?) -> Void) {
        guard self.tracks != nil else {
            completion(NapsterError.TracksEmpty)
            return
        }
        api.convertPlaylist(playlist: self.tracks!, updateCallback: { (track, songs) in
            // FIXME: add unknown songs
            guard songs.count > 0 else {
                print("Did not find a song for \(track.name)")
                return
            }
            do {
                let choiceSongs = songs.filter { song in
                    //return true //song.attributes.playParams != nil
                    return song.attributes.playParams != nil
                }.map { song in
                    AppleMusicApi.SongInfo(song: song)
                }
                if choiceSongs.count > 0 {
                    try self.appleChoices.append(AppleChoice(id: self.appleChoices.count, songs: choiceSongs))
                } else {
                    print("did not found any playable songs for \(track.name)")
                }
            } catch {
                print("error adding to choices: \(error)")
            }
            DispatchQueue.main.async {
                self.objectWillChange.send()
            }
        }, completion: { error in
            if let error = error {
                print("error resolving: \(error)")
            } else {
                self.synced = true
                print("finisched syncing")
            }
            DispatchQueue.main.async {
                self.objectWillChange.send()
            }
            completion(error)
        })
    }
    
    public func updateId(_ id: String) {
        self.id = id
        // Invalidate caches
    }
    
    //public func createApplePlaylistAPI(completion: @escaping (Result<))
    
    public func createApplePlaylist(completion: @escaping (Result<MPMediaPlaylist, Error>) -> Void) {
        /*self.musicPlayer.setQueue(with: self.appleChoices.map({s in
            s.song.attributes.playParams.id
        }))
        self.musicPlayer.play()*/
        
        // TODO: check input variables
        guard self.cachedNapsterSource != nil else {
            completion(.failure(NANapsterError.NotCachedError))
            return
        }
        
        let playlistUUID = UUID()
        
        let playlistCreationMetadata = MPMediaPlaylistCreationMetadata(name: self.name)
        playlistCreationMetadata.descriptionText = self.cachedNapsterSource?.description ?? "" + "\n\nFrom napster"
        
        MPMediaLibrary.default().getPlaylist(with: playlistUUID, creationMetadata: playlistCreationMetadata, completionHandler: { (playlist, error) in
            guard error == nil else {
                completion(.failure(error!))
                return
            }
            
            self.applePlaylist = playlist
            completion(.success(playlist!))
        })
    }
    
    public func convertToApplePlaylist(completion: @escaping (Result<(), Error>) -> Void) {
        guard let playlist = self.applePlaylist else {
            completion(.failure(NapsterError.NoPlaylistCreated))
            return
        }
        
        /*guard self.appleChoices.count > 0 else {
            completion(.failure(NapsterError.NotEnoughSongs))
            return
        }*/
        guard self.synced else {
            completion(.failure(NapsterError.NotEnoughSongs))
            return
        }
        
        var pos = 0
        
        // TODO: clear playlist
        
        var callback: (Error?) -> Void = {_ in}
        callback = { error in
            print("callback: adding song \(self.appleChoices[pos].song.name) to playlist")
            guard error == nil else {
                completion(.failure(error!))
                return
            }
            
            if pos < self.appleChoices.count - 1 {
                pos += 1;
                while self.appleChoices[pos].song.attributes.playParams?.id == nil {
                    print("did not found a id for song \(self.appleChoices[pos].song.name)")
                    pos += 1;
                }
                playlist.addItem(withProductID: self.appleChoices[pos].song.attributes.playParams!.id, completionHandler: callback)
            } else {
                completion(.success(()))
            }
        }
        
        print("add first item")
        playlist.addItem(withProductID: self.appleChoices[pos].song.attributes.playParams!.id, completionHandler: callback)
    }
    
    public struct AppleChoice: Identifiable, CustomStringConvertible {
        init(id: Int, songs: [AppleMusicApi.SongInfo]) throws {
            guard songs.count > 0 else {
                throw NapsterError.NotEnoughSongs
            }
            
            self.id = id
            self.songs = songs
        }
        
        var id: Int
        var songs: [AppleMusicApi.SongInfo]
        var choice: Int = 0
        
        var song: AppleMusicApi.SongInfo {
            songs[choice]
        }
        
        var description: String {
            song.attributes.name
        }
    }
}

public enum NapsterError: Error {
    case TracksEmpty
    case NotEnoughSongs
    case NoPlaylistCreated
}