IrisGridUtils.ts

import {
  type GridMetrics,
  type GridRange,
  type GridState,
  GridUtils,
  type ModelIndex,
  type ModelSizeMap,
  type MoveOperation,
  type VisibleIndex,
} from '@deephaven/grid';
import type { dh as DhType } from '@deephaven/jsapi-types';
import {
  DateUtils,
  TableUtils,
  type ReverseType,
  type SortDirection,
  type FormattingRule,
  type SortDescriptor,
} from '@deephaven/jsapi-utils';
import Log from '@deephaven/log';
import {
  assertNotNull,
  bindAllMethods,
  EMPTY_ARRAY,
  EMPTY_MAP,
  isNotNullOrUndefined,
} from '@deephaven/utils';
import AggregationUtils from './sidebar/aggregations/AggregationUtils';
import AggregationOperation from './sidebar/aggregations/AggregationOperation';
import { type FilterData, type IrisGridState } from './IrisGrid';
import {
  type ColumnName,
  type ReadonlyAdvancedFilterMap,
  type ReadonlyQuickFilterMap,
  type InputFilter,
  type CellData,
  type PendingDataMap,
  type UIRow,
  type AdvancedFilterOptions,
} from './CommonTypes';
import { type UIRollupConfig } from './sidebar/RollupRows';
import { type AggregationSettings } from './sidebar/aggregations/Aggregations';
import { type FormattingRule as SidebarFormattingRule } from './sidebar/conditional-formatting/ConditionalFormattingUtils';
import type IrisGridModel from './IrisGridModel';
import type AdvancedSettingsType from './sidebar/AdvancedSettingsType';
import AdvancedSettings from './sidebar/AdvancedSettings';
import ColumnHeaderGroup, {
  type ColumnHeaderGroupConfig,
} from './ColumnHeaderGroup';
import {
  isPartitionedGridModelProvider,
  type PartitionConfig,
} from './PartitionedGridModel';
import { type IrisGridThemeType } from './IrisGridTheme';

const log = Log.module('IrisGridUtils');

export type HydratedIrisGridState = Pick<
  IrisGridState,
  | 'advancedFilters'
  | 'aggregationSettings'
  | 'customColumnFormatMap'
  | 'columnAlignmentMap'
  | 'isFilterBarShown'
  | 'quickFilters'
  | 'customColumns'
  | 'reverse'
  | 'rollupConfig'
  | 'showSearchBar'
  | 'searchValue'
  | 'selectDistinctColumns'
  | 'selectedSearchColumns'
  | 'sorts'
  | 'invertSearchColumns'
  | 'pendingDataMap'
  | 'frozenColumns'
  | 'conditionalFormats'
  | 'columnHeaderGroups'
  | 'partitionConfig'
> & {
  metrics?: Partial<GridMetrics>;
};

export type DehydratedPendingDataMap<T> = [number, { data: [string, T][] }][];

export type DehydratedAdvancedFilter = [
  number,
  {
    options: AdvancedFilterOptions;
  },
];

export type DehydratedQuickFilter = [
  number,
  {
    text: string;
  },
];

export type DehydratedCustomColumnFormat = [string, FormattingRule];

export type DehydratedUserColumnAlignment = [string, CanvasTextAlign];

export type DehydratedUserColumnWidth = [ColumnName, number];

export type DehydratedUserRowHeight = [number, number];

export type DehydratedPartitionConfig = PartitionConfig;

/** @deprecated Use `DehydratedSort` instead */
export interface LegacyDehydratedSort {
  column: ModelIndex;
  isAbs: boolean;
  direction: SortDirection;
}

export interface DehydratedSort {
  column: ColumnName;
  isAbs: boolean;
  direction: string;
}

export interface TableSettings {
  quickFilters?: readonly DehydratedQuickFilter[];
  advancedFilters?: readonly DehydratedAdvancedFilter[];
  inputFilters?: readonly InputFilter[];
  sorts?: readonly (DehydratedSort | LegacyDehydratedSort)[];
  partitions?: unknown[];
  partitionColumns?: ColumnName[];
}

export interface DehydratedIrisGridState {
  advancedFilters: readonly DehydratedAdvancedFilter[];
  aggregationSettings: AggregationSettings;
  customColumnFormatMap: readonly DehydratedCustomColumnFormat[];
  columnAlignmentMap: readonly DehydratedUserColumnAlignment[];
  isFilterBarShown: boolean;
  quickFilters: readonly DehydratedQuickFilter[];
  sorts: readonly DehydratedSort[];
  userColumnWidths: readonly DehydratedUserColumnWidth[];
  userRowHeights: readonly DehydratedUserRowHeight[];
  customColumns: readonly ColumnName[];
  conditionalFormats: readonly SidebarFormattingRule[];
  /** @deprecated use `reverse` instead. Can be removed after DHE sanluis release */
  reverseType?: ReverseType;
  reverse: boolean;
  rollupConfig?: UIRollupConfig;
  showSearchBar: boolean;
  searchValue: string;
  selectDistinctColumns: readonly ColumnName[];
  selectedSearchColumns: readonly ColumnName[];
  invertSearchColumns: boolean;
  pendingDataMap: DehydratedPendingDataMap<unknown>;
  frozenColumns: readonly ColumnName[];
  columnHeaderGroups?: readonly DhType.ColumnGroup[];
  partitionConfig?: DehydratedPartitionConfig;
}

export interface DehydratedIrisGridPanelStateV1 {
  isSelectingPartition: boolean;
  partition: string | null;
  advancedSettings: [AdvancedSettingsType, boolean][];
}

export interface DehydratedIrisGridPanelStateV2 {
  isSelectingPartition: boolean;
  partitions: (string | null)[];
  advancedSettings: [AdvancedSettingsType, boolean][];
}

export type DehydratedIrisGridPanelState =
  | DehydratedIrisGridPanelStateV1
  | DehydratedIrisGridPanelStateV2;

export function isPanelStateV1(
  state: DehydratedIrisGridPanelState
): state is DehydratedIrisGridPanelStateV1 {
  return (state as DehydratedIrisGridPanelStateV1).partition !== undefined;
}

export function isPanelStateV2(
  state: DehydratedIrisGridPanelState
): state is DehydratedIrisGridPanelStateV2 {
  return Array.isArray((state as DehydratedIrisGridPanelStateV2).partitions);
}

/**
 * Checks if an index is valid for the given array
 * @param x The index to check
 * @param array The array
 * @returns True if the index if valid within the array
 */
function isValidIndex(x: number, array: readonly unknown[]): boolean {
  return x >= 0 && x < array.length;
}

function isDateWrapper(value: unknown): value is DhType.DateWrapper {
  return (value as DhType.DateWrapper)?.asDate != null;
}

export type HydratedGridState = Pick<
  GridState,
  'isStuckToBottom' | 'isStuckToRight' | 'movedColumns' | 'movedRows'
>;

export type DehydratedGridState = {
  isStuckToBottom: boolean;
  isStuckToRight: boolean;
  movedColumns: readonly {
    from: string | [string, string] | ModelIndex | [ModelIndex, ModelIndex];
    to: string | ModelIndex;
  }[];
  movedRows: readonly MoveOperation[];
};

class IrisGridUtils {
  /**
   * Exports the state from Grid component to a JSON stringifiable object.
   * See IrisGridCacheUtil for memoization and comparing dehydrated states.
   * @param model The table model to export the Grid state for
   * @param gridState The state of the Grid to export
   * @returns An object that can be stringified and imported with {{@link hydrateGridState}}
   */
  static dehydrateGridState(
    model: IrisGridModel,
    gridState: HydratedGridState
  ): DehydratedGridState {
    const { isStuckToBottom, isStuckToRight, movedColumns, movedRows } =
      gridState;

    const { columns } = model;

    return {
      isStuckToBottom,
      isStuckToRight,
      movedColumns: [...movedColumns]
        .filter(
          ({ to, from }) =>
            isValidIndex(to, columns) &&
            ((typeof from === 'number' && isValidIndex(from, columns)) ||
              (Array.isArray(from) &&
                isValidIndex(from[0], columns) &&
                isValidIndex(from[1], columns)))
        )
        .map(({ to, from }) => ({
          to: columns[to].name,
          from: Array.isArray(from)
            ? [columns[from[0]].name, columns[from[1]].name]
            : columns[from].name,
        })),
      movedRows: [...movedRows],
    };
  }

  /**
   * Import a state for Grid that was exported with {{@link dehydrateGridState}}
   * @param model The table model to import the state for
   * @param gridState The state of the panel that was saved
   * @returns The gridState props to set on the Grid
   */
  static hydrateGridState(
    model: IrisGridModel,
    gridState: DehydratedGridState,
    customColumns: readonly string[] = []
  ): HydratedGridState {
    const { isStuckToBottom, isStuckToRight, movedColumns, movedRows } =
      gridState;

    const { columns } = model;
    const customColumnNames =
      IrisGridUtils.parseCustomColumnNames(customColumns);
    const columnNames = columns
      .map(({ name }) => name)
      .concat(customColumnNames);

    return {
      isStuckToBottom,
      isStuckToRight,
      movedColumns: [...movedColumns]
        .map(({ to, from }) => {
          const getIndex = (x: string | number): number =>
            typeof x === 'string'
              ? columnNames.findIndex(name => name === x)
              : x;

          return {
            to: getIndex(to),
            from: Array.isArray(from)
              ? ([getIndex(from[0]), getIndex(from[1])] as [number, number])
              : getIndex(from),
          };
        })
        .filter(
          ({ to, from }) =>
            isValidIndex(to, columnNames) &&
            ((typeof from === 'number' && isValidIndex(from, columnNames)) ||
              (Array.isArray(from) &&
                isValidIndex(from[0], columnNames) &&
                isValidIndex(from[1], columnNames)))
        ),
      movedRows: [...movedRows],
    };
  }

  /**
   * Export the IrisGridPanel state.
   * @param model The table model the state is being dehydrated with
   * @param irisGridPanelState The current IrisGridPanel state
   * @returns The dehydrated IrisGridPanel state
   */
  static dehydrateIrisGridPanelState(
    model: IrisGridModel,
    irisGridPanelState: {
      // This needs to be changed after IrisGridPanel is done
      isSelectingPartition: boolean;
      partitions: (string | null)[];
      advancedSettings: Map<AdvancedSettingsType, boolean>;
    }
  ): DehydratedIrisGridPanelState {
    const { isSelectingPartition, partitions, advancedSettings } =
      irisGridPanelState;

    // Return value will be serialized, should not contain undefined
    return {
      isSelectingPartition,
      partitions,
      advancedSettings: [...advancedSettings],
    };
  }

  /**
   * Import the saved IrisGridPanel state.
   * @param model The model the state is being hydrated with
   * @param irisGridPanelState Exported IrisGridPanel state
   * @returns The state to apply to the IrisGridPanel
   */
  static hydrateIrisGridPanelState(
    model: IrisGridModel,
    irisGridPanelState: DehydratedIrisGridPanelState
  ): {
    isSelectingPartition: boolean;
    partitions: (string | null)[];
    advancedSettings: Map<AdvancedSettingsType, boolean>;
  } {
    const { isSelectingPartition, advancedSettings } = irisGridPanelState;

    let partitions: (string | null)[] = [];
    if (isPanelStateV2(irisGridPanelState)) {
      partitions = irisGridPanelState.partitions;
    } else if (irisGridPanelState.partition != null) {
      partitions = [irisGridPanelState.partition];
    }

    return {
      isSelectingPartition,
      partitions,
      advancedSettings: new Map([
        ...AdvancedSettings.DEFAULTS,
        ...advancedSettings,
      ]),
    };
  }

  /**
   * Export the quick filters to JSON striginfiable object
   * @param quickFilters The quick filters to dehydrate
   * @returns The dehydrated quick filters
   */
  static dehydrateQuickFilters(
    quickFilters: ReadonlyQuickFilterMap
  ): DehydratedQuickFilter[] {
    return [...quickFilters].map(([columnIndex, quickFilter]) => {
      const { text } = quickFilter;
      return [columnIndex, { text }];
    });
  }

  static dehydrateLong<T>(value: T): string | null {
    return value != null ? `${value}` : null;
  }

  /**
   * Export the sorts from the provided table sorts to JSON stringifiable object
   * @param  sorts The table sorts
   * @returns The dehydrated sorts
   */
  static dehydrateSort(sorts: readonly SortDescriptor[]): DehydratedSort[] {
    return sorts.map(sort => {
      const { column, isAbs, direction } = sort;
      return {
        column: column.name,
        isAbs,
        direction,
      };
    });
  }

  /**
   * Pulls just the table settings from the panel state, eg. filters/sorts
   * @param  panelState The dehydrated panel state
   * @returns A dehydrated table settings object, { partition, partitionColumn, advancedFilters, quickFilters, sorts }
   */
  static extractTableSettings<AF, QF, S>(
    panelState: {
      irisGridState: { advancedFilters: AF; quickFilters: QF; sorts: S };
      irisGridPanelState: DehydratedIrisGridPanelState;
    },
    inputFilters: InputFilter[] = []
  ): {
    partitions: unknown[];
    advancedFilters: AF;
    inputFilters: InputFilter[];
    quickFilters: QF;
    sorts: S;
  } {
    const { irisGridPanelState, irisGridState } = panelState;
    const partitions = isPanelStateV2(irisGridPanelState)
      ? irisGridPanelState.partitions
      : [irisGridPanelState.partition];
    const { advancedFilters, quickFilters, sorts } = irisGridState;

    return {
      advancedFilters,
      inputFilters,
      partitions,
      quickFilters,
      sorts,
    };
  }

  static getInputFiltersForColumns(
    columns: readonly { name: string; type: string }[],
    inputFilters: readonly InputFilter[] = []
  ): InputFilter[] {
    return inputFilters.filter(({ name, type }) =>
      columns.find(
        ({ name: columnName, type: columnType }) =>
          columnName === name && columnType === type
      )
    );
  }

  static getFiltersFromFilterMap(
    filterMap: ReadonlyAdvancedFilterMap | ReadonlyQuickFilterMap
  ): DhType.FilterCondition[] {
    const filters = [];

    const keys = Array.from(filterMap.keys());
    for (let i = 0; i < keys.length; i += 1) {
      const key = keys[i];
      const item = filterMap.get(key);
      if (item?.filter != null) {
        filters.push(item.filter);
      }
    }

    return filters;
  }

  /**
   * Get array of hidden column indexes
   * @param  userColumnWidths Map of user column widths
   * @returns Array of hidden column indexes
   */
  static getHiddenColumns(userColumnWidths: ModelSizeMap): ModelIndex[] {
    return [...userColumnWidths.entries()]
      .filter(([, value]) => value === 0)
      .map(([key]) => key);
  }

  static parseCustomColumnNames(
    customColumns: readonly ColumnName[]
  ): ColumnName[] {
    return customColumns.map(customColumn => customColumn.split('=')[0]);
  }

  static getRemovedCustomColumnNames(
    oldCustomColumns: readonly ColumnName[],
    customColumns: readonly ColumnName[]
  ): ColumnName[] {
    const oldCustomColumnsNames =
      IrisGridUtils.parseCustomColumnNames(oldCustomColumns);
    const customColumnNames =
      IrisGridUtils.parseCustomColumnNames(customColumns);
    return oldCustomColumnsNames.filter(
      oldCustomColumnName => !customColumnNames.includes(oldCustomColumnName)
    );
  }

  static removeSortsInColumns(
    sorts: readonly SortDescriptor[],
    columnNames: readonly string[]
  ): readonly SortDescriptor[] {
    return sorts.filter(sort => !columnNames.includes(sort.column.name));
  }

  static removeFiltersInColumns<T>(
    columns: readonly DhType.Column[],
    filters: ReadonlyMap<number, T>,
    removedColumnNames: readonly ColumnName[]
  ): Map<number, T> {
    const columnNames = columns.map(({ name }) => name);
    const newFilter = new Map(filters);
    removedColumnNames.forEach(columnName =>
      newFilter.delete(columnNames.indexOf(columnName))
    );
    return newFilter;
  }

  static removeColumnFromMovedColumns(
    columns: readonly DhType.Column[],
    movedColumns: readonly MoveOperation[],
    removedColumnNames: readonly ColumnName[]
  ): MoveOperation[] {
    const columnNames = columns.map(({ name }) => name);
    let newMoves = [...movedColumns];
    for (let i = 0; i < removedColumnNames.length; i += 1) {
      const removedColumnName = removedColumnNames[i];
      let removedColumnIndex = columnNames.findIndex(
        name => name === removedColumnName
      );
      const moves: MoveOperation[] = [];
      for (let j = 0; j < newMoves.length; j += 1) {
        const move = newMoves[j];
        const newMove = { ...move };
        let [fromStart, fromEnd] = Array.isArray(move.from)
          ? move.from
          : [move.from, move.from];

        if (removedColumnIndex <= move.to) {
          newMove.to -= 1;
        }

        // If equal to fromStart, the new fromStart would stay the same
        // It's just the next element in the range which will have the same index after deletion
        if (removedColumnIndex < fromStart) {
          fromStart -= 1;
        }

        if (removedColumnIndex <= fromEnd) {
          fromEnd -= 1;
        }

        if (fromStart <= fromEnd && fromStart !== newMove.to) {
          if (fromStart === fromEnd) {
            moves.push({ ...newMove, from: fromStart });
          } else {
            moves.push({ ...newMove, from: [fromStart, fromEnd] });
          }
        }

        // get the next index of the removed column after the move is applied
        // eslint-disable-next-line prefer-destructuring
        removedColumnIndex = GridUtils.applyItemMoves(
          removedColumnIndex,
          removedColumnIndex,
          [move]
        )[0][0];
      }

      newMoves = moves;
      columnNames.splice(
        columnNames.findIndex(name => name === removedColumnName),
        1
      );
    }
    return newMoves;
  }

  static removeColumnsFromSelectDistinctColumns(
    selectDistinctColumns: readonly ColumnName[],
    removedColumnNames: readonly ColumnName[]
  ): ColumnName[] {
    return selectDistinctColumns.filter(
      columnName => !removedColumnNames.includes(columnName)
    );
  }

  static getVisibleColumnsInRange(
    tableColumns: readonly DhType.Column[],
    left: number,
    right: number,
    movedColumns: readonly MoveOperation[],
    hiddenColumns: readonly number[]
  ): DhType.Column[] {
    const columns: DhType.Column[] = [];
    for (let i = left; i <= right; i += 1) {
      const modelIndex = GridUtils.getModelIndex(i, movedColumns);
      if (
        modelIndex >= 0 &&
        modelIndex < tableColumns.length &&
        !hiddenColumns.includes(modelIndex)
      ) {
        columns.push(tableColumns[modelIndex]);
      }
    }
    return columns;
  }

  static getPrevVisibleColumns(
    tableColumns: readonly DhType.Column[],
    startIndex: VisibleIndex,
    count: number,
    movedColumns: readonly MoveOperation[],
    hiddenColumns: readonly VisibleIndex[]
  ): DhType.Column[] {
    const columns = [];
    let i = startIndex;
    while (i >= 0 && columns.length < count) {
      const modelIndex = GridUtils.getModelIndex(i, movedColumns);
      if (
        modelIndex >= 0 &&
        modelIndex < tableColumns.length &&
        !hiddenColumns.includes(modelIndex)
      ) {
        columns.unshift(tableColumns[modelIndex]);
      }
      i -= 1;
    }
    return columns;
  }

  static getNextVisibleColumns(
    tableColumns: readonly DhType.Column[],
    startIndex: VisibleIndex,
    count: number,
    movedColumns: readonly MoveOperation[],
    hiddenColumns: readonly VisibleIndex[]
  ): DhType.Column[] {
    const columns = [];
    let i = startIndex;
    while (i < tableColumns.length && columns.length < count) {
      const modelIndex = GridUtils.getModelIndex(i, movedColumns);
      if (
        modelIndex >= 0 &&
        modelIndex < tableColumns.length &&
        !hiddenColumns.includes(modelIndex)
      ) {
        columns.push(tableColumns[modelIndex]);
      }
      i += 1;
    }
    return columns;
  }

  static getColumnsToFetch(
    tableColumns: readonly DhType.Column[],
    viewportColumns: readonly DhType.Column[],
    alwaysFetchColumnNames: readonly ColumnName[]
  ): DhType.Column[] {
    const columnsToFetch = [...viewportColumns];
    alwaysFetchColumnNames.forEach(columnName => {
      const column = tableColumns.find(({ name }) => name === columnName);
      if (column != null && !viewportColumns.includes(column)) {
        columnsToFetch.push(column);
      }
    });
    return columnsToFetch;
  }

  static getModelViewportColumns(
    columns: readonly DhType.Column[],
    left: number | null,
    right: number | null,
    movedColumns: readonly MoveOperation[],
    hiddenColumns: readonly VisibleIndex[] = [],
    alwaysFetchColumnNames: readonly ColumnName[] = [],
    bufferPages = 0
  ): DhType.Column[] | undefined {
    if (left == null || right == null) {
      return undefined;
    }

    const columnsCenter = IrisGridUtils.getVisibleColumnsInRange(
      columns,
      left,
      right,
      movedColumns,
      hiddenColumns
    );
    const bufferWidth = columnsCenter.length * bufferPages;
    const columnsLeft = IrisGridUtils.getPrevVisibleColumns(
      columns,
      left - 1,
      bufferWidth,
      movedColumns,
      hiddenColumns
    );
    const columnsRight = IrisGridUtils.getNextVisibleColumns(
      columns,
      right + 1,
      bufferWidth,
      movedColumns,
      hiddenColumns
    );

    const bufferedColumns = [...columnsLeft, ...columnsCenter, ...columnsRight];

    return IrisGridUtils.getColumnsToFetch(
      columns,
      bufferedColumns,
      alwaysFetchColumnNames
    );
  }

  /**
   * Validate whether the ranges passed in are valid to take a snapshot from.
   * Multiple selections are valid if all of the selected rows have the same columns selected.
   *
   * @param ranges The ranges to validate
   * @returns True if the ranges are valid, false otherwise
   */
  static isValidSnapshotRanges(ranges: readonly GridRange[]): boolean {
    if (ranges == null || ranges.length === 0) {
      return false;
    }

    // To verify all the rows selected have the same set of columns selected, build a map with string representations
    // of each range.
    const rangeMap = new Map();
    for (let i = 0; i < ranges.length; i += 1) {
      const range = ranges[i];
      const rowMapIndex = `${range.startRow}:${range.endRow}`;
      const columnMapIndex = `${range.startColumn}:${range.endColumn}`;
      if (!rangeMap.has(rowMapIndex)) {
        rangeMap.set(rowMapIndex, []);
      }
      rangeMap.get(rowMapIndex).push(columnMapIndex);
    }

    const keys = [...rangeMap.keys()];
    const matchColumnRanges = rangeMap.get(keys[0]).sort().join(',');
    for (let i = 1; i < keys.length; i += 1) {
      if (rangeMap.get(keys[i]).sort().join(',') !== matchColumnRanges) {
        return false;
      }
    }

    return true;
  }

  /**
   * Check if the provided value is a valid table index
   * @param  value A value to check if it's a valid table index
   */
  static isValidIndex(value: unknown): boolean {
    if (!Number.isInteger(value)) {
      return false;
    }
    if (!(typeof value === 'number')) {
      return false;
    }
    return value >= 0;
  }

  /**
   * Returns all columns used in any of the ranges provided
   * @param  ranges The model ranges to get columns for
   * @param  allColumns All the columns to pull from
   * @returns The columns selected in the range
   */
  static columnsFromRanges(
    ranges: readonly GridRange[],
    allColumns: readonly DhType.Column[]
  ): DhType.Column[] {
    if (ranges == null || ranges.length === 0) {
      return [];
    }
    if (ranges[0].startColumn === null && ranges[0].endColumn === null) {
      // Snapshot of all the columns
      return [...allColumns];
    }

    const columnSet = new Set<ModelIndex>();
    for (let i = 0; i < ranges.length; i += 1) {
      const range = ranges[i];
      assertNotNull(range.startColumn);
      assertNotNull(range.endColumn);
      for (
        let c = range.startColumn ?? 0;
        c <= (range.endColumn ?? allColumns.length - 1);
        c += 1
      ) {
        columnSet.add(c);
      }
    }
    return [...columnSet].map(c => allColumns[c]);
  }

  /**
   * Transforms an iris data snapshot into a simple data matrix
   * @param  data The Iris formatted table data
   * @returns A matrix of the values of the data
   */
  static snapshotDataToMatrix(data: DhType.TableData): unknown[][] {
    const { columns, rows } = data;
    const result = [];
    for (let r = 0; r < rows.length; r += 1) {
      const row = rows[r];
      const rowData = [];
      for (let c = 0; c < columns.length; c += 1) {
        const column = columns[c];
        const value = row.get(column);
        rowData.push(value);
      }
      result.push(rowData);
    }
    return result;
  }

  /**
   * Hydrate model rollup config
   * @param  originalColumns Original model columns
   * @param  config Dehydrated rollup config
   * @param  aggregationSettings Aggregation settings
   * @returns Rollup config for the model
   */
  static getModelRollupConfig(
    originalColumns: readonly DhType.Column[],
    config: UIRollupConfig | undefined,
    aggregationSettings: AggregationSettings
  ): DhType.RollupConfig | null {
    if ((config?.columns?.length ?? 0) === 0) {
      return null;
    }

    const {
      columns: groupingColumns = [],
      showConstituents: includeConstituents = true,
      showNonAggregatedColumns = true,
      includeDescriptions = true,
    } = config ?? {};
    const { aggregations = [] } = aggregationSettings ?? {};
    const filteredAggregations = aggregations.filter(
      ({ operation }) => !AggregationUtils.isRollupProhibited(operation)
    );
    const aggregationColumns = filteredAggregations.map(
      ({ operation, selected, invert }) =>
        AggregationUtils.isRollupOperation(operation)
          ? []
          : AggregationUtils.getOperationColumnNames(
              originalColumns,
              operation,
              selected,
              invert
            )
    );

    const aggregationMap = {} as Record<AggregationOperation, string[]>;
    // Aggregation columns should show first, add them first
    for (let i = 0; i < filteredAggregations.length; i += 1) {
      aggregationMap[filteredAggregations[i].operation] = aggregationColumns[i];
    }

    if (showNonAggregatedColumns) {
      // Filter out any column that already has an aggregation or grouping
      const nonAggregatedColumnSet = new Set(
        originalColumns
          .map(c => c.name)
          .filter(name => !groupingColumns.includes(name))
      );
      aggregationColumns.forEach(columns => {
        columns.forEach(name => nonAggregatedColumnSet.delete(name));
      });

      if (nonAggregatedColumnSet.size > 0) {
        const existingColumns =
          aggregationMap[AggregationOperation.FIRST] ?? [];
        aggregationMap[AggregationOperation.FIRST] = [
          ...existingColumns,
          ...nonAggregatedColumnSet,
        ];
      }
    }

    return {
      groupingColumns,
      includeConstituents,
      includeDescriptions,
      aggregations: aggregationMap,
    };
  }

  /**
   * @param  pendingDataMap Map of pending data
   * @returns A map with the errors in the pending data
   */
  static getPendingErrors(pendingDataMap: Map<number, UIRow>): void {
    pendingDataMap.forEach((row, rowIndex) => {
      if (!IrisGridUtils.isValidIndex(rowIndex)) {
        throw new Error(`Invalid rowIndex ${rowIndex}`);
      }

      const { data } = row;
      data.forEach((value, columnIndex) => {
        if (!IrisGridUtils.isValidIndex(columnIndex)) {
          throw new Error(`Invalid columnIndex ${columnIndex}`);
        }
      });
    });
  }

  /**
   * Retrieves a column from the provided array at the index, or `null` and logs an error if it's invalid
   *
   * @param  columns The columns to get the column from
   * @param  columnIndex The column index to get
   */
  static getColumn(
    columns: readonly DhType.Column[],
    columnIndex: ModelIndex
  ): DhType.Column | null {
    if (columnIndex < columns.length) {
      return columns[columnIndex];
    }

    log.error('Unable to retrieve column', columnIndex, '>=', columns.length);

    return null;
  }

  /**
   * Retrieves a column from the provided array matching the name, or `null` and logs an error if not found
   * @param  columns The columns to get the column from
   * @param  columnName The column name to retrieve
   */
  static getColumnByName(
    columns: readonly DhType.Column[],
    columnName: ColumnName
  ): DhType.Column | undefined {
    // Columns can contain ColumnBy sources with negative indexes
    const column = Object.values(columns).find(
      ({ name }) => name === columnName
    );
    if (column == null) {
      log.error(
        'Unable to retrieve column by name',
        columnName,
        columns.map(({ name }) => name)
      );
    }

    return column;
  }

  /**
   * Get filter configs with column names changed to indexes, exclude missing columns
   * @param  columns The columns to get column indexes from
   * @param  filters Filter configs
   * @returns Updated filter configs with column names changed to indexes
   */
  static changeFilterColumnNamesToIndexes<T>(
    columns: readonly DhType.Column[],
    filters: { name: ColumnName; filter: T }[]
  ): [number, T][] {
    return filters
      .map(({ name, filter }): null | [number, T] => {
        const index = columns.findIndex(column => column.name === name);
        return index < 0 ? null : [index, filter];
      })
      .filter(filterConfig => filterConfig != null) as [number, T][];
  }

  /**
   * @param columnType The column type that the filters will be applied to.
   * @param filterList The list of filters to be combined.
   * @returns The combination of the filters in filterList as text.
   */
  static combineFiltersFromList(
    columnType: string | null,
    filterList: FilterData[]
  ): string {
    filterList.sort((a, b) => {
      // move all 'equals' comparisons to end of list
      if (a.operator === 'eq' && b.operator !== 'eq') {
        return 1;
      }
      if (a.operator !== 'eq' && b.operator === 'eq') {
        return -1;
      }
      return a.startColumnIndex - b.startColumnIndex;
    });

    let combinedText = '';
    for (let i = 0; i < filterList.length; i += 1) {
      const { text, value, operator } = filterList[i];
      if (value !== undefined) {
        let symbol = '';
        if (operator !== undefined) {
          if (value == null && operator === 'eq') {
            symbol = '=';
          } else if (operator !== 'eq') {
            if (operator === 'startsWith' || operator === 'endsWith') {
              symbol = '*';
            } else {
              symbol = TableUtils.getFilterOperatorString(operator);
            }
          }
        }

        let filterText = `${symbol}${text}`;
        if (operator === 'startsWith') {
          filterText = `${text}${symbol}`;
        }
        if (
          columnType != null &&
          value !== null &&
          TableUtils.isCharType(columnType)
        ) {
          filterText = `${symbol}${String.fromCharCode(parseInt(text, 10))}`;
        }
        if (i !== 0) {
          combinedText += operator === 'eq' ? ' || ' : ' && ';
        }
        combinedText += filterText;
      }
    }
    return combinedText;
  }

  /**
   * Parses the column header groups provided.
   * If undefined, should provide default groups such as from layoutHints
   *
   * @returns Object containing groups array, max depth, map of name to parent group, and map of name to group
   */
  static parseColumnHeaderGroups<
    T extends ColumnHeaderGroup,
    C extends ColumnHeaderGroupConfig,
  >(
    model: IrisGridModel,
    groupsParam: readonly (DhType.ColumnGroup | T)[],
    makeColumnHeaderGroup: (args: C) => T = (args: C) =>
      new ColumnHeaderGroup(args) as T
  ): {
    groups: T[];
    maxDepth: number;
    parentMap: Map<string, T>;
    groupMap: Map<string, T>;
  } {
    let maxDepth = 1;
    const parentMap: Map<string, T> = new Map();
    const groupMap: Map<string, T> = new Map();

    // Remove any empty groups before parsing
    const groups = groupsParam?.filter(
      ({ children }) => children != null && children.length > 0
    );

    if (groups.length === 0) {
      return { groups: [], maxDepth, parentMap, groupMap };
    }

    const originalGroupMap = new Map(groups.map(group => [group.name, group]));
    const seenChildren = new Set<string>();

    const addGroup = (group: DhType.ColumnGroup | T): T => {
      const { name } = group;

      assertNotNull(name, 'Column header group has no name');

      const columnIndex = model.getColumnIndexByName(name);
      // Groups cannot have names matching columns to avoid parent-child collision
      // unless they refer to ColumnBy sources with negative indexes
      if (columnIndex != null && columnIndex >= 0) {
        throw new Error(`Column header group has same name as column: ${name}`);
      }

      const existingGroup = groupMap.get(name);

      if (existingGroup) {
        return existingGroup;
      }

      const childIndexes: T['childIndexes'] = [];
      let depth = 1;

      if (group.children == null) {
        throw new Error(`Column header group ${name} has no children`);
      }

      group.children.forEach(childName => {
        if (seenChildren.has(childName)) {
          throw new Error(
            `Column group child ${childName} specified in multiple groups`
          );
        }
        seenChildren.add(childName);

        const childGroup = originalGroupMap.get(childName);
        const childIndex = model.getColumnIndexByName(childName);
        if (childGroup) {
          // Adding another column header group
          const addedGroup = addGroup(childGroup);
          childIndexes.push(...addedGroup.childIndexes);
          depth = Math.max(depth, addedGroup.depth + 1);
        } else if (childIndex != null) {
          // Adding a base column
          childIndexes.push(childIndex);
          depth = Math.max(depth, 1);
        } else {
          throw new Error(`Unknown child ${childName} in group ${name}`);
        }
      });

      const headerGroupConfig = {
        ...(group as C),
        name,
        children: group.children,
        depth,
        childIndexes: childIndexes.flat(),
      };

      const columnHeaderGroup = makeColumnHeaderGroup(headerGroupConfig);

      groupMap.set(name, columnHeaderGroup);
      group.children?.forEach(childName =>
        parentMap.set(childName, columnHeaderGroup)
      );

      maxDepth = Math.max(maxDepth, columnHeaderGroup.depth + 1);
      return columnHeaderGroup;
    };

    const groupNames = new Set();

    groups.forEach(group => {
      const { name } = group;
      if (groupNames.has(name)) {
        throw new Error(`Duplicate column group name: ${name}`);
      }
      groupNames.add(name);
      addGroup(group);
    });

    groupMap.forEach(group => {
      group.setParent(parentMap.get(group.name)?.name);
    });

    return { groups: [...groupMap.values()], maxDepth, groupMap, parentMap };
  }

  /**
   * @param value The value of the cell in a column
   * @param columnType The type of the column
   * @returns The value of the cell converted to text
   */
  static convertValueToText(value: unknown, columnType: string): string {
    if (
      columnType != null &&
      TableUtils.isCharType(columnType) &&
      value != null &&
      typeof value === 'number'
    ) {
      return String.fromCharCode(value);
    }
    if (TableUtils.isDateType(columnType) && isDateWrapper(value)) {
      const date = new Date(value.asDate());
      const offset = date.getTimezoneOffset();
      const offsetDate = new Date(date.getTime() - offset * 60 * 1000);
      const dateText = offsetDate.toISOString();
      const formattedText = dateText.replace('T', ' ').substring(0, 23);
      return formattedText;
    }
    if (value == null) {
      return '';
    }
    return `${value}`;
  }

  private dh: typeof DhType;

  private tableUtils: TableUtils;

  constructor(dh: typeof DhType) {
    this.dh = dh;
    this.tableUtils = new TableUtils(dh);
    bindAllMethods(this);
  }

  /**
   * Exports the state from IrisGrid to a JSON stringifiable object.
   * See IrisGridCacheUtil for memoization and comparing dehydrated states.
   * @param model The table model to export the state for
   * @param irisGridState The current state of the IrisGrid
   */
  dehydrateIrisGridState(
    model: IrisGridModel,
    irisGridState: HydratedIrisGridState
  ): DehydratedIrisGridState {
    const {
      aggregationSettings = { aggregations: EMPTY_ARRAY, showOnTop: false },
      advancedFilters,
      customColumnFormatMap,
      columnAlignmentMap = EMPTY_MAP,
      isFilterBarShown,
      metrics: {
        userColumnWidths = new Map<ModelIndex, number>(),
        userRowHeights = new Map<ModelIndex, number>(),
      } = {},
      quickFilters,
      customColumns,
      conditionalFormats = EMPTY_ARRAY,
      reverse,
      rollupConfig,
      showSearchBar,
      searchValue,
      selectDistinctColumns = EMPTY_ARRAY,
      selectedSearchColumns,
      sorts,
      invertSearchColumns,
      pendingDataMap = EMPTY_MAP,
      frozenColumns,
      columnHeaderGroups,
      partitionConfig,
    } = irisGridState;
    const { columns } = model;
    const partitionColumns = isPartitionedGridModelProvider(model)
      ? model.partitionColumns
      : [];

    // Return value will be serialized, should not contain undefined
    return {
      advancedFilters: this.dehydrateAdvancedFilters(columns, advancedFilters),
      aggregationSettings,
      customColumnFormatMap: [...customColumnFormatMap],
      columnAlignmentMap: [...columnAlignmentMap],
      isFilterBarShown,
      quickFilters: IrisGridUtils.dehydrateQuickFilters(quickFilters),
      sorts: IrisGridUtils.dehydrateSort(sorts),
      userColumnWidths: [...userColumnWidths]
        .filter(
          ([columnIndex]) =>
            columnIndex != null &&
            columnIndex >= 0 &&
            columnIndex < columns.length
        )
        .map(([columnIndex, width]) => [columns[columnIndex].name, width]),
      userRowHeights: [...userRowHeights],
      customColumns: [...customColumns],
      conditionalFormats: [...conditionalFormats],
      reverse,
      rollupConfig,
      showSearchBar,
      searchValue,
      selectDistinctColumns: [...selectDistinctColumns],
      selectedSearchColumns,
      invertSearchColumns,
      pendingDataMap: this.dehydratePendingDataMap(columns, pendingDataMap),
      frozenColumns,
      columnHeaderGroups: columnHeaderGroups?.map(item => ({
        name: item.name,
        children: item.children,
        color: item.color ?? null,
      })),
      partitionConfig: this.dehydratePartitionConfig(
        partitionColumns,
        partitionConfig
      ),
    };
  }

  /**
   * Import a state for IrisGrid that was exported with {{@link dehydrateIrisGridState}}
   * @param model The table model to import the state with
   * @param irisGridState The saved IrisGrid state
   */
  hydrateIrisGridState(
    model: IrisGridModel,
    irisGridState: DehydratedIrisGridState
  ): Omit<HydratedIrisGridState, 'metrics'> & {
    userColumnWidths: ModelSizeMap;
    userRowHeights: ModelSizeMap;
  } {
    const {
      advancedFilters,
      aggregationSettings = { aggregations: [], showOnTop: false },
      customColumnFormatMap,
      columnAlignmentMap = [],
      isFilterBarShown,
      quickFilters,
      sorts,
      customColumns,
      conditionalFormats,
      userColumnWidths,
      userRowHeights,
      reverseType,
      reverse,
      rollupConfig = undefined,
      showSearchBar,
      searchValue,
      selectDistinctColumns,
      selectedSearchColumns,
      invertSearchColumns = true,
      pendingDataMap = [],
      frozenColumns,
      columnHeaderGroups,
      partitionConfig,
    } = irisGridState;
    const { columns, formatter } = model;
    const partitionColumns = isPartitionedGridModelProvider(model)
      ? model.partitionColumns
      : [];
    return {
      advancedFilters: this.hydrateAdvancedFilters(
        columns,
        advancedFilters,
        formatter.timeZone
      ),
      aggregationSettings,
      customColumnFormatMap: new Map(customColumnFormatMap),
      columnAlignmentMap: new Map(columnAlignmentMap),
      isFilterBarShown,
      quickFilters: this.hydrateQuickFilters(
        columns,
        quickFilters,
        formatter.timeZone
      ),
      sorts: this.hydrateSort(columns, sorts, true),
      userColumnWidths: new Map(
        userColumnWidths
          .map(
            ([column, width]: [string | number, number]): [number, number] => {
              if (
                typeof column === 'string' ||
                (column as unknown) instanceof String
              ) {
                return [
                  columns.findIndex(({ name }) => name === column),
                  width,
                ];
              }
              return [column, width];
            }
          )
          .filter(
            ([column]) =>
              column != null && column >= 0 && column < columns.length
          )
      ),
      customColumns,
      conditionalFormats,
      userRowHeights: new Map(userRowHeights),
      reverse: reverseType === TableUtils.REVERSE_TYPE.POST_SORT || reverse,
      rollupConfig,
      showSearchBar,
      searchValue,
      selectDistinctColumns,
      selectedSearchColumns,
      invertSearchColumns,
      pendingDataMap: this.hydratePendingDataMap(
        columns,
        pendingDataMap
      ) as PendingDataMap<UIRow>,
      frozenColumns,
      columnHeaderGroups: IrisGridUtils.parseColumnHeaderGroups(
        model,
        columnHeaderGroups ?? model.layoutHints?.columnGroups ?? []
      ).groups,
      partitionConfig: this.hydratePartitionConfig(
        partitionColumns,
        partitionConfig
      ),
    };
  }

  /**
   * Import the saved quick filters to apply to the columns. Does not actually apply the filters.
   * @param  columns The columns the filters will be applied to
   * @param  savedQuickFilters Exported quick filters definitions
   * @param  timeZone The time zone to make this value in if it is a date type. E.g. America/New_York
   * @returns The quick filters to apply to the columns
   */
  hydrateQuickFilters(
    columns: readonly DhType.Column[],
    savedQuickFilters: readonly DehydratedQuickFilter[],
    timeZone?: string
  ): ReadonlyQuickFilterMap {
    const importedFilters = savedQuickFilters.map(
      ([columnIndex, quickFilter]: DehydratedQuickFilter): [
        number,
        { text: string; filter: DhType.FilterCondition | null },
      ] => {
        const { text } = quickFilter;

        let filter = null;
        try {
          const column = IrisGridUtils.getColumn(columns, columnIndex);
          if (column != null) {
            filter = this.tableUtils.makeQuickFilter(column, text, timeZone);
          }
        } catch (error) {
          log.error('hydrateQuickFilters error with', text, error);
        }

        return [columnIndex, { text, filter }];
      }
    );

    return new Map(importedFilters);
  }

  /**
   * Export the advanced filters from the provided columns to JSON striginfiable object
   * @param columns The columns for the filters
   * @param advancedFilters The advanced filters to dehydrate
   * @returns The dehydrated advanced filters
   */
  dehydrateAdvancedFilters(
    columns: readonly DhType.Column[],
    advancedFilters: ReadonlyAdvancedFilterMap
  ): DehydratedAdvancedFilter[] {
    return [...advancedFilters].map(([columnIndex, advancedFilter]) => {
      const column = IrisGridUtils.getColumn(columns, columnIndex);
      assertNotNull(column);
      const options = this.dehydrateAdvancedFilterOptions(
        column,
        advancedFilter.options
      );
      return [columnIndex, { options }];
    });
  }

  /**
   * Import the saved advanced filters to apply to the columns. Does not actually apply the filters.
   * @param  columns The columns the filters will be applied to
   * @param  savedAdvancedFilters Exported advanced filters definitions
   * @param  timeZone The time zone to make this filter in if it is a date type. E.g. America/New_York
   * @returns The advanced filters to apply to the columns
   */
  hydrateAdvancedFilters(
    columns: readonly DhType.Column[],
    savedAdvancedFilters: readonly DehydratedAdvancedFilter[],
    timeZone: string
  ): ReadonlyAdvancedFilterMap {
    const importedFilters = savedAdvancedFilters.map(
      ([columnIndex, advancedFilter]: DehydratedAdvancedFilter): [
        number,
        {
          options: AdvancedFilterOptions;
          filter: DhType.FilterCondition | null;
        },
      ] => {
        const column = IrisGridUtils.getColumn(columns, columnIndex);
        assertNotNull(column);
        const options = this.hydrateAdvancedFilterOptions(
          column,
          advancedFilter.options
        );
        let filter = null;

        try {
          const columnRetrieved = IrisGridUtils.getColumn(columns, columnIndex);
          if (columnRetrieved != null) {
            filter = this.tableUtils.makeAdvancedFilter(
              column,
              options,
              timeZone
            );
          }
        } catch (error) {
          log.error('hydrateAdvancedFilters error with', options, error);
        }

        return [columnIndex, { options, filter }];
      }
    );

    return new Map(importedFilters);
  }

  dehydrateAdvancedFilterOptions(
    column: DhType.Column,
    options: AdvancedFilterOptions
  ): AdvancedFilterOptions {
    const { selectedValues, ...otherOptions } = options;
    return {
      selectedValues: selectedValues?.map((value: unknown) =>
        this.dehydrateValue(value, column?.type)
      ),
      ...otherOptions,
    };
  }

  hydrateAdvancedFilterOptions(
    column: DhType.Column,
    options: AdvancedFilterOptions
  ): AdvancedFilterOptions {
    const { selectedValues, ...otherOptions } = options;
    return {
      selectedValues: selectedValues?.map(value =>
        this.hydrateValue(value, column?.type)
      ),
      ...otherOptions,
    };
  }

  dehydratePendingDataMap(
    columns: readonly DhType.Column[],
    pendingDataMap: PendingDataMap
  ): DehydratedPendingDataMap<unknown> {
    return [...pendingDataMap].map(([rowIndex, { data }]) => [
      rowIndex,
      {
        data: [...data]
          .filter(([c]) => typeof c === 'number')
          .map(([c, cellData]) => [
            columns[c as number].name,
            this.dehydrateValue(cellData.value, columns[c as number].type),
          ]),
      },
    ]);
  }

  hydratePendingDataMap(
    columns: readonly DhType.Column[],
    pendingDataMap: DehydratedPendingDataMap<unknown>
  ): Map<
    number,
    {
      data: Map<ModelIndex | null, CellData>;
    }
  > {
    const columnMap = new Map<ColumnName, number>();
    const getColumnIndex = (columnName: ColumnName): number | undefined => {
      if (!columnMap.has(columnName)) {
        columnMap.set(
          columnName,
          columns.findIndex(({ name }) => name === columnName)
        );
      }
      return columnMap.get(columnName);
    };

    return new Map(
      pendingDataMap.map(
        ([rowIndex, { data }]: [number, { data: [string, unknown][] }]) => [
          rowIndex,
          {
            data: new Map(
              data.map(([columnName, value]) => {
                const index = getColumnIndex(columnName);
                assertNotNull(index);
                return [
                  getColumnIndex(columnName) ?? null,
                  { value: this.hydrateValue(value, columns[index].type) },
                ];
              })
            ),
          },
        ]
      )
    );
  }

  dehydratePartitionConfig(
    partitionColumns: readonly DhType.Column[],
    partitionConfig: PartitionConfig | undefined
  ): PartitionConfig | undefined {
    if (partitionConfig == null) {
      return partitionConfig;
    }

    return {
      ...partitionConfig,
      partitions: partitionConfig.partitions.map((partition, index) =>
        this.dehydrateValue(partition, partitionColumns[index].type)
      ),
    };
  }

  hydratePartitionConfig(
    partitionColumns: readonly DhType.Column[],
    partitionConfig: PartitionConfig | undefined
  ): PartitionConfig | undefined {
    if (partitionConfig == null) {
      return partitionConfig;
    }

    return {
      ...partitionConfig,
      partitions: partitionConfig.partitions.map((partition, index) =>
        this.hydrateValue(partition, partitionColumns[index].type)
      ),
    };
  }

  /**
   * Dehydrates/serializes a value for storage.
   * @param  value The value to dehydrate
   * @param  columnType The column type
   */
  dehydrateValue<T>(value: T, columnType: string): string | T | null {
    if (TableUtils.isDateType(columnType)) {
      return this.dehydrateDateTime(
        value as unknown as number | DhType.DateWrapper | Date
      );
    }

    if (TableUtils.isLongType(columnType)) {
      return IrisGridUtils.dehydrateLong(value);
    }

    return value;
  }

  /**
   * Hydrate a value from it's serialized state
   * @param  value The dehydrated value that needs to be hydrated
   * @param  columnType The type of column
   */
  hydrateValue<T>(
    value: T,
    columnType: string
  ): DhType.DateWrapper | DhType.LongWrapper | T | null {
    if (TableUtils.isDateType(columnType)) {
      return this.hydrateDateTime(value as unknown as string);
    }

    if (TableUtils.isLongType(columnType)) {
      return this.hydrateLong(value as unknown as string);
    }

    return value;
  }

  dehydrateDateTime(value: number | DhType.DateWrapper | Date): string | null {
    return value != null
      ? this.dh.i18n.DateTimeFormat.format(DateUtils.FULL_DATE_FORMAT, value)
      : null;
  }

  hydrateDateTime(value: string): DhType.DateWrapper | null {
    return value != null
      ? this.dh.i18n.DateTimeFormat.parse(DateUtils.FULL_DATE_FORMAT, value)
      : null;
  }

  hydrateLong(value: string): DhType.LongWrapper | null {
    return value != null ? this.dh.LongWrapper.ofString(value) : null;
  }

  /**
   * Import the saved sorts to apply to the model. Does not actually apply the sort.
   * @param columns The columns the sorts will be applied to
   * @param sorts Exported sort definitions
   * @param dropReverse If true, drop reverse sort descriptors from the result
   * @returns The sort descriptors to apply to the model
   */
  hydrateSort(
    columns: readonly DhType.Column[],
    sorts: readonly (DehydratedSort | LegacyDehydratedSort)[],
    dropReverse = false
  ): readonly SortDescriptor[] {
    const { dh } = this;
    return (
      sorts
        .map(sort => {
          const { column: columnIndexOrName, isAbs, direction } = sort;
          if (direction === TableUtils.sortDirection.reverse) {
            return dh.Table.reverse();
          }

          const column =
            typeof columnIndexOrName === 'string'
              ? IrisGridUtils.getColumnByName(columns, columnIndexOrName)
              : IrisGridUtils.getColumn(columns, columnIndexOrName);

          if (column != null) {
            return {
              column: {
                name: column.name,
                type: column.type,
              },
              isAbs,
              direction,
            };
          }
          return null;
        })
        // If we can't find the column any more, it's null, filter it out
        // If the item is a reverse sort item, and dropReverse is true, filter it out
        // - it will get applied with the `reverse` property
        // This should only happen when loading a legacy dashboard
        .filter(
          item =>
            item != null &&
            (item.direction !== TableUtils.sortDirection.reverse ||
              !dropReverse)
        ) as SortDescriptor[]
    );
  }

  hydrateDhSort(
    columns: readonly DhType.Column[],
    sorts: readonly SortDescriptor[]
  ): DhType.Sort[] {
    const { dh } = this;
    return (
      sorts
        .map(sortDescriptor => {
          const {
            column: { name },
            isAbs,
            direction,
          } = sortDescriptor;

          if (direction === TableUtils.sortDirection.reverse) {
            return dh.Table.reverse();
          }

          const column = IrisGridUtils.getColumnByName(columns, name);

          if (column != null) {
            let columnSort = column.sort();
            if (isAbs) {
              columnSort = columnSort.abs();
            }
            if (direction === TableUtils.sortDirection.descending) {
              columnSort = columnSort.desc();
            } else {
              columnSort = columnSort.asc();
            }
            return columnSort;
          }

          return null;
        })
        // If we can't find the column any more, it's null, filter it out
        .filter(isNotNullOrUndefined) as DhType.Sort[]
    );
  }

  /**
   * Applies the passed in table settings directly to the provided table
   * @param  table The table to apply the settings to
   * @param  tableSettings Dehydrated table settings extracted with `extractTableSettings`
   * @param  timeZone The time zone to make this value in if it is a date type. E.g. America/New_York
   */
  applyTableSettings(
    table: DhType.Table,
    tableSettings: TableSettings,
    timeZone: string
  ): void {
    const { columns } = table;

    let quickFilters: DhType.FilterCondition[] = [];
    if (tableSettings.quickFilters) {
      quickFilters = IrisGridUtils.getFiltersFromFilterMap(
        this.hydrateQuickFilters(columns, tableSettings.quickFilters, timeZone)
      );
    }

    let advancedFilters: DhType.FilterCondition[] = [];
    if (tableSettings.advancedFilters) {
      advancedFilters = IrisGridUtils.getFiltersFromFilterMap(
        this.hydrateAdvancedFilters(
          columns,
          tableSettings.advancedFilters,
          timeZone
        )
      );
    }
    const inputFilters = this.getFiltersFromInputFilters(
      columns,
      tableSettings.inputFilters,
      timeZone
    );

    let sorts: DhType.Sort[] = [];
    if (tableSettings.sorts) {
      sorts = this.hydrateDhSort(
        columns,
        this.hydrateSort(columns, tableSettings.sorts)
      );
    }

    let filters = [...quickFilters, ...advancedFilters];
    const { partitions, partitionColumns: partitionColumnNames } =
      tableSettings;
    if (
      partitions &&
      partitions.length &&
      partitionColumnNames &&
      partitionColumnNames?.length
    ) {
      const partitionColumns = partitionColumnNames.map(partitionColumnName =>
        IrisGridUtils.getColumnByName(columns, partitionColumnName)
      );
      for (let i = 0; i < partitionColumns.length; i += 1) {
        if (partitionColumns[i] !== undefined && partitions[i] != null) {
          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
          const partitionFilter = partitionColumns[i]!.filter().eq(
            this.dh.FilterValue.ofString(partitions[i])
          );
          filters = [partitionFilter, ...filters];
        }
      }
    }
    filters = [...inputFilters, ...filters];

    table.applyFilter(filters);
    table.applySort(sorts);
  }

  getFiltersFromInputFilters(
    columns: readonly DhType.Column[],
    inputFilters: readonly InputFilter[] = [],
    timeZone?: string
  ): DhType.FilterCondition[] {
    return inputFilters
      .map(({ name, type, value }) => {
        const column = columns.find(
          ({ name: columnName, type: columnType }) =>
            columnName === name && columnType === type
        );
        if (column) {
          try {
            return this.tableUtils.makeQuickFilter(column, value, timeZone);
          } catch (e) {
            // It may be unable to create it because user hasn't completed their input
            log.debug('Unable to create input filter', e);
          }
        }

        return null;
      })
      .filter(filter => filter != null) as DhType.FilterCondition[];
  }

  /**
   * Get the dh.RangeSet representation of the provided ranges.
   * Ranges are sorted prior to creating the RangeSet. Only the rows are taken into account,
   * RangeSet does not have an option for columns.
   * @param  ranges The ranges to get the range set for
   * @returns The rangeset for the provided ranges
   */
  rangeSetFromRanges(ranges: readonly GridRange[]): DhType.RangeSet {
    const { dh } = this;
    const rangeSets = ranges
      .slice()
      .sort((a, b): number => {
        assertNotNull(a.startRow);
        assertNotNull(b.startRow);
        return a.startRow - b.startRow;
      })
      .map(range => {
        const { startRow, endRow } = range;
        assertNotNull(startRow);
        assertNotNull(endRow);
        return dh.RangeSet.ofRange(startRow, endRow);
      });
    return dh.RangeSet.ofRanges(rangeSets);
  }

  /**
   * Get the color for a cell value
   * @param theme The IrisGrid theme
   * @param columnType The type of the column
   * @param columnName The name of the column
   * @param value The value of the cell
   * @returns The color for the cell value
   */
  static colorForValue(
    theme: IrisGridThemeType,
    columnType: string,
    columnName: string,
    value: unknown
  ): string {
    if (TableUtils.isDateType(columnType) || columnName === 'Date') {
      assertNotNull(theme.dateColor);
      return theme.dateColor;
    }
    if (TableUtils.isNumberType(columnType)) {
      if ((value as number) > 0) {
        assertNotNull(theme.positiveNumberColor);
        return theme.positiveNumberColor;
      }
      if ((value as number) < 0) {
        assertNotNull(theme.negativeNumberColor);
        return theme.negativeNumberColor;
      }
      assertNotNull(theme.zeroNumberColor);
      return theme.zeroNumberColor;
    }
    return theme.textColor;
  }

  /**
   * Determines the text alignment for a cell value
   * @param columnType The type of the column
   * @param columnName The name of the column
   * @returns The text alignment for the cell value
   */
  static textAlignForValue(
    columnType: string,
    columnName: string
  ): CanvasTextAlign {
    if (TableUtils.isDateType(columnType) || columnName === 'Date') {
      return 'center';
    }

    if (TableUtils.isNumberType(columnType)) {
      return 'right';
    }

    return 'left';
  }
}

export default IrisGridUtils;