dashboard-context.tsx

import React, { createContext, useContext, useState, useEffect, useCallback, useRef, useMemo } from 'react';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { useConnection } from './connection-context';
import { useToast } from './toast-context';
import { ColumnInfo } from '@/types';
import { type MutationRequest } from '@/lib/mutation';
import { type Filter } from '@/lib/filters';
import type { SavedQuery } from '@/types';
import { useSavedQueries } from '../hooks/use-saved-queries';
import { db } from '@/lib/db';
import { type TableStatsData } from '../components/table-stats';
import { type Tab } from '../components/tab-bar';

interface DashboardContextType {
  openTabs: Tab[];
  activeTabId: string | undefined;
  openTab: (name: string, type?: Tab['type']) => void;
  closeTab: (tabId: string) => void;
  setActiveTab: (tabId: string) => void;
  closeAllTabs: () => void;
  closeOtherTabs: (tabId: string) => void;
  reorderTabs: (fromId: string, toId: string) => void;
  toggleTabPin: (tabId: string) => void;
  tables: string[];
  schemas: string[];
  selectedSchema: string;
  selectedTable: string | undefined;
  tableData: any[];
  columns: string[];
  schema: ColumnInfo[];
  views: string[];
  materializedViews: string[];
  dbFunctions: any[];
  relationships: any[];
  indexes: any[];
  isLoadingTables: boolean;
  isLoading: boolean;
  isLoadingSchema: boolean;
  currentPage: number;
  totalItems: number;
  countIsEstimate: boolean;
  sortColumn: string | null;
  sortDirection: 'asc' | 'desc' | null;
  visibleColumns: string[];
  tableSearch: string;
  tableFilters: Filter[];
  setTableFilters: React.Dispatch<React.SetStateAction<Filter[]>>;
  addTableFilter: (filter: Filter) => void;
  removeTableFilter: (column: string) => void;
  clearTableFilters: () => void;
  error: string | null;
  itemsPerPage: number;
  setItemsPerPage: (size: number) => void;
  primaryKeys: string[];
  tableStats: TableStatsData | null;
  isLoadingStats: boolean;
  schemaMap: Record<string, string[]>;
  tableRowCounts: Record<string, number>;
  setSelectedSchema: (schema: string) => void;
  setSelectedTable: (table: string | undefined) => void;
  setCurrentPage: (page: number) => void;
  setSortColumn: (col: string | null) => void;
  setSortDirection: (dir: 'asc' | 'desc' | null) => void;
  setVisibleColumns: React.Dispatch<React.SetStateAction<string[]>>;
  setTableSearch: (search: string) => void;
  loadTables: (schema?: string) => Promise<void>;
  loadTableData: (tableName: string, page: number) => Promise<void>;
  loadTableSchema: (tableName: string) => Promise<void>;
  loadRelationships: (tableName: string) => Promise<void>;
  handleSchemaChange: (schema: string) => void;
  handleTableSelect: (table: string) => void;
  handleSort: (column: string) => void;
  mutateRow: (request: MutationRequest) => Promise<void>;
  refreshTableData: () => Promise<void>;
  openQueryTab: (label: string, rows: any[], cols: string[], executionTime: number) => void;
  queryTabResults: Record<string, { rows: any[]; columns: string[]; executionTime: number }>;
  isQueryTab: boolean;
  openEditorTab: (initialQuery?: string) => void;
  isEditorTab: boolean;
  savedQueries: SavedQuery[];
  saveQuery: (name: string, query: string, tags: string[]) => void;
  updateSavedQuery: (id: string, updates: Partial<Pick<SavedQuery, 'name' | 'query' | 'tags'>>) => void;
  deleteSavedQuery: (id: string) => void;
}

const DashboardContext = createContext<DashboardContextType | undefined>(undefined);

// Per-tab UI state (not data — TanStack caches the data)
interface TabUIState {
  currentPage: number;
  sortColumn: string | null;
  sortDirection: 'asc' | 'desc' | null;
  visibleColumns: string[];
  tableSearch: string;
  tableFilters: Filter[];
}

export function DashboardProvider({ children }: { children: React.ReactNode }) {
  const { isConnected, databaseType, databaseName } = useConnection();
  const { addToast } = useToast();
  const queryClient = useQueryClient();
  const [itemsPerPage, setItemsPerPage] = useState(100);
  const {
    savedQueries,
    saveQuery,
    updateQuery: updateSavedQuery,
    deleteQuery: deleteSavedQuery,
  } = useSavedQueries();

  // UI state
  const [selectedTable, setSelectedTable] = useState<string | undefined>();
  const [selectedSchema, setSelectedSchema] = useState('public');
  const [currentPage, setCurrentPage] = useState(1);
  const [sortColumn, setSortColumn] = useState<string | null>(null);
  const [sortDirection, setSortDirection] = useState<'asc' | 'desc' | null>(null);
  const [visibleColumns, setVisibleColumns] = useState<string[]>([]);
  const [tableSearch, setTableSearch] = useState('');
  const [tableFilters, setTableFilters] = useState<Filter[]>([]);
  const [openTabs, setOpenTabs] = useState<Tab[]>([]);
  const [activeTabId, setActiveTabId] = useState<string | undefined>();
  const [queryTabResults, setQueryTabResults] = useState<Record<string, { rows: any[]; columns: string[]; executionTime: number }>>({});

  // Per-tab UI state cache
  const tabUIStateRef = useRef<Record<string, TabUIState>>({});

  const saveCurrentTabUIState = useCallback(() => {
    if (!activeTabId) return;
    tabUIStateRef.current[activeTabId] = {
      currentPage,
      sortColumn,
      sortDirection,
      visibleColumns,
      tableSearch,
      tableFilters,
    };
  }, [activeTabId, currentPage, sortColumn, sortDirection, visibleColumns, tableSearch, tableFilters]);

  const restoreTabUIState = useCallback((tabId: string): boolean => {
    const cached = tabUIStateRef.current[tabId];
    if (!cached) return false;
    setCurrentPage(cached.currentPage);
    setSortColumn(cached.sortColumn);
    setSortDirection(cached.sortDirection);
    setVisibleColumns(cached.visibleColumns);
    setTableSearch(cached.tableSearch);
    setTableFilters(cached.tableFilters ?? []);
    return true;
  }, []);

  const clearTabUIState = useCallback((tabId: string) => {
    delete tabUIStateRef.current[tabId];
  }, []);

  // Tracks which database we've already restored tabs for, so we can gate
  // localStorage writes until the one-shot restore has completed.
  const tabsRestoredForRef = useRef<string | null>(null);
  // Track which database we last set the default schema for. Resetting on
  // databaseName change (not just on isConnected toggling off) is what
  // makes Connections→another-DB without an explicit Disconnect work
  // correctly. Previously `hasLoadedRef` was a once-per-session gate that
  // never re-fired when the user swapped from a SQLite session to a
  // Postgres one — `selectedSchema` stayed stuck at `main` against
  // Postgres and every catalog query came back empty.
  // Track the (databaseName, databaseType) tuple we last initialized for.
  // Resetting on either change covers both "switched to a different DB"
  // and "the backend kind changed underneath us" (e.g. saved connection
  // round-trip lost the type and is now corrected).
  const schemaInitializedForRef = useRef<string | null>(null);
  useEffect(() => {
    if (isConnected && databaseName) {
      const key = `${databaseType}::${databaseName}`;
      if (schemaInitializedForRef.current !== key) {
        schemaInitializedForRef.current = key;
        const defaultSchema = databaseType === 'sqlite'
          ? 'main'
          : databaseType === 'mysql' && databaseName ? databaseName : 'public';
        setSelectedSchema(defaultSchema);
      }
    }
    if (!isConnected) {
      schemaInitializedForRef.current = null;
      tabsRestoredForRef.current = null;
      setSelectedTable(undefined);
      setOpenTabs([]);
      setActiveTabId(undefined);
      queryClient.clear();
    }
  }, [isConnected, databaseType, databaseName, queryClient]);

  // Restore persisted tabs once per database connection. Tabs are stored
  // per-database so switching DBs swaps the whole set; if the target DB has
  // no saved tabs we clear the bar instead of leaking the previous DB's
  // tabs (which point at tables that may not exist in the new schema).
  useEffect(() => {
    if (!isConnected || !databaseName) return;
    if (tabsRestoredForRef.current === databaseName) return;
    const isSwitching = tabsRestoredForRef.current !== null;
    tabsRestoredForRef.current = databaseName;
    // Switching DBs — drop any cached table data from the previous one so
    // a same-named table in the new DB doesn't render stale rows.
    if (isSwitching) queryClient.clear();
    let restored = false;
    try {
      const raw = localStorage.getItem(`dbview-tabs-${databaseName}`);
      if (raw) {
        const parsed = JSON.parse(raw) as { openTabs?: Tab[]; activeTabId?: string };
        if (Array.isArray(parsed.openTabs)) {
          setOpenTabs(parsed.openTabs);
          setActiveTabId(parsed.activeTabId);
          const active = parsed.openTabs.find((t) => t.id === parsed.activeTabId);
          if (active && active.type === 'table') {
            setSelectedTable(active.label);
          } else {
            setSelectedTable(undefined);
          }
          restored = true;
        }
      }
    } catch {
      // corrupt entry — fall through to the clean-slate path below
    }
    if (!restored) {
      setOpenTabs([]);
      setActiveTabId(undefined);
      setSelectedTable(undefined);
      tabUIStateRef.current = {};
    }
  }, [isConnected, databaseName, queryClient]);

  // Persist tab bar whenever it changes (after restore has completed).
  useEffect(() => {
    if (!isConnected || !databaseName) return;
    if (tabsRestoredForRef.current !== databaseName) return;
    try {
      localStorage.setItem(
        `dbview-tabs-${databaseName}`,
        JSON.stringify({ openTabs, activeTabId })
      );
    } catch {
      // quota exceeded or storage disabled — best effort
    }
  }, [openTabs, activeTabId, isConnected, databaseName]);

  const schemasQuery = useQuery({
    queryKey: ['schemas'],
    queryFn: () => db.listSchemas(),
    enabled: isConnected,
  });

  const tablesQuery = useQuery({
    queryKey: ['tables', selectedSchema],
    queryFn: () => db.listTables(selectedSchema),
    enabled: isConnected,
  });

  const viewsQuery = useQuery({
    queryKey: ['views', selectedSchema],
    queryFn: () => db.listViews(selectedSchema),
    enabled: isConnected,
  });

  const functionsQuery = useQuery({
    queryKey: ['functions', selectedSchema],
    queryFn: () => db.listFunctions(selectedSchema),
    enabled: isConnected,
  });

  const schemaMapQuery = useQuery({
    queryKey: ['schemaMap', selectedSchema],
    queryFn: () => db.schemaMap(selectedSchema),
    enabled: isConnected,
  });

  const tableCountsQuery = useQuery({
    queryKey: ['tableCounts', selectedSchema],
    queryFn: () => db.tableCounts(selectedSchema),
    enabled: isConnected,
    // Counts are estimates (Postgres reltuples / MySQL TABLE_ROWS) — keep
    // them cached aggressively to avoid hammering the catalog on every
    // sidebar mount.
    staleTime: 1000 * 60 * 5,
  });

  const tableDataQuery = useQuery({
    queryKey: ['tableData', selectedTable, selectedSchema, currentPage, sortColumn, sortDirection, itemsPerPage, tableFilters],
    queryFn: async () => {
      const offset = (currentPage - 1) * itemsPerPage;
      const data = await db.tableRows({
        table: selectedTable!,
        schema: selectedSchema,
        limit: itemsPerPage,
        offset,
        sortColumn: sortColumn ?? undefined,
        sortDirection: sortDirection ?? undefined,
        filters: tableFilters,
      });
      const rows = data.rows || [];
      const cols = rows.length > 0 ? Object.keys(rows[0]) : [];
      return {
        rows,
        columns: cols,
        total: data.total || 0,
        countIsEstimate: data.countIsEstimate || false,
      };
    },
    enabled: isConnected && !!selectedTable,
  });

  const tableSchemaQuery = useQuery({
    queryKey: ['tableSchema', selectedTable, selectedSchema],
    queryFn: async () => {
      const cols = await db.tableSchema(selectedTable!, selectedSchema);
      return (cols as any[]).map((row: any) => ({
        name: row.column_name ?? row.name,
        type: row.data_type ?? row.type,
        nullable: row.is_nullable === 'YES' || row.nullable === true,
        default: row.column_default ?? row.default ?? null,
        isPrimaryKey: row.is_primary_key ?? row.isPrimaryKey ?? false,
      })) as ColumnInfo[];
    },
    enabled: isConnected && !!selectedTable,
  });

  const relationshipsQuery = useQuery({
    queryKey: ['relationships', selectedTable, selectedSchema],
    queryFn: () => db.relationships(selectedTable!, selectedSchema),
    enabled: isConnected && !!selectedTable,
  });

  const tableStatsQuery = useQuery({
    queryKey: ['tableStats', selectedTable, selectedSchema],
    queryFn: () => db.tableStats(selectedTable!, selectedSchema) as Promise<TableStatsData | null>,
    enabled: isConnected && !!selectedTable,
  });

  const tables = tablesQuery.data ?? [];
  const schemas = schemasQuery.data ?? [];
  const tableData = tableDataQuery.data?.rows ?? [];
  // Prefer columns inferred from the first row (preserves the actual return
  // order from the DB). For empty tables there are no rows to infer from, so
  // fall back to the schema metadata — without this DataTable receives an
  // empty columns array and renders neither headers nor the empty-row
  // affordance, leaving a blank panel.
  const columns = useMemo(() => {
    const fromRows = tableDataQuery.data?.columns ?? [];
    if (fromRows.length > 0) return fromRows;
    return (tableSchemaQuery.data ?? []).map((c) => c.name);
  }, [tableDataQuery.data?.columns, tableSchemaQuery.data]);
  const totalItems = tableDataQuery.data?.total ?? 0;
  const countIsEstimate = tableDataQuery.data?.countIsEstimate ?? false;
  const schema = useMemo(() => tableSchemaQuery.data ?? [], [tableSchemaQuery.data]);
  const views = viewsQuery.data?.views ?? [];
  const materializedViews = viewsQuery.data?.materializedViews ?? [];
  const dbFunctions = functionsQuery.data ?? [];
  const relationships = relationshipsQuery.data?.relationships ?? [];
  const indexes = relationshipsQuery.data?.indexes ?? [];
  const schemaMap = schemaMapQuery.data ?? {};
  const tableRowCounts = tableCountsQuery.data ?? {};
  const tableStats = tableStatsQuery.data ?? null;

  const isLoadingTables = tablesQuery.isLoading;
  // `isFetching` covers reload-button refetches (when there's already
  // cached data); `isLoading` alone would only spin on first load.
  const isLoading = tableDataQuery.isLoading || tableDataQuery.isFetching;
  const isLoadingSchema = tableSchemaQuery.isLoading;
  const isLoadingStats = tableStatsQuery.isLoading;

  const error = tableDataQuery.error?.message ?? tablesQuery.error?.message ?? null;

  // Set visibleColumns when table data loads
  useEffect(() => {
    if (columns.length > 0 && visibleColumns.length === 0) {
      setVisibleColumns(columns);
    }
  }, [columns, visibleColumns.length]);

  const primaryKeys = useMemo(() => {
    return schema.filter((col) => col.isPrimaryKey).map((col) => col.name);
  }, [schema]);

  const addTableFilter = useCallback((filter: Filter) => {
    setTableFilters((prev) => {
      // Replace any existing filter on the same column — single filter per
      // column for v1 keeps the UI simple. Multi-condition is a follow-up.
      const without = prev.filter((f) => f.column !== filter.column);
      return [...without, filter];
    });
    setCurrentPage(1);
  }, []);

  const removeTableFilter = useCallback((column: string) => {
    setTableFilters((prev) => prev.filter((f) => f.column !== column));
    setCurrentPage(1);
  }, []);

  const clearTableFilters = useCallback(() => {
    setTableFilters([]);
    setCurrentPage(1);
  }, []);

  const loadTables = useCallback(async (schemaName?: string) => {
    if (schemaName && schemaName !== selectedSchema) {
      // Will be handled by query key change after setSelectedSchema
      return;
    }
    await queryClient.invalidateQueries({ queryKey: ['tables', schemaName || selectedSchema] });
  }, [queryClient, selectedSchema]);

  const loadTableData = useCallback(async (tableName: string, _page: number) => {
    await queryClient.invalidateQueries({ queryKey: ['tableData', tableName] });
  }, [queryClient]);

  const loadTableSchema = useCallback(async (tableName: string) => {
    await queryClient.invalidateQueries({ queryKey: ['tableSchema', tableName] });
  }, [queryClient]);

  const loadRelationshipsImperative = useCallback(async (tableName: string) => {
    await queryClient.invalidateQueries({ queryKey: ['relationships', tableName] });
  }, [queryClient]);

  const refreshTableData = useCallback(async () => {
    if (!selectedTable) return;
    // Use refetchQueries (not invalidateQueries) so the network call fires
    // synchronously. invalidateQueries only marks the cache stale, which
    // races against component-mount observation — feels broken to users
    // who click the reload button on a table they're already viewing.
    await queryClient.refetchQueries({ queryKey: ['tableData', selectedTable] });
  }, [selectedTable, queryClient]);

  const mutateRow = useCallback(async (request: MutationRequest) => {
    await db.mutate(request);
    addToast(`${request.type} successful`, 'success');
    await refreshTableData();
  }, [addToast, refreshTableData]);

  const openTab = useCallback((name: string, type: Tab['type'] = 'table') => {
    const tabId = `${type}:${name}`;
    if (tabId === activeTabId) return;
    saveCurrentTabUIState();
    setOpenTabs((prev) => {
      if (prev.some((t) => t.id === tabId)) return prev;
      return [...prev, { id: tabId, label: name, type }];
    });
    setActiveTabId(tabId);
    setSelectedTable(name);
    if (!restoreTabUIState(tabId)) {
      setCurrentPage(1);
      setSortColumn(null);
      setSortDirection(null);
      setVisibleColumns([]);
      setTableSearch('');
      setTableFilters([]);
    }
  }, [activeTabId, saveCurrentTabUIState, restoreTabUIState]);

  const closeTab = useCallback((tabId: string) => {
    clearTabUIState(tabId);
    if (tabId.startsWith('query:')) {
      setQueryTabResults((prev) => {
        const next = { ...prev };
        delete next[tabId];
        return next;
      });
    }
    if (tabId.startsWith('editor:') && typeof window !== 'undefined') {
      try {
        localStorage.removeItem(`dbview-editor-${tabId}`);
      } catch {
        // ignore
      }
    }
    setOpenTabs((prev) => {
      const next = prev.filter((t) => t.id !== tabId);
      if (tabId === activeTabId) {
        const closedIndex = prev.findIndex((t) => t.id === tabId);
        const newActive = next[Math.min(closedIndex, next.length - 1)];
        if (newActive) {
          setActiveTabId(newActive.id);
          if (newActive.type === 'query' || newActive.type === 'editor') {
            setSelectedTable(undefined);
          } else {
            setSelectedTable(newActive.label);
            if (!restoreTabUIState(newActive.id)) {
              setCurrentPage(1);
              setSortColumn(null);
              setSortDirection(null);
              setVisibleColumns([]);
              setTableSearch('');
              setTableFilters([]);
            }
          }
        } else {
          setActiveTabId(undefined);
          setSelectedTable(undefined);
        }
      }
      return next;
    });
  }, [activeTabId, clearTabUIState, restoreTabUIState]);

  const setActiveTab = useCallback((tabId: string) => {
    if (tabId === activeTabId) return;
    saveCurrentTabUIState();
    setActiveTabId(tabId);
    setOpenTabs((prev) => {
      const tab = prev.find((t) => t.id === tabId);
      if (tab) {
        if (tab.type === 'query' || tab.type === 'editor') {
          setSelectedTable(undefined);
        } else {
          setSelectedTable(tab.label);
          if (!restoreTabUIState(tabId)) {
            setCurrentPage(1);
            setSortColumn(null);
            setSortDirection(null);
            setVisibleColumns([]);
            setTableSearch('');
            setTableFilters([]);
          }
        }
      }
      return prev;
    });
  }, [activeTabId, saveCurrentTabUIState, restoreTabUIState]);

  const editorCounterRef = useRef(0);
  const openEditorTab = useCallback((initialQuery?: string) => {
    editorCounterRef.current += 1;
    const tabId = `editor:${Date.now()}_${editorCounterRef.current}`;
    const label = `SQL Editor ${editorCounterRef.current}`;
    if (initialQuery && typeof window !== 'undefined') {
      // Seed the per-tab editor storage so QueryEditor reads it on mount.
      try {
        localStorage.setItem(`dbview-editor-${tabId}`, initialQuery);
      } catch {
        // ignore
      }
    }
    saveCurrentTabUIState();
    setOpenTabs((prev) => [...prev, { id: tabId, label, type: 'editor' }]);
    setActiveTabId(tabId);
    setSelectedTable(undefined);
  }, [saveCurrentTabUIState]);

  const openQueryTab = useCallback((label: string, rows: any[], cols: string[], executionTime: number) => {
    const tabId = `query:${label}_${Date.now()}`;
    saveCurrentTabUIState();
    setOpenTabs((prev) => [...prev, { id: tabId, label, type: 'query' }]);
    setActiveTabId(tabId);
    setSelectedTable(undefined);
    setQueryTabResults((prev) => ({ ...prev, [tabId]: { rows, columns: cols, executionTime } }));
  }, [saveCurrentTabUIState]);

  const closeAllTabs = useCallback(() => {
    setOpenTabs([]);
    setActiveTabId(undefined);
    setSelectedTable(undefined);
    setQueryTabResults({});
  }, []);

  const closeOtherTabs = useCallback((tabId: string) => {
    setOpenTabs((prev) => prev.filter((t) => t.id === tabId));
    setActiveTabId(tabId);
  }, []);

  const reorderTabs = useCallback((fromId: string, toId: string) => {
    setOpenTabs((prev) => {
      const fromIdx = prev.findIndex((t) => t.id === fromId);
      const toIdx = prev.findIndex((t) => t.id === toId);
      if (fromIdx === -1 || toIdx === -1) return prev;
      const next = [...prev];
      const [moved] = next.splice(fromIdx, 1);
      next.splice(toIdx, 0, moved);
      return next;
    });
  }, []);

  const toggleTabPin = useCallback((tabId: string) => {
    setOpenTabs((prev) =>
      prev.map((t) => (t.id === tabId ? { ...t, pinned: !t.pinned } : t))
    );
  }, []);

  const handleSchemaChange = useCallback((newSchema: string) => {
    setSelectedSchema(newSchema);
    setSelectedTable(undefined);
    setOpenTabs([]);
    setActiveTabId(undefined);
  }, []);

  const handleTableSelect = useCallback((table: string) => {
    openTab(table, 'table');
  }, [openTab]);

  const handleSort = useCallback((column: string) => {
    if (sortColumn === column) {
      if (sortDirection === 'asc') {
        setSortDirection('desc');
      } else if (sortDirection === 'desc') {
        setSortColumn(null);
        setSortDirection(null);
      }
    } else {
      setSortColumn(column);
      setSortDirection('asc');
    }
    setCurrentPage(1);
  }, [sortColumn, sortDirection]);

  // Reset page on sort change
  useEffect(() => {
    setCurrentPage(1);
  }, [sortColumn, sortDirection]);

  return (
    <DashboardContext.Provider
      value={{
        openTabs,
        activeTabId,
        openTab,
        closeTab,
        setActiveTab,
        closeAllTabs,
        reorderTabs,
        toggleTabPin,
        closeOtherTabs,
        tables,
        schemas,
        selectedSchema,
        selectedTable,
        tableData,
        columns,
        schema,
        views,
        materializedViews,
        dbFunctions,
        relationships,
        indexes,
        isLoadingTables,
        isLoading,
        isLoadingSchema,
        currentPage,
        totalItems,
        countIsEstimate,
        sortColumn,
        sortDirection,
        visibleColumns,
        tableSearch,
        error,
        itemsPerPage,
        setItemsPerPage,
        primaryKeys,
        tableStats,
        isLoadingStats,
        schemaMap,
        tableRowCounts,
        setSelectedSchema,
        setSelectedTable,
        setCurrentPage,
        setSortColumn,
        setSortDirection,
        setVisibleColumns,
        setTableSearch,
        tableFilters,
        setTableFilters,
        addTableFilter,
        removeTableFilter,
        clearTableFilters,
        loadTables,
        loadTableData,
        loadTableSchema,
        loadRelationships: loadRelationshipsImperative,
        handleSchemaChange,
        handleTableSelect,
        handleSort,
        mutateRow,
        refreshTableData,
        openQueryTab,
        queryTabResults,
        isQueryTab: activeTabId?.startsWith('query:') ?? false,
        openEditorTab,
        isEditorTab: activeTabId?.startsWith('editor:') ?? false,
        savedQueries,
        saveQuery,
        updateSavedQuery,
        deleteSavedQuery,
      }}
    >
      {children}
    </DashboardContext.Provider>
  );
}

export function useDashboard() {
  const context = useContext(DashboardContext);
  if (context === undefined) {
    throw new Error('useDashboard must be used within a DashboardProvider');
  }
  return context;
}