Fetch lyrics from online source when enabled

Adds support for fetching track lyrics from lrclib.net
in case it is not available locally and user has the setting
enabled to fetch online.

Author: kushalpandya

Core/LyricsLoader.swift

@@ -2,29 +2,52 @@ import Foundation
 import GRDB
 
 struct LyricsLoader {
-    /// Load lyrics for a track, checking external files first, then embedded lyrics
+    /// Load lyrics for a track, checking external files first, then embedded lyrics, then online
     /// - Parameters:
     ///   - track: The track to load lyrics for
     ///   - dbQueue: Database queue for fetching embedded lyrics
+    ///   - databaseManager: Database manager for online lyrics storage (optional)
     /// - Returns: Tuple containing lyrics text and source type
     static func loadLyrics(
         for track: Track,
-        using dbQueue: DatabaseQueue
+        using dbQueue: DatabaseQueue,
+        databaseManager: DatabaseManager? = nil
     ) async throws -> (lyrics: String, source: LyricsSource) {
+        var rawLyrics: String?
+        var source: LyricsSource = .none
+        
         // First, check for external LRC/SRT files
         if let externalLyrics = try? loadExternalLyrics(for: track) {
-            return externalLyrics
+            rawLyrics = externalLyrics.lyrics
+            source = externalLyrics.source
         }
 
-        // Fall back to embedded lyrics
-        if let fullTrack = try? await track.fullTrack(using: dbQueue),
+        // Second, check for embedded lyrics (stored in db during library scan)
+        let fullTrack = try? await track.fullTrack(using: dbQueue)
+        if rawLyrics == nil,
+           let fullTrack = fullTrack,
            let embeddedLyrics = fullTrack.extendedMetadata?.lyrics,
            !embeddedLyrics.isEmpty {
-            return (embeddedLyrics, .embedded)
+            rawLyrics = embeddedLyrics
+            source = .embedded
+        }
+        
+        // Finally, try fetching from online source
+        if rawLyrics == nil,
+           let fullTrack = fullTrack,
+           let databaseManager = databaseManager,
+           let onlineLyrics = await LyricsManager.shared.fetchLyrics(for: fullTrack, using: databaseManager) {
+            rawLyrics = onlineLyrics
+            source = .online
         }
 
-        // No lyrics found
-        return ("", .none)
+        // Strip timestamps for display
+        guard let lyrics = rawLyrics else {
+            return ("", .none)
+        }
+        
+        let displayLyrics = stripTimestamps(lyrics)
+        return (displayLyrics, source)
     }
 
     /// Check for and load external lyrics files (.lrc or .srt)
@@ -68,54 +91,87 @@ struct LyricsLoader {
         return nil
     }
 
+    // MARK: - Timestamp Stripping
+            
+    /// Strip LRC-style timestamps from lyrics for display
+    private static func stripTimestamps(_ content: String) -> String {
+        let lines = content.components(separatedBy: .newlines)
+        var strippedLines: [String] = []
+        
+        for line in lines {
+            var currentLine = line
+            
+            // Remove all timestamp tags [mm:ss.xx] from the line
+            while currentLine.hasPrefix("[") {
+                if let endBracket = currentLine.firstIndex(of: "]") {
+                    let tag = String(currentLine[currentLine.index(after: currentLine.startIndex)..<endBracket])
+                    // Check if it's a timestamp (contains digits and colons/periods)
+                    let isTimestamp = tag.contains(":") && tag.rangeOfCharacter(from: .decimalDigits) != nil
+                    
+                    if isTimestamp {
+                        currentLine = String(currentLine[currentLine.index(after: endBracket)...])
+                    } else {
+                        break
+                    }
+                } else {
+                    break
+                }
+            }
+            
+            let trimmed = currentLine.trimmingCharacters(in: .whitespaces)
+            if !trimmed.isEmpty {
+                strippedLines.append(trimmed)
+            }
+        }
+        
+        return strippedLines.joined(separator: "\n")
+    }
+    
+    // MARK: - Format Parsing
+    
     /// Parse LRC file format and extract lyrics text
     private static func parseLRC(_ content: String) -> String {
         let lines = content.components(separatedBy: .newlines)
         var lyricsLines: [String] = []
 
         for line in lines {
-            // LRC format: [mm:ss.xx]lyrics text
-            // Remove timestamp and metadata tags for now
             if line.hasPrefix("[") {
                 if let endBracket = line.firstIndex(of: "]") {
-                    let afterBracket = line.index(after: endBracket)
-                    if afterBracket < line.endIndex {
-                        let lyricsText = String(line[afterBracket...]).trimmingCharacters(in: .whitespaces)
-                        if !lyricsText.isEmpty {
-                            // Skip metadata lines (ar:, ti:, al:, etc.)
-                            let tag = String(line[line.index(after: line.startIndex)..<endBracket])
-                            if !tag.contains(":") || tag.contains(".") {
-                                lyricsLines.append(lyricsText)
-                            }
-                        }
+                    let tag = String(line[line.index(after: line.startIndex)..<endBracket])
+                    
+                    // Skip metadata lines (ar:, ti:, al:, etc.) but not timestamps
+                    let isMetadata = tag.contains(":") && tag.rangeOfCharacter(from: .decimalDigits) == nil
+                    if isMetadata {
+                        continue
                     }
+                    
+                    // Keep the full line (with timestamps) for now
+                    lyricsLines.append(line)
                 }
             } else if !line.trimmingCharacters(in: .whitespaces).isEmpty {
                 lyricsLines.append(line)
             }
         }
 
-        return lyricsLines.joined(separator: "\n")
+        // Strip timestamps at the end
+        return stripTimestamps(lyricsLines.joined(separator: "\n"))
     }
 
-    /// Parse SRT file format and extract lyrics text (ignoring timestamps for now)
+    /// Parse SRT file format and extract lyrics text
     private static func parseSRT(_ content: String) -> String {
         let lines = content.components(separatedBy: .newlines)
         var lyricsLines: [String] = []
-        var skipNext = false
 
         for line in lines {
             let trimmed = line.trimmingCharacters(in: .whitespaces)
 
-            // Skip empty lines and sequence numbers
+            // Skip empty lines
             if trimmed.isEmpty {
-                skipNext = false
                 continue
             }
 
             // Skip timestamp lines (format: 00:00:00,000 --> 00:00:00,000)
             if trimmed.contains("-->") {
-                skipNext = true
                 continue
             }
 
@@ -124,12 +180,6 @@ struct LyricsLoader {
                 continue
             }
 
-            // Skip the line immediately after timestamp
-            if skipNext {
-                skipNext = false
-            }
-            
-            // This is lyrics text
             lyricsLines.append(trimmed)
         }
 
@@ -141,5 +191,6 @@ enum LyricsSource {
     case lrc
     case srt
     case embedded
+    case online
     case none
 }

Managers/Database/DMTrackUpdate.swift

@@ -32,7 +32,7 @@ extension DatabaseManager {
         }
     }
 
-    // Batch update for track properties (more efficient for multiple updates)
+    /// Batch update for track properties
     func updateTrack(_ track: Track) async throws {
         guard track.trackId != nil else {
             throw DatabaseError.invalidTrackId
@@ -42,4 +42,21 @@ extension DatabaseManager {
             try track.update(db)
         }
     }
+    
+    /// Updates a track's lyrics in extended_metadata
+    func updateTrackLyrics(for fullTrack: FullTrack, lyrics: String) async throws {
+        guard fullTrack.trackId != nil else {
+            throw DatabaseError.invalidTrackId
+        }
+        
+        var updatedTrack = fullTrack
+        var extendedMetadata = updatedTrack.extendedMetadata ?? ExtendedMetadata()
+        extendedMetadata.lyrics = lyrics
+        updatedTrack.extendedMetadata = extendedMetadata
+        
+        let trackToSave = updatedTrack
+        try await dbQueue.write { db in
+            try trackToSave.update(db)
+        }
+    }
 }