'use client';

import React, { createContext, useContext, useState, useCallback, useMemo } from 'react';

interface BulkSelectionContextType {
    selectedIds: string[];
    isAllInQueueSelected: boolean;
    totalInQueue: number;
    toggleSelection: (id: string) => void;
    setPageSelection: (ids: string[], selected: boolean) => void;
    setAllInQueueSelection: (total: number, selected: boolean) => void;
    clearSelection: () => void;
    setTotalInQueue: (total: number) => void;
    selectedCount: number;
}

const BulkSelectionContext = createContext<BulkSelectionContextType | undefined>(undefined);

export function BulkSelectionProvider({ children }: { children: React.ReactNode }) {
    const [selectedIds, setSelectedIds] = useState<string[]>([]);
    const [isAllInQueueSelected, setIsAllInQueueSelected] = useState(false);
    const [totalInQueue, setTotalInQueue] = useState(0);

    const toggleSelection = useCallback((id: string) => {
        setIsAllInQueueSelected(false); // Reset "Select All In Queue" if any individual is toggled
        setSelectedIds(prev =>
            prev.includes(id)
                ? prev.filter(currentId => currentId !== id)
                : [...prev, id]
        );
    }, []);

    const setPageSelection = useCallback((ids: string[], selected: boolean) => {
        setIsAllInQueueSelected(false);
        setSelectedIds(prev => {
            if (selected) {
                // Add all ids from page that aren't already selected
                const newIds = ids.filter(id => !prev.includes(id));
                return [...prev, ...newIds];
            } else {
                // Remove all ids from page
                return prev.filter(id => !ids.includes(id));
            }
        });
    }, []);

    const setAllInQueueSelection = useCallback((total: number, selected: boolean) => {
        setIsAllInQueueSelected(selected);
        setTotalInQueue(selected ? total : 0);
        setSelectedIds([]); // Clear individual selections
    }, []);

    const clearSelection = useCallback(() => {
        setSelectedIds([]);
        setIsAllInQueueSelected(false);
        setTotalInQueue(0);
    }, []);

    const selectedCount = useMemo(() => {
        return isAllInQueueSelected ? totalInQueue : selectedIds.length;
    }, [isAllInQueueSelected, totalInQueue, selectedIds.length]);

    const value = useMemo(() => ({
        selectedIds,
        isAllInQueueSelected,
        totalInQueue,
        toggleSelection,
        setPageSelection,
        setAllInQueueSelection,
        clearSelection,
        setTotalInQueue,
        selectedCount
    }), [
        selectedIds,
        isAllInQueueSelected,
        totalInQueue,
        toggleSelection,
        setPageSelection,
        setAllInQueueSelection,
        clearSelection,
        setTotalInQueue,
        selectedCount
    ]);

    return (
        <BulkSelectionContext.Provider value={value}>
            {children}
        </BulkSelectionContext.Provider>
    );
}

export function useBulkSelection() {
    const context = useContext(BulkSelectionContext);
    if (context === undefined) {
        throw new Error('useBulkSelection must be used within a BulkSelectionProvider');
    }
    return context;
}
