import { describe, expect, it, vi } from 'vitest'
import { createSelection } from './selection'

// ---------------------------------------------------------------------------
// Fake controller (`ctx`) helpers. The selection factory reads/writes plain
// state on `ctx` and calls a small set of `ctx.grid.*` methods. We build the
// minimal surface each tested path touches.
// ---------------------------------------------------------------------------

function makeGroupRow(id: string) {
  // isGroupRow() checks `typeof row.getCanExpand === 'function' && row.getCanExpand()`
  return { id, getCanExpand: () => true, toggleExpanded: vi.fn(), original: {} }
}
function makeDataRow(id: string, original: any = {}) {
  return {
    id,
    getCanExpand: () => false,
    original,
    getCellValueByColumnId: (colId: string) => original?.[colId],
  }
}
function makeColumn(id: string, columnDef: any = {}) {
  return { id, columnDef }
}

function makeCtx(overrides: any = {}) {
  let rowSelection: Record<string, boolean> = overrides.rowSelectionState ?? {}
  let activeCell: any = overrides.activeCell ?? null
  const setRowSelection = vi.fn((updater: any) => {
    rowSelection =
      typeof updater === 'function' ? updater(rowSelection) : updater
    ctx.rowSelectionState = rowSelection
  })
  const setActiveCell = vi.fn((cell: any) => {
    activeCell = cell
  })
  const ctx: any = {
    rowSelectionState: rowSelection,
    allRows: [],
    allColumns: [],
    headerSelectionState: 'none',
    userHasActivatedCell: false,
    enableCellSelectionEffective: true,
    selectionRange: { anchor: null, focus: null },
    isDraggingSelection: false,
    fillDrag: null,
    activeAtPointerDown: null,
    editingEnabled: false,
    editingCell: undefined,
    scrollContainer: null,
    rowVirtualizationEnabled: false,
    rowScrollScalingActive: false,
    renderedColumnItems: [],
    columnVirtualizer: null,
    theadEl: null,
    headerHeight: 0,
    props: {},
    gridRootEl: null,
    getCellDisplayValue: vi.fn((_r: string, _c: string, base: any) => base),
    toggleBooleanCell: vi.fn(),
    onCellDoubleClick: vi.fn(),
    onFillPointerUp: vi.fn(),
    onFillPointerMove: vi.fn(),
    grid: {
      setRowSelection,
      setActiveCell,
      getState: () => ({ activeCell }),
    },
    ...overrides,
  }
  ctx.rowSelectionState = rowSelection
  return ctx
}

describe('createSelection - row selection', () => {
  it('isRowSelected reflects rowSelectionState', () => {
    const ctx = makeCtx({ rowSelectionState: { r1: true, r2: false } })
    const sel = createSelection(ctx)
    expect(sel.isRowSelected('r1')).toBe(true)
    expect(sel.isRowSelected('r2')).toBe(false)
    expect(sel.isRowSelected('missing')).toBe(false)
  })

  it('toggleRowSelectionById flips the single row', () => {
    const ctx = makeCtx({ rowSelectionState: { r1: false } })
    const sel = createSelection(ctx)
    sel.toggleRowSelectionById('r1')
    expect(ctx.rowSelectionState.r1).toBe(true)
    sel.toggleRowSelectionById('r1')
    expect(ctx.rowSelectionState.r1).toBe(false)
  })

  it('toggleSelectAllRows selects every non-group row when not all selected', () => {
    const ctx = makeCtx({
      headerSelectionState: 'none',
      allRows: [makeDataRow('r1'), makeGroupRow('g1'), makeDataRow('r2')],
    })
    const sel = createSelection(ctx)
    sel.toggleSelectAllRows()
    expect(ctx.rowSelectionState.r1).toBe(true)
    expect(ctx.rowSelectionState.r2).toBe(true)
    // group row excluded
    expect(ctx.rowSelectionState.g1).toBeUndefined()
  })

  it('toggleSelectAllRows deselects all when header state is "all"', () => {
    const ctx = makeCtx({
      headerSelectionState: 'all',
      rowSelectionState: { r1: true, r2: true },
      allRows: [makeDataRow('r1'), makeDataRow('r2')],
    })
    const sel = createSelection(ctx)
    sel.toggleSelectAllRows()
    expect(ctx.rowSelectionState.r1).toBeUndefined()
    expect(ctx.rowSelectionState.r2).toBeUndefined()
  })
})

describe('createSelection - setActiveCell', () => {
  it('sets active cell and flags userHasActivatedCell', () => {
    const ctx = makeCtx({ allColumns: [makeColumn('a'), makeColumn('b')] })
    const sel = createSelection(ctx)
    sel.setActiveCell(2, 1)
    expect(ctx.userHasActivatedCell).toBe(true)
    expect(ctx.grid.setActiveCell).toHaveBeenCalledWith(
      expect.objectContaining({ rowIndex: 2, colIndex: 1 }),
    )
  })

  it('fires onActiveCellChange with resolved columnId', () => {
    const onActiveCellChange = vi.fn()
    const ctx = makeCtx({
      allColumns: [makeColumn('a'), makeColumn('b')],
      props: { onActiveCellChange },
    })
    const sel = createSelection(ctx)
    sel.setActiveCell(0, 1)
    expect(onActiveCellChange).toHaveBeenCalledWith({
      rowIndex: 0,
      colIndex: 1,
      columnId: 'b',
    })
  })

  it('onActiveCellChange columnId falls back to "" when column missing', () => {
    const onActiveCellChange = vi.fn()
    const ctx = makeCtx({ allColumns: [], props: { onActiveCellChange } })
    const sel = createSelection(ctx)
    sel.setActiveCell(0, 5)
    expect(onActiveCellChange).toHaveBeenCalledWith(
      expect.objectContaining({ columnId: '' }),
    )
  })
})

describe('createSelection - range math', () => {
  it('setSelection sets anchor and focus to the same point', () => {
    const ctx = makeCtx()
    const sel = createSelection(ctx)
    sel.setSelection(3, 4)
    expect(ctx.selectionRange).toEqual({
      anchor: { rowIndex: 3, colIndex: 4 },
      focus: { rowIndex: 3, colIndex: 4 },
    })
  })

  it('setSelection is a no-op when cell selection disabled', () => {
    const ctx = makeCtx({ enableCellSelectionEffective: false })
    const before = ctx.selectionRange
    const sel = createSelection(ctx)
    sel.setSelection(1, 1)
    expect(ctx.selectionRange).toBe(before)
  })

  it('extendSelection keeps the existing anchor and moves focus', () => {
    const ctx = makeCtx({
      selectionRange: { anchor: { rowIndex: 1, colIndex: 1 }, focus: { rowIndex: 1, colIndex: 1 } },
    })
    const sel = createSelection(ctx)
    sel.extendSelection(4, 5)
    expect(ctx.selectionRange.anchor).toEqual({ rowIndex: 1, colIndex: 1 })
    expect(ctx.selectionRange.focus).toEqual({ rowIndex: 4, colIndex: 5 })
  })

  it('extendSelection uses the new point as anchor when none exists', () => {
    const ctx = makeCtx({ selectionRange: { anchor: null, focus: null } })
    const sel = createSelection(ctx)
    sel.extendSelection(2, 3)
    expect(ctx.selectionRange.anchor).toEqual({ rowIndex: 2, colIndex: 3 })
    expect(ctx.selectionRange.focus).toEqual({ rowIndex: 2, colIndex: 3 })
  })

  it('extendSelection is a no-op when cell selection disabled', () => {
    const ctx = makeCtx({ enableCellSelectionEffective: false })
    const before = ctx.selectionRange
    const sel = createSelection(ctx)
    sel.extendSelection(1, 1)
    expect(ctx.selectionRange).toBe(before)
  })

  it('isCellInSelectedRange covers normalized ranges (anchor > focus)', () => {
    const ctx = makeCtx({
      selectionRange: { anchor: { rowIndex: 4, colIndex: 4 }, focus: { rowIndex: 1, colIndex: 1 } },
    })
    const sel = createSelection(ctx)
    expect(sel.isCellInSelectedRange(2, 3)).toBe(true)
    expect(sel.isCellInSelectedRange(1, 1)).toBe(true)
    expect(sel.isCellInSelectedRange(4, 4)).toBe(true)
    expect(sel.isCellInSelectedRange(0, 0)).toBe(false)
    expect(sel.isCellInSelectedRange(5, 5)).toBe(false)
  })

  it('isCellInSelectedRange returns false when no range', () => {
    const ctx = makeCtx({ selectionRange: { anchor: null, focus: null } })
    const sel = createSelection(ctx)
    expect(sel.isCellInSelectedRange(0, 0)).toBe(false)
  })
})

describe('createSelection - getCellRangeEdges', () => {
  it('returns null outside the range', () => {
    const ctx = makeCtx({
      selectionRange: { anchor: { rowIndex: 1, colIndex: 1 }, focus: { rowIndex: 3, colIndex: 3 } },
    })
    const sel = createSelection(ctx)
    expect(sel.getCellRangeEdges(0, 0)).toBeNull()
    expect(sel.getCellRangeEdges(5, 5)).toBeNull()
  })

  it('returns null when range unset', () => {
    const ctx = makeCtx()
    const sel = createSelection(ctx)
    expect(sel.getCellRangeEdges(0, 0)).toBeNull()
  })

  it('marks all four edges for a single-cell range', () => {
    const ctx = makeCtx({
      selectionRange: { anchor: { rowIndex: 2, colIndex: 2 }, focus: { rowIndex: 2, colIndex: 2 } },
    })
    const sel = createSelection(ctx)
    expect(sel.getCellRangeEdges(2, 2)).toEqual({ top: true, bottom: true, left: true, right: true })
  })

  it('flags only the corner edges for a corner cell of a wider range', () => {
    const ctx = makeCtx({
      selectionRange: { anchor: { rowIndex: 1, colIndex: 1 }, focus: { rowIndex: 3, colIndex: 3 } },
    })
    const sel = createSelection(ctx)
    expect(sel.getCellRangeEdges(1, 1)).toEqual({ top: true, bottom: false, left: true, right: false })
    expect(sel.getCellRangeEdges(2, 2)).toEqual({ top: false, bottom: false, left: false, right: false })
    expect(sel.getCellRangeEdges(3, 3)).toEqual({ top: false, bottom: true, left: false, right: true })
  })
})

describe('createSelection - isInFillPreview', () => {
  it('returns false when no fill drag active', () => {
    const ctx = makeCtx({ fillDrag: null })
    const sel = createSelection(ctx)
    expect(sel.isInFillPreview(0, 0)).toBe(false)
  })

  it('returns false for cells outside the preview rectangle', () => {
    const ctx = makeCtx({
      fillDrag: { sourceMinRow: 0, sourceMaxRow: 1, sourceMinCol: 0, sourceMaxCol: 0, targetRow: 3, targetCol: 0 },
    })
    const sel = createSelection(ctx)
    expect(sel.isInFillPreview(5, 0)).toBe(false)
    expect(sel.isInFillPreview(0, 5)).toBe(false)
  })

  it('returns true for cells in the preview but outside the source', () => {
    const ctx = makeCtx({
      fillDrag: { sourceMinRow: 0, sourceMaxRow: 1, sourceMinCol: 0, sourceMaxCol: 0, targetRow: 3, targetCol: 0 },
    })
    const sel = createSelection(ctx)
    expect(sel.isInFillPreview(2, 0)).toBe(true) // below source, within preview
    expect(sel.isInFillPreview(0, 0)).toBe(false) // inside the source range
  })
})

describe('createSelection - findColumnById', () => {
  it('finds a column by id or returns undefined', () => {
    const ctx = makeCtx({ allColumns: [makeColumn('a'), makeColumn('b')] })
    const sel = createSelection(ctx)
    expect(sel.findColumnById('b')?.id).toBe('b')
    expect(sel.findColumnById('zzz')).toBeUndefined()
  })
})

describe('createSelection - onCellPointerDown', () => {
  function baseCtx(over: any = {}) {
    return makeCtx({
      allRows: [makeDataRow('r0'), makeDataRow('r1')],
      allColumns: [makeColumn('c0', { editorType: 'text' }), makeColumn('c1', { editorType: 'text' })],
      ...over,
    })
  }

  it('ignores non-left button', () => {
    const ctx = baseCtx()
    const sel = createSelection(ctx)
    sel.onCellPointerDown(0, 0, { button: 2 } as any)
    expect(ctx.grid.setActiveCell).not.toHaveBeenCalled()
  })

  it('ignores group rows', () => {
    const ctx = baseCtx({ allRows: [makeGroupRow('g0')] })
    const sel = createSelection(ctx)
    sel.onCellPointerDown(0, 0, { button: 0, shiftKey: false } as any)
    expect(ctx.grid.setActiveCell).not.toHaveBeenCalled()
  })

  it('starts a drag on checkbox columns too (by editorType)', () => {
    // A range drag must be able to START on a checkbox cell; the plain-click
    // toggle still runs via onCellClick (same-cell click).
    const ctx = baseCtx({
      allColumns: [makeColumn('c0', { editorType: 'checkbox' })],
    })
    const sel = createSelection(ctx)
    sel.onCellPointerDown(0, 0, { button: 0, shiftKey: false } as any)
    expect(ctx.grid.setActiveCell).toHaveBeenCalled()
    expect(ctx.isDraggingSelection).toBe(true)
  })

  it('starts a drag on boolean-valued cells too', () => {
    const ctx = baseCtx({
      getCellDisplayValue: vi.fn(() => true),
    })
    const sel = createSelection(ctx)
    sel.onCellPointerDown(0, 0, { button: 0, shiftKey: false } as any)
    expect(ctx.grid.setActiveCell).toHaveBeenCalled()
    expect(ctx.isDraggingSelection).toBe(true)
  })

  it('plain click sets active + selection and starts a drag', () => {
    const ctx = baseCtx()
    const sel = createSelection(ctx)
    sel.onCellPointerDown(1, 1, { button: 0, shiftKey: false } as any)
    expect(ctx.isDraggingSelection).toBe(true)
    expect(ctx.selectionRange.anchor).toEqual({ rowIndex: 1, colIndex: 1 })
    expect(ctx.grid.setActiveCell).toHaveBeenCalled()
    expect(ctx.activeAtPointerDown).toBeNull()
  })

  it('shift click extends the existing range without starting a drag', () => {
    const ctx = baseCtx({
      selectionRange: { anchor: { rowIndex: 0, colIndex: 0 }, focus: { rowIndex: 0, colIndex: 0 } },
      activeCell: { rowIndex: 0, colIndex: 0 },
    })
    const sel = createSelection(ctx)
    sel.onCellPointerDown(1, 1, { button: 0, shiftKey: true } as any)
    expect(ctx.isDraggingSelection).toBe(false)
    expect(ctx.selectionRange.anchor).toEqual({ rowIndex: 0, colIndex: 0 })
    expect(ctx.selectionRange.focus).toEqual({ rowIndex: 1, colIndex: 1 })
    expect(ctx.activeAtPointerDown).toEqual({ rowIndex: 0, colIndex: 0 })
  })
})

describe('createSelection - onCellPointerEnter / drag', () => {
  it('does nothing when not dragging', () => {
    const ctx = makeCtx({ isDraggingSelection: false, allRows: [makeDataRow('r0')] })
    const sel = createSelection(ctx)
    sel.onCellPointerEnter(0, 0)
    expect(ctx.grid.setActiveCell).not.toHaveBeenCalled()
  })

  it('extends selection and moves active cell while dragging', () => {
    const ctx = makeCtx({
      isDraggingSelection: true,
      selectionRange: { anchor: { rowIndex: 0, colIndex: 0 }, focus: { rowIndex: 0, colIndex: 0 } },
      allRows: [makeDataRow('r0'), makeDataRow('r1')],
      allColumns: [makeColumn('c0'), makeColumn('c1')],
    })
    const sel = createSelection(ctx)
    sel.onCellPointerEnter(1, 1)
    expect(ctx.selectionRange.focus).toEqual({ rowIndex: 1, colIndex: 1 })
    expect(ctx.grid.setActiveCell).toHaveBeenCalled()
  })

  it('ignores group rows while dragging', () => {
    const ctx = makeCtx({ isDraggingSelection: true, allRows: [makeGroupRow('g0')] })
    const sel = createSelection(ctx)
    sel.onCellPointerEnter(0, 0)
    expect(ctx.grid.setActiveCell).not.toHaveBeenCalled()
  })
})

describe('createSelection - endDragSelection / window move', () => {
  it('endDragSelection clears the drag flag', () => {
    const ctx = makeCtx({ isDraggingSelection: true })
    const sel = createSelection(ctx)
    sel.endDragSelection()
    expect(ctx.isDraggingSelection).toBe(false)
  })

  it('endDragSelection commits a pending fill drag', () => {
    const ctx = makeCtx({ isDraggingSelection: true, fillDrag: { x: 1 } })
    const sel = createSelection(ctx)
    sel.endDragSelection()
    expect(ctx.onFillPointerUp).toHaveBeenCalled()
  })

  it('onWindowPointerMove delegates to fill move when fill active', () => {
    const ctx = makeCtx({ fillDrag: { x: 1 } })
    const sel = createSelection(ctx)
    const ev = { buttons: 1 } as any
    sel.onWindowPointerMove(ev)
    expect(ctx.onFillPointerMove).toHaveBeenCalledWith(ev)
  })

  it('onWindowPointerMove ignores when not dragging and no fill', () => {
    const ctx = makeCtx({ fillDrag: null, isDraggingSelection: false })
    const sel = createSelection(ctx)
    sel.onWindowPointerMove({ buttons: 0 } as any)
    expect(ctx.onFillPointerUp).not.toHaveBeenCalled()
  })

  it('onWindowPointerMove ends the drag when no buttons held', () => {
    const ctx = makeCtx({ fillDrag: null, isDraggingSelection: true })
    const sel = createSelection(ctx)
    sel.onWindowPointerMove({ buttons: 0 } as any)
    expect(ctx.isDraggingSelection).toBe(false)
  })

  it('onWindowPointerMove keeps the drag while a button is held', () => {
    const ctx = makeCtx({ fillDrag: null, isDraggingSelection: true })
    const sel = createSelection(ctx)
    sel.onWindowPointerMove({ buttons: 1 } as any)
    expect(ctx.isDraggingSelection).toBe(true)
  })
})

describe('createSelection - onCellClick', () => {
  function clickCtx(over: any = {}) {
    return makeCtx({
      allRows: [makeDataRow('r0', { id: 0 }), makeDataRow('r1', { id: 1 })],
      allColumns: [makeColumn('c0', { editorType: 'text' }), makeColumn('c1', { editorType: 'text' })],
      gridRootEl: { focus: vi.fn() },
      ...over,
    })
  }

  it('returns early when row or column missing', () => {
    const ctx = clickCtx({ allRows: [] })
    const sel = createSelection(ctx)
    sel.onCellClick(0, 0)
    expect(ctx.gridRootEl.focus).not.toHaveBeenCalled()
  })

  it('toggles expansion for a group row', () => {
    const group = makeGroupRow('g0')
    const ctx = clickCtx({ allRows: [group] })
    const sel = createSelection(ctx)
    sel.onCellClick(0, 0)
    expect(group.toggleExpanded).toHaveBeenCalled()
    expect(ctx.grid.setActiveCell).toHaveBeenCalled()
  })

  it('emits onCellClick and onRowClick for data cells', () => {
    const onCellClick = vi.fn()
    const onRowClick = vi.fn()
    const ctx = clickCtx({ props: { onCellClick, onRowClick } })
    const sel = createSelection(ctx)
    sel.onCellClick(1, 0)
    expect(onCellClick).toHaveBeenCalledWith(
      expect.objectContaining({ rowIndex: 1, colIndex: 0, columnId: 'c0' }),
    )
    expect(onRowClick).toHaveBeenCalledWith(
      expect.objectContaining({ rowIndex: 1, columnId: 'c0' }),
    )
  })

  it('toggles a checkbox cell and clears editing', () => {
    const ctx = clickCtx({
      allColumns: [makeColumn('c0', { editorType: 'checkbox' })],
      editingCell: { rowIndex: 0, colIndex: 0 },
    })
    const sel = createSelection(ctx)
    sel.onCellClick(0, 0)
    expect(ctx.toggleBooleanCell).toHaveBeenCalledWith(0, 0)
    expect(ctx.editingCell).toBeNull()
    expect(ctx.selectionRange.anchor).toEqual({ rowIndex: 0, colIndex: 0 })
  })

  it('enters edit mode when clicking the previously-active editable cell', () => {
    const ctx = clickCtx({
      editingEnabled: true,
      activeAtPointerDown: { rowIndex: 0, colIndex: 0 },
    })
    const sel = createSelection(ctx)
    sel.onCellClick(0, 0)
    expect(ctx.onCellDoubleClick).toHaveBeenCalledWith(0, 0)
  })

  it('clears editing when not re-clicking the active cell', () => {
    const ctx = clickCtx({
      editingEnabled: true,
      activeAtPointerDown: { rowIndex: 1, colIndex: 1 },
      editingCell: { rowIndex: 0, colIndex: 0 },
    })
    const sel = createSelection(ctx)
    sel.onCellClick(0, 0)
    expect(ctx.onCellDoubleClick).not.toHaveBeenCalled()
    expect(ctx.editingCell).toBeNull()
  })
})

describe('createSelection - emitCellDoubleClick', () => {
  it('emits the public double-click events and runs edit entry', () => {
    const onCellDoubleClick = vi.fn()
    const onRowDoubleClick = vi.fn()
    const ctx = makeCtx({
      allRows: [makeDataRow('r0', { id: 0 })],
      allColumns: [makeColumn('c0', { editorType: 'text' })],
      props: { onCellDoubleClick, onRowDoubleClick },
    })
    const sel = createSelection(ctx)
    sel.emitCellDoubleClick(0, 0)
    expect(onCellDoubleClick).toHaveBeenCalledWith(
      expect.objectContaining({ rowIndex: 0, colIndex: 0, columnId: 'c0' }),
    )
    expect(onRowDoubleClick).toHaveBeenCalled()
    expect(ctx.onCellDoubleClick).toHaveBeenCalledWith(0, 0)
  })

  it('skips the public events for group rows but still runs edit entry', () => {
    const onCellDoubleClick = vi.fn()
    const ctx = makeCtx({
      allRows: [makeGroupRow('g0')],
      allColumns: [makeColumn('c0')],
      props: { onCellDoubleClick },
    })
    const sel = createSelection(ctx)
    sel.emitCellDoubleClick(0, 0)
    expect(onCellDoubleClick).not.toHaveBeenCalled()
    expect(ctx.onCellDoubleClick).toHaveBeenCalledWith(0, 0)
  })
})

describe('createSelection - scrollActiveCellIntoView', () => {
  it('returns early without a scroll container', () => {
    const ctx = makeCtx({ scrollContainer: null })
    const sel = createSelection(ctx)
    expect(() => sel.scrollActiveCellIntoView(0, 0)).not.toThrow()
  })

  it('returns early for out-of-bounds indices', () => {
    const container = document.createElement('div')
    const ctx = makeCtx({
      scrollContainer: container,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0')],
    })
    const sel = createSelection(ctx)
    // rowIndex out of range -> early return, no throw
    expect(() => sel.scrollActiveCellIntoView(5, 0)).not.toThrow()
    expect(() => sel.scrollActiveCellIntoView(0, 5)).not.toThrow()
  })

  it('adjusts scrollLeft in non-virtualized mode using column virtualizer offsets', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientWidth', { value: 100, configurable: true })
    Object.defineProperty(container, 'clientHeight', { value: 100, configurable: true })
    container.scrollLeft = 500
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: false,
      allRows: [makeDataRow('r0'), makeDataRow('r1')],
      allColumns: [makeColumn('c0'), makeColumn('c1'), makeColumn('c2')],
      renderedColumnItems: [],
      columnVirtualizer: {
        getOffsetForIndex: (i: number) => i * 140,
        getSizeForIndex: () => 140,
      },
      theadEl: { offsetHeight: 0 },
    })
    const sel = createSelection(ctx)
    // target column 0 is left of the current scrollLeft -> scroll left to it
    sel.scrollActiveCellIntoView(0, 0)
    expect(container.scrollLeft).toBe(0)
  })

  it('virtualized: uses native scrollIntoView when the row is mounted', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientWidth', { value: 100, configurable: true })
    Object.defineProperty(container, 'clientHeight', { value: 100, configurable: true })
    const tr = document.createElement('tr')
    tr.className = 'sv-grid-row'
    const cell = document.createElement('td')
    cell.setAttribute('data-svgrid-row', '0')
    tr.appendChild(cell)
    container.appendChild(tr)
    const scrollIntoView = vi.fn()
    tr.scrollIntoView = scrollIntoView
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: true,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0')],
      renderedColumnItems: [{ index: 0, start: 0, size: 140 }],
    })
    const sel = createSelection(ctx)
    sel.scrollActiveCellIntoView(0, 0)
    expect(scrollIntoView).toHaveBeenCalledWith(
      expect.objectContaining({ block: 'nearest' }),
    )
  })

  it('virtualized + scroll scaling: maps the logical offset into DOM space', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientHeight', { value: 100, configurable: true })
    container.scrollTop = 0
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: true,
      rowScrollScalingActive: true,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0')],
      theadEl: { offsetHeight: 10 },
      virtualizer: { getOffsetForIndex: () => 1000, getSizeForIndex: () => 20 },
      logicalToDomRowOffset: (n: number) => n / 2, // 1000 -> 500
      columnVirtualizer: { getOffsetForIndex: () => 0, getSizeForIndex: () => 140 },
    })
    const sel = createSelection(ctx)
    sel.scrollActiveCellIntoView(0, 0)
    // nextTop = max(500 - 10, 0) = 490
    expect(container.scrollTop).toBe(490)
  })

  it('virtualized: computes scrollTop manually when the row is offscreen', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientHeight', { value: 100, configurable: true })
    container.scrollTop = 0
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: true,
      rowScrollScalingActive: false,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0')],
      theadEl: { offsetHeight: 10 },
      virtualizer: { getOffsetForIndex: () => 500, getSizeForIndex: () => 30 },
      columnVirtualizer: { getOffsetForIndex: () => 0, getSizeForIndex: () => 140 },
    })
    const sel = createSelection(ctx)
    sel.scrollActiveCellIntoView(0, 0)
    // rowBottom = 10 + 500 + 30 = 540 > 0 + 100 -> nextTop = 540 - 100 = 440
    expect(container.scrollTop).toBe(440)
  })

  it('non-virtualized: scrolls up when the cell overlaps the sticky header', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientHeight', { value: 200, configurable: true })
    Object.defineProperty(container, 'clientWidth', { value: 500, configurable: true })
    container.scrollTop = 100
    container.scrollLeft = 0
    container.getBoundingClientRect = () =>
      ({ top: 0, left: 0, bottom: 200, right: 500 } as DOMRect)
    const td = document.createElement('td')
    td.setAttribute('data-svgrid-row', '0')
    td.setAttribute('data-svgrid-col', '0')
    td.getBoundingClientRect = () =>
      ({ top: 5, bottom: 35, left: 0, right: 140 } as DOMRect)
    container.appendChild(td)
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: false,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0')],
      headerHeight: 30,
      theadEl: { offsetHeight: 30 },
      renderedColumnItems: [{ index: 0, start: 0, size: 140 }],
    })
    const sel = createSelection(ctx)
    sel.scrollActiveCellIntoView(0, 0)
    // cellTopInView (5) < headerHeight (30) -> nextTop = 100 + 5 - 30 = 75
    expect(container.scrollTop).toBe(75)
  })

  it('non-virtualized: scrolls down when the cell is past the bottom', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientHeight', { value: 200, configurable: true })
    Object.defineProperty(container, 'clientWidth', { value: 500, configurable: true })
    container.scrollTop = 0
    container.scrollLeft = 0
    container.getBoundingClientRect = () =>
      ({ top: 0, left: 0, bottom: 200, right: 500 } as DOMRect)
    const td = document.createElement('td')
    td.setAttribute('data-svgrid-row', '0')
    td.setAttribute('data-svgrid-col', '0')
    td.getBoundingClientRect = () =>
      ({ top: 250, bottom: 290, left: 0, right: 140 } as DOMRect)
    container.appendChild(td)
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: false,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0')],
      headerHeight: 30,
      theadEl: { offsetHeight: 30 },
      renderedColumnItems: [{ index: 0, start: 0, size: 140 }],
    })
    const sel = createSelection(ctx)
    sel.scrollActiveCellIntoView(0, 0)
    // cellBotInView (290) > clientHeight (200) -> nextTop = 0 + 290 - 200 = 90
    expect(container.scrollTop).toBe(90)
  })

  it('scrolls right when the target column is past the viewport', () => {
    const container = document.createElement('div')
    Object.defineProperty(container, 'clientWidth', { value: 100, configurable: true })
    Object.defineProperty(container, 'clientHeight', { value: 100, configurable: true })
    container.scrollLeft = 0
    const ctx = makeCtx({
      scrollContainer: container,
      rowVirtualizationEnabled: false,
      allRows: [makeDataRow('r0')],
      allColumns: [makeColumn('c0'), makeColumn('c1'), makeColumn('c2')],
      renderedColumnItems: [{ index: 2, start: 280, size: 140 }],
      theadEl: { offsetHeight: 0 },
    })
    const sel = createSelection(ctx)
    sel.scrollActiveCellIntoView(0, 2)
    // cellEnd (420) - clientWidth (100) = 320
    expect(container.scrollLeft).toBe(320)
  })
})

describe('createSelection - fillMarqueeEdges (Excel fill marquee)', () => {
  // Union rectangle spans rows 1..4, cols 0..2 (source cols 0..1 extended to col 2,
  // source rows 1..2 extended to row 4).
  const fillDrag = {
    sourceMinRow: 1, sourceMaxRow: 2, sourceMinCol: 0, sourceMaxCol: 1,
    targetRow: 4, targetCol: 2,
  }

  it('returns null when there is no fill drag', () => {
    const sel = createSelection(makeCtx())
    expect(sel.fillMarqueeEdges(1, 0)).toBeNull()
  })

  it('flags the outer edges of the whole target rectangle', () => {
    const sel = createSelection(makeCtx({ fillDrag }))
    expect(sel.fillMarqueeEdges(1, 0)).toEqual({ top: true, bottom: false, left: true, right: false })
    expect(sel.fillMarqueeEdges(4, 2)).toEqual({ top: false, bottom: true, left: false, right: true })
    expect(sel.fillMarqueeEdges(1, 1)).toEqual({ top: true, bottom: false, left: false, right: false })
  })

  it('returns null for interior cells and cells outside the rectangle', () => {
    const sel = createSelection(makeCtx({ fillDrag }))
    expect(sel.fillMarqueeEdges(2, 1)).toBeNull() // interior
    expect(sel.fillMarqueeEdges(0, 0)).toBeNull() // above
    expect(sel.fillMarqueeEdges(5, 2)).toBeNull() // below
  })
})