Add ability to manually reorder tracks within playlists

Adds ability to manually reorder tracks within playlists
by setting sort order to `Custom`.

Fixes #197

Author: kushalpandya

Managers/Playlist/PMRegularPlaylists.swift

@@ -270,6 +270,28 @@ extension PlaylistManager {
         }
     }
 
+    /// Reorder tracks within a playlist
+    func reorderPlaylistTracks(playlistID: UUID, reorderedTracks: [Track]) async {
+        guard let index = playlists.firstIndex(where: { $0.id == playlistID }),
+              playlists[index].type == .regular,
+              playlists[index].isContentEditable else { return }
+
+        await MainActor.run {
+            self.playlists[index].tracks = reorderedTracks
+            self.playlists[index].dateModified = Date()
+        }
+
+        let updatedPlaylist = await MainActor.run { self.playlists[index] }
+        do {
+            if let dbManager = libraryManager?.databaseManager {
+                try await dbManager.savePlaylistAsync(updatedPlaylist)
+                Logger.info("Saved reordered playlist '\(updatedPlaylist.name)' with \(updatedPlaylist.tracks.count) tracks")
+            }
+        } catch {
+            Logger.error("Failed to save reordered playlist: \(error)")
+        }
+    }
+
     /// Refresh playlists after a folder is removed from the library
     func refreshPlaylistsAfterFolderRemoval() {
         // Remove tracks that no longer exist from regular playlists

Managers/PlaylistSortManager.swift

@@ -9,12 +9,13 @@ import SwiftUI
 /// Manages playlist-specific sorting preferences
 class PlaylistSortManager: ObservableObject {
     static let shared = PlaylistSortManager()
-    
+
+    // Legacy type kept for API compatibility with existing callers
     enum SortCriteria: String, CaseIterable {
         case dateAdded
         case title
         case custom
-        
+
         var displayName: String {
             switch self {
             case .dateAdded: return "Date added"
@@ -23,78 +24,81 @@ class PlaylistSortManager: ObservableObject {
             }
         }
     }
-    
+
     // Store sort preferences per playlist
-    @AppStorage("playlistSortCriteria")
-    private var sortCriteriaData: Data = Data()
-    
+    @AppStorage("playlistSortFields")
+    private var sortFieldsData: Data = Data()
+
     @AppStorage("playlistSortAscending")
     private var sortAscendingData: Data = Data()
-    
-    // Cache for current table sort column (when custom is selected)
-    private var customSortColumns: [UUID: String] = [:]
-    
-    private var sortCriteria: [UUID: SortCriteria] = [:] {
-        didSet {
-            savePreferences()
-        }
+
+    private var sortFields: [UUID: String] = [:] {
+        didSet { savePreferences() }
     }
-    
+
     private var sortAscending: [UUID: Bool] = [:] {
-        didSet {
-            savePreferences()
-        }
+        didSet { savePreferences() }
     }
-    
+
     init() {
         loadPreferences()
     }
-    
+
     // MARK: - Public Methods
-    
+
+    func getSortField(for playlistID: UUID) -> TrackSortField {
+        guard let rawValue = sortFields[playlistID],
+              let field = TrackSortField(rawValue: rawValue) else {
+            return .dateAdded
+        }
+        return field
+    }
+
     func getSortCriteria(for playlistID: UUID) -> SortCriteria {
-        sortCriteria[playlistID] ?? .dateAdded
+        let field = getSortField(for: playlistID)
+        switch field {
+        case .custom: return .custom
+        case .title: return .title
+        case .dateAdded: return .dateAdded
+        default: return .custom
+        }
     }
-    
+
     func getSortAscending(for playlistID: UUID) -> Bool {
         sortAscending[playlistID] ?? true
     }
-    
-    func setSortCriteria(_ criteria: SortCriteria, for playlistID: UUID) {
-        sortCriteria[playlistID] = criteria
+
+    func setSortField(_ field: TrackSortField, for playlistID: UUID) {
+        sortFields[playlistID] = field.rawValue
         objectWillChange.send()
     }
-    
+
+    func setSortCriteria(_ criteria: SortCriteria, for playlistID: UUID) {
+        let field: TrackSortField
+        switch criteria {
+        case .custom: field = .custom
+        case .title: field = .title
+        case .dateAdded: field = .dateAdded
+        }
+        setSortField(field, for: playlistID)
+    }
+
     func setSortAscending(_ ascending: Bool, for playlistID: UUID) {
         sortAscending[playlistID] = ascending
         objectWillChange.send()
     }
-    
-    func setCustomSortColumn(_ column: String, for playlistID: UUID) {
-        customSortColumns[playlistID] = column
-        setSortCriteria(.custom, for: playlistID)
-    }
-    
-    func getCustomSortColumn(for playlistID: UUID) -> String? {
-        customSortColumns[playlistID]
-    }
-    
+
     // MARK: - Persistence
-    
+
     private func loadPreferences() {
-        // Load sort criteria
-        if let decoded = try? JSONDecoder().decode([String: String].self, from: sortCriteriaData) {
-            sortCriteria = decoded.compactMapValues { rawValue in
-                SortCriteria(rawValue: rawValue)
-            }
-            .reduce(into: [:]) { result, pair in
+        if let decoded = try? JSONDecoder().decode([String: String].self, from: sortFieldsData) {
+            sortFields = decoded.reduce(into: [:]) { result, pair in
                 if let uuid = UUID(uuidString: pair.key) {
                     result[uuid] = pair.value
                 }
             }
         }
-        
-        // Load sort ascending
+
         if let decoded = try? JSONDecoder().decode([String: Bool].self, from: sortAscendingData) {
             sortAscending = decoded.reduce(into: [:]) { result, pair in
                 if let uuid = UUID(uuidString: pair.key) {
@@ -103,17 +107,15 @@ class PlaylistSortManager: ObservableObject {
             }
         }
     }
-    
+
     private func savePreferences() {
-        // Save sort criteria
-        let criteriaDict = sortCriteria.reduce(into: [String: String]()) { result, pair in
-            result[pair.key.uuidString] = pair.value.rawValue
+        let fieldsDict = sortFields.reduce(into: [String: String]()) { result, pair in
+            result[pair.key.uuidString] = pair.value
         }
-        if let encoded = try? JSONEncoder().encode(criteriaDict) {
-            sortCriteriaData = encoded
+        if let encoded = try? JSONEncoder().encode(fieldsDict) {
+            sortFieldsData = encoded
         }
-        
-        // Save sort ascending
+
         let ascendingDict = sortAscending.reduce(into: [String: Bool]()) { result, pair in
             result[pair.key.uuidString] = pair.value
         }

Models/Core/Playlist.swift

@@ -314,77 +314,80 @@ struct Playlist: Identifiable, FetchableRecord, PersistableRecord {
         // Check if all tracks are from the same album
         let uniqueAlbums = Set(tracks.map { $0.album })
         let isSingleAlbum = uniqueAlbums.count == 1
-        
+
         // If single album or single track, just use the first track's artwork
         if isSingleAlbum || tracks.count == 1 {
             return tracks.first?.artworkData
         }
-        
+
         // Get up to 4 tracks with artwork for collage
         let tracksWithArt = tracks.prefix(4).filter { $0.artworkData != nil }
-        
+
         guard !tracksWithArt.isEmpty else { return nil }
-        
-        let imageSize: CGFloat = 256
-        let collageImage = NSImage(size: NSSize(width: imageSize, height: imageSize))
-        
-        collageImage.lockFocus()
-        
-        // Clear background
-        NSColor.black.setFill()
-        NSRect(x: 0, y: 0, width: imageSize, height: imageSize).fill()
-        
+
+        let pixelSize = 256
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+
+        // Create opaque bitmap context (no alpha) to avoid HEIC encoder warnings
+        guard let context = CGContext(
+            data: nil,
+            width: pixelSize,
+            height: pixelSize,
+            bitsPerComponent: 8,
+            bytesPerRow: 0,
+            space: colorSpace,
+            bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue
+        ) else {
+            Logger.warning("Failed to create CGContext for collage")
+            return nil
+        }
+
+        // Fill black background
+        context.setFillColor(CGColor(red: 0, green: 0, blue: 0, alpha: 1))
+        context.fill(CGRect(x: 0, y: 0, width: pixelSize, height: pixelSize))
+
         let count = tracksWithArt.count
-        
-        // Special handling based on track count
+        let size = CGFloat(pixelSize)
+
         if count == 1 {
-            // Single track - just draw it full size (this case is already handled above, but keeping for safety)
             if let artworkData = tracksWithArt[0].artworkData,
-               let image = NSImage(data: artworkData) {
-                image.draw(in: NSRect(x: 0, y: 0, width: imageSize, height: imageSize),
-                           from: NSRect(origin: .zero, size: image.size),
-                           operation: .copy,
-                           fraction: 1.0)
+               let source = CGImageSourceCreateWithData(artworkData as CFData, nil),
+               let cgImage = CGImageSourceCreateImageAtIndex(source, 0, nil) {
+                context.draw(cgImage, in: CGRect(x: 0, y: 0, width: size, height: size))
             }
         } else {
             // 2 or more tracks - always create 2x2 grid
-            let positions = [(0, 0), (1, 0), (0, 1), (1, 1)]  // (col, row) for each quadrant
-            
+            let positions = [(0, 0), (1, 0), (0, 1), (1, 1)]
+
             for (index, (col, row)) in positions.enumerated() {
                 let trackIndex: Int
-                
+
                 if count == 2 {
-                    // For 2 tracks: diagonal pattern (0, 1, 1, 0)
                     trackIndex = (index == 0 || index == 3) ? 0 : 1
                 } else {
-                    // For 3+ tracks: use available tracks, repeating if necessary
                     trackIndex = index % count
                 }
-                
+
                 guard let artworkData = tracksWithArt[trackIndex].artworkData,
-                      let image = NSImage(data: artworkData) else { continue }
-                
-                let destRect = NSRect(
-                    x: CGFloat(col) * imageSize / 2,
-                    y: CGFloat(row) * imageSize / 2,
-                    width: imageSize / 2,
-                    height: imageSize / 2
+                      let source = CGImageSourceCreateWithData(artworkData as CFData, nil),
+                      let cgImage = CGImageSourceCreateImageAtIndex(source, 0, nil) else { continue }
+
+                let destRect = CGRect(
+                    x: CGFloat(col) * size / 2,
+                    y: CGFloat(row) * size / 2,
+                    width: size / 2,
+                    height: size / 2
                 )
-                
-                image.draw(in: destRect,
-                           from: NSRect(origin: .zero, size: image.size),
-                           operation: .copy,
-                           fraction: 1.0)
+
+                context.draw(cgImage, in: destRect)
             }
         }
-        
-        collageImage.unlockFocus()
-        
-        guard let cgImage = collageImage.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
-            Logger.warning("Failed to create CGImage from collage")
+
+        guard let collageImage = context.makeImage() else {
+            Logger.warning("Failed to create CGImage from collage context")
             return nil
         }
-        return ImageUtils.encodeHEIC(cgImage)
+        return ImageUtils.encodeHEIC(collageImage)
     }
 }
 

Utilities/Constants.swift

@@ -77,6 +77,7 @@ enum Icons {
     // Sort Icons
     static let sortAscending = "sort.ascending"
     static let sortDescending = "sort.descending"
+    static let reorderTracks = "arrow.up.and.down.text.horizontal"
 
     // Custom Icons (from project assets)
     static let customLossless = "custom.lossless"