muxr_client/

copy_selection.rs

use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::time::Instant;

use muxr_core::ClientMousePosition;
use muxr_core::ClientRequest;
use muxr_core::PaneId;
use muxr_core::PaneRegionContainment;
use muxr_core::PaneRegionSnapshot;
use muxr_core::PaneRegionsSnapshot;
use muxr_core::PaneScrollDirection;
use muxr_core::PaneScrollLineMove;
use muxr_core::RenderCellWidth;
use muxr_core::RowWrap;
use rootcause::prelude::ResultExt;
use rootcause::report;

use crate::frame_buffer::FrameBuffer;

const DOUBLE_CLICK_THRESHOLD: std::time::Duration = std::time::Duration::from_millis(400);

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SelectionInput {
    Start(ClientMousePosition),
    Update(ClientMousePosition),
    End(ClientMousePosition),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SelectionClickOutcome {
    Double,
    Single,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SelectionChange {
    Changed,
    Unchanged,
}

impl SelectionChange {
    fn between(next: Option<&SelectionRange>, previous: Option<&SelectionRange>) -> Self {
        if next == previous {
            Self::Unchanged
        } else {
            Self::Changed
        }
    }
}

#[derive(Clone, Debug, Default)]
pub struct SelectionClickTracker {
    count: u8,
    previous: Option<TrackedClick>,
}

impl SelectionClickTracker {
    pub fn record_selection_start(
        &mut self,
        position: ClientMousePosition,
        regions: &PaneRegionsSnapshot,
        frame_buffer: &FrameBuffer,
        now: Instant,
    ) -> SelectionClickOutcome {
        let Some(target) = self::click_target(position, regions, frame_buffer) else {
            self.reset();
            return SelectionClickOutcome::Single;
        };
        self.record_target(target, now)
    }

    pub fn retain_for_regions(&mut self, regions: &PaneRegionsSnapshot) {
        let keep_previous = self
            .previous
            .as_ref()
            .is_some_and(|previous| previous.target.region_state(regions) == ClickTargetRegion::Present);
        if !keep_previous {
            self.reset();
        }
    }

    const fn reset(&mut self) {
        self.count = 0;
        self.previous = None;
    }

    fn record_target(&mut self, target: ClickTarget, now: Instant) -> SelectionClickOutcome {
        let continues_previous = self.previous.as_ref().is_some_and(|previous| {
            previous.target == target
                && now
                    .checked_duration_since(previous.at)
                    .is_some_and(|elapsed| elapsed <= DOUBLE_CLICK_THRESHOLD)
        });
        self.count = if continues_previous {
            self.count.saturating_add(1)
        } else {
            1
        };
        self.previous = Some(TrackedClick { at: now, target });
        if self.count == 2 {
            SelectionClickOutcome::Double
        } else {
            SelectionClickOutcome::Single
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
enum ClickTarget {
    Cell {
        pane_id: PaneId,
        position: ClientMousePosition,
    },
    Word {
        end: ClientMousePosition,
        pane_id: PaneId,
        start: ClientMousePosition,
    },
}

impl ClickTarget {
    fn region_state(&self, regions: &PaneRegionsSnapshot) -> ClickTargetRegion {
        match self {
            Self::Cell { pane_id, position } => {
                if regions.pane_at(*position).is_some_and(|region| region.id() == pane_id) {
                    ClickTargetRegion::Present
                } else {
                    ClickTargetRegion::Missing
                }
            }
            Self::Word { end, pane_id, start } => {
                if self::matching_region(regions, *pane_id).is_some_and(|region| {
                    region.containment(start.row, start.col) == PaneRegionContainment::Inside
                        && region.containment(end.row, end.col) == PaneRegionContainment::Inside
                }) {
                    ClickTargetRegion::Present
                } else {
                    ClickTargetRegion::Missing
                }
            }
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ClickTargetRegion {
    Missing,
    Present,
}

#[derive(Clone, Debug)]
struct TrackedClick {
    at: Instant,
    target: ClickTarget,
}

// Tracks one edge-scroll request through server ack and rendered-frame ack so retry cannot outrun viewport updates.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
enum SelectionEdgeScrollPendingState {
    #[default]
    Idle,
    WaitingForViewportMove(SelectionEdgeScrollPending),
    WaitingForRender(SelectionEdgeScrollPending),
}

impl SelectionEdgeScrollPendingState {
    const fn pending(&self) -> Option<&SelectionEdgeScrollPending> {
        match self {
            Self::Idle => None,
            Self::WaitingForRender(pending) | Self::WaitingForViewportMove(pending) => Some(pending),
        }
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SelectionEdgeScrollState {
    drag: Option<SelectionEdgeDrag>,
    pending: SelectionEdgeScrollPendingState,
}

impl SelectionEdgeScrollState {
    pub fn retain_for_regions(&mut self, regions: &PaneRegionsSnapshot) {
        self.drag = self
            .drag
            .take()
            .and_then(|drag| self::matching_region(regions, drag.pane_id).map(|_| drag));
        self.update_pending(regions);
    }

    pub fn set_edge_drag(
        &mut self,
        position: ClientMousePosition,
        forced_direction: Option<PaneScrollDirection>,
        drag_region: Option<&PaneRegionSnapshot>,
    ) -> Option<SelectionEdgeScrollRequest> {
        self.set_edge_drag_with_trigger(
            position,
            forced_direction,
            drag_region,
            SelectionEdgeScrollTrigger::EdgeRow,
        )
    }

    pub fn set_outside_edge_drag(
        &mut self,
        position: ClientMousePosition,
        drag_region: Option<&PaneRegionSnapshot>,
    ) -> Option<SelectionEdgeScrollRequest> {
        self.set_edge_drag_with_trigger(position, None, drag_region, SelectionEdgeScrollTrigger::OutsideOnly)
    }

    pub fn drag_position(&self, regions: &PaneRegionsSnapshot) -> Option<ClientMousePosition> {
        let drag = self.drag.as_ref()?;
        let region = self::matching_region(regions, drag.pane_id)?;
        Some(ClientMousePosition {
            row: self::selection_edge_row(&region, drag.direction),
            col: drag.col.clamp(region.col(), self::last_region_col_saturating(&region)),
        })
    }

    pub fn scroll_request(&self, regions: &PaneRegionsSnapshot) -> Option<SelectionEdgeScrollRequest> {
        let drag = self.drag.clone()?;
        let region = self::matching_region(regions, drag.pane_id)?;
        let position = self.drag_position(regions)?;
        self.scroll_request_for(drag.direction, drag.pane_id, region.visible_top_row(), position)
    }

    pub fn apply_scroll_pane_line_result(
        &mut self,
        position: ClientMousePosition,
        direction: PaneScrollDirection,
        movement: PaneScrollLineMove,
    ) {
        let matches_pending = self
            .pending
            .pending()
            .is_some_and(|pending| pending.position == position && pending.direction == direction);
        if matches_pending && matches!(movement, PaneScrollLineMove::Unchanged) {
            // No-op scrolls, usually hard top/bottom scrollback bounds, do not produce a render ack. Clear only the
            // matching pending request so the held edge drag can retry without unrelated events breaking coalescing.
            self.pending = SelectionEdgeScrollPendingState::Idle;
        }
    }

    pub fn clear_render_acknowledged_pending(&mut self, expected: &SelectionEdgeScrollPending) {
        if matches!(&self.pending, SelectionEdgeScrollPendingState::WaitingForRender(pending) if pending == expected) {
            self.pending = SelectionEdgeScrollPendingState::Idle;
        }
    }

    pub const fn active_state(&self) -> SelectionEdgeScrollActive {
        match self.drag {
            Some(_) => SelectionEdgeScrollActive::Active,
            None => SelectionEdgeScrollActive::Inactive,
        }
    }

    pub const fn waits_for_render(&self) -> bool {
        matches!(&self.pending, SelectionEdgeScrollPendingState::WaitingForRender(_))
    }

    pub const fn render_pending(&self) -> Option<&SelectionEdgeScrollPending> {
        match &self.pending {
            SelectionEdgeScrollPendingState::WaitingForRender(pending) => Some(pending),
            SelectionEdgeScrollPendingState::Idle | SelectionEdgeScrollPendingState::WaitingForViewportMove(_) => None,
        }
    }

    pub const fn mark_sent(&mut self, pending: SelectionEdgeScrollPending) {
        self.pending = SelectionEdgeScrollPendingState::WaitingForViewportMove(pending);
    }

    pub const fn clear(&mut self) {
        self.drag = None;
        self.pending = SelectionEdgeScrollPendingState::Idle;
    }

    fn set_edge_drag_with_trigger(
        &mut self,
        position: ClientMousePosition,
        forced_direction: Option<PaneScrollDirection>,
        drag_region: Option<&PaneRegionSnapshot>,
        trigger: SelectionEdgeScrollTrigger,
    ) -> Option<SelectionEdgeScrollRequest> {
        let Some(region) = drag_region else {
            self.pending = SelectionEdgeScrollPendingState::Idle;
            return None;
        };
        let (direction, row) = if let Some(direction) = forced_direction {
            (direction, self::selection_edge_row(region, direction))
        } else if let Some(direction) = self::selection_edge_direction(position, region, trigger) {
            (direction, self::selection_edge_row(region, direction))
        } else {
            self.drag = None;
            self.pending = SelectionEdgeScrollPendingState::Idle;
            return None;
        };
        if self
            .pending
            .pending()
            .is_some_and(|pending| pending.direction != direction || pending.pane_id != *region.id())
        {
            self.pending = SelectionEdgeScrollPendingState::Idle;
        }
        let col = position
            .col
            .clamp(region.col(), self::last_region_col_saturating(region));
        let pane_id = *region.id();
        self.drag = Some(SelectionEdgeDrag {
            col,
            direction,
            pane_id,
        });
        self.scroll_request_for(
            direction,
            pane_id,
            region.visible_top_row(),
            ClientMousePosition { row, col },
        )
    }

    const fn scroll_request_for(
        &self,
        direction: PaneScrollDirection,
        pane_id: PaneId,
        previous_visible_top_row: u64,
        position: ClientMousePosition,
    ) -> Option<SelectionEdgeScrollRequest> {
        if !matches!(&self.pending, SelectionEdgeScrollPendingState::Idle) {
            return None;
        }
        Some(SelectionEdgeScrollRequest {
            pending: SelectionEdgeScrollPending {
                direction,
                pane_id,
                position,
                previous_visible_top_row,
            },
            request: ClientRequest::ScrollPaneLineAt { direction, position },
        })
    }

    fn update_pending(&mut self, regions: &PaneRegionsSnapshot) {
        let Some(pending) = self.pending.pending().cloned() else {
            return;
        };
        let Some(region) = self::matching_region(regions, pending.pane_id) else {
            self.pending = SelectionEdgeScrollPendingState::Idle;
            return;
        };
        let viewport_moved = match pending.direction {
            PaneScrollDirection::Down => region.visible_top_row() > pending.previous_visible_top_row,
            PaneScrollDirection::Up => region.visible_top_row() < pending.previous_visible_top_row,
        };
        self.pending = if viewport_moved {
            SelectionEdgeScrollPendingState::WaitingForRender(pending)
        } else {
            SelectionEdgeScrollPendingState::WaitingForViewportMove(pending)
        };
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SelectionEdgeScrollActive {
    Active,
    Inactive,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct SelectionEdgeDrag {
    col: u16,
    direction: PaneScrollDirection,
    pane_id: PaneId,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SelectionEdgeScrollPending {
    direction: PaneScrollDirection,
    pane_id: PaneId,
    position: ClientMousePosition,
    previous_visible_top_row: u64,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SelectionEdgeScrollRequest {
    pending: SelectionEdgeScrollPending,
    request: ClientRequest,
}

impl SelectionEdgeScrollRequest {
    pub fn into_parts(self) -> (SelectionEdgeScrollPending, ClientRequest) {
        (self.pending, self.request)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum SelectionEdgeScrollTrigger {
    EdgeRow,
    OutsideOnly,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SelectionState {
    // Copy text is cached by stable content row so viewport scrolling moves the highlight without dropping rows that
    // have already passed off-screen during a drag selection. The final joined string is built lazily on copy so drag
    // updates do not rebuild the full selected text every mouse packet.
    cached_rows: BTreeMap<u64, CachedSelectionRow>,
    drag: Option<SelectionDrag>,
    selected: Option<SelectionRange>,
}

impl SelectionState {
    pub fn apply(
        &mut self,
        input: SelectionInput,
        regions: &PaneRegionsSnapshot,
        frame_buffer: &FrameBuffer,
    ) -> rootcause::Result<SelectionChange> {
        let previous = self.selected.clone();
        match input {
            SelectionInput::Start(position) => self.start(position, regions, frame_buffer),
            SelectionInput::Update(position) => self.update(position, frame_buffer)?,
            SelectionInput::End(position) => self.end(position, frame_buffer)?,
        }
        Ok(SelectionChange::between(self.selected.as_ref(), previous.as_ref()))
    }

    pub fn clear_if_regions_changed(&mut self, regions: &PaneRegionsSnapshot) -> SelectionChange {
        let previous = self.selected.clone();
        self.drag = self.drag.take().and_then(|drag| {
            self::matching_region(regions, *drag.region.id()).map(|region| SelectionDrag {
                anchor: drag.anchor,
                raw_anchor: self::clamp_to_region(drag.raw_anchor, &region),
                region,
            })
        });
        self.selected = self.selected.take().and_then(|selected| {
            self::matching_region(regions, *selected.region.id()).map(|region| selected.with_region(region))
        });
        if self.selected.is_none() {
            self.cached_rows.clear();
        } else {
            self.retain_cached_rows();
        }
        SelectionChange::between(self.selected.as_ref(), previous.as_ref())
    }

    pub fn selected_text(&self) -> Option<String> {
        self.selected
            .as_ref()
            .and_then(|selection| self::selected_text(&self.cached_rows, selection))
            .filter(|text| !text.is_empty())
    }

    pub fn selected_inline_text(&self) -> Option<String> {
        self.selected
            .as_ref()
            .and_then(|selection| self::selected_inline_text(&self.cached_rows, selection))
            .filter(|text| !text.is_empty())
    }

    pub fn select_word(
        &mut self,
        position: ClientMousePosition,
        regions: &PaneRegionsSnapshot,
        frame_buffer: &FrameBuffer,
    ) -> rootcause::Result<SelectionChange> {
        let previous = self.selected.clone();
        self.drag = None;
        self.set_selected(self::word_selection_at(position, regions, frame_buffer), frame_buffer)?;
        Ok(SelectionChange::between(self.selected.as_ref(), previous.as_ref()))
    }

    #[must_use]
    pub const fn range(&self) -> Option<&SelectionRange> {
        self.selected.as_ref()
    }

    #[must_use]
    pub fn drag_region(&self) -> Option<&PaneRegionSnapshot> {
        self.drag.as_ref().map(|drag| &drag.region)
    }

    pub fn refresh_visible_rows(&mut self, frame_buffer: &FrameBuffer) -> rootcause::Result<()> {
        self.rebuild_selected_text(frame_buffer)
    }

    fn start(&mut self, position: ClientMousePosition, regions: &PaneRegionsSnapshot, frame_buffer: &FrameBuffer) {
        let Some(region) = regions.pane_at(position) else {
            self.clear();
            return;
        };
        let region = region.clone();
        let raw_anchor = self::clamp_to_region(position, &region);
        let Some(anchor) =
            self::content_position(self::selectable_position(raw_anchor, &region, frame_buffer), &region)
        else {
            self.clear();
            return;
        };
        self.drag = Some(SelectionDrag {
            anchor,
            raw_anchor,
            region,
        });
        self.selected = None;
        self.cached_rows.clear();
    }

    fn update(&mut self, position: ClientMousePosition, frame_buffer: &FrameBuffer) -> rootcause::Result<()> {
        let Some(drag) = &self.drag else {
            return Ok(());
        };
        let raw_focus = self::clamp_to_region(position, &drag.region);
        let Some(focus) = self::content_position(
            self::selectable_position(raw_focus, &drag.region, frame_buffer),
            &drag.region,
        ) else {
            self.set_selected(None, frame_buffer)?;
            return Ok(());
        };
        self.set_selected(
            Some(SelectionRange {
                anchor: drag.anchor,
                focus,
                region: drag.region.clone(),
            }),
            frame_buffer,
        )
    }

    fn end(&mut self, position: ClientMousePosition, frame_buffer: &FrameBuffer) -> rootcause::Result<()> {
        let Some(drag) = self.drag.take() else {
            return Ok(());
        };
        let raw_focus = self::clamp_to_region(position, &drag.region);
        let Some(focus) = self::content_position(
            self::selectable_position(raw_focus, &drag.region, frame_buffer),
            &drag.region,
        ) else {
            self.set_selected(None, frame_buffer)?;
            return Ok(());
        };
        let selected = (raw_focus != drag.raw_anchor).then_some(SelectionRange {
            anchor: drag.anchor,
            focus,
            region: drag.region,
        });
        self.set_selected(selected, frame_buffer)
    }

    fn set_selected(&mut self, selected: Option<SelectionRange>, frame_buffer: &FrameBuffer) -> rootcause::Result<()> {
        self.selected = selected;
        self.rebuild_selected_text(frame_buffer)?;
        Ok(())
    }

    fn rebuild_selected_text(&mut self, frame_buffer: &FrameBuffer) -> rootcause::Result<()> {
        if self.selected.is_none() {
            self.cached_rows.clear();
            return Ok(());
        }

        self.retain_cached_rows();
        if let Some(selection) = self.selected.as_ref() {
            self::cache_visible_selected_rows(&mut self.cached_rows, frame_buffer, selection)?;
        }
        Ok(())
    }

    fn retain_cached_rows(&mut self) {
        let Some(selected) = self.selected.as_ref() else {
            self.cached_rows.clear();
            return;
        };
        self.cached_rows
            .retain(|content_row, _| selected.contains_content_row(*content_row));
    }

    fn clear(&mut self) {
        self.cached_rows.clear();
        self.drag = None;
        self.selected = None;
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SelectionRange {
    anchor: SelectionContentPosition,
    focus: SelectionContentPosition,
    region: PaneRegionSnapshot,
}

impl SelectionRange {
    #[must_use]
    pub fn contains(&self, row: u16, col: u16) -> bool {
        if self.region.containment(row, col) == PaneRegionContainment::Outside {
            return false;
        }
        let Some(position) = self::content_position(ClientMousePosition { row, col }, &self.region) else {
            return false;
        };

        let bounds = self.bounds();
        if position.row < bounds.start.row || position.row > bounds.end.row {
            return false;
        }

        if bounds.start.row == bounds.end.row {
            return position.col >= bounds.start.col && position.col <= bounds.end.col;
        }
        if position.row == bounds.start.row {
            return position.col >= bounds.start.col;
        }
        if position.row == bounds.end.row {
            return position.col <= bounds.end.col;
        }
        true
    }

    #[must_use]
    pub fn row_bounds(&self) -> Option<(u16, u16)> {
        let bounds = self.bounds();
        let viewport_start = self.region.visible_top_row();
        let viewport_end = viewport_start.saturating_add(u64::from(self.region.rows().saturating_sub(1)));
        let start = bounds.start.row.max(viewport_start);
        let end = bounds.end.row.min(viewport_end);
        if start > end {
            return None;
        }

        Some((
            self::visible_row_for_content_row(&self.region, start)?,
            self::visible_row_for_content_row(&self.region, end)?,
        ))
    }

    #[must_use]
    pub fn bounds_positions(&self) -> Option<(ClientMousePosition, ClientMousePosition)> {
        let bounds = self.bounds();
        Some((
            self::visible_position(&self.region, bounds.start)?,
            self::visible_position(&self.region, bounds.end)?,
        ))
    }

    #[must_use]
    pub const fn pane_id(&self) -> PaneId {
        *self.region.id()
    }

    fn bounds(&self) -> SelectionBounds {
        if (self.anchor.row, self.anchor.col) <= (self.focus.row, self.focus.col) {
            SelectionBounds {
                start: self.anchor,
                end: self.focus,
            }
        } else {
            SelectionBounds {
                start: self.focus,
                end: self.anchor,
            }
        }
    }

    fn contains_content_row(&self, row: u64) -> bool {
        let bounds = self.bounds();
        row >= bounds.start.row && row <= bounds.end.row
    }

    fn with_region(self, region: PaneRegionSnapshot) -> Self {
        let last_col = region.cols().saturating_sub(1);
        Self {
            anchor: self.anchor.clamp_col(last_col),
            focus: self.focus.clamp_col(last_col),
            region,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct SelectionContentPosition {
    col: u16,
    row: u64,
}

impl SelectionContentPosition {
    #[must_use]
    const fn clamp_col(self, last_col: u16) -> Self {
        Self {
            col: if self.col > last_col { last_col } else { self.col },
            row: self.row,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct SelectionDrag {
    anchor: SelectionContentPosition,
    raw_anchor: ClientMousePosition,
    region: PaneRegionSnapshot,
}

#[derive(Clone, Copy)]
struct SelectionBounds {
    end: SelectionContentPosition,
    start: SelectionContentPosition,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct CachedSelectionCell {
    text: String,
    width: RenderCellWidth,
}

#[derive(Clone, Debug, Eq, PartialEq)]
enum CachedSelectionRow {
    EndsBeforeSoftWrap(Vec<CachedSelectionCell>),
    EndsWithSoftWrap(Vec<CachedSelectionCell>),
}

impl CachedSelectionRow {
    const fn new(cells: Vec<CachedSelectionCell>, row_wrap: RowWrap) -> Self {
        match row_wrap {
            RowWrap::EndsBeforeSoftWrap => Self::EndsBeforeSoftWrap(cells),
            RowWrap::EndsWithSoftWrap => Self::EndsWithSoftWrap(cells),
        }
    }

    fn cells(&self) -> &[CachedSelectionCell] {
        match self {
            Self::EndsBeforeSoftWrap(cells) | Self::EndsWithSoftWrap(cells) => cells,
        }
    }

    const fn row_wrap(&self) -> RowWrap {
        match self {
            Self::EndsBeforeSoftWrap(_) => RowWrap::EndsBeforeSoftWrap,
            Self::EndsWithSoftWrap(_) => RowWrap::EndsWithSoftWrap,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
enum SelectedRowText {
    EndsBeforeSoftWrap(String),
    EndsWithSoftWrap(String),
}

impl SelectedRowText {
    fn text(&self) -> &str {
        match self {
            Self::EndsBeforeSoftWrap(text) | Self::EndsWithSoftWrap(text) => text,
        }
    }

    fn into_text(self) -> String {
        match self {
            Self::EndsBeforeSoftWrap(text) | Self::EndsWithSoftWrap(text) => text,
        }
    }

    const fn row_wrap(&self) -> RowWrap {
        match self {
            Self::EndsBeforeSoftWrap(_) => RowWrap::EndsBeforeSoftWrap,
            Self::EndsWithSoftWrap(_) => RowWrap::EndsWithSoftWrap,
        }
    }
}

pub fn copy_to_clipboard(text: &str) -> rootcause::Result<()> {
    let mut bytes = text.as_bytes();
    Ok(ytil_sys::file::cp_to_system_clipboard(&mut bytes).context("failed to copy muxr selection to clipboard")?)
}

fn selected_inline_text(cached_rows: &BTreeMap<u64, CachedSelectionRow>, selection: &SelectionRange) -> Option<String> {
    let bounds = selection.bounds();
    let mut inlined = String::new();
    // Terminal wrap metadata is the only reliable boundary signal: full-width hard lines and soft-wrapped lines can
    // have identical cells, but only soft wraps should suppress the inline separator.
    let mut previous_row_wrap = RowWrap::EndsBeforeSoftWrap;
    for content_row in bounds.start.row..=bounds.end.row {
        let cached_row = cached_rows.get(&content_row)?;
        let start_col = if content_row == bounds.start.row {
            bounds.start.col
        } else {
            0
        };
        let end_col = if content_row == bounds.end.row {
            bounds.end.col
        } else {
            selection.region.cols().saturating_sub(1)
        };
        let selected_row = self::selected_row_text(cached_row.cells(), start_col, end_col, cached_row.row_wrap());
        let row_wrap = selected_row.row_wrap();
        let line = selected_row.text().trim();
        if line.is_empty() {
            previous_row_wrap = RowWrap::EndsBeforeSoftWrap;
            continue;
        }
        if !inlined.is_empty() && previous_row_wrap != RowWrap::EndsWithSoftWrap {
            inlined.push(' ');
        }
        inlined.push_str(line);
        previous_row_wrap = if content_row == bounds.end.row {
            RowWrap::EndsBeforeSoftWrap
        } else {
            row_wrap
        };
    }
    Some(inlined)
}

pub fn changed_selection_rows(previous: Option<&SelectionRange>, next: Option<&SelectionRange>) -> Vec<u16> {
    let mut rows = BTreeSet::new();
    for selection in [previous, next].into_iter().flatten() {
        if let Some((start_row, end_row)) = selection.row_bounds() {
            for row in start_row..=end_row {
                rows.insert(row);
            }
        }
    }
    rows.into_iter().collect()
}

fn word_selection_at(
    position: ClientMousePosition,
    regions: &PaneRegionsSnapshot,
    frame_buffer: &FrameBuffer,
) -> Option<SelectionRange> {
    let region = regions.pane_at(position)?.clone();
    let position = self::clamp_to_region(position, &region);
    if WordCell::at(frame_buffer, position.row, position.col, &region) == WordCell::No {
        return None;
    }

    let start_col = self::word_start_col(frame_buffer, position.row, position.col, &region);
    let end_col = self::word_end_col(frame_buffer, position.row, position.col, &region);
    Some(SelectionRange {
        anchor: self::content_position(
            ClientMousePosition {
                row: position.row,
                col: start_col,
            },
            &region,
        )?,
        focus: self::content_position(
            ClientMousePosition {
                row: position.row,
                col: end_col,
            },
            &region,
        )?,
        region: region.clone(),
    })
}

fn click_target(
    position: ClientMousePosition,
    regions: &PaneRegionsSnapshot,
    frame_buffer: &FrameBuffer,
) -> Option<ClickTarget> {
    let region = regions.pane_at(position)?;
    if let Some(selection) = self::word_selection_at(position, regions, frame_buffer)
        && let Some((start, end)) = selection.bounds_positions()
    {
        return Some(ClickTarget::Word {
            end,
            pane_id: selection.pane_id(),
            start,
        });
    }

    Some(ClickTarget::Cell {
        pane_id: *region.id(),
        position,
    })
}

fn selected_text(cached_rows: &BTreeMap<u64, CachedSelectionRow>, selection: &SelectionRange) -> Option<String> {
    let bounds = selection.bounds();
    let mut lines = Vec::new();
    for content_row in bounds.start.row..=bounds.end.row {
        let Some(cached_row) = cached_rows.get(&content_row) else {
            // A selected range is copyable only when every selected content row was rendered and cached; copying a
            // subset would silently drop text after skipped/coalesced edge-scroll renders.
            return None;
        };
        let start_col = if content_row == bounds.start.row {
            bounds.start.col
        } else {
            0
        };
        let end_col = if content_row == bounds.end.row {
            bounds.end.col
        } else {
            selection.region.cols().saturating_sub(1)
        };
        lines.push(self::selected_row_text(cached_row.cells(), start_col, end_col, cached_row.row_wrap()).into_text());
    }
    Some(lines.join("\n"))
}

fn cache_visible_selected_rows(
    cached_rows: &mut BTreeMap<u64, CachedSelectionRow>,
    frame_buffer: &FrameBuffer,
    selection: &SelectionRange,
) -> rootcause::Result<()> {
    let bounds = selection.bounds();
    let viewport_start = selection.region.visible_top_row();
    let viewport_end = viewport_start.saturating_add(u64::from(selection.region.rows().saturating_sub(1)));
    let start = bounds.start.row.max(viewport_start);
    let end = bounds.end.row.min(viewport_end);
    if start > end {
        return Ok(());
    }

    for content_row in start..=end {
        let Some(visible_row) = self::visible_row_for_content_row(&selection.region, content_row) else {
            continue;
        };
        cached_rows.insert(
            content_row,
            CachedSelectionRow::new(
                self::cached_row_cells(frame_buffer, visible_row, &selection.region)?,
                selection.region.content_row_wrap(content_row),
            ),
        );
    }
    Ok(())
}

fn cached_row_cells(
    frame_buffer: &FrameBuffer,
    row: u16,
    region: &PaneRegionSnapshot,
) -> rootcause::Result<Vec<CachedSelectionCell>> {
    let mut cells = Vec::with_capacity(usize::from(region.cols()));
    for local_col in 0..region.cols() {
        let absolute_col = region
            .col()
            .checked_add(local_col)
            .ok_or_else(|| report!("muxr pane region column range overflowed"))?;
        let cell = frame_buffer.cell(row, absolute_col).map_or_else(
            || CachedSelectionCell {
                text: String::new(),
                width: RenderCellWidth::Narrow,
            },
            |cell| CachedSelectionCell {
                text: cell.text().to_owned(),
                width: cell.width(),
            },
        );
        cells.push(cell);
    }
    Ok(cells)
}

fn selected_row_text(
    cells: &[CachedSelectionCell],
    start_col: u16,
    end_col: u16,
    row_wrap: RowWrap,
) -> SelectedRowText {
    let mut line = String::new();
    for local_col in start_col..=end_col {
        let Some(cell) = cells.get(usize::from(local_col)) else {
            continue;
        };
        if matches!(cell.width, RenderCellWidth::WideContinuation) {
            continue;
        }
        if cell.text.is_empty() {
            line.push(' ');
        } else {
            line.push_str(&cell.text);
        }
    }
    while line.ends_with(' ') {
        line.pop();
    }
    match row_wrap {
        RowWrap::EndsBeforeSoftWrap => SelectedRowText::EndsBeforeSoftWrap(line),
        RowWrap::EndsWithSoftWrap => SelectedRowText::EndsWithSoftWrap(line),
    }
}

fn word_start_col(frame_buffer: &FrameBuffer, row: u16, col: u16, region: &PaneRegionSnapshot) -> u16 {
    let mut start_col = col;
    while start_col > region.col() {
        let previous_col = start_col.saturating_sub(1);
        if WordCell::at(frame_buffer, row, previous_col, region) == WordCell::No {
            break;
        }
        start_col = previous_col;
    }
    start_col
}

fn word_end_col(frame_buffer: &FrameBuffer, row: u16, col: u16, region: &PaneRegionSnapshot) -> u16 {
    let mut end_col = col;
    let last_col = self::last_region_col_saturating(region);
    while end_col < last_col {
        let next_col = end_col.saturating_add(1);
        if WordCell::at(frame_buffer, row, next_col, region) == WordCell::No {
            break;
        }
        end_col = next_col;
    }
    end_col
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum WordCell {
    No,
    Yes,
}

impl WordCell {
    fn at(frame_buffer: &FrameBuffer, row: u16, col: u16, region: &PaneRegionSnapshot) -> Self {
        if region.containment(row, col) == PaneRegionContainment::Outside {
            return Self::No;
        }
        let Some(cell) = frame_buffer.cell(row, col) else {
            return Self::No;
        };

        if matches!(cell.width(), RenderCellWidth::WideContinuation) {
            let Some(previous_col) = col.checked_sub(1) else {
                return Self::No;
            };
            if region.containment(row, previous_col) == PaneRegionContainment::Outside {
                return Self::No;
            }
            let Some(previous_cell) = frame_buffer.cell(row, previous_col) else {
                return Self::No;
            };
            return if matches!(previous_cell.width(), RenderCellWidth::Wide)
                && CellWhitespace::from(previous_cell.text()) == CellWhitespace::NonWhitespace
            {
                Self::Yes
            } else {
                Self::No
            };
        }

        if CellWhitespace::from(cell.text()) == CellWhitespace::NonWhitespace {
            Self::Yes
        } else {
            Self::No
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum CellWhitespace {
    NonWhitespace,
    Whitespace,
}

impl From<&str> for CellWhitespace {
    fn from(text: &str) -> Self {
        if text.is_empty() || text.chars().all(char::is_whitespace) {
            Self::Whitespace
        } else {
            Self::NonWhitespace
        }
    }
}

fn matching_region(regions: &PaneRegionsSnapshot, pane_id: PaneId) -> Option<PaneRegionSnapshot> {
    regions.regions().iter().find(|region| *region.id() == pane_id).cloned()
}

fn content_position(position: ClientMousePosition, region: &PaneRegionSnapshot) -> Option<SelectionContentPosition> {
    if region.containment(position.row, position.col) == PaneRegionContainment::Outside {
        return None;
    }
    let row = region
        .visible_top_row()
        .checked_add(u64::from(position.row.saturating_sub(region.row())))?;
    Some(SelectionContentPosition {
        col: position.col.saturating_sub(region.col()),
        row,
    })
}

fn visible_position(region: &PaneRegionSnapshot, position: SelectionContentPosition) -> Option<ClientMousePosition> {
    if position.col >= region.cols() {
        return None;
    }
    let row = self::visible_row_for_content_row(region, position.row)?;
    Some(ClientMousePosition {
        row,
        col: region.col().checked_add(position.col)?,
    })
}

fn visible_row_for_content_row(region: &PaneRegionSnapshot, row: u64) -> Option<u16> {
    let local_row = row.checked_sub(region.visible_top_row())?;
    let local_row = u16::try_from(local_row).ok()?;
    if local_row >= region.rows() {
        return None;
    }
    region.row().checked_add(local_row)
}

fn selectable_position(
    position: ClientMousePosition,
    region: &PaneRegionSnapshot,
    frame_buffer: &FrameBuffer,
) -> ClientMousePosition {
    let position = self::clamp_to_region(position, region);
    let Some(cell) = frame_buffer.cell(position.row, position.col) else {
        return position;
    };
    if !matches!(cell.width(), RenderCellWidth::WideContinuation) {
        return position;
    }
    let Some(previous_col) = position.col.checked_sub(1) else {
        return position;
    };
    if region.containment(position.row, previous_col) == PaneRegionContainment::Outside {
        return position;
    }
    let Some(previous_cell) = frame_buffer.cell(position.row, previous_col) else {
        return position;
    };
    // Mouse reports can land on the continuation half of a wide cell; snap back so copy/render keeps the glyph.
    if matches!(previous_cell.width(), RenderCellWidth::Wide) {
        ClientMousePosition {
            row: position.row,
            col: previous_col,
        }
    } else {
        position
    }
}

fn clamp_to_region(position: ClientMousePosition, region: &PaneRegionSnapshot) -> ClientMousePosition {
    ClientMousePosition {
        row: position
            .row
            .clamp(region.row(), self::last_region_row_saturating(region)),
        col: position
            .col
            .clamp(region.col(), self::last_region_col_saturating(region)),
    }
}

const fn selection_edge_row(region: &PaneRegionSnapshot, direction: PaneScrollDirection) -> u16 {
    match direction {
        PaneScrollDirection::Up => region.row(),
        PaneScrollDirection::Down => self::last_region_row_saturating(region),
    }
}

const fn selection_edge_direction(
    position: ClientMousePosition,
    region: &PaneRegionSnapshot,
    trigger: SelectionEdgeScrollTrigger,
) -> Option<PaneScrollDirection> {
    match trigger {
        SelectionEdgeScrollTrigger::EdgeRow if position.row <= region.row() => Some(PaneScrollDirection::Up),
        SelectionEdgeScrollTrigger::EdgeRow if position.row >= self::last_region_row_saturating(region) => {
            Some(PaneScrollDirection::Down)
        }
        SelectionEdgeScrollTrigger::OutsideOnly if position.row < region.row() => Some(PaneScrollDirection::Up),
        SelectionEdgeScrollTrigger::OutsideOnly if position.row > self::last_region_row_saturating(region) => {
            Some(PaneScrollDirection::Down)
        }
        SelectionEdgeScrollTrigger::EdgeRow | SelectionEdgeScrollTrigger::OutsideOnly => None,
    }
}

const fn last_region_col_saturating(region: &PaneRegionSnapshot) -> u16 {
    region.col().saturating_add(region.cols().saturating_sub(1))
}

const fn last_region_row_saturating(region: &PaneRegionSnapshot) -> u16 {
    region.row().saturating_add(region.rows().saturating_sub(1))
}

#[cfg(test)]
pub mod test_helpers {
    use muxr_core::ClientRequest;

    use super::SelectionEdgeScrollRequest;

    pub const fn edge_scroll_request(request: &SelectionEdgeScrollRequest) -> &ClientRequest {
        &request.request
    }
}

#[cfg(test)]
mod tests {
    use std::time::Duration;
    use std::time::Instant;

    use muxr_core::RenderBaseline;
    use muxr_core::RenderCell;
    use muxr_core::RenderCursor;
    use muxr_core::RenderRowSpan;
    use muxr_core::RenderStyle;
    use muxr_core::RenderUpdate;
    use muxr_core::TerminalSize;
    use test_that::prelude::*;

    use super::*;

    #[rstest::rstest]
    #[case::same_cell_within_threshold(0, 0, 399, SelectionClickOutcome::Double)]
    #[case::same_cell_after_threshold(0, 0, 401, SelectionClickOutcome::Single)]
    #[case::different_cell_within_threshold(0, 1, 100, SelectionClickOutcome::Single)]
    fn test_selection_click_tracker_record_selection_start_when_clicks_are_repeated_detects_double_click(
        #[case] row: u16,
        #[case] col: u16,
        #[case] elapsed_ms: u64,
        #[case] expected_outcome: SelectionClickOutcome,
    ) -> rootcause::Result<()> {
        let mut clicks = SelectionClickTracker::default();
        let frame_buffer = FrameBuffer::default();
        let regions = pane_regions()?;
        let now = Instant::now();
        assert_that!(
            clicks.record_selection_start(ClientMousePosition { row: 0, col: 0 }, &regions, &frame_buffer, now),
            eq(SelectionClickOutcome::Single)
        );

        let next_click_at = now
            .checked_add(Duration::from_millis(elapsed_ms))
            .ok_or_else(|| report!("muxr click tracker test instant overflowed"))?;
        assert_that!(
            clicks.record_selection_start(ClientMousePosition { row, col }, &regions, &frame_buffer, next_click_at),
            eq(expected_outcome)
        );
        Ok(())
    }

    #[test]
    fn test_selection_state_when_drag_crosses_pane_border_clamps_to_start_pane() -> rootcause::Result<()> {
        let mut selection = SelectionState::default();
        let frame_buffer = FrameBuffer::default();

        assert_that!(
            selection.apply(
                SelectionInput::Start(ClientMousePosition { row: 0, col: 2 }),
                &pane_regions()?,
                &frame_buffer,
            )?,
            eq(SelectionChange::Unchanged)
        );
        assert_that!(
            selection.apply(
                SelectionInput::Update(ClientMousePosition { row: 0, col: 8 }),
                &pane_regions()?,
                &frame_buffer,
            )?,
            eq(SelectionChange::Changed)
        );

        let range = selection
            .range()
            .ok_or_else(|| report!("expected muxr selection range"))?;
        assert_that!(
            range.bounds_positions(),
            eq(Some((
                ClientMousePosition { row: 0, col: 2 },
                ClientMousePosition { row: 0, col: 4 },
            )))
        );
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_text_when_vertical_split_exists_copies_only_selected_pane() -> rootcause::Result<()>
    {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(render_baseline()?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 1 }),
            &pane_regions()?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 0, col: 9 }),
            &pane_regions()?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_text(), eq(Some("eft".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_text_when_drag_starts_on_wide_continuation_copies_wide_cell()
    -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(wide_render_baseline()?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 1 }),
            &wide_pane_regions()?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 0, col: 2 }),
            &wide_pane_regions()?,
            &frame_buffer,
        )?;

        let range = selection
            .range()
            .ok_or_else(|| report!("expected muxr wide-cell drag selection range"))?;
        assert_that!(
            range.bounds_positions(),
            eq(Some((
                ClientMousePosition { row: 0, col: 0 },
                ClientMousePosition { row: 0, col: 2 },
            )))
        );
        assert_that!(selection.selected_text(), eq(Some("表".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_select_word_when_word_is_clicked_selects_whitespace_delimited_word() -> rootcause::Result<()>
    {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(render_baseline()?))?;
        let mut selection = SelectionState::default();

        assert_that!(
            selection.select_word(ClientMousePosition { row: 0, col: 8 }, &pane_regions()?, &frame_buffer,)?,
            eq(SelectionChange::Changed)
        );

        assert_that!(selection.selected_text(), eq(Some("right".to_owned())));
        Ok(())
    }

    #[rstest::rstest]
    #[case::wide_start(0)]
    #[case::wide_continuation(1)]
    fn test_selection_state_select_word_when_wide_cell_is_clicked_selects_whole_wide_cell(
        #[case] col: u16,
    ) -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(wide_render_baseline()?))?;
        let mut selection = SelectionState::default();

        assert_that!(
            selection.select_word(
                ClientMousePosition { row: 0, col },
                &wide_pane_regions()?,
                &frame_buffer,
            )?,
            eq(SelectionChange::Changed)
        );

        let range = selection
            .range()
            .ok_or_else(|| report!("expected muxr wide-cell selection range"))?;
        assert_that!(
            range.bounds_positions(),
            eq(Some((
                ClientMousePosition { row: 0, col: 0 },
                ClientMousePosition { row: 0, col: 1 },
            )))
        );
        assert_that!(selection.selected_text(), eq(Some("表".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_when_pane_scrolls_keeps_text_and_moves_highlight_with_content() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(three_row_render_baseline("aa", "bb", "cc")?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 1, col: 0 }),
            &three_row_pane_regions(10)?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 1, col: 1 }),
            &three_row_pane_regions(10)?,
            &frame_buffer,
        )?;
        frame_buffer.apply(RenderUpdate::Baseline(three_row_render_baseline("zz", "aa", "bb")?))?;

        assert_that!(
            selection.clear_if_regions_changed(&three_row_pane_regions(9)?),
            eq(SelectionChange::Changed)
        );

        let range = selection
            .range()
            .ok_or_else(|| report!("expected muxr scrolled selection range"))?;
        assert_that!(
            range.bounds_positions(),
            eq(Some((
                ClientMousePosition { row: 2, col: 0 },
                ClientMousePosition { row: 2, col: 1 },
            )))
        );
        assert_that!(selection.selected_text(), eq(Some("bb".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_when_edge_drag_scrolls_keeps_offscreen_selected_text() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(three_row_render_baseline("aa", "bb", "cc")?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &three_row_pane_regions(9)?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::Update(ClientMousePosition { row: 2, col: 1 }),
            &three_row_pane_regions(9)?,
            &frame_buffer,
        )?;
        frame_buffer.apply(RenderUpdate::Baseline(three_row_render_baseline("bb", "cc", "dd")?))?;
        assert_that!(
            selection.clear_if_regions_changed(&three_row_pane_regions(10)?),
            eq(SelectionChange::Changed)
        );
        selection.refresh_visible_rows(&frame_buffer)?;
        selection.apply(
            SelectionInput::Update(ClientMousePosition { row: 2, col: 1 }),
            &three_row_pane_regions(10)?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_text(), eq(Some("aa\nbb\ncc\ndd".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_inline_text_when_rows_do_not_reach_edge_inserts_space() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(two_row_render_baseline(10, "let value", "+ 2")?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &two_row_pane_regions(10)?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 1, col: 2 }),
            &two_row_pane_regions(10)?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_inline_text(), eq(Some("let value + 2".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_inline_text_when_wrap_splits_word_continues_word() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(two_row_render_baseline(
            8, "(reasoni", "ng 54)",
        )?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &two_row_pane_regions_with_wraps(8, [RowWrap::EndsWithSoftWrap, RowWrap::EndsBeforeSoftWrap])?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 1, col: 5 }),
            &two_row_pane_regions_with_wraps(8, [RowWrap::EndsWithSoftWrap, RowWrap::EndsBeforeSoftWrap])?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_inline_text(), eq(Some("(reasoning 54)".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_inline_text_when_wrap_splits_number_continues_number() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(two_row_render_baseline(
            27,
            "output=107,820 (reasoning 5",
            "4,014)",
        )?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &two_row_pane_regions_with_wraps(27, [RowWrap::EndsWithSoftWrap, RowWrap::EndsBeforeSoftWrap])?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 1, col: 5 }),
            &two_row_pane_regions_with_wraps(27, [RowWrap::EndsWithSoftWrap, RowWrap::EndsBeforeSoftWrap])?,
            &frame_buffer,
        )?;

        assert_that!(
            selection.selected_inline_text(),
            eq(Some("output=107,820 (reasoning 54,014)".to_owned()))
        );
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_inline_text_when_hard_line_reaches_edge_inserts_space() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(two_row_render_baseline(4, "WARN", "next")?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &two_row_pane_regions(4)?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 1, col: 3 }),
            &two_row_pane_regions(4)?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_inline_text(), eq(Some("WARN next".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_inline_text_when_wrap_ends_with_wide_cell_continues_word() -> rootcause::Result<()>
    {
        let style = RenderStyle::default();
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(two_row_render_baseline_cells(
            3,
            vec![
                RenderCell::narrow("a", style),
                RenderCell::wide("表", style),
                RenderCell::wide_continuation(style),
            ],
            padded_render_cells(3, "b"),
        )?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &two_row_pane_regions_with_wraps(3, [RowWrap::EndsWithSoftWrap, RowWrap::EndsBeforeSoftWrap])?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::End(ClientMousePosition { row: 1, col: 0 }),
            &two_row_pane_regions_with_wraps(3, [RowWrap::EndsWithSoftWrap, RowWrap::EndsBeforeSoftWrap])?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_inline_text(), eq(Some("a表b".to_owned())));
        Ok(())
    }

    #[test]
    fn test_selection_state_selected_text_when_cached_row_is_missing_returns_none() -> rootcause::Result<()> {
        let mut frame_buffer = FrameBuffer::default();
        frame_buffer.apply(RenderUpdate::Baseline(three_row_render_baseline("aa", "bb", "cc")?))?;
        let mut selection = SelectionState::default();

        selection.apply(
            SelectionInput::Start(ClientMousePosition { row: 0, col: 0 }),
            &three_row_pane_regions(9)?,
            &frame_buffer,
        )?;
        selection.apply(
            SelectionInput::Update(ClientMousePosition { row: 2, col: 1 }),
            &three_row_pane_regions(9)?,
            &frame_buffer,
        )?;
        frame_buffer.apply(RenderUpdate::Baseline(three_row_render_baseline("ee", "ff", "gg")?))?;
        assert_that!(
            selection.clear_if_regions_changed(&three_row_pane_regions(13)?),
            eq(SelectionChange::Changed)
        );
        selection.refresh_visible_rows(&frame_buffer)?;
        selection.apply(
            SelectionInput::Update(ClientMousePosition { row: 2, col: 1 }),
            &three_row_pane_regions(13)?,
            &frame_buffer,
        )?;

        assert_that!(selection.selected_text(), eq(None));
        Ok(())
    }

    fn pane_regions() -> rootcause::Result<PaneRegionsSnapshot> {
        PaneRegionsSnapshot::new(vec![
            PaneRegionSnapshot::new(PaneId::new(1)?, 0, 0, 5, 1, muxr_core::PaneMouseMode::None, 0)?,
            PaneRegionSnapshot::new(PaneId::new(2)?, 6, 0, 5, 1, muxr_core::PaneMouseMode::None, 0)?,
        ])
    }

    fn wide_pane_regions() -> rootcause::Result<PaneRegionsSnapshot> {
        PaneRegionsSnapshot::new(vec![PaneRegionSnapshot::new(
            PaneId::new(1)?,
            0,
            0,
            3,
            1,
            muxr_core::PaneMouseMode::None,
            0,
        )?])
    }

    fn three_row_pane_regions(visible_top_row: u64) -> rootcause::Result<PaneRegionsSnapshot> {
        PaneRegionsSnapshot::new(vec![PaneRegionSnapshot::new(
            PaneId::new(1)?,
            0,
            0,
            2,
            3,
            muxr_core::PaneMouseMode::None,
            visible_top_row,
        )?])
    }

    fn two_row_pane_regions(cols: u16) -> rootcause::Result<PaneRegionsSnapshot> {
        self::two_row_pane_regions_with_wraps(cols, [RowWrap::EndsBeforeSoftWrap, RowWrap::EndsBeforeSoftWrap])
    }

    fn two_row_pane_regions_with_wraps(
        cols: u16,
        wrapped_rows: [RowWrap; 2],
    ) -> rootcause::Result<PaneRegionsSnapshot> {
        PaneRegionsSnapshot::new(vec![
            PaneRegionSnapshot::new(PaneId::new(1)?, 0, 0, cols, 2, muxr_core::PaneMouseMode::None, 0)?
                .with_wrapped_rows(wrapped_rows.to_vec())?,
        ])
    }

    fn render_baseline() -> rootcause::Result<RenderBaseline> {
        RenderBaseline::new(
            1,
            TerminalSize::new(11, 1)?,
            RenderCursor {
                row: 0,
                col: 0,
                shape: muxr_core::RenderCursorShape::Default,
                visibility: muxr_core::RenderCursorVisibility::Visible,
            },
            vec![RenderRowSpan::new(
                0,
                0,
                "left |right"
                    .chars()
                    .map(|ch| RenderCell::narrow(ch.to_string(), RenderStyle::default()))
                    .collect(),
            )?],
        )
    }

    fn wide_render_baseline() -> rootcause::Result<RenderBaseline> {
        let style = RenderStyle::default();
        RenderBaseline::new(
            1,
            TerminalSize::new(3, 1)?,
            RenderCursor {
                row: 0,
                col: 0,
                shape: muxr_core::RenderCursorShape::Default,
                visibility: muxr_core::RenderCursorVisibility::Visible,
            },
            vec![RenderRowSpan::new(
                0,
                0,
                vec![
                    RenderCell::wide("表", style),
                    RenderCell::wide_continuation(style),
                    RenderCell::narrow(" ", style),
                ],
            )?],
        )
    }

    fn three_row_render_baseline(first: &str, second: &str, third: &str) -> rootcause::Result<RenderBaseline> {
        RenderBaseline::new(
            1,
            TerminalSize::new(2, 3)?,
            RenderCursor {
                row: 0,
                col: 0,
                shape: muxr_core::RenderCursorShape::Default,
                visibility: muxr_core::RenderCursorVisibility::Visible,
            },
            vec![
                RenderRowSpan::new(0, 0, first.chars().map(render_cell).collect())?,
                RenderRowSpan::new(1, 0, second.chars().map(render_cell).collect())?,
                RenderRowSpan::new(2, 0, third.chars().map(render_cell).collect())?,
            ],
        )
    }

    fn two_row_render_baseline(cols: u16, first: &str, second: &str) -> rootcause::Result<RenderBaseline> {
        self::two_row_render_baseline_cells(
            cols,
            padded_render_cells(cols, first),
            padded_render_cells(cols, second),
        )
    }

    fn two_row_render_baseline_cells(
        cols: u16,
        first: Vec<RenderCell>,
        second: Vec<RenderCell>,
    ) -> rootcause::Result<RenderBaseline> {
        RenderBaseline::new(
            1,
            TerminalSize::new(cols, 2)?,
            RenderCursor {
                row: 0,
                col: 0,
                shape: muxr_core::RenderCursorShape::Default,
                visibility: muxr_core::RenderCursorVisibility::Visible,
            },
            vec![RenderRowSpan::new(0, 0, first)?, RenderRowSpan::new(1, 0, second)?],
        )
    }

    fn padded_render_cells(cols: u16, text: &str) -> Vec<RenderCell> {
        let mut cells = text.chars().map(render_cell).collect::<Vec<_>>();
        while cells.len() < usize::from(cols) {
            cells.push(render_cell(' '));
        }
        cells
    }

    fn render_cell(ch: char) -> RenderCell {
        RenderCell::narrow(ch.to_string(), RenderStyle::default())
    }
}