ghostgram/submodules/TelegramUI/Components/RichTextEditor/Tests/RichTextEditorUIKitTests/SelectionInteractionTests.swift

#if canImport(UIKit)
import XCTest
import UIKit
@testable import RichTextEditorUIKit
import RichTextEditorCore

final class SelectionInteractionTests: XCTestCase {
    /// Keeps the test window alive for the duration of a test (a view only becomes first responder once it's
    /// in a window). Recreated per test via `setUp`.
    private var window: UIWindow!

    override func setUp() {
        super.setUp()
        window = UIWindow(frame: CGRect(x: 0, y: 0, width: 400, height: 800))
        window.makeKeyAndVisible()
    }
    override func tearDown() {
        window.isHidden = true
        window = nil
        super.tearDown()
    }

    /// Adds `v` to the key window (so `becomeFirstResponder` can succeed) and lays it out.
    private func hostInWindow(_ v: DocumentCanvasView) {
        window.addSubview(v)
        v.layoutIfNeeded()
    }

    private func canvasWithInteraction() -> DocumentCanvasView {
        let v = DocumentCanvasView()
        v.setBlocks([.paragraph(ParagraphBlock(id: BlockID("p"), runs: [TextRun(text: "Hello world")]))], width: 320)
        v.frame = CGRect(x: 0, y: 0, width: 320, height: 200)
        v.installSelectionInteractions()
        hostInWindow(v)
        return v
    }

    /// A canvas with a leading paragraph + a wide (horizontally-scrollable) table, sized so the table
    /// overflows the canvas width (7 columns × 100pt grid columns in a 390pt-wide canvas → scrolls).
    private func canvasWithWideTable() -> (canvas: DocumentCanvasView, table: TableBlockBox) {
        func cell(_ id: String, _ text: String) -> Cell {
            Cell(id: BlockID(id), blocks: [.paragraph(ParagraphBlock(id: BlockID("\(id)p"), runs: [TextRun(text: text)]))])
        }
        let cols = (0..<7).map { _ in ColumnSpec(width: 100) }
        let header = Row(id: BlockID("hr"), isHeader: true, cells: (0..<7).map { cell("h\($0)", "H\($0)") })
        let body = Row(id: BlockID("br"), cells: (0..<7).map { cell("b\($0)", "B\($0)") })
        let table = TableBlock(id: BlockID("wt"), columns: cols, rows: [header, body])
        let v = DocumentCanvasView()
        v.setBlocks([
            .paragraph(ParagraphBlock(id: BlockID("p"), runs: [TextRun(text: "Lead paragraph")])),
            .table(table),
        ], width: 390)
        v.frame = CGRect(x: 0, y: 0, width: 390, height: 600)
        v.installSelectionInteractions()
        hostInWindow(v)
        let box = v.boxes.compactMap { $0 as? TableBlockBox }.first { $0.id == BlockID("wt") }!
        return (v, box)
    }

    /// Two stacked body paragraphs, so the END handle's knob (drawn BELOW paragraph 1's line) sits over
    /// paragraph 2's territory — the geometry that exposes the line-centering drag bug.
    private func canvasWithTwoParagraphs() -> DocumentCanvasView {
        let v = DocumentCanvasView()
        v.setBlocks([
            .paragraph(ParagraphBlock(id: BlockID("p1"), runs: [TextRun(text: "First line")])),
            .paragraph(ParagraphBlock(id: BlockID("p2"), runs: [TextRun(text: "Second line")])),
        ], width: 320)
        v.frame = CGRect(x: 0, y: 0, width: 320, height: 200)
        v.installSelectionInteractions()
        hostInWindow(v)
        return v
    }

    // MARK: - Handle drag preserves the initial touch→knob offset (iOS-style, not line-centered)

    func test_selectionHandleDrag_preservesGrabOffset_doesNotSnapToAdjacentLine() {
        // Grabbing a selection knob should keep the endpoint at its starting offset from the touch — the knob
        // is drawn OFFSET from the text line, so mapping the raw finger point snaps the endpoint to whatever
        // line is under the finger (here: paragraph 2). The drag must instead track the grabbed endpoint.
        let v = canvasWithTwoParagraphs()
        _ = v.becomeFirstResponder()
        let head = v.boxes[0].textStart + 5            // select "First" in paragraph 1
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head)
        v.setSelectionHead(global: head)

        let r = SelectionHandleView.knobRadius
        let caret = v.caretRect(for: DocumentTextPosition(head))
        let endKnob = CGPoint(x: caret.midX, y: caret.maxY + r)   // END knob, drawn BELOW paragraph 1's line

        // Precondition: a RAW knob touch projects onto the adjacent line (the bug we're fixing).
        XCTAssertNotEqual(v.closestGlobalPosition(to: endKnob), head,
                          "precondition: a raw knob touch lands on the adjacent line, not the grabbed endpoint")

        // Begin the drag at the knob (captures the touch→endpoint offset), then map at the SAME touch point.
        v.captureSelectionDragOffset(endpoint: .head, touch: endKnob)
        XCTAssertEqual(v.selectionDragPosition(forTouch: endKnob), head,
                       "the drag preserves the grab offset — maps to the grabbed endpoint, not the finger's line")
    }

    func test_selectionDragPosition_tracksTheCaretAnchoredPoint_whenTouchMoves() {
        // After a grab, moving the touch by Δ must map as if the finger were Δ from the captured anchor
        // (touch + storedOffset), i.e. the offset is preserved across the whole drag — not re-derived per move.
        let v = canvasWithTwoParagraphs()
        _ = v.becomeFirstResponder()
        let head = v.boxes[0].textStart + 5
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head)
        v.setSelectionHead(global: head)

        let r = SelectionHandleView.knobRadius
        let caret = v.caretRect(for: DocumentTextPosition(head))
        let endKnob = CGPoint(x: caret.midX, y: caret.maxY + r)
        v.captureSelectionDragOffset(endpoint: .head, touch: endKnob)

        let delta = CGPoint(x: 40, y: 0)
        let moved = CGPoint(x: endKnob.x + delta.x, y: endKnob.y + delta.y)
        // storedOffset == caretCenter − endKnob, so selectionDragPosition(moved) == closest(caretCenter + delta).
        let expected = v.closestGlobalPosition(to: CGPoint(x: caret.midX + delta.x, y: caret.midY + delta.y))
        XCTAssertEqual(v.selectionDragPosition(forTouch: moved), expected,
                       "drag maps touch+storedOffset, preserving the initial grab offset as the touch moves")
    }

    // MARK: - Handle views are host-configurable (carry Display dismiss-gesture flags)

    func test_selectionHandleViews_areInteractive_soTheyCanCarryHostFlags() {
        // The handle views must be hit-testable for a knob touch to resolve to THEM (not the whole editor),
        // so a host-set `disablesInteractiveModalDismiss`/`…Keyboard…` flag is scoped to knob interaction.
        let v = canvasWithInteraction()
        XCTAssertTrue(v.startHandleView.isUserInteractionEnabled)
        XCTAssertTrue(v.endHandleView.isUserInteractionEnabled)
    }

    func test_configureSelectionHandleView_isAppliedToBothHandles() {
        let v = canvasWithInteraction()
        var configuredIsStart: [Bool] = []
        v.configureSelectionHandleView = { handle in
            if let h = handle as? SelectionHandleView { configuredIsStart.append(h.isStart) }
        }
        XCTAssertEqual(Set(configuredIsStart), Set([true, false]),
                       "the host hook is applied to both the start and end handle views")
    }

    func test_selectionHandleView_hitArea_matchesTheDragTolerance_aroundTheCaret() {
        // The interactive hit area must match the canvas drag gate (±dragHitTolerance around the endpoint
        // caret) so the dismiss-gesture flag covers exactly where a handle drag can start.
        let handle = SelectionHandleView(isStart: false)
        let caret = CGRect(x: 50, y: 100, width: 2, height: 20)
        handle.frame = handle.boundingFrame(forCaret: caret)
        handle.setCaretLocalRect(handle.caretLocalRect(forCaret: caret))
        let tol = SelectionHandleView.dragHitTolerance
        let local = handle.caretLocalRect(forCaret: caret)
        XCTAssertTrue(handle.point(inside: CGPoint(x: local.midX, y: local.midY), with: nil), "on the caret")
        XCTAssertTrue(handle.point(inside: CGPoint(x: local.midX, y: local.maxY + tol - 1), with: nil), "within tolerance below")
        XCTAssertFalse(handle.point(inside: CGPoint(x: local.midX, y: local.maxY + tol + 5), with: nil), "beyond tolerance")
    }

    // MARK: - The move-cursor long-press yields to an active selection handle

    func test_cursorLongPress_isBlocked_onAnActiveSelectionHandle_soTheHandleCanBeGrabbed() {
        // With a ranged selection the two handle lollipops show. Pressing one to drag it must NOT let the
        // loupe / move-cursor long-press begin — otherwise it fires on the stationary hold (before the handle
        // pan can move), collapses the selection via setCaret, and the handles vanish before they can be
        // grabbed. So the long-press gate fails on a touch that lands on a handle (an "active item").
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head)
        v.setSelectionHead(global: v.boxes[0].textStart + 5)

        let startCaret = v.caretRect(for: DocumentTextPosition(v.selFrom))
        let endCaret = v.caretRect(for: DocumentTextPosition(v.selTo))
        XCTAssertFalse(v.shouldBeginCursorLongPress(at: CGPoint(x: startCaret.midX, y: startCaret.midY)),
                       "the long-press must not begin on the START handle — the handle pan owns that touch")
        XCTAssertFalse(v.shouldBeginCursorLongPress(at: CGPoint(x: endCaret.midX, y: endCaret.midY)),
                       "the long-press must not begin on the END handle")
    }

    func test_cursorLongPress_stillBegins_awayFromTheHandles_whileASelectionIsActive() {
        // Only a touch ON a handle blocks the long-press; a long-press elsewhere in the document still moves
        // the cursor (standard iOS: it collapses the selection at the pressed point).
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head)
        v.setSelectionHead(global: v.boxes[0].textStart + 5)

        let endCaret = v.caretRect(for: DocumentTextPosition(v.selTo))
        let farPoint = CGPoint(x: 300, y: endCaret.midY)   // far to the right of both endpoints
        XCTAssertTrue(v.shouldBeginCursorLongPress(at: farPoint),
                      "away from both handles the move-cursor long-press proceeds normally")
    }

    func test_cursorLongPress_alwaysBegins_whenSelectionIsCollapsed() {
        // No ranged selection ⇒ no handles ⇒ nothing to protect; grabbing the caret with a long-press must
        // still work even directly on the caret.
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        v.setCaret(global: v.boxes[0].textStart + 2)
        let caret = v.caretRect(for: DocumentTextPosition(v.head))
        XCTAssertTrue(v.shouldBeginCursorLongPress(at: CGPoint(x: caret.midX, y: caret.midY)),
                      "with a collapsed selection the long-press begins even on the caret (grab-the-cursor)")
    }

    // MARK: - Loupe end does not re-present (flicker) an already-open menu on a stationary press

    func test_loupeEnd_suppressesRepresent_forAStationaryPressOnAnAlreadyOpenMenu() {
        // A quick tap near the caret is caught as a loupe (0.05s near-cursor delay). If the menu is already open,
        // the loupe dismisses it on .began; re-presenting on .ended is the disappear-then-reappear flicker. A
        // stationary press (caret didn't move) on an open menu is a tap-like toggle-off → do NOT re-present.
        let v = canvasWithInteraction()
        XCTAssertFalse(v.loupeShouldPresentMenuOnEnd(menuWasVisibleAtBegan: true, caretMoved: false),
                       "stationary press on an already-open menu → toggle off, no re-present (no flicker)")
        // A press that began with no menu is a normal long-press → present the menu on release.
        XCTAssertTrue(v.loupeShouldPresentMenuOnEnd(menuWasVisibleAtBegan: false, caretMoved: false),
                      "long-press with no menu open → present on release")
        // A real cursor DRAG presents at the new caret even if the menu was open (native behavior).
        XCTAssertTrue(v.loupeShouldPresentMenuOnEnd(menuWasVisibleAtBegan: true, caretMoved: true),
                      "a drag re-presents at the new caret position")
        XCTAssertTrue(v.loupeShouldPresentMenuOnEnd(menuWasVisibleAtBegan: false, caretMoved: true),
                      "a drag from no menu presents on release")
    }

    // MARK: - The loupe gray "shadow" caret shows only once the accent glider diverges from it

    func test_loupeShadowShouldShow_onlyBeyondMinSeparation() {
        // During a loupe drag the gray "shadow" (the snapped real caret) is hidden while the accent glider (at
        // the finger) sits on top of it, and appears only once they diverge by >= loupeShadowMinSeparation.
        let v = canvasWithInteraction()
        let sep = DocumentCanvasView.loupeShadowMinSeparation
        XCTAssertFalse(v.loupeShadowShouldShow(accentX: 100, snappedX: 100), "coincident → shadow hidden")
        XCTAssertFalse(v.loupeShadowShouldShow(accentX: 100 + sep - 0.5, snappedX: 100), "just within the threshold → hidden")
        XCTAssertTrue(v.loupeShadowShouldShow(accentX: 100 + sep, snappedX: 100), "at the threshold → shown")
        XCTAssertTrue(v.loupeShadowShouldShow(accentX: 100 - sep - 5, snappedX: 100), "diverged to the left → shown (symmetric)")
    }

    // MARK: - Long-press loupe drag reports the selection ONCE (at the final position), not per frame

    func test_setCaret_withReportSuppressed_defersHostReport_untilTheDragEnds() {
        // A long-press loupe cursor drag moves the caret every frame, but the host must be told the selection
        // ONCE at the final position (the spacebar-trackpad model) — NOT continuously. Mid-drag the caret is
        // set with `reportSelectionChange: false`, which still moves the caret + brackets the input delegate
        // (the OS stays in sync) but suppresses `onSelectionChange` (the host report). The terminal setter
        // reports exactly once.
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        var reportCount = 0
        v.onSelectionChange = { reportCount += 1 }

        // Per-frame drag moves: caret advances, host is NOT told.
        v.setCaret(global: v.boxes[0].textStart + 1, reportSelectionChange: false)
        v.setCaret(global: v.boxes[0].textStart + 2, reportSelectionChange: false)
        v.setCaret(global: v.boxes[0].textStart + 3, reportSelectionChange: false)
        XCTAssertEqual(reportCount, 0, "a mid-drag caret move does not report the selection to the host")
        XCTAssertEqual(v.head, v.boxes[0].textStart + 3, "the caret still moves each frame (just silently)")

        // The drag's terminal setter (default: reports) fires exactly one host report at the final position.
        v.setCaret(global: v.boxes[0].textStart + 3)
        XCTAssertEqual(reportCount, 1, "the final caret position is reported to the host exactly once")
    }

    func test_loupeDrag_coalescesInputDelegate_soKeyboardSuggestionsDoNotChurn() {
        // The keyboard recomputes its autocorrect/candidate bar on every `selectionDidChange` — so a per-frame
        // input-delegate bracket during the cursor drag makes the suggestions visibly JUMP. The drag coalesces
        // those brackets (`beginCoalescedSelectionDrag` + `setCaret(reportSelectionChange:false)` skipping the
        // bracket while coalescing) and fires exactly ONE at the end (`endCoalescedSelectionDrag`).
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        let spy = SelectionDelegateSpy()
        v.inputDelegate = spy

        v.beginCoalescedSelectionDrag()
        v.setCaret(global: v.boxes[0].textStart + 1, reportSelectionChange: false)
        v.setCaret(global: v.boxes[0].textStart + 2, reportSelectionChange: false)
        v.setCaret(global: v.boxes[0].textStart + 3, reportSelectionChange: false)
        XCTAssertEqual(spy.didChangeCount, 0,
                       "no per-frame selectionDidChange during the drag → the keyboard suggestion bar doesn't churn")

        v.endCoalescedSelectionDrag()
        XCTAssertEqual(spy.didChangeCount, 1, "the keyboard is told the final selection exactly once, at the end")
    }

    // MARK: - A gesture selection fires ONE input-delegate bracket (no autocorrect jiggle)

    func test_applySelection_firesASingleSelectionBracket_noAutocorrectJiggle() {
        // A deliberate word/paragraph/Select-All selection brackets the OS input delegate exactly ONCE. It must
        // NOT do the old autocorrect-dismiss "jiggle" (a fake→real selection round-trip = two EXTRA brackets):
        // each `selectionDidChange` drives the keyboard's synchronous `updateForChangedSelection` (~25ms on
        // device), so the jiggle tripled the double-tap selection latency for a non-standard nicety. Dropped —
        // a pending correction now just commits on selection-move like a stock UITextView.
        let v = canvasWithInteraction()   // "Hello world"
        _ = v.becomeFirstResponder()
        v.setCaret(global: v.boxes[0].textStart + 2)
        let spy = SelectionDelegateSpy()
        v.inputDelegate = spy
        spy.reset()

        v.selectWord(at: v.boxes[0].textStart + 2)
        XCTAssertEqual(spy.didChangeCount, 1, "a word selection fires exactly one selectionDidChange (no jiggle)")
        XCTAssertNotEqual(v.selFrom, v.selTo, "the word is selected")

        spy.reset()
        v.selectAllText()
        XCTAssertEqual(spy.didChangeCount, 1, "Select-All also fires exactly one selectionDidChange (no jiggle)")
    }

    // MARK: - Outer scroll yields to a selection-handle grip

    func test_gripYieldingScrollView_yieldsOnlyNearASelectionGrip() {
        // The outer document scroll (and the inner table scroll) must yield their pan to the canvas's
        // handle-drag when the touch is on a selection grip — otherwise a vertical knob drag races the scroll.
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        let scroll = GripYieldingScrollView()
        scroll.canvas = v

        // No ranged selection → there is no grip, so the scroll never yields.
        XCTAssertFalse(scroll.yieldsToGrip(at: CGPoint(x: 20, y: 20)), "no selection ⇒ no grip ⇒ scroll, don't yield")

        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head)
        v.setSelectionHead(global: v.boxes[0].textStart + 5)
        let caret = v.caretRect(for: DocumentTextPosition(v.selFrom))
        XCTAssertTrue(scroll.yieldsToGrip(at: CGPoint(x: caret.midX, y: caret.midY)),
                      "yields on a selection grip so the canvas handle-drag wins")
        XCTAssertFalse(scroll.yieldsToGrip(at: CGPoint(x: caret.midX, y: caret.midY + 200)),
                       "does not yield far from any grip — normal scrolling")
    }

    // MARK: - No OS selection-display interaction (app draws everything itself)

    func test_noSelectionDisplayInteraction_isInstalled() {
        // The canvas owns every selection visual (caret/wash/handles), so it must NOT attach a
        // `UITextSelectionDisplayInteraction`. On iOS 18+ that interaction installs its own default selection
        // chrome (`_UITextSelectionLollipopView`/highlight/cursor) that custom no-draw replacement views no
        // longer suppress — the default lollipops leak at the container origin (handle knobs at ~CGPoint.zero).
        let v = canvasWithInteraction()
        if #available(iOS 17.0, *) {   // the type itself is iOS 17+ (it's what we assert we DON'T install)
            XCTAssertFalse(v.interactions.contains { $0 is UITextSelectionDisplayInteraction },
                           "no UITextSelectionDisplayInteraction (its default handle chrome would leak at the origin)")
        }
    }

    func test_appDrawsItsOwnHandles_forARangedSelection() {
        // The app draws handles itself so they ride a table's horizontal scroll/overscroll. With no OS
        // interaction, these own-drawn `SelectionHandleView`s are the ONLY handles.
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head); v.setSelectionHead(global: v.boxes[0].textStart + 5)
        XCTAssertFalse(v.startHandleView.isHidden, "the app's own start handle shows for a range")
        XCTAssertFalse(v.endHandleView.isHidden, "the app's own end handle shows for a range")
    }

    // MARK: - Own-drawn caret

    func test_appDrawsItsOwnCaret_forACollapsedSelection() {
        // We draw the caret ourselves (a `CaretView`) so it rides a table's horizontal scroll/overscroll;
        // there is no OS cursor view to compete with it.
        let v = canvasWithInteraction()
        _ = v.becomeFirstResponder()
        v.setCaret(global: v.boxes[0].textStart + 2)
        XCTAssertFalse(v.caretView.isHidden, "the app's own caret shows for a collapsed selection")
        XCTAssertTrue(v.caretView.superview === v, "a paragraph caret is hosted on the canvas")
    }

    func test_caretInWideTableCell_isHostedInsideTheTableContentView_andBlinks() {
        let (v, table) = canvasWithWideTable()
        _ = v.becomeFirstResponder()
        let target = table.cellTextStart(row: 1, column: 0)!
        v.setCaret(global: target)

        // The caret view rides the scroll: it lives inside the table's scrolling content view.
        XCTAssertTrue(v.caretView.superview is TableContentView,
                      "a caret inside a table cell is hosted in the table's scrolling content view")

        // Its frame ≈ the cell caret in content-local coords (unscrolled canvas − table.frame.origin).
        let (region, local) = v.leafRegion(containingGlobal: target)!
        let expected = region.layout.caretRect(atOffset: local)
            .offsetBy(dx: region.canvasOrigin.x - table.frame.minX,
                      dy: region.canvasOrigin.y - table.frame.minY)
        XCTAssertEqual(v.caretView.frame.minX, expected.minX, accuracy: 0.5)
        XCTAssertEqual(v.caretView.frame.minY, expected.minY, accuracy: 0.5)
        XCTAssertEqual(v.caretView.frame.height, expected.height, accuracy: 0.5)

        // A blink animation is running.
        XCTAssertFalse(v.caretView.layer.animationKeys()?.isEmpty ?? true,
                       "the caret view blinks (has a running opacity animation)")
    }

    func test_caretInParagraph_isHostedOnTheCanvas() {
        let (v, _) = canvasWithWideTable()
        _ = v.becomeFirstResponder()
        v.setCaret(global: v.boxes[0].textStart + 2)   // inside the lead paragraph

        XCTAssertTrue(v.caretView.superview === v, "a paragraph caret is hosted directly on the canvas")
        let (region, local) = v.leafRegion(containingGlobal: v.head)!
        let expected = region.layout.caretRect(atOffset: local)
            .offsetBy(dx: region.canvasOrigin.x, dy: region.canvasOrigin.y)
        XCTAssertEqual(v.caretView.frame.minX, expected.minX, accuracy: 0.5)
        XCTAssertEqual(v.caretView.frame.minY, expected.minY, accuracy: 0.5)
    }

    func test_caretHidden_whenRangedSelection() {
        let (v, _) = canvasWithWideTable()
        _ = v.becomeFirstResponder()
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.head)
        v.setSelectionHead(global: v.boxes[0].textStart + 4)   // a ranged (non-collapsed) selection
        XCTAssertTrue(v.caretView.isHidden || v.caretView.superview == nil,
                      "no blinking caret while a range is selected")
    }

    func test_caretHidden_whenStructuralTableSelection() {
        let (v, _) = canvasWithWideTable()
        _ = v.becomeFirstResponder()
        v.selectTableColumns(0...0)   // structural row/column selection → outline is the indicator, no caret
        XCTAssertTrue(v.caretView.isHidden || v.caretView.superview == nil,
                      "no blinking caret while a table row/column is structurally selected")
    }

    func test_updateCaretView_isIdempotent_doesNotRestartBlinkOnNoOp() {
        // Re-running updateCaretView with the SAME caret (e.g. on a scroll tick) must NOT restart the
        // blink — otherwise the caret would never finish a blink cycle while the table scrolls.
        let (v, table) = canvasWithWideTable()
        _ = v.becomeFirstResponder()
        v.setCaret(global: table.cellTextStart(row: 1, column: 0)!)
        let resetsAfterFirst = v.caretView.blinkResetCount
        v.updateCaretView()
        v.updateCaretView()
        XCTAssertEqual(v.caretView.blinkResetCount, resetsAfterFirst,
                       "a no-op updateCaretView (same container + frame) does not restart the blink")
    }

    // MARK: - Selection-handle drag auto-scrolls the document vertically near the viewport edge

    /// Tall content inside a short scroll view so a selection-handle drag has vertical room to scroll.
    private func tallCanvasInScroll() -> (canvas: DocumentCanvasView, scroll: UIScrollView) {
        let scroll = UIScrollView(frame: CGRect(x: 0, y: 0, width: 300, height: 200))
        let v = DocumentCanvasView()
        v.setBlocks((0..<40).map {
            .paragraph(ParagraphBlock(id: BlockID("p\($0)"), runs: [TextRun(text: "Line \($0)")]))
        }, width: 300)
        v.frame = CGRect(x: 0, y: 0, width: 300, height: 1600)
        scroll.addSubview(v); scroll.contentSize = v.frame.size; v.layoutIfNeeded()
        return (v, scroll)
    }

    func test_dragAutoScroll_scrollsDocumentDown_whenHandleNearsBottomEdge() {
        let (v, scroll) = tallCanvasInScroll()
        // A non-collapsed selection whose HEAD we drag toward the bottom edge (no table involved).
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.boxes[1].textStart)
        let beforeY = scroll.contentOffset.y
        let beforeHead = v.head

        // A drag point in the viewport's bottom band (band = 60 of the 200pt viewport), in canvas coords.
        let bottomBand = CGPoint(x: 40, y: scroll.contentOffset.y + 190)
        v.updateDragAutoScroll(point: bottomBand, headInTable: false)
        for _ in 0..<5 { v.dragAutoScrollTick() }

        XCTAssertGreaterThan(scroll.contentOffset.y, beforeY,
                             "dragging a selection handle near the bottom edge scrolls the document down")
        XCTAssertNotEqual(v.head, beforeHead,
                          "the selection head re-extends to the content under the finger as it scrolls")
        v.stopDragAutoScroll()
        let maxY = scroll.contentSize.height - scroll.bounds.height
        XCTAssertLessThanOrEqual(scroll.contentOffset.y, maxY + 0.5, "clamped to the max content offset")
    }

    func test_dragAutoScroll_scrollsDocumentUp_whenHandleNearsTopEdge() {
        let (v, scroll) = tallCanvasInScroll()
        scroll.contentOffset.y = 800   // scrolled into the middle so there is room to scroll UP
        v.setSelectionForTesting(anchor: v.boxes[20].textStart, head: v.boxes[20].textStart + 1)
        let beforeY = scroll.contentOffset.y

        // A drag point in the viewport's top band, in canvas coords.
        let topBand = CGPoint(x: 40, y: scroll.contentOffset.y + 10)
        v.updateDragAutoScroll(point: topBand, headInTable: false)
        for _ in 0..<5 { v.dragAutoScrollTick() }

        XCTAssertLessThan(scroll.contentOffset.y, beforeY,
                          "dragging a selection handle near the top edge scrolls the document up")
        v.stopDragAutoScroll()
        XCTAssertGreaterThanOrEqual(scroll.contentOffset.y, -0.5, "clamped to zero")
    }

    func test_dragAutoScroll_reextendsTheDraggedAnchor_notTheHead() {
        let (v, scroll) = tallCanvasInScroll()
        // A range selection, then grab the ANCHOR (start) handle and drag it toward the bottom edge. The
        // auto-scroller must re-extend the endpoint being dragged (the anchor), leaving the head put.
        v.setSelectionForTesting(anchor: v.boxes[2].textStart, head: v.boxes[1].textStart)
        v.draggingEndpoint = .anchor
        let headBefore = v.head
        let anchorBefore = v.anchor

        let bottomBand = CGPoint(x: 40, y: scroll.contentOffset.y + 190)
        v.updateDragAutoScroll(point: bottomBand, headInTable: false)
        for _ in 0..<5 { v.dragAutoScrollTick() }

        XCTAssertGreaterThan(scroll.contentOffset.y, 0, "the document scrolls while dragging the anchor near the edge")
        XCTAssertNotEqual(v.anchor, anchorBefore, "the dragged ANCHOR re-extends as the document scrolls")
        XCTAssertEqual(v.head, headBefore, "the head (the endpoint NOT being dragged) stays put")
        v.stopDragAutoScroll()
        v.draggingEndpoint = nil
    }

    func test_dragAutoScroll_doesNotScroll_whenHandleInViewportMiddle() {
        let (v, scroll) = tallCanvasInScroll()
        v.setSelectionForTesting(anchor: v.boxes[0].textStart, head: v.boxes[1].textStart)
        let beforeY = scroll.contentOffset.y

        // A point in the middle of the viewport must not start the auto-scroller.
        v.updateDragAutoScroll(point: CGPoint(x: 40, y: scroll.contentOffset.y + 100), headInTable: false)
        XCTAssertNil(v.dragAutoScrollLink, "no auto-scroll link starts for a mid-viewport handle")
        for _ in 0..<5 { v.dragAutoScrollTick() }
        XCTAssertEqual(scroll.contentOffset.y, beforeY, accuracy: 0.5, "no scroll when the handle is mid-viewport")
        v.stopDragAutoScroll()
    }
}

/// Records `selectionDidChange` calls so a test can assert (a) the input-delegate bracket is coalesced during a
/// caret drag (fired once at the end, not per frame) and (b) the autocorrect-dismiss "jiggle" notifies the
/// keyboard of an intermediate selection before restoring the real one. `headSequence` captures the canvas's
/// `head` at each callback. The iOS-18.4 `conversationContext(_:didChange:)` requirement is stubbed under
/// `@available` so the class conforms on the current SDK.
private final class SelectionDelegateSpy: NSObject, UITextInputDelegate {
    var didChangeCount = 0
    var headSequence: [Int] = []
    func selectionWillChange(_ textInput: (any UITextInput)?) {}
    func selectionDidChange(_ textInput: (any UITextInput)?) {
        didChangeCount += 1
        if let canvas = textInput as? DocumentCanvasView { headSequence.append(canvas.head) }
    }
    func textWillChange(_ textInput: (any UITextInput)?) {}
    func textDidChange(_ textInput: (any UITextInput)?) {}
    @available(iOS 18.4, *)
    func conversationContext(_ context: UIConversationContext?, didChange textInput: (any UITextInput)?) {}
    func reset() { didChangeCount = 0; headSequence = [] }
}
#endif