mbrucedogs/singsalot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Signed-off-by: mbrucedogs <mbrucedogs@gmail.com>

Browse Source
This commit is contained in:
mbrucedogs 2025-07-20 20:46:11 -05:00
parent 0005c2b348
commit aad198d533
1 changed files with 3 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
src/hooks/useQueue.ts
View File

@ -1,19 +1,17 @@
import { useCallback, useEffect } from 'react';
import { useAppSelector, selectQueueWithUserInfo, selectQueueStats, selectCanReorderQueue } from '../redux';
import { useSongOperations } from './useSongOperations';
import { useToast } from './useToast';
import { useActions } from './useActions';
import { queueService } from '../firebase/services';
import { selectControllerName } from '../redux';
import { debugLog } from '../utils/logger';
import type { QueueItem } from '../types';
export const useQueue = () => {
const queueItems = useAppSelector(selectQueueWithUserInfo);
const queueStats = useAppSelector(selectQueueStats);
const canReorder = useAppSelector(selectCanReorderQueue);
const controllerName = useAppSelector(selectControllerName);
const { removeFromQueue, toggleFavorite } = useSongOperations();
const { showSuccess, showError } = useToast();
const { handleRemoveFromQueue, handleToggleFavorite } = useActions();
// Fix queue order if needed
const fixQueueOrder = useCallback(async () => {
@ -63,184 +61,9 @@ export const useQueue = () => {
initializeQueue();
}, [controllerName, fixQueueOrder]);
const handleRemoveFromQueue = useCallback(async (queueItem: QueueItem) => {
if (!queueItem.key) return;
try {
await removeFromQueue(queueItem.key);
showSuccess('Song removed from queue');
} catch {
showError('Failed to remove song from queue');
}
}, [removeFromQueue, showSuccess, showError]);
const handleToggleFavorite = useCallback(async (song: QueueItem['song']) => {
try {
await toggleFavorite(song);
showSuccess(song.favorite ? 'Removed from favorites' : 'Added to favorites');
} catch {
showError('Failed to update favorites');
}
}, [toggleFavorite, showSuccess, showError]);
const handleMoveUp = useCallback(async (queueItem: QueueItem) => {
debugLog('handleMoveUp called with:', queueItem);
debugLog('Current queueItems:', queueItems);
debugLog('Controller name:', controllerName);
if (!controllerName || !queueItem.key || queueItem.order <= 1) {
debugLog('Early return - conditions not met:', {
controllerName: !!controllerName,
queueItemKey: !!queueItem.key,
order: queueItem.order
});
return; // Can't move up if already at the top
}
try {
// Find the item above this one
const itemAbove = queueItems.find(item => item.order === queueItem.order - 1);
debugLog('Item above:', itemAbove);
if (!itemAbove || !itemAbove.key) {
debugLog('No item above found');
showError('Cannot move item up');
return;
}
debugLog('Swapping orders:', {
currentItem: { key: queueItem.key, order: queueItem.order },
itemAbove: { key: itemAbove.key, order: itemAbove.order }
});
// Swap the order values
await Promise.all([
queueService.updateQueueItem(controllerName, queueItem.key, { order: queueItem.order - 1 }),
queueService.updateQueueItem(controllerName, itemAbove.key, { order: queueItem.order })
]);
debugLog('Move up completed successfully');
showSuccess('Song moved up in queue');
} catch (error) {
console.error('Failed to move song up:', error);
showError('Failed to move song up');
}
}, [controllerName, queueItems, showSuccess, showError]);
const handleMoveDown = useCallback(async (queueItem: QueueItem) => {
debugLog('handleMoveDown called with:', queueItem);
debugLog('Current queueItems:', queueItems);
debugLog('Controller name:', controllerName);
if (!controllerName || !queueItem.key || queueItem.order >= queueItems.length) {
debugLog('Early return - conditions not met:', {
controllerName: !!controllerName,
queueItemKey: !!queueItem.key,
order: queueItem.order,
queueLength: queueItems.length
});
return; // Can't move down if already at the bottom
}
try {
// Find the item below this one
const itemBelow = queueItems.find(item => item.order === queueItem.order + 1);
debugLog('Item below:', itemBelow);
if (!itemBelow || !itemBelow.key) {
debugLog('No item below found');
showError('Cannot move item down');
return;
}
debugLog('Swapping orders:', {
currentItem: { key: queueItem.key, order: queueItem.order },
itemBelow: { key: itemBelow.key, order: itemBelow.order }
});
// Swap the order values
await Promise.all([
queueService.updateQueueItem(controllerName, queueItem.key, { order: queueItem.order + 1 }),
queueService.updateQueueItem(controllerName, itemBelow.key, { order: queueItem.order })
]);
debugLog('Move down completed successfully');
showSuccess('Song moved down in queue');
} catch (error) {
console.error('Failed to move song down:', error);
showError('Failed to move song down');
}
}, [controllerName, queueItems, showSuccess, showError]);
const handleReorder = useCallback(async (oldIndex: number, newIndex: number) => {
debugLog('handleReorder called with:', { oldIndex, newIndex });
debugLog('Current queueItems:', queueItems);
debugLog('Controller name:', controllerName);
if (!controllerName || oldIndex === newIndex) {
debugLog('Early return - conditions not met:', {
controllerName: !!controllerName,
oldIndex,
newIndex
});
return;
}
try {
const itemToMove = queueItems[oldIndex];
if (!itemToMove || !itemToMove.key) {
debugLog('No item to move found');
showError('Cannot reorder item');
return;
}
debugLog('Moving item:', {
item: { key: itemToMove.key, order: itemToMove.order },
fromIndex: oldIndex,
toIndex: newIndex
});
// Calculate the new order for the moved item
const newOrder = newIndex + 1;
// Update all affected items' orders
const updatePromises: Promise<void>[] = [];
if (oldIndex < newIndex) {
// Moving down: shift items between oldIndex and newIndex up by 1
for (let i = oldIndex + 1; i <= newIndex; i++) {
const item = queueItems[i];
if (item && item.key) {
updatePromises.push(
queueService.updateQueueItem(controllerName, item.key, { order: item.order - 1 })
);
}
}
} else {
// Moving up: shift items between newIndex and oldIndex down by 1
for (let i = newIndex; i < oldIndex; i++) {
const item = queueItems[i];
if (item && item.key) {
updatePromises.push(
queueService.updateQueueItem(controllerName, item.key, { order: item.order + 1 })
);
}
}
}
// Update the moved item's order
updatePromises.push(
queueService.updateQueueItem(controllerName, itemToMove.key, { order: newOrder })
);
await Promise.all(updatePromises);
debugLog('Reorder completed successfully');
showSuccess('Queue reordered successfully');
} catch (error) {
console.error('Failed to reorder queue:', error);
showError('Failed to reorder queue');
}
}, [controllerName, queueItems, showSuccess, showError]);
return {
queueItems,
@ -248,8 +71,5 @@ export const useQueue = () => {
canReorder,
handleRemoveFromQueue,
handleToggleFavorite,
handleMoveUp,
handleMoveDown,
handleReorder,
};
};