import type * as React from 'react';
import { useCallback, useEffect } from 'react';
import { useAppStateStore, useSetAppState } from 'src/state/AppState.js';
import type { Theme } from '../utils/theme.js';
type Priority = 'low' | 'medium' | 'high' | 'immediate';
type BaseNotification = {
  key: string;
  /**
   * Keys of notifications that this notification invalidates.
   * If a notification is invalidated, it will be removed from the queue
   * and, if currently displayed, cleared immediately.
   */
  invalidates?: string[];
  priority: Priority;
  timeoutMs?: number;
  /**
   * Combine notifications with the same key, like Array.reduce().
   * Called as fold(accumulator, incoming) when a notification with a matching
   * key already exists in the queue or is currently displayed.
   * Returns the merged notification (should carry fold forward for future merges).
   */
  fold?: (accumulator: Notification, incoming: Notification) => Notification;
};
type TextNotification = BaseNotification & {
  text: string;
  color?: keyof Theme;
};
type JSXNotification = BaseNotification & {
  jsx: React.ReactNode;
};
type AddNotificationFn = (content: Notification) => void;
type RemoveNotificationFn = (key: string) => void;
export type Notification = TextNotification | JSXNotification;
const DEFAULT_TIMEOUT_MS = 8000;

// Track current timeout to clear it when immediate notifications arrive
let currentTimeoutId: NodeJS.Timeout | null = null;
export function useNotifications(): {
  addNotification: AddNotificationFn;
  removeNotification: RemoveNotificationFn;
} {
  const store = useAppStateStore();
  const setAppState = useSetAppState();

  // Process queue when current notification finishes or queue changes
  const processQueue = useCallback(() => {
    setAppState(prev => {
      const next = getNext(prev.notifications.queue);
      if (prev.notifications.current !== null || !next) {
        return prev;
      }
      currentTimeoutId = setTimeout((setAppState, nextKey, processQueue) => {
        currentTimeoutId = null;
        setAppState(prev => {
          // Compare by key instead of reference to handle re-created notifications
          if (prev.notifications.current?.key !== nextKey) {
            return prev;
          }
          return {
            ...prev,
            notifications: {
              queue: prev.notifications.queue,
              current: null
            }
          };
        });
        processQueue();
      }, next.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, next.key, processQueue);
      return {
        ...prev,
        notifications: {
          queue: prev.notifications.queue.filter(_ => _ !== next),
          current: next
        }
      };
    });
  }, [setAppState]);
  const addNotification = useCallback<AddNotificationFn>((notif: Notification) => {
    // Handle immediate priority notifications
    if (notif.priority === 'immediate') {
      // Clear any existing timeout since we're showing a new immediate notification
      if (currentTimeoutId) {
        clearTimeout(currentTimeoutId);
        currentTimeoutId = null;
      }

      // Set up timeout for the immediate notification
      currentTimeoutId = setTimeout((setAppState, notif, processQueue) => {
        currentTimeoutId = null;
        setAppState(prev => {
          // Compare by key instead of reference to handle re-created notifications
          if (prev.notifications.current?.key !== notif.key) {
            return prev;
          }
          return {
            ...prev,
            notifications: {
              queue: prev.notifications.queue.filter(_ => !notif.invalidates?.includes(_.key)),
              current: null
            }
          };
        });
        processQueue();
      }, notif.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, notif, processQueue);

      // Show the immediate notification right away
      setAppState(prev => ({
        ...prev,
        notifications: {
          current: notif,
          queue:
          // Only re-queue the current notification if it's not immediate
          [...(prev.notifications.current ? [prev.notifications.current] : []), ...prev.notifications.queue].filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key))
        }
      }));
      return; // IMPORTANT: Exit addNotification for immediate notifications
    }

    // Handle non-immediate notifications
    setAppState(prev => {
      // Check if we can fold into an existing notification with the same key
      if (notif.fold) {
        // Fold into current notification if keys match
        if (prev.notifications.current?.key === notif.key) {
          const folded = notif.fold(prev.notifications.current, notif);
          // Reset timeout for the folded notification
          if (currentTimeoutId) {
            clearTimeout(currentTimeoutId);
            currentTimeoutId = null;
          }
          currentTimeoutId = setTimeout((setAppState, foldedKey, processQueue) => {
            currentTimeoutId = null;
            setAppState(p => {
              if (p.notifications.current?.key !== foldedKey) {
                return p;
              }
              return {
                ...p,
                notifications: {
                  queue: p.notifications.queue,
                  current: null
                }
              };
            });
            processQueue();
          }, folded.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, folded.key, processQueue);
          return {
            ...prev,
            notifications: {
              current: folded,
              queue: prev.notifications.queue
            }
          };
        }

        // Fold into queued notification if keys match
        const queueIdx = prev.notifications.queue.findIndex(_ => _.key === notif.key);
        if (queueIdx !== -1) {
          const folded = notif.fold(prev.notifications.queue[queueIdx]!, notif);
          const newQueue = [...prev.notifications.queue];
          newQueue[queueIdx] = folded;
          return {
            ...prev,
            notifications: {
              current: prev.notifications.current,
              queue: newQueue
            }
          };
        }
      }

      // Only add to queue if not already present (prevent duplicates)
      const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key));
      const shouldAdd = !queuedKeys.has(notif.key) && prev.notifications.current?.key !== notif.key;
      if (!shouldAdd) return prev;
      const invalidatesCurrent = prev.notifications.current !== null && notif.invalidates?.includes(prev.notifications.current.key);
      if (invalidatesCurrent && currentTimeoutId) {
        clearTimeout(currentTimeoutId);
        currentTimeoutId = null;
      }
      return {
        ...prev,
        notifications: {
          current: invalidatesCurrent ? null : prev.notifications.current,
          queue: [...prev.notifications.queue.filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key)), notif]
        }
      };
    });

    // Process queue after adding the notification
    processQueue();
  }, [setAppState, processQueue]);
  const removeNotification = useCallback<RemoveNotificationFn>((key: string) => {
    setAppState(prev => {
      const isCurrent = prev.notifications.current?.key === key;
      const inQueue = prev.notifications.queue.some(n => n.key === key);
      if (!isCurrent && !inQueue) {
        return prev;
      }
      if (isCurrent && currentTimeoutId) {
        clearTimeout(currentTimeoutId);
        currentTimeoutId = null;
      }
      return {
        ...prev,
        notifications: {
          current: isCurrent ? null : prev.notifications.current,
          queue: prev.notifications.queue.filter(n => n.key !== key)
        }
      };
    });
    processQueue();
  }, [setAppState, processQueue]);

  // Process queue on mount if there are notifications in the initial state.
  // Imperative read (not useAppState) — a subscription in a mount-only
  // effect would be vestigial and make every caller re-render on queue changes.
  // eslint-disable-next-line react-hooks/exhaustive-deps
  // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref
  useEffect(() => {
    if (store.getState().notifications.queue.length > 0) {
      processQueue();
    }
  }, []);
  return {
    addNotification,
    removeNotification
  };
}
const PRIORITIES: Record<Priority, number> = {
  immediate: 0,
  high: 1,
  medium: 2,
  low: 3
};
export function getNext(queue: Notification[]): Notification | undefined {
  if (queue.length === 0) return undefined;
  return queue.reduce((min, n) => PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useAppStateStore","useSetAppState","Theme","Priority","BaseNotification","key","invalidates","priority","timeoutMs","fold","accumulator","Notification","incoming","TextNotification","text","color","JSXNotification","jsx","ReactNode","AddNotificationFn","content","RemoveNotificationFn","DEFAULT_TIMEOUT_MS","currentTimeoutId","NodeJS","Timeout","useNotifications","addNotification","removeNotification","store","setAppState","processQueue","prev","next","getNext","notifications","queue","current","setTimeout","nextKey","filter","_","notif","clearTimeout","includes","folded","foldedKey","p","queueIdx","findIndex","newQueue","queuedKeys","Set","map","shouldAdd","has","invalidatesCurrent","isCurrent","inQueue","some","n","getState","length","PRIORITIES","Record","immediate","high","medium","low","undefined","reduce","min"],"sources":["notifications.tsx"],"sourcesContent":["import type * as React from 'react'\nimport { useCallback, useEffect } from 'react'\nimport { useAppStateStore, useSetAppState } from 'src/state/AppState.js'\nimport type { Theme } from '../utils/theme.js'\n\ntype Priority = 'low' | 'medium' | 'high' | 'immediate'\n\ntype BaseNotification = {\n  key: string\n  /**\n   * Keys of notifications that this notification invalidates.\n   * If a notification is invalidated, it will be removed from the queue\n   * and, if currently displayed, cleared immediately.\n   */\n  invalidates?: string[]\n  priority: Priority\n  timeoutMs?: number\n  /**\n   * Combine notifications with the same key, like Array.reduce().\n   * Called as fold(accumulator, incoming) when a notification with a matching\n   * key already exists in the queue or is currently displayed.\n   * Returns the merged notification (should carry fold forward for future merges).\n   */\n  fold?: (accumulator: Notification, incoming: Notification) => Notification\n}\n\ntype TextNotification = BaseNotification & {\n  text: string\n  color?: keyof Theme\n}\n\ntype JSXNotification = BaseNotification & {\n  jsx: React.ReactNode\n}\n\ntype AddNotificationFn = (content: Notification) => void\ntype RemoveNotificationFn = (key: string) => void\n\nexport type Notification = TextNotification | JSXNotification\n\nconst DEFAULT_TIMEOUT_MS = 8000\n\n// Track current timeout to clear it when immediate notifications arrive\nlet currentTimeoutId: NodeJS.Timeout | null = null\n\nexport function useNotifications(): {\n  addNotification: AddNotificationFn\n  removeNotification: RemoveNotificationFn\n} {\n  const store = useAppStateStore()\n  const setAppState = useSetAppState()\n\n  // Process queue when current notification finishes or queue changes\n  const processQueue = useCallback(() => {\n    setAppState(prev => {\n      const next = getNext(prev.notifications.queue)\n      if (prev.notifications.current !== null || !next) {\n        return prev\n      }\n\n      currentTimeoutId = setTimeout(\n        (setAppState, nextKey, processQueue) => {\n          currentTimeoutId = null\n          setAppState(prev => {\n            // Compare by key instead of reference to handle re-created notifications\n            if (prev.notifications.current?.key !== nextKey) {\n              return prev\n            }\n            return {\n              ...prev,\n              notifications: {\n                queue: prev.notifications.queue,\n                current: null,\n              },\n            }\n          })\n          processQueue()\n        },\n        next.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n        setAppState,\n        next.key,\n        processQueue,\n      )\n\n      return {\n        ...prev,\n        notifications: {\n          queue: prev.notifications.queue.filter(_ => _ !== next),\n          current: next,\n        },\n      }\n    })\n  }, [setAppState])\n\n  const addNotification = useCallback<AddNotificationFn>(\n    (notif: Notification) => {\n      // Handle immediate priority notifications\n      if (notif.priority === 'immediate') {\n        // Clear any existing timeout since we're showing a new immediate notification\n        if (currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        // Set up timeout for the immediate notification\n        currentTimeoutId = setTimeout(\n          (setAppState, notif, processQueue) => {\n            currentTimeoutId = null\n            setAppState(prev => {\n              // Compare by key instead of reference to handle re-created notifications\n              if (prev.notifications.current?.key !== notif.key) {\n                return prev\n              }\n              return {\n                ...prev,\n                notifications: {\n                  queue: prev.notifications.queue.filter(\n                    _ => !notif.invalidates?.includes(_.key),\n                  ),\n                  current: null,\n                },\n              }\n            })\n            processQueue()\n          },\n          notif.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n          setAppState,\n          notif,\n          processQueue,\n        )\n\n        // Show the immediate notification right away\n        setAppState(prev => ({\n          ...prev,\n          notifications: {\n            current: notif,\n            queue:\n              // Only re-queue the current notification if it's not immediate\n              [\n                ...(prev.notifications.current\n                  ? [prev.notifications.current]\n                  : []),\n                ...prev.notifications.queue,\n              ].filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n          },\n        }))\n        return // IMPORTANT: Exit addNotification for immediate notifications\n      }\n\n      // Handle non-immediate notifications\n      setAppState(prev => {\n        // Check if we can fold into an existing notification with the same key\n        if (notif.fold) {\n          // Fold into current notification if keys match\n          if (prev.notifications.current?.key === notif.key) {\n            const folded = notif.fold(prev.notifications.current, notif)\n            // Reset timeout for the folded notification\n            if (currentTimeoutId) {\n              clearTimeout(currentTimeoutId)\n              currentTimeoutId = null\n            }\n            currentTimeoutId = setTimeout(\n              (setAppState, foldedKey, processQueue) => {\n                currentTimeoutId = null\n                setAppState(p => {\n                  if (p.notifications.current?.key !== foldedKey) {\n                    return p\n                  }\n                  return {\n                    ...p,\n                    notifications: {\n                      queue: p.notifications.queue,\n                      current: null,\n                    },\n                  }\n                })\n                processQueue()\n              },\n              folded.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n              setAppState,\n              folded.key,\n              processQueue,\n            )\n\n            return {\n              ...prev,\n              notifications: {\n                current: folded,\n                queue: prev.notifications.queue,\n              },\n            }\n          }\n\n          // Fold into queued notification if keys match\n          const queueIdx = prev.notifications.queue.findIndex(\n            _ => _.key === notif.key,\n          )\n          if (queueIdx !== -1) {\n            const folded = notif.fold(\n              prev.notifications.queue[queueIdx]!,\n              notif,\n            )\n            const newQueue = [...prev.notifications.queue]\n            newQueue[queueIdx] = folded\n            return {\n              ...prev,\n              notifications: {\n                current: prev.notifications.current,\n                queue: newQueue,\n              },\n            }\n          }\n        }\n\n        // Only add to queue if not already present (prevent duplicates)\n        const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key))\n        const shouldAdd =\n          !queuedKeys.has(notif.key) &&\n          prev.notifications.current?.key !== notif.key\n\n        if (!shouldAdd) return prev\n\n        const invalidatesCurrent =\n          prev.notifications.current !== null &&\n          notif.invalidates?.includes(prev.notifications.current.key)\n\n        if (invalidatesCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: invalidatesCurrent ? null : prev.notifications.current,\n            queue: [\n              ...prev.notifications.queue.filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n              notif,\n            ],\n          },\n        }\n      })\n\n      // Process queue after adding the notification\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  const removeNotification = useCallback<RemoveNotificationFn>(\n    (key: string) => {\n      setAppState(prev => {\n        const isCurrent = prev.notifications.current?.key === key\n        const inQueue = prev.notifications.queue.some(n => n.key === key)\n\n        if (!isCurrent && !inQueue) {\n          return prev\n        }\n\n        if (isCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: isCurrent ? null : prev.notifications.current,\n            queue: prev.notifications.queue.filter(n => n.key !== key),\n          },\n        }\n      })\n\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  // Process queue on mount if there are notifications in the initial state.\n  // Imperative read (not useAppState) — a subscription in a mount-only\n  // effect would be vestigial and make every caller re-render on queue changes.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref\n  useEffect(() => {\n    if (store.getState().notifications.queue.length > 0) {\n      processQueue()\n    }\n  }, [])\n\n  return { addNotification, removeNotification }\n}\n\nconst PRIORITIES: Record<Priority, number> = {\n  immediate: 0,\n  high: 1,\n  medium: 2,\n  low: 3,\n}\nexport function getNext(queue: Notification[]): Notification | undefined {\n  if (queue.length === 0) return undefined\n  return queue.reduce((min, n) =>\n    PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min,\n  )\n}\n"],"mappings":"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","ignoreList":[]}
