Adds support for fetching and showing artist image & bio

Adds support for fetching and showing artist image & bio
from Deezer and TMDB, in case images are not available,
user can manually set an image via search or absolute URL.

Author: kushalpandya

.swiftlint.yml

@@ -172,7 +172,7 @@ custom_rules:
   space_after_comment:
     included: ".*\\.swift"
     name: "Space After Comment"
-    regex: '(\/\/\w+)'
+    regex: '(?<!:)(\/\/\w+)'
     message: "Add a space after //"
     severity: warning
 

Configuration/Info.plist

@@ -64,5 +64,9 @@
     <string>$(LASTFM_API_KEY)</string>
     <key>LASTFM_SHARED_SECRET</key>
     <string>$(LASTFM_SHARED_SECRET)</string>
+
+    <!--  TMDB  -->
+    <key>TMDB_READ_ACCESS_TOKEN</key>
+    <string>$(TMDB_READ_ACCESS_TOKEN)</string>
 </dict>
 </plist>

Configuration/Secrets.xcconfig.template

@@ -1,5 +1,9 @@
 // Last.fm API Credentials
 // Copy this file to Secrets.xcconfig and fill in your own values
 // Get your API key at: https://www.last.fm/api/account/create
-LASTFM_API_KEY = 
-LASTFM_SHARED_SECRET =
+LASTFM_API_KEY =
+LASTFM_SHARED_SECRET =
+
+// TMDB API Credentials
+// Get your token at: https://www.themoviedb.org/settings/api
+TMDB_READ_ACCESS_TOKEN =

Managers/ArtistBioManager.swift

@@ -0,0 +1,350 @@
+//
+//  ArtistBioManager.swift
+//  Petrichor
+//
+//  Handles fetching artist images (Deezer, TMDB) and bios (Last.fm)
+//  from online sources and storing them in the database.
+//
+
+import Foundation
+
+class ArtistBioManager {
+    // MARK: - Singleton
+
+    static let shared = ArtistBioManager()
+    
+    /// Minimum image size in bytes to filter out placeholder/silhouette images
+    private static let minimumImageSize = 15_000
+
+    // MARK: - Constants
+
+    private enum Deezer {
+        static let searchURL = "https://api.deezer.com/search/artist"
+        static let rateLimitDelay: TimeInterval = 0.12 // ~50 req / 5s
+    }
+
+    private enum TMDB {
+        static let searchURL = "https://api.themoviedb.org/3/search/person"
+        static let imageBaseURL = "https://image.tmdb.org/t/p/w500"
+        static let rateLimitDelay: TimeInterval = 0.3 // ~40 req / 10s
+    }
+
+    private enum LastFM {
+        static let apiBaseURL = "https://ws.audioscrobbler.com/2.0/"
+        static let rateLimitDelay: TimeInterval = 0.25
+    }
+
+    private enum UserDefaultsKeys {
+        static let artistInfoFetchEnabled = "artistInfoFetchEnabled"
+    }
+
+    // MARK: - Properties
+
+    private var fetchTask: Task<Void, Never>?
+    private var lastDeezerRequest: Date?
+    private var lastTMDBRequest: Date?
+    private var lastLastFMRequest: Date?
+
+    private var tmdbReadAccessToken: String? {
+        Bundle.main.object(forInfoDictionaryKey: "TMDB_READ_ACCESS_TOKEN") as? String
+    }
+
+    private var lastfmApiKey: String? {
+        Bundle.main.object(forInfoDictionaryKey: "LASTFM_API_KEY") as? String
+    }
+
+    var isArtistInfoFetchEnabled: Bool {
+        if UserDefaults.standard.object(forKey: UserDefaultsKeys.artistInfoFetchEnabled) == nil {
+            return true
+        }
+        return UserDefaults.standard.bool(forKey: UserDefaultsKeys.artistInfoFetchEnabled)
+    }
+
+    // MARK: - Initialization
+
+    private init() {}
+
+    // MARK: - Types
+
+    struct ImageResult {
+        let imageData: Data
+        let imageUrl: String
+        let source: String
+    }
+
+    // MARK: - Public Methods
+
+    func fetchMissingArtistImages(using libraryManager: LibraryManager) {
+        fetchTask?.cancel()
+
+        let databaseManager = libraryManager.databaseManager
+
+        fetchTask = Task.detached(priority: .utility) { [weak self] in
+            guard let self else { return }
+            guard self.isArtistInfoFetchEnabled else {
+                Logger.info("ArtistBioManager: Artist info fetching is disabled")
+                return
+            }
+
+            let artists = databaseManager.getArtistsNeedingImageOrBio()
+            guard !artists.isEmpty else {
+                Logger.info("ArtistBioManager: No artists need fetching")
+                return
+            }
+
+            Logger.info("ArtistBioManager: Starting fetch for \(artists.count) artists")
+
+            var pendingUpdates: [(name: String, artworkData: Data)] = []
+            var lastUIUpdate = Date.distantPast
+            let uiUpdateInterval: TimeInterval = 2
+
+            for artist in artists {
+                guard !Task.isCancelled, self.isArtistInfoFetchEnabled else {
+                    Logger.info("ArtistBioManager: Fetch stopped")
+                    break
+                }
+
+                // Fetch image and bio, then write once
+                let imageResult = artist.hasImage ? nil : await self.fetchArtistImage(name: artist.name)
+                let bio = artist.hasBio ? nil : await self.fetchArtistBio(name: artist.name)
+
+                if let imageResult,
+                   let compressed = ImageUtils.compressImage(from: imageResult.imageData, source: "ArtistBioManager/\(imageResult.source)") {
+                    let source = imageResult.source.components(separatedBy: " – ").first ?? imageResult.source
+                    databaseManager.updateArtistInfo(
+                        artistId: artist.id,
+                        imageData: compressed,
+                        imageUrl: imageResult.imageUrl,
+                        imageSource: source,
+                        bio: bio,
+                        bioSource: bio != nil ? "last.fm" : nil
+                    )
+                    pendingUpdates.append((name: artist.name, artworkData: compressed))
+                } else if let bio {
+                    databaseManager.updateArtistInfo(artistId: artist.id, bio: bio, bioSource: "last.fm")
+                    if !artist.hasImage {
+                        databaseManager.markArtistImageFetchFailed(artistId: artist.id)
+                    }
+                } else if !artist.hasImage {
+                    databaseManager.markArtistImageFetchFailed(artistId: artist.id)
+                }
+
+                // Flush pending UI updates every 2 seconds
+                if !pendingUpdates.isEmpty && Date().timeIntervalSince(lastUIUpdate) >= uiUpdateInterval {
+                    let updates = pendingUpdates
+                    pendingUpdates.removeAll()
+                    lastUIUpdate = Date()
+                    await MainActor.run {
+                        for update in updates {
+                            libraryManager.updateArtistEntityArtwork(name: update.name, artworkData: update.artworkData)
+                        }
+                    }
+                }
+            }
+
+            // Flush remaining updates
+            if !pendingUpdates.isEmpty {
+                let updates = pendingUpdates
+                await MainActor.run {
+                    for update in updates {
+                        libraryManager.updateArtistEntityArtwork(name: update.name, artworkData: update.artworkData)
+                    }
+                }
+            }
+
+            Logger.info("ArtistBioManager: Finished fetch")
+        }
+    }
+
+    /// Search both Deezer and TMDB for all available artist images (used by image picker sheet)
+    func searchAllImages(for artistName: String) async -> [ImageResult] {
+        async let deezerResults = searchDeezerImages(name: artistName)
+        async let tmdbResults = searchTMDBImages(name: artistName)
+        return await deezerResults + tmdbResults
+    }
+
+    // MARK: - Private: Image Fetch
+
+    private func fetchArtistImage(name: String) async -> ImageResult? {
+        if let result = await searchDeezerImages(name: name, limit: 1).first {
+            return result
+        }
+        return await searchTMDBImages(name: name, limit: 1).first
+    }
+
+    // MARK: - Deezer Search
+
+    private func searchDeezerImages(name: String, limit: Int = 6) async -> [ImageResult] {
+        if limit == 1 {
+            await waitForRateLimit(lastRequest: &lastDeezerRequest, delay: Deezer.rateLimitDelay)
+        }
+
+        guard var components = URLComponents(string: Deezer.searchURL) else { return [] }
+        components.queryItems = [URLQueryItem(name: "q", value: name)]
+        guard let url = components.url else { return [] }
+
+        do {
+            var request = URLRequest(url: url)
+            request.setValue(AppInfo.userAgent, forHTTPHeaderField: "User-Agent")
+
+            let (data, response) = try await AppInfo.urlSession.data(for: request)
+            guard let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200,
+                  let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let results = json["data"] as? [[String: Any]] else {
+                return []
+            }
+
+            var images: [ImageResult] = []
+            for result in results.prefix(limit) {
+                guard let pictureXL = result["picture_xl"] as? String,
+                      !isDeezerPlaceholder(pictureXL) else { continue }
+
+                // For auto-fetch, only accept close name matches
+                if limit == 1, let resultName = result["name"] as? String,
+                   !isNameMatch(query: name, result: resultName) { continue }
+
+                if let imageData = await downloadImageData(from: pictureXL) {
+                    let label = limit == 1 ? "deezer" : (result["name"] as? String).map { "deezer – \($0)" } ?? "deezer"
+                    images.append(ImageResult(imageData: imageData, imageUrl: pictureXL, source: label))
+                }
+            }
+            return images
+        } catch {
+            Logger.error("ArtistBioManager: Deezer error for '\(name)': \(error.localizedDescription)")
+            return []
+        }
+    }
+
+    // MARK: - TMDB Search
+
+    private func searchTMDBImages(name: String, limit: Int = 6) async -> [ImageResult] {
+        guard let token = tmdbReadAccessToken, !token.isEmpty else { return [] }
+
+        if limit == 1 {
+            await waitForRateLimit(lastRequest: &lastTMDBRequest, delay: TMDB.rateLimitDelay)
+        }
+
+        guard var components = URLComponents(string: TMDB.searchURL) else { return [] }
+        components.queryItems = [URLQueryItem(name: "query", value: name)]
+        guard let url = components.url else { return [] }
+
+        do {
+            var request = URLRequest(url: url)
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+            request.setValue(AppInfo.userAgent, forHTTPHeaderField: "User-Agent")
+
+            let (data, response) = try await AppInfo.urlSession.data(for: request)
+            guard let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200,
+                  let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let results = json["results"] as? [[String: Any]] else {
+                return []
+            }
+
+            var images: [ImageResult] = []
+            for result in results.prefix(limit) {
+                guard let profilePath = result["profile_path"] as? String else { continue }
+
+                // For auto-fetch, only accept close name matches
+                if limit == 1, let resultName = result["name"] as? String,
+                   !isNameMatch(query: name, result: resultName) { continue }
+
+                let imageUrlString = TMDB.imageBaseURL + profilePath
+
+                if let imageData = await downloadImageData(from: imageUrlString) {
+                    let label = limit == 1 ? "tmdb" : (result["name"] as? String).map { "tmdb – \($0)" } ?? "tmdb"
+                    images.append(ImageResult(imageData: imageData, imageUrl: imageUrlString, source: label))
+                }
+            }
+            return images
+        } catch {
+            Logger.error("ArtistBioManager: TMDB error for '\(name)': \(error.localizedDescription)")
+            return []
+        }
+    }
+
+    // MARK: - Last.fm Bio
+
+    private func fetchArtistBio(name: String) async -> String? {
+        guard let apiKey = lastfmApiKey, !apiKey.isEmpty else { return nil }
+
+        await waitForRateLimit(lastRequest: &lastLastFMRequest, delay: LastFM.rateLimitDelay)
+
+        guard var components = URLComponents(string: LastFM.apiBaseURL) else { return nil }
+        components.queryItems = [
+            URLQueryItem(name: "method", value: "artist.getinfo"),
+            URLQueryItem(name: "artist", value: name),
+            URLQueryItem(name: "api_key", value: apiKey),
+            URLQueryItem(name: "format", value: "json")
+        ]
+
+        guard let url = components.url else { return nil }
+
+        do {
+            var request = URLRequest(url: url)
+            request.setValue(AppInfo.userAgent, forHTTPHeaderField: "User-Agent")
+
+            let (data, response) = try await AppInfo.urlSession.data(for: request)
+            guard let httpResponse = response as? HTTPURLResponse,
+                  httpResponse.statusCode == 200 else {
+                return nil
+            }
+
+            guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let artist = json["artist"] as? [String: Any],
+                  let bio = artist["bio"] as? [String: Any],
+                  let content = bio["summary"] as? String else {
+                return nil
+            }
+
+            // Last.fm appends a "Read more" link in HTML — strip it
+            let cleaned = content
+                .replacingOccurrences(of: "<a href=\".*?\">.*?</a>", with: "", options: .regularExpression)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+
+            return cleaned.isEmpty ? nil : cleaned
+        } catch {
+            Logger.error("ArtistBioManager: Last.fm bio error for '\(name)': \(error.localizedDescription)")
+            return nil
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func downloadImageData(from urlString: String) async -> Data? {
+        guard let url = URL(string: urlString) else { return nil }
+        guard let (data, response) = try? await AppInfo.urlSession.data(from: url),
+              let httpResponse = response as? HTTPURLResponse,
+              httpResponse.statusCode == 200,
+              data.count >= Self.minimumImageSize else {
+            return nil
+        }
+        return data
+    }
+
+    /// Check if the API result name is a close match to the search query.
+    /// Accepts exact matches (case-insensitive) or when one name contains the other.
+    private func isNameMatch(query: String, result: String) -> Bool {
+        let q = query.lowercased()
+        let r = result.lowercased()
+        return q == r || q.contains(r) || r.contains(q)
+    }
+
+    private func isDeezerPlaceholder(_ url: String) -> Bool {
+        url.contains("/images/artist//")
+    }
+
+    // MARK: - Rate Limiting
+
+    private func waitForRateLimit(lastRequest: inout Date?, delay: TimeInterval) async {
+        if let last = lastRequest {
+            let elapsed = Date().timeIntervalSince(last)
+            let waitTime = delay - elapsed
+            if waitTime > 0 {
+                try? await Task.sleep(nanoseconds: UInt64(waitTime * 1_000_000_000))
+            }
+        }
+        lastRequest = Date()
+    }
+}