Cell selection

/**
 * Selection over the cells of a grid, as rectangles. A range is two corners —
 * the anchor, which stays, and the focus, which moves as the range is extended
 * — so a column of a million rows is one range, and extending it is changing
 * one number.
 *
 * A selection is a list of ranges. The last is the active one: its anchor is
 * the active cell, where typing goes, and Shift extends it. Command-click adds
 * a range and makes it active.
 */

export interface Cell {
  readonly row: number;
  readonly column: number;
}

export interface CellRange {
  readonly anchor: Cell;
  readonly focus: Cell;
}

export type GridSelection = readonly CellRange[];

export const EMPTY_GRID_SELECTION: GridSelection = Object.freeze([]);

export interface Bounds {
  readonly top: number;
  readonly left: number;
  /** Inclusive, as are the others. */
  readonly bottom: number;
  readonly right: number;
}

export function boundsOf({ anchor, focus }: CellRange): Bounds {
  return {
    top: Math.min(anchor.row, focus.row),
    left: Math.min(anchor.column, focus.column),
    bottom: Math.max(anchor.row, focus.row),
    right: Math.max(anchor.column, focus.column),
  };
}

/** One cell selected, and active. */
export function selectCell(cell: Cell): GridSelection {
  return [{ anchor: cell, focus: cell }];
}

/** The active range redrawn from its anchor to `cell`; other ranges are kept. */
export function extendTo(selection: GridSelection, cell: Cell): GridSelection {
  const active = selection.at(-1);
  if (active === undefined) return selectCell(cell);
  if (active.focus.row === cell.row && active.focus.column === cell.column) return selection;
  return [...selection.slice(0, -1), { anchor: active.anchor, focus: cell }];
}

/** The corner a rectangle is held by: where it starts, or where it ends, in both directions. */
export type Corner = "start" | "end";

/**
 * One rectangle, redrawn by a corner taken to `cell`: the opposite corner stays
 * where it is and is the active cell, which is what a range is measured from.
 * A corner taken past the one that stays turns the rectangle over.
 */
export function dragCorner(bounds: Bounds, corner: Corner, cell: Cell): GridSelection {
  const anchor =
    corner === "start"
      ? { row: bounds.bottom, column: bounds.right }
      : { row: bounds.top, column: bounds.left };
  return [{ anchor, focus: cell }];
}

/** A further range of one cell, which becomes the active one. */
export function addCell(selection: GridSelection, cell: Cell): GridSelection {
  return [...selection, { anchor: cell, focus: cell }];
}

/** Every cell of rows `from` through `to`, with the active cell in the first column of `from`. */
export function selectRows(from: number, to: number, columnCount: number): GridSelection {
  return [{ anchor: { row: from, column: 0 }, focus: { row: to, column: columnCount - 1 } }];
}

/** Every cell of columns `from` through `to`, with the active cell in the first row of `from`. */
export function selectColumns(from: number, to: number, rowCount: number): GridSelection {
  return [{ anchor: { row: 0, column: from }, focus: { row: rowCount - 1, column: to } }];
}

/** Every cell, keeping the active cell where it is. */
export function selectAll(selection: GridSelection, rowCount: number, columnCount: number): GridSelection {
  if (rowCount === 0 || columnCount === 0) return EMPTY_GRID_SELECTION;
  const active = activeCell(selection) ?? { row: 0, column: 0 };
  // Two ranges cover everything while leaving the anchor on the active cell:
  // the whole grid, then the active cell's own range drawn over it.
  return [
    { anchor: { row: 0, column: 0 }, focus: { row: rowCount - 1, column: columnCount - 1 } },
    { anchor: active, focus: active },
  ];
}

/** The cell that typing goes to: the anchor of the active range. */
export function activeCell(selection: GridSelection): Cell | null {
  return selection.at(-1)?.anchor ?? null;
}

/** The far corner of the active range: what Shift with an arrow moves. */
export function focusCell(selection: GridSelection): Cell | null {
  return selection.at(-1)?.focus ?? null;
}

/**
 * The one rectangle a selection is, when it is one: a range that holds every
 * other — all cells, with the active cell's own range within it. Otherwise the
 * active range. This is what is copied, cut and pasted over, so that what is
 * cleared by a cut is exactly what was copied.
 */
export function clipboardBounds(selection: GridSelection): Bounds | null {
  const active = selection.at(-1);
  if (active === undefined) return null;
  const bounds = selection.map(boundsOf);
  const whole = bounds.find((outer) =>
    bounds.every(
      (inner) =>
        inner.top >= outer.top &&
        inner.left >= outer.left &&
        inner.bottom <= outer.bottom &&
        inner.right <= outer.right,
    ),
  );
  return whole ?? boundsOf(active);
}

/** The columns of one row that are selected, as spans `first-last` joined by commas: a row's whole stake in a selection. */
export function rowSpans(selection: GridSelection, row: number): string {
  let spans = "";
  for (const range of selection) {
    const { top, left, bottom, right } = boundsOf(range);
    if (row >= top && row <= bottom) spans += `${spans === "" ? "" : ","}${left}-${right}`;
  }
  return spans;
}

/** Whether a column is within spans written by `rowSpans`. */
export function inSpans(spans: string, column: number): boolean {
  if (spans === "") return false;
  for (const span of spans.split(",")) {
    const dash = span.indexOf("-");
    if (column >= Number(span.slice(0, dash)) && column <= Number(span.slice(dash + 1))) return true;
  }
  return false;
}

export function isCellSelected(selection: GridSelection, row: number, column: number): boolean {
  for (const range of selection) {
    const { top, left, bottom, right } = boundsOf(range);
    if (row >= top && row <= bottom && column >= left && column <= right) return true;
  }
  return false;
}

/** The selection with every cell held inside a grid that has shrunk. */
export function clampSelection(
  selection: GridSelection,
  rowCount: number,
  columnCount: number,
): GridSelection {
  if (rowCount === 0 || columnCount === 0) return EMPTY_GRID_SELECTION;
  const clamp = (cell: Cell): Cell => ({
    row: Math.min(Math.max(cell.row, 0), rowCount - 1),
    column: Math.min(Math.max(cell.column, 0), columnCount - 1),
  });
  let changed = false;
  const next = selection.map((range) => {
    const anchor = clamp(range.anchor);
    const focus = clamp(range.focus);
    if (
      anchor.row === range.anchor.row &&
      anchor.column === range.anchor.column &&
      focus.row === range.focus.row &&
      focus.column === range.focus.column
    ) {
      return range;
    }
    changed = true;
    return { anchor, focus };
  });
  return changed ? next : selection;
}