Save fetched remote artwork to album directory

Persephone/Services/AlbumArtService.swift

@@ -13,16 +13,14 @@ class AlbumArtService {
   var preferences = Preferences()
   let song: Song
   let album: Album
-  
+
   let cachedArtworkSize = 180
   let cachedArtworkQuality: CGFloat = 0.5
 
+  let bigArtworkSize = 600
+
   var session = URLSession(configuration: .default)
-  let artworkQueue = DispatchQueue(
+  let artworkQueue = DispatchQueue(label: "albumArtQueue", qos: .background)
-    label: "albumArtQueue",
-    qos: .background,
-    attributes: .concurrent
-  )
 
   init(song: Song) {
     self.song = song
@@ -32,8 +30,18 @@ class AlbumArtService {
   func fetchBigAlbumArt() -> Promise<NSImage?> {
     return firstly {
       self.getArtworkFromFilesystem()
-    }.then { (artwork: NSImage?) -> Promise<NSImage?> in
+    }.then { (image: NSImage?) -> Promise<NSImage?> in
-      artwork.map(Promise.value) ?? self.getRemoteArtwork().map(Optional.some)
+      image.map(Promise.value) ?? self.getRemoteArtwork().map(Optional.some)
+    }.compactMap(on :artworkQueue) { image in
+      if self.fileSystemArtworkFilePath() != nil {
+        let sizedImage = image?.toFitBox(
+          size: NSSize(width: self.bigArtworkSize, height: self.bigArtworkSize)
+        )
+        self.saveArtworkToFilesystem(data: sizedImage?.jpegData(compressionQuality: self.cachedArtworkQuality))
+        return sizedImage
+      } else {
+        return image
+      }
     }
   }
 

Persephone/Services/Extensions/AlbumArtService+Filesystem.swift

@@ -10,30 +10,55 @@ import Cocoa
 import PromiseKit
 
 extension AlbumArtService {
-  func getArtworkFromFilesystem() -> Promise<NSImage?> {
+  var coverArtFilenames: [String] {
-    let coverArtFilenames = [
+    return [
       "folder.jpg",
       "cover.jpg",
       "\(album.artist) - \(album.title).jpg"
     ]
+  }
 
-    let musicDir = self.preferences.expandedMpdLibraryDir
+  var musicDir: String {
-    let songPath = self.songPath()
+    return self.preferences.expandedMpdLibraryDir
+  }
 
+  func getArtworkFromFilesystem() -> Promise<NSImage?> {
     return Promise { seal in
       artworkQueue.async {
-        let image = coverArtFilenames
+        guard let artworkPath = self.fileSystemArtworkFilePath()
-          .lazy
+          else { seal.fulfill(nil); return }
-          .map { "\(musicDir)/\(songPath)/\($0)" }
+
-          .compactMap(self.tryImage)
+        let image = self.tryImage(artworkPath)
-          .first
 
         seal.fulfill(image)
       }
     }
   }
 
-  func songPath() -> String {
+  func saveArtworkToFilesystem(data: Data?) {
+    let artworkFileName = coverArtFilenames.first!
+
+    if self.fileSystemArtworkFilePath() == nil {
+      FileManager.default.createFile(
+        atPath: "\(self.musicDir)/\(self.songPath)/\(artworkFileName)",
+        contents: data,
+        attributes: nil
+      )
+    }
+  }
+
+  func fileSystemArtworkFilePath() -> String? {
+    let musicDir = self.preferences.expandedMpdLibraryDir
+
+    return self.coverArtFilenames
+      .lazy
+      .map { "\(musicDir)/\(self.songPath)/\($0)" }
+      .first {
+        FileManager.default.fileExists(atPath: $0)
+      }
+  }
+
+  var songPath: String {
     return song
       .mpdSong
       .uriString