From 577ae320f574721c7de22b01d109ab86d7074b9f Mon Sep 17 00:00:00 2001
From: Matt Bruce <mbrucedogs@gmail.com>
Date: Sat, 19 Jul 2025 13:53:27 -0500
Subject: [PATCH] Signed-off-by: Matt Bruce <mbrucedogs@gmail.com>

---
 src/hooks/useFavorites.ts | 27 ++++++++++++++++++++++-----
 src/hooks/useHistory.ts   | 27 ++++++++++++++++++++++-----
 src/hooks/useNewSongs.ts  | 27 ++++++++++++++++++++++-----
 3 files changed, 66 insertions(+), 15 deletions(-)

diff --git a/src/hooks/useFavorites.ts b/src/hooks/useFavorites.ts
index f90b648..d33deec 100644
--- a/src/hooks/useFavorites.ts
+++ b/src/hooks/useFavorites.ts
@@ -12,21 +12,38 @@ export const useFavorites = () => {
   const allFavoritesItems = useAppSelector(selectFavoritesArray);
   const { addToQueue, toggleFavorite } = useSongOperations();
   const { showSuccess, showError } = useToast();
-  const { filterDisabledSongs, isSongDisabled, addDisabledSong, removeDisabledSong } = useDisabledSongs();
+  const { disabledSongPaths, isSongDisabled, addDisabledSong, removeDisabledSong, loading: disabledSongsLoading } = useDisabledSongs();
   
   const [currentPage, setCurrentPage] = useState(1);
 
   // Filter out disabled songs and paginate
   const favoritesItems = useMemo(() => {
-    const filteredItems = filterDisabledSongs(allFavoritesItems);
+    // Don't return any results if disabled songs are still loading
+    if (disabledSongsLoading) {
+      debugLog('useFavorites - disabled songs still loading, returning empty array');
+      return [];
+    }
+
+    // Filter out disabled songs first
+    const filteredItems = allFavoritesItems.filter(song => !disabledSongPaths.has(song.path));
     const endIndex = currentPage * ITEMS_PER_PAGE;
+    
+    debugLog('useFavorites - filtering favorites:', {
+      totalFavorites: allFavoritesItems.length,
+      afterDisabledFilter: filteredItems.length,
+      currentPage,
+      endIndex
+    });
+    
     return filteredItems.slice(0, endIndex);
-  }, [allFavoritesItems, currentPage, filterDisabledSongs]);
+  }, [allFavoritesItems, currentPage, disabledSongPaths, disabledSongsLoading]);
 
   const hasMore = useMemo(() => {
-    const filteredItems = filterDisabledSongs(allFavoritesItems);
+    if (disabledSongsLoading) return false;
+    
+    const filteredItems = allFavoritesItems.filter(song => !disabledSongPaths.has(song.path));
     return filteredItems.length > ITEMS_PER_PAGE && favoritesItems.length < filteredItems.length;
-  }, [favoritesItems.length, allFavoritesItems.length, filterDisabledSongs]);
+  }, [favoritesItems.length, allFavoritesItems, disabledSongPaths, disabledSongsLoading]);
 
   const loadMore = useCallback(() => {
     debugLog('useFavorites - loadMore called:', { hasMore, currentPage, allFavoritesItemsLength: allFavoritesItems.length });
diff --git a/src/hooks/useHistory.ts b/src/hooks/useHistory.ts
index c2969b8..f8fd817 100644
--- a/src/hooks/useHistory.ts
+++ b/src/hooks/useHistory.ts
@@ -12,21 +12,38 @@ export const useHistory = () => {
   const allHistoryItems = useAppSelector(selectHistoryArray);
   const { addToQueue, toggleFavorite } = useSongOperations();
   const { showSuccess, showError } = useToast();
-  const { filterDisabledSongs, isSongDisabled, addDisabledSong, removeDisabledSong } = useDisabledSongs();
+  const { disabledSongPaths, isSongDisabled, addDisabledSong, removeDisabledSong, loading: disabledSongsLoading } = useDisabledSongs();
   
   const [currentPage, setCurrentPage] = useState(1);
 
   // Filter out disabled songs and paginate
   const historyItems = useMemo(() => {
-    const filteredItems = filterDisabledSongs(allHistoryItems);
+    // Don't return any results if disabled songs are still loading
+    if (disabledSongsLoading) {
+      debugLog('useHistory - disabled songs still loading, returning empty array');
+      return [];
+    }
+
+    // Filter out disabled songs first
+    const filteredItems = allHistoryItems.filter(song => !disabledSongPaths.has(song.path));
     const endIndex = currentPage * ITEMS_PER_PAGE;
+    
+    debugLog('useHistory - filtering history:', {
+      totalHistory: allHistoryItems.length,
+      afterDisabledFilter: filteredItems.length,
+      currentPage,
+      endIndex
+    });
+    
     return filteredItems.slice(0, endIndex);
-  }, [allHistoryItems, currentPage, filterDisabledSongs]);
+  }, [allHistoryItems, currentPage, disabledSongPaths, disabledSongsLoading]);
 
   const hasMore = useMemo(() => {
-    const filteredItems = filterDisabledSongs(allHistoryItems);
+    if (disabledSongsLoading) return false;
+    
+    const filteredItems = allHistoryItems.filter(song => !disabledSongPaths.has(song.path));
     return filteredItems.length > ITEMS_PER_PAGE && historyItems.length < filteredItems.length;
-  }, [historyItems.length, allHistoryItems.length, filterDisabledSongs]);
+  }, [historyItems.length, allHistoryItems, disabledSongPaths, disabledSongsLoading]);
 
   const loadMore = useCallback(() => {
     debugLog('useHistory - loadMore called:', { hasMore, currentPage, allHistoryItemsLength: allHistoryItems.length });
diff --git a/src/hooks/useNewSongs.ts b/src/hooks/useNewSongs.ts
index 1eccc68..031f604 100644
--- a/src/hooks/useNewSongs.ts
+++ b/src/hooks/useNewSongs.ts
@@ -12,21 +12,38 @@ export const useNewSongs = () => {
   const allNewSongsItems = useAppSelector(selectNewSongsArray);
   const { addToQueue, toggleFavorite } = useSongOperations();
   const { showSuccess, showError } = useToast();
-  const { filterDisabledSongs, isSongDisabled, addDisabledSong, removeDisabledSong } = useDisabledSongs();
+  const { disabledSongPaths, isSongDisabled, addDisabledSong, removeDisabledSong, loading: disabledSongsLoading } = useDisabledSongs();
   
   const [currentPage, setCurrentPage] = useState(1);
 
   // Filter out disabled songs and paginate
   const newSongsItems = useMemo(() => {
-    const filteredItems = filterDisabledSongs(allNewSongsItems);
+    // Don't return any results if disabled songs are still loading
+    if (disabledSongsLoading) {
+      debugLog('useNewSongs - disabled songs still loading, returning empty array');
+      return [];
+    }
+
+    // Filter out disabled songs first
+    const filteredItems = allNewSongsItems.filter(song => !disabledSongPaths.has(song.path));
     const endIndex = currentPage * ITEMS_PER_PAGE;
+    
+    debugLog('useNewSongs - filtering new songs:', {
+      totalNewSongs: allNewSongsItems.length,
+      afterDisabledFilter: filteredItems.length,
+      currentPage,
+      endIndex
+    });
+    
     return filteredItems.slice(0, endIndex);
-  }, [allNewSongsItems, currentPage, filterDisabledSongs]);
+  }, [allNewSongsItems, currentPage, disabledSongPaths, disabledSongsLoading]);
 
   const hasMore = useMemo(() => {
-    const filteredItems = filterDisabledSongs(allNewSongsItems);
+    if (disabledSongsLoading) return false;
+    
+    const filteredItems = allNewSongsItems.filter(song => !disabledSongPaths.has(song.path));
     return filteredItems.length > ITEMS_PER_PAGE && newSongsItems.length < filteredItems.length;
-  }, [newSongsItems.length, allNewSongsItems.length, filterDisabledSongs]);
+  }, [newSongsItems.length, allNewSongsItems, disabledSongPaths, disabledSongsLoading]);
 
   const loadMore = useCallback(() => {
     debugLog('useNewSongs - loadMore called:', { hasMore, currentPage, allNewSongsItemsLength: allNewSongsItems.length });