         }
     }
     
-    @discardableResult
-    fileprivate func remove(album: PHAssetCollection, indexPath: IndexPath? = nil, isFetchedIndex: Bool = true) -> PHAssetCollection {
+    fileprivate func remove(album: PHAssetCollection, indexPath: IndexPath? = nil) {
         if let indexPath = indexPath {
-            if isFetchedIndex {
-                let removedAlbum = fetchedAlbumsArray[indexPath.section].remove(at: indexPath.row)
-                if let indexInSortedArray = sortedAlbumsArray[indexPath.section].index(of: removedAlbum) {
-                    sortedAlbumsArray[indexPath.section].remove(at: indexInSortedArray)
-                } else {
-                    logc("Error on model manipulation logic.")
-                }
-            } else {
-                let removedAlbum = sortedAlbumsArray[indexPath.section].remove(at: indexPath.row)
-                if let indexInFetchedArray = fetchedAlbumsArray[indexPath.section].index(of: removedAlbum) {
-                    fetchedAlbumsArray[indexPath.section].remove(at: indexInFetchedArray)
-                } else {
-                    logc("Error on model manipulation logic.")
-                }
-            }
-        }
-        albumMap.removeValue(forKey: album.localIdentifier)
-        fetchMap.removeValue(forKey: album.localIdentifier)
-        return album
-    }
-    
-    fileprivate func append(album: PHAssetCollection, inSection: Int) {
-        if let album = albumMap[album.localIdentifier] {
-            log("Album already exists: \(album.localizedTitle ?? album.localIdentifier)")
+            sortedAlbumsArray[indexPath.section].remove(at: indexPath.row)
         } else {
-            albumMap[album.localIdentifier] = album
-            sortedAlbumsArray[inSection].append(album)
-        }
-    }
-    
-    fileprivate func insert(album: PHAssetCollection, at indexPath: IndexPath) {
-        albumMap[album.localIdentifier] = album
-        sortedAlbumsArray[indexPath.section].insert(album, at: indexPath.row)
+            for (section, sortedAlbums) in sortedAlbumsArray.enumerated() {
+                if let row = sortedAlbums.index(of: album) {
+                    sortedAlbumsArray[section].remove(at: row)
+                }
+            }
+        }
     }
     
     fileprivate func sortedAlbums(fromAlbums albums: [PHAssetCollection]) -> [PHAssetCollection] {

    }
    
    open func indexPath(forAlbum target: PHAssetCollection) -> IndexPath? {
        var typeIndex: Int = -1
        var subtypeIndex: Int = -1
        for (i, albums) in sortedAlbumsArray.enumerated() {
            if let collectionType = albums.first?.assetCollectionType, collectionType == target.assetCollectionType {
                typeIndex = i
            } else {
                continue
            }
            for (j, album) in albums.enumerated() {
                subtypeIndex = j
                if target.localIdentifier == album.localIdentifier {
                    break
                }
            }
        }
        if typeIndex > -1 && subtypeIndex > -1 {
            return IndexPath(row: subtypeIndex, section: typeIndex)
        } else {
            logw("Failed to find indexPath for album: \(target.localizedTitle ?? "")")
            return nil

                    updateMap[sortedUpdatedIndex.row] = true
                }
                
                if updatedAlbums.count > 0 {
                    DispatchQueue.main.sync {
                        for subscriber in self.subscribers {
                            subscriber.assetsManager(manager: self, updatedAlbums: updatedAlbums, at: sortedUpdatedIndexes)
                        }
                    }
                }
            }
