starr-philproperties/src/modules/admin/components/users/ArchiveUserTable.jsx

import { useMemo, useRef, useState } from "react";
import { useNavigate } from "react-router-dom";

import { useUsers } from "@/contexts/AdminUserContext";
import { useAuth } from "@/contexts/AuthContext";
import DataTable from "@/components/generic/Table/DataTable";
import { FilterSheet } from "@/components/generic/Sheet/FilterSheet";
import { RestoreDialog } from "@/components/generic/Dialogs/RestoreDialog";
import { PermanentDeleteDialog } from "@/components/generic/Dialogs/PermanentDeleteDialog";

import { buildUserColumns, columnPinning } from "../../config/users/archive/columns.config";
import { buildToolbarActions } from "../../config/users/archive/toolbar.config";
import { buildSelectionActions } from "../../config/users/archive/selection.config";
import { buildRowActions } from "../../config/users/archive/rowActions.config";

import { getTimestamp } from "@/utils/timestamp.util";
import { formatGeneratedBy } from "@/utils/generatedBy.util";

export default function ArchiveGroupTable() {
    const [restoreTarget, setRestoreTarget] = useState(null);   // single: row object
    const [restoreIds, setRestoreIds] = useState(null);          // bulk: array of ids
    const [deleteTarget, setDeleteTarget] = useState(null);
    const [deleteIds, setDeleteIds] = useState(null);
    const tableRefsRef = useRef({ getFilters: () => [], getSort: () => [], resetSelection: () => { } });
    const navigate = useNavigate();
    const { user: currentUser } = useAuth();

    const {
        users,
        attributes,
        pagination,
        setPagination,
        loading,
        fetchArchivedUsers,
        fetchUserFieldValues,
        restoreUser,
        restoreUsers,
        permanentlyDeleteUser,
        permanentlyDeleteUsers
    } = useUsers();

    // Shared export config — passed into toolbar + selection configs
    const exportConfig = {
        allData: users,
        attributes,
        filename: `${getTimestamp()}_ArchivedUserGroups`,
        sheetName: "ArchivedUserGroups",
        generatedBy: formatGeneratedBy(currentUser),
    };

    const rowActions = buildRowActions({
        navigate,
        onRestore: (row) => setRestoreTarget(row),
        onDelete: (row) => setDeleteTarget(row),
    });
    const toolbarActions = buildToolbarActions({
        fetchArchivedUsers, pagination, exportConfig, navigate,
        getFilters: () => tableRefsRef.current.getFilters(),
        getSort: () => tableRefsRef.current.getSort(),
        getTableInstance: () => tableRefsRef.current.tableInstance,
    });
    const selectionActions = buildSelectionActions({
        exportConfig,
        restoreUser: (row) => setRestoreTarget(row),
        restoreUsers: (ids) => setRestoreIds(ids),
        onDeleteUser: (row) => setDeleteTarget(row),
        onDeleteUsers: (ids) => setDeleteIds(ids),
        getTableInstance: () => tableRefsRef.current.tableInstance,
    });

    const columns = useMemo(() => buildUserColumns(attributes, rowActions), [attributes]);

    const handleRestoreSuccess = () => {
        setRestoreTarget(null);
        setRestoreIds(null);
        tableRefsRef.current.resetSelection?.();   // ← clear selection
        fetchArchivedUsers({ page: 1, limit: pagination.limit });
    };

    const handleDeleteSuccess = () => {
        setDeleteTarget(null);
        setDeleteIds(null);
        tableRefsRef.current.resetSelection?.();
        fetchArchivedUsers({ page: 1, limit: pagination.limit });
    };

    return (
        <>
            <DataTable
                title="Archived Users"
                data={users}
                columns={columns}
                attributes={attributes}
                pagination={pagination}
                setPagination={setPagination}
                loading={loading}
                onFetch={fetchArchivedUsers}
                onFetchFilterData={fetchUserFieldValues}
                onRefsReady={(refs) => tableRefsRef.current = refs}
                renderFilterSheet={({ open, onOpenChange, column, attr, data, loading }) => (
                    <FilterSheet
                        open={open}
                        onOpenChange={onOpenChange}
                        column={column}
                        attr={attr}
                        data={data}
                        loading={loading}
                    />
                )}
                columnPinning={columnPinning}
                toolbarActions={toolbarActions}
                selectionActions={selectionActions}
                recordLabel="user"
                emptyMessage="No users match the current filters."
            />

            {/* Single restore */}
            <RestoreDialog
                open={!!restoreTarget}
                onOpenChange={(v) => !v && setRestoreTarget(null)}
                entity={restoreTarget}
                entityLabel="User"
                getName={(u) => u?.personal_info?.name?.full_name ?? u?.email}
                onRestore={(u) => restoreUser(u?.user_id)}
                loading={loading}
                onSuccess={handleRestoreSuccess}
            />

            {/* Bulk restore */}
            <RestoreDialog
                open={!!restoreIds}
                onOpenChange={(v) => !v && setRestoreIds(null)}
                ids={restoreIds ?? []}
                entityLabel="User"
                onRestore={restoreUsers}
                loading={loading}
                onSuccess={handleRestoreSuccess}
            />

            {/* Single permanent delete */}
            <PermanentDeleteDialog
                open={!!deleteTarget}
                onOpenChange={(v) => !v && setDeleteTarget(null)}
                entity={deleteTarget}
                entityLabel="User"
                getName={(u) => u?.personal_info?.name?.full_name ?? u?.email}
                onDelete={(u) => permanentlyDeleteUser(u?.user_id)}
                loading={loading}
                onSuccess={handleDeleteSuccess}
            />

            {/* Bulk permanent delete */}
            <PermanentDeleteDialog
                open={!!deleteIds}
                onOpenChange={(v) => !v && setDeleteIds(null)}
                ids={deleteIds ?? []}
                entityLabel="User"
                onDelete={permanentlyDeleteUsers}
                loading={loading}
                onSuccess={handleDeleteSuccess}
            />
        </>
    );
}