use std::collections::{HashMap, HashSet};

use crate::{
    ConstraintKind, ConstraintWarning, Direction, GapConfig, LayoutError, LayoutResult, Rect, SizeConstraints,
    WindowId, normalized_constraints, record_minimum_warnings,
};

const DEFAULT_WIDTH: f64 = 0.5;
const MIN_COLUMN_WIDTH: f64 = 0.1;
const MAX_COLUMN_WIDTH: f64 = 2.0;
const MIN_ROW_HEIGHT: f64 = 0.05;
const REVEAL_EPSILON: f64 = 0.5;

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ColumnWidth {
    Proportion(f64),
    Fixed(f64),
    Full,
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum ViewportFocusStrategy {
    #[default]
    Minimal,
    Center,
    Paged,
}

impl Default for ColumnWidth {
    fn default() -> Self {
        Self::Proportion(DEFAULT_WIDTH)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct Column {
    pub windows: Vec<WindowId>,
    pub active: usize,
    pub width: ColumnWidth,
    pub heights: Vec<f64>,
}

impl Column {
    fn new(window: WindowId, width: ColumnWidth) -> Self {
        Self {
            windows: vec![window],
            active: 0,
            width: normalized_width(width),
            heights: vec![1.0],
        }
    }

    fn normalize_heights(&mut self) {
        if self.windows.is_empty() {
            self.heights.clear();
            return;
        }
        if self.heights.len() != self.windows.len() {
            self.heights.resize(self.windows.len(), 1.0);
        }
        self.heights.iter_mut().for_each(|height| {
            if !height.is_finite() || *height <= 0.0 {
                *height = 1.0;
            }
        });
        let total = self.heights.iter().sum::<f64>();
        self.heights.iter_mut().for_each(|height| *height /= total);
        self.active = self.active.min(self.windows.len() - 1);
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ScrollingLayout {
    columns: Vec<Column>,
    active_column: Option<usize>,
    viewport_x: f64,
    default_width: ColumnWidth,
    focus_strategy: ViewportFocusStrategy,
    reveal_pending: Option<WindowId>,
    swipe_focus_pending: Option<(WindowId, WindowId)>,
    width_cycle_pending: bool,
    last_viewport_width: Option<f64>,
}

impl Default for ScrollingLayout {
    fn default() -> Self {
        Self {
            columns: Vec::new(),
            active_column: None,
            viewport_x: 0.0,
            default_width: ColumnWidth::default(),
            focus_strategy: ViewportFocusStrategy::Minimal,
            reveal_pending: None,
            swipe_focus_pending: None,
            width_cycle_pending: false,
            last_viewport_width: None,
        }
    }
}

impl ScrollingLayout {
    pub fn set_default_width(&mut self, width: ColumnWidth) {
        self.default_width = normalized_width(width);
    }

    pub fn with_default_width(default_width: ColumnWidth) -> Self {
        Self {
            default_width: normalized_width(default_width),
            ..Self::default()
        }
    }

    pub fn set_focus_strategy(&mut self, strategy: ViewportFocusStrategy) {
        self.focus_strategy = strategy;
        self.reveal_pending = self.active_window();
        self.swipe_focus_pending = None;
    }

    pub fn default_width(&self) -> ColumnWidth {
        self.default_width
    }

    pub fn columns(&self) -> &[Column] {
        &self.columns
    }

    pub fn active_column(&self) -> Option<usize> {
        self.active_column
    }

    pub fn active_window(&self) -> Option<WindowId> {
        let column = self.columns.get(self.active_column?)?;
        column.windows.get(column.active).copied()
    }

    pub fn viewport_x(&self) -> f64 {
        self.viewport_x
    }

    pub fn contains(&self, window: WindowId) -> bool {
        self.window_location(window).is_some()
    }

    pub fn window_ids(&self) -> impl Iterator<Item = WindowId> + '_ {
        self.columns.iter().flat_map(|column| column.windows.iter().copied())
    }

    pub fn insert(&mut self, window: WindowId, focused: Option<WindowId>) -> Result<(), LayoutError> {
        if self.contains(window) {
            return Err(LayoutError::DuplicateWindow(window));
        }

        let index = focused
            .and_then(|focused| self.window_location(focused))
            .map(|(column, _)| column + 1)
            .unwrap_or(self.columns.len());
        self.columns.insert(index, Column::new(window, self.default_width));
        self.active_column = Some(index);
        self.reveal_pending = (self.columns.len() > 1).then_some(window);

        debug_assert!(self.validate().is_ok());
        Ok(())
    }

    pub fn remove(&mut self, window: WindowId) -> Result<(), LayoutError> {
        let (column_index, window_index) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        let column = &mut self.columns[column_index];
        let removed_active_column = self.active_column == Some(column_index) && column.windows.len() == 1;
        column.windows.remove(window_index);
        column.heights.remove(window_index);

        if column.windows.is_empty() {
            self.columns.remove(column_index);
            self.active_column = match self.active_column {
                None => None,
                Some(_) if self.columns.is_empty() => None,
                Some(active) if active > column_index => Some(active - 1),
                Some(active) => Some(active.min(self.columns.len() - 1)),
            };
        } else {
            column.active = column.active.min(column.windows.len() - 1);
            column.normalize_heights();
        }
        if self.reveal_pending == Some(window)
            || removed_active_column
            || self.focus_strategy == ViewportFocusStrategy::Paged
        {
            self.reveal_pending = self.active_window();
        }

        debug_assert!(self.validate().is_ok());
        Ok(())
    }

    pub fn focus(&mut self, window: WindowId) -> Result<(), LayoutError> {
        let (column, index) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        let changed_column = self.active_column != Some(column);
        self.active_column = Some(column);
        self.columns[column].active = index;
        if changed_column {
            self.reveal_pending = Some(window);
        }
        Ok(())
    }

    /// Hover changes the active window without requesting viewport movement.
    /// Keep any earlier explicit reveal attached to its original window.
    pub fn focus_without_reveal(&mut self, window: WindowId) -> Result<(), LayoutError> {
        let (column, index) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        self.active_column = Some(column);
        self.columns[column].active = index;
        Ok(())
    }

    /// An explicit selection must reveal even a window already focused by hover.
    pub fn focus_and_reveal(&mut self, window: WindowId) -> Result<(), LayoutError> {
        self.focus_without_reveal(window)?;
        self.reveal_pending = Some(window);
        self.swipe_focus_pending = None;
        Ok(())
    }

    pub fn slide_focus_from(&mut self, previous: WindowId, focused: WindowId) -> Result<(), LayoutError> {
        self.window_location(previous)
            .ok_or(LayoutError::UnknownWindow(previous))?;
        if self.focus_strategy == ViewportFocusStrategy::Minimal {
            return self.focus_and_reveal(focused);
        }
        self.focus_without_reveal(focused)?;
        self.reveal_pending = None;
        self.swipe_focus_pending = Some((previous, focused));
        Ok(())
    }

    pub fn move_into_column(&mut self, window: WindowId, target: WindowId) -> Result<(), LayoutError> {
        if window == target {
            return Ok(());
        }
        self.window_location(target).ok_or(LayoutError::UnknownWindow(target))?;
        self.remove(window)?;
        let (target_column, target_index) = self
            .window_location(target)
            .expect("removing another window preserves the target");
        let column = &mut self.columns[target_column];
        let insertion = (target_index + 1).min(column.windows.len());
        column.windows.insert(insertion, window);
        column.heights.insert(insertion, 1.0);
        column.active = insertion;
        column.normalize_heights();
        self.active_column = Some(target_column);
        self.reveal_pending = self.active_window();

        debug_assert!(self.validate().is_ok());
        Ok(())
    }

    pub fn extract_to_column(&mut self, window: WindowId) -> Result<(), LayoutError> {
        let (source, _) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        if self.columns[source].windows.len() == 1 {
            self.active_column = Some(source);
            return Ok(());
        }

        self.remove(window)?;
        let insertion = (source + 1).min(self.columns.len());
        self.columns.insert(insertion, Column::new(window, self.default_width));
        self.active_column = Some(insertion);
        self.reveal_pending = self.active_window();

        debug_assert!(self.validate().is_ok());
        Ok(())
    }

    pub fn set_column_width(&mut self, window: WindowId, width: ColumnWidth) -> Result<(), LayoutError> {
        let (column, _) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        self.columns[column].width = normalized_width(width);
        self.reveal_pending = self.active_window();
        Ok(())
    }

    pub fn cycle_column_width(&mut self, window: WindowId, presets: &[ColumnWidth]) -> Result<bool, LayoutError> {
        let (column, _) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        let presets = presets.iter().copied().map(normalized_width).collect::<Vec<_>>();
        if presets.is_empty() {
            return Ok(false);
        }

        let current = normalized_width(self.columns[column].width);
        let next = presets
            .iter()
            .position(|preset| *preset == current)
            .map(|index| presets[(index + 1) % presets.len()])
            .unwrap_or(presets[0]);
        self.columns[column].width = next;
        self.width_cycle_pending = next != current;
        Ok(next != current)
    }

    pub fn center_window(
        &mut self,
        window: WindowId,
        bounds: Rect,
        gaps: GapConfig,
        constraints: &HashMap<WindowId, SizeConstraints>,
    ) -> Result<bool, LayoutError> {
        let before = self.viewport_x;
        let result = self.geometry_with_constraints(bounds, gaps, constraints, Some(window))?;
        let rect = result
            .geometry
            .get(&window)
            .copied()
            .ok_or(LayoutError::UnknownWindow(window))?;
        let viewport_center = bounds.x + bounds.width / 2.0;
        let window_center = rect.x + rect.width / 2.0;
        self.viewport_x += window_center - viewport_center;
        self.geometry_with_constraints(bounds, gaps, constraints, Some(window))?;

        Ok(self.viewport_x != before)
    }

    pub fn directional_neighbor(
        &self,
        window: WindowId,
        direction: Direction,
    ) -> Result<Option<WindowId>, LayoutError> {
        let (column, row) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        let neighbor = match direction {
            Direction::Up => row.checked_sub(1).map(|row| self.columns[column].windows[row]),
            Direction::Down => self.columns[column].windows.get(row + 1).copied(),
            Direction::Left => column.checked_sub(1).map(|column| {
                let column = &self.columns[column];
                column.windows[column.active]
            }),
            Direction::Right => self.columns.get(column + 1).map(|column| column.windows[column.active]),
        };

        Ok(neighbor)
    }

    pub fn move_window(&mut self, window: WindowId, direction: Direction) -> Result<bool, LayoutError> {
        let (column, row) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;

        match direction {
            Direction::Up if row > 0 => {
                self.columns[column].windows.swap(row, row - 1);
                self.columns[column].heights.swap(row, row - 1);
                self.columns[column].active = row - 1;
            }
            Direction::Down if row + 1 < self.columns[column].windows.len() => {
                self.columns[column].windows.swap(row, row + 1);
                self.columns[column].heights.swap(row, row + 1);
                self.columns[column].active = row + 1;
            }
            Direction::Left if column > 0 => self.move_horizontally(window, column - 1)?,
            Direction::Right if column + 1 < self.columns.len() => self.move_horizontally(window, column + 1)?,
            _ => return Ok(false),
        }

        debug_assert!(self.validate().is_ok());
        Ok(true)
    }

    pub fn resize_window(&mut self, window: WindowId, direction: Direction, amount: f64) -> Result<bool, LayoutError> {
        let (column, row) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        let amount = if amount.is_finite() { amount.abs() } else { 0.0 };
        if amount == 0.0 {
            return Ok(false);
        }

        let changed = match direction {
            Direction::Left | Direction::Right => {
                let current = match normalized_width(self.columns[column].width) {
                    ColumnWidth::Proportion(value) => value,
                    ColumnWidth::Fixed(_) | ColumnWidth::Full => DEFAULT_WIDTH,
                };
                let adjustment = if direction == Direction::Right { amount } else { -amount };
                let resized = (current + adjustment).clamp(MIN_COLUMN_WIDTH, MAX_COLUMN_WIDTH);
                self.columns[column].width = ColumnWidth::Proportion(resized);
                resized != current
            }
            Direction::Up if row > 0 => resize_rows(&mut self.columns[column], row, row - 1, amount),
            Direction::Down if row + 1 < self.columns[column].windows.len() => {
                resize_rows(&mut self.columns[column], row, row + 1, amount)
            }
            Direction::Up | Direction::Down => false,
        };

        debug_assert!(self.validate().is_ok());
        Ok(changed)
    }

    pub fn geometry_with_constraints(
        &mut self,
        bounds: Rect,
        gaps: GapConfig,
        constraints: &HashMap<WindowId, SizeConstraints>,
        focused: Option<WindowId>,
    ) -> Result<LayoutResult, LayoutError> {
        if let Some(focused) = focused {
            self.focus(focused)?;
        }

        self.validate_scalars()?;
        debug_assert!(self.validate().is_ok());

        if self.columns.is_empty() {
            self.viewport_x = 0.0;
            return Ok(LayoutResult::default());
        }

        let window_count = self.window_ids().count();
        let inner = finite_nonnegative(gaps.inner);
        let outer = if gaps.smart && window_count == 1 {
            0.0
        } else {
            finite_nonnegative(gaps.outer)
        };
        let viewport_width = (bounds.width - outer * 2.0).max(1.0);
        let viewport_height = (bounds.height - outer * 2.0).max(1.0);
        // Strip coordinates start at the viewport's inset left edge. Inner
        // gaps belong to column positions; outer margins inset the viewport
        // and are added back exactly once when placing windows on the output.
        let mut column_positions = Vec::with_capacity(self.columns.len());
        let mut next_column_x = 0.0;

        for column in &self.columns {
            let requested = match normalized_width(column.width) {
                ColumnWidth::Proportion(proportion) => ((viewport_width + inner) * proportion - inner).max(1.0),
                ColumnWidth::Fixed(width) => width,
                ColumnWidth::Full => viewport_width,
            };
            let minimum = column
                .windows
                .iter()
                .map(|window| {
                    constraints
                        .get(window)
                        .copied()
                        .map(normalized_constraints)
                        .unwrap_or_default()
                        .min_width
                })
                .fold(1.0_f64, f64::max);
            let width = requested.max(minimum).max(1.0);
            column_positions.push((next_column_x, width));
            next_column_x += width + inner;
        }
        let viewport_resized = self.last_viewport_width != Some(viewport_width);
        self.last_viewport_width = Some(viewport_width);
        if self.width_cycle_pending {
            self.retarget_after_width_cycle(&column_positions, viewport_width);
            self.width_cycle_pending = false;
            self.reveal_pending = None;
            self.swipe_focus_pending = None;
        } else if let Some((previous, focused)) = self.swipe_focus_pending.take() {
            if let (Some((from, _)), Some((to, _))) = (self.window_location(previous), self.window_location(focused)) {
                let last_end = column_positions
                    .last()
                    .map(|(start, width)| start + width)
                    .unwrap_or(0.0);
                let max_offset = (last_end - viewport_width).max(0.0);
                self.viewport_x =
                    (self.viewport_x + column_positions[to].0 - column_positions[from].0).clamp(0.0, max_offset);
            }
            self.reveal_pending = None;
        } else {
            let reveal = self.reveal_pending.take().or_else(|| {
                (viewport_resized && self.focus_strategy == ViewportFocusStrategy::Paged)
                    .then(|| self.active_window())
                    .flatten()
            });
            if let Some((column, _)) = reveal.and_then(|window| self.window_location(window)) {
                self.reveal_column(&column_positions, viewport_width, column);
            }
        }

        let mut result = LayoutResult::default();
        for (column_index, column) in self.columns.iter().enumerate() {
            let (column_x, column_width) = column_positions[column_index];
            let available_height = (viewport_height - inner * (column.windows.len().saturating_sub(1) as f64)).max(1.0);
            let mut y = bounds.y + outer;

            for (window_index, window) in column.windows.iter().enumerate() {
                let mut rect = Rect::new(
                    bounds.x + outer + column_x - self.viewport_x,
                    y,
                    column_width,
                    available_height * column.heights[window_index],
                );
                let constraint = constraints
                    .get(window)
                    .copied()
                    .map(normalized_constraints)
                    .unwrap_or_default();
                record_minimum_warnings(*window, rect, constraint, &mut result.warnings);
                apply_maximums(*window, &mut rect, constraint, &mut result.warnings);
                y += available_height * column.heights[window_index] + inner;
                result.geometry.insert(*window, rect);
            }
        }

        Ok(result)
    }

    fn reveal_column(&mut self, positions: &[(f64, f64)], viewport_width: f64, active: usize) {
        if let Some(start) = self.paged_viewport(positions, viewport_width, Some(active)) {
            self.viewport_x = start;
            return;
        }
        let (start, width) = positions[active];
        let end = start + width;
        if self.focus_strategy == ViewportFocusStrategy::Center {
            self.viewport_x = start + width / 2.0 - viewport_width / 2.0;
            return;
        }

        if start >= self.viewport_x - REVEAL_EPSILON && end <= self.viewport_x + viewport_width + REVEAL_EPSILON {
            return;
        }

        let target = if width >= viewport_width {
            // Approaching from the left reveals the left edge; approaching
            // from the right reveals the right edge. Keep an existing view
            // inside an oversized column stable on repeated focus.
            self.viewport_x.clamp(start, end - viewport_width)
        } else if start < self.viewport_x {
            start
        } else if end > self.viewport_x + viewport_width {
            end - viewport_width
        } else {
            self.viewport_x
        };
        if (target - self.viewport_x).abs() > REVEAL_EPSILON {
            self.viewport_x = target;
        }
    }

    fn paged_viewport(&self, positions: &[(f64, f64)], viewport_width: f64, active: Option<usize>) -> Option<f64> {
        if self.focus_strategy != ViewportFocusStrategy::Paged {
            return None;
        }
        let active = active?;
        // Pack actual allocated widths, including gaps and client constraints.
        // Page boundaries are independent of focus direction. An oversized
        // column occupies its own page rather than overlapping its neighbors.
        let mut first = 0;
        while first < positions.len() {
            let (start, _) = positions[first];
            let mut last = first;
            while let Some(&(next_start, next_width)) = positions.get(last + 1) {
                if next_start + next_width - start > viewport_width + 1e-6 {
                    break;
                }
                last += 1;
            }
            if active <= last {
                return Some(start);
            }
            first = last + 1;
        }
        None
    }

    fn retarget_after_width_cycle(&mut self, positions: &[(f64, f64)], viewport_width: f64) {
        if let Some(start) = self.paged_viewport(positions, viewport_width, self.active_column) {
            self.viewport_x = start;
            return;
        }
        let Some(active) = self.active_column else {
            return;
        };
        let Some(&(start, width)) = positions.get(active) else {
            return;
        };
        let Some(&(last_start, last_width)) = positions.last() else {
            return;
        };
        let strip_width = last_start + last_width;

        if strip_width <= viewport_width {
            self.viewport_x = 0.0;
        } else if width >= viewport_width {
            self.viewport_x = start;
        } else {
            self.viewport_x = (start + width - viewport_width).max(0.0);
        }
    }

    fn move_horizontally(&mut self, window: WindowId, destination: usize) -> Result<(), LayoutError> {
        let (source, _) = self.window_location(window).ok_or(LayoutError::UnknownWindow(window))?;
        if self.columns[source].windows.len() == 1 {
            self.columns.swap(source, destination);
            self.active_column = Some(destination);
            self.reveal_pending = self.active_window();
            return Ok(());
        }

        let insertion = if destination < source { source } else { source + 1 };
        self.remove(window)?;
        let insertion = insertion.min(self.columns.len());
        self.columns.insert(insertion, Column::new(window, self.default_width));
        self.active_column = Some(insertion);
        self.reveal_pending = self.active_window();
        Ok(())
    }

    fn window_location(&self, window: WindowId) -> Option<(usize, usize)> {
        self.columns.iter().enumerate().find_map(|(column, data)| {
            data.windows
                .iter()
                .position(|candidate| *candidate == window)
                .map(|index| (column, index))
        })
    }

    fn validate_scalars(&self) -> Result<(), LayoutError> {
        if !self.viewport_x.is_finite() {
            return Err(LayoutError::InvalidTree("scrolling viewport offset is invalid"));
        }
        if normalized_width(self.default_width) != self.default_width {
            return Err(LayoutError::InvalidTree("scrolling default column width is invalid"));
        }
        if self.columns.is_empty() {
            return if self.active_column.is_none() {
                Ok(())
            } else {
                Err(LayoutError::InvalidTree("empty scrolling layout has an active column"))
            };
        }
        if self.active_column.is_none_or(|active| active >= self.columns.len()) {
            return Err(LayoutError::InvalidTree("scrolling active column is invalid"));
        }
        Ok(())
    }

    pub fn validate(&self) -> Result<(), LayoutError> {
        self.validate_scalars()?;

        let mut windows = HashSet::new();
        for column in &self.columns {
            if normalized_width(column.width) != column.width {
                return Err(LayoutError::InvalidTree("scrolling column width is invalid"));
            }
            if column.windows.is_empty() {
                return Err(LayoutError::InvalidTree("scrolling column is empty"));
            }
            if column.active >= column.windows.len() || column.heights.len() != column.windows.len() {
                return Err(LayoutError::InvalidTree("scrolling column metadata is invalid"));
            }
            if !column.heights.iter().all(|height| height.is_finite() && *height > 0.0) {
                return Err(LayoutError::InvalidTree("scrolling height is invalid"));
            }
            for window in &column.windows {
                if !windows.insert(*window) {
                    return Err(LayoutError::DuplicateWindow(*window));
                }
            }
        }
        Ok(())
    }
}

fn resize_rows(column: &mut Column, row: usize, neighbor: usize, amount: f64) -> bool {
    let transferable = (column.heights[neighbor] - MIN_ROW_HEIGHT).max(0.0);
    let adjustment = amount.min(transferable);
    if adjustment == 0.0 {
        return false;
    }

    column.heights[row] += adjustment;
    column.heights[neighbor] -= adjustment;
    true
}

fn normalized_width(width: ColumnWidth) -> ColumnWidth {
    match width {
        ColumnWidth::Proportion(value) if value.is_finite() && value > 0.0 => ColumnWidth::Proportion(value),
        ColumnWidth::Fixed(value) if value.is_finite() && value > 0.0 => ColumnWidth::Fixed(value),
        ColumnWidth::Full => ColumnWidth::Full,
        _ => ColumnWidth::default(),
    }
}

fn finite_nonnegative(value: f64) -> f64 {
    if value.is_finite() { value.max(0.0) } else { 0.0 }
}

fn apply_maximums(
    window: WindowId,
    rect: &mut Rect,
    constraints: SizeConstraints,
    warnings: &mut Vec<ConstraintWarning>,
) {
    if let Some(maximum) = constraints.max_width
        && rect.width > maximum
    {
        warnings.push(ConstraintWarning {
            window,
            kind: ConstraintKind::MaximumWidth,
            requested: maximum,
            assigned: rect.width,
        });
        rect.width = maximum;
    }
    if let Some(maximum) = constraints.max_height
        && rect.height > maximum
    {
        warnings.push(ConstraintWarning {
            window,
            kind: ConstraintKind::MaximumHeight,
            requested: maximum,
            assigned: rect.height,
        });
        rect.height = maximum;
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn window(id: u64) -> WindowId {
        WindowId(id)
    }

    #[test]
    fn inserts_new_columns_after_focus() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        layout.insert(window(3), Some(window(1))).unwrap();

        assert_eq!(
            layout.window_ids().collect::<Vec<_>>(),
            vec![window(1), window(3), window(2)]
        );
        assert_eq!(layout.active_column(), Some(1));
    }

    #[test]
    fn configured_default_width_is_applied_to_new_columns() {
        let mut layout = ScrollingLayout::with_default_width(ColumnWidth::Full);
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();

        assert_eq!(layout.default_width(), ColumnWidth::Full);
        assert!(layout.columns().iter().all(|column| column.width == ColumnWidth::Full));
    }

    #[test]
    fn hover_does_not_replace_a_pending_explicit_reveal() {
        for strategy in [
            ViewportFocusStrategy::Minimal,
            ViewportFocusStrategy::Center,
            ViewportFocusStrategy::Paged,
        ] {
            let mut layout = ScrollingLayout::default();
            layout.set_focus_strategy(strategy);
            for id in 1..=3 {
                layout.insert(window(id), None).unwrap();
            }
            let bounds = Rect::new(0.0, 0.0, 1000.0, 800.0);
            let gaps = GapConfig {
                inner: 0.0,
                outer: 0.0,
                smart: false,
            };
            for target in [3, 1] {
                layout.focus_and_reveal(window(target)).unwrap();
                let mut expected = layout.clone();
                expected
                    .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(target)))
                    .unwrap();
                layout.focus_without_reveal(window(2)).unwrap();
                layout
                    .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
                    .unwrap();
                assert_eq!(layout.active_window(), Some(window(2)));
                assert_eq!(layout.viewport_x(), expected.viewport_x(), "{strategy:?}");
            }
            layout.focus_and_reveal(window(3)).unwrap();
            layout.focus_without_reveal(window(2)).unwrap();
            layout.remove(window(3)).unwrap();
            assert!(
                layout
                    .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
                    .is_ok()
            );
        }
    }

    #[test]
    fn focus_reveal_scrolls_only_as_far_as_needed() {
        let mut layout = ScrollingLayout::default();
        for id in 1..=4 {
            layout.insert(window(id), Some(window(id.saturating_sub(1)))).unwrap();
        }
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };

        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(4)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 1_000.0);
        assert_eq!(result.geometry[&window(4)].x, 500.0);
    }

    #[test]
    fn minimal_reveal_uses_the_nearest_edge_and_keeps_visible_columns_still() {
        for (viewport, start, width, expected) in [
            (500.0, 500.0, 500.0, 500.0),
            (500.0, 1000.0, 500.0, 500.0),
            (500.0, 400.0, 500.0, 400.0),
            (500.0, 1100.0, 500.0, 600.0),
            (500.0, 400.0, 1000.0, 400.0),
            (500.0, 1100.0, 1000.0, 1100.0),
            (500.0, 400.0, 1500.0, 500.0),
            (500.0, -1000.0, 1500.0, -500.0),
            (500.0, 1100.0, 1500.0, 1100.0),
        ] {
            let mut layout = ScrollingLayout {
                viewport_x: viewport,
                ..ScrollingLayout::default()
            };
            layout.reveal_column(&[(start, width)], 1000.0, 0);
            assert_eq!(
                layout.viewport_x(),
                expected,
                "viewport={viewport}, start={start}, width={width}"
            );
            layout.reveal_column(&[(start, width)], 1000.0, 0);
            assert_eq!(layout.viewport_x(), expected, "repeated reveal must stay still");
        }
    }

    #[test]
    fn minimal_reveal_ignores_subpixel_edge_drift() {
        for (start, width, expected) in [
            (499.5, 500.0, 500.0),
            (1000.5, 500.0, 500.0),
            (499.4, 500.0, 499.4),
            (1000.6, 500.0, 500.6),
            (499.5, 1000.0, 500.0),
            (500.5, 1000.0, 500.0),
            (500.5, 1500.0, 500.0),
            (-0.5, 1500.0, 500.0),
        ] {
            let mut layout = ScrollingLayout {
                viewport_x: 500.0,
                ..ScrollingLayout::default()
            };
            layout.reveal_column(&[(start, width)], 1000.0, 0);
            assert!(
                (layout.viewport_x() - expected).abs() < 1e-9,
                "start={start}, width={width}"
            );
        }
    }

    #[test]
    fn minimal_reveal_enters_oversized_columns_from_either_side() {
        let mut layout = ScrollingLayout::default();
        for id in 1..=3 {
            layout.insert(window(id), Some(window(id.saturating_sub(1)))).unwrap();
        }
        layout.columns[1].width = ColumnWidth::Fixed(1500.0);
        let bounds = Rect::new(0.0, 0.0, 1000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };
        for (focused, expected) in [(1, 0.0), (2, 500.0), (3, 1500.0), (2, 1000.0), (2, 1000.0)] {
            layout.focus_and_reveal(window(focused)).unwrap();
            layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                .unwrap();
            assert_eq!(layout.viewport_x(), expected);
        }
    }

    #[test]
    fn minimal_reveal_aligns_full_width_columns_without_neighbor_context() {
        let mut layout = ScrollingLayout::with_default_width(ColumnWidth::Full);
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        let bounds = Rect::new(0.0, 0.0, 1000.0, 800.0);
        let gaps = GapConfig {
            inner: 10.0,
            outer: 0.0,
            smart: false,
        };
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        assert_eq!(layout.viewport_x(), 1010.0);
        assert_eq!(result.geometry[&window(2)].x, 0.0);
        let previous = result.geometry[&window(1)];
        assert!(previous.x + previous.width <= 0.0);
        layout.focus_and_reveal(window(1)).unwrap();
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();
        assert_eq!(layout.viewport_x(), 0.0);
        assert_eq!(result.geometry[&window(1)].x, 0.0);
        assert!(result.geometry[&window(2)].x >= bounds.width);
    }

    #[test]
    fn minimal_reveal_accounts_for_fractional_gaps_and_outer_margins() {
        let bounds = Rect::new(100.25, 30.5, 1000.5, 800.0);
        let gaps = GapConfig {
            inner: 9.5,
            outer: 13.25,
            smart: false,
        };
        for (width, offsets) in [
            (ColumnWidth::Fixed(400.0), [0.0, 245.0, 245.0, 0.0]),
            (ColumnWidth::Full, [0.0, 1967.0, 983.5, 0.0]),
        ] {
            let mut layout = ScrollingLayout::with_default_width(width);
            for id in 1..=3 {
                layout.insert(window(id), Some(window(id.saturating_sub(1)))).unwrap();
            }
            for (focused, offset) in [1, 3, 2, 1].into_iter().zip(offsets) {
                layout.focus_and_reveal(window(focused)).unwrap();
                let result = layout
                    .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                    .unwrap();
                let rect = result.geometry[&window(focused)];
                assert_eq!(layout.viewport_x(), offset, "width={width:?}, focused={focused}");
                if focused == 1 || width == ColumnWidth::Full {
                    assert_eq!(rect.x, 113.5, "left edge includes the outer margin");
                }
                if focused == 3 || width == ColumnWidth::Full {
                    assert_eq!(rect.x + rect.width, 1087.5, "right edge includes the outer margin");
                }
                let next = result.geometry[&window(2)];
                let first = result.geometry[&window(1)];
                assert_eq!(next.x - (first.x + first.width), 9.5, "inner gap stays intact");
            }
        }
    }

    #[test]
    fn two_half_width_columns_fit_without_focus_scrolling() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            inner: 10.0,
            outer: 10.0,
            smart: false,
        };

        let first = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();
        assert_eq!(layout.viewport_x(), 0.0);
        let second = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 0.0);
        assert_eq!(first.geometry, second.geometry);
        assert_eq!(second.geometry[&window(1)], Rect::new(10.0, 10.0, 485.0, 780.0));
        assert_eq!(second.geometry[&window(2)], Rect::new(505.0, 10.0, 485.0, 780.0));
    }

    #[test]
    fn full_width_column_stays_in_strip_when_new_half_window_opens() {
        let (mut layout, bounds, gaps) = two_half_width_layout();
        layout.set_focus_strategy(ViewportFocusStrategy::Paged);
        layout
            .set_column_width(window(2), ColumnWidth::Proportion(1.0))
            .unwrap();
        let zoomed = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        assert_eq!(zoomed.geometry[&window(2)].width, 980.0);
        layout.insert(window(3), Some(window(2))).unwrap();
        let opened = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(3)))
            .unwrap();
        let previous = opened.geometry[&window(2)];
        let new = opened.geometry[&window(3)];
        assert_eq!(previous.width, 980.0);
        assert_eq!(new, Rect::new(10.0, 10.0, 485.0, 780.0));
        assert_eq!(previous.x + previous.width + gaps.inner, new.x);
        assert_eq!(layout.active_window(), Some(window(3)));
        layout
            .set_column_width(window(2), ColumnWidth::Proportion(0.5))
            .unwrap();
        let restored = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        assert_eq!(restored.geometry[&window(2)].width, 485.0);
    }

    fn paged_layout(count: u64) -> (ScrollingLayout, Rect, GapConfig) {
        let (mut layout, bounds, gaps) = two_half_width_layout();
        layout.set_focus_strategy(ViewportFocusStrategy::Paged);
        for id in 3..=count {
            layout.insert(window(id), Some(window(id - 1))).unwrap();
        }
        (layout, bounds, gaps)
    }

    #[test]
    fn paged_focus_snaps_six_half_columns_in_both_directions() {
        let (mut layout, bounds, gaps) = paged_layout(6);
        for focused in [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1] {
            let geometry = layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                .unwrap()
                .geometry;
            let first = (focused - 1) / 2 * 2 + 1;
            assert_eq!(layout.viewport_x(), ((first - 1) / 2) as f64 * 990.0);
            assert_eq!(geometry[&window(first)].x, 10.0);
            assert_eq!(geometry[&window(first + 1)].x, 505.0);
            assert_eq!(
                geometry[&window(first + 1)].x + geometry[&window(first + 1)].width,
                990.0
            );
        }
    }

    #[test]
    fn minimal_swipe_focus_reveals_only_hidden_edges() {
        let mut layout = ScrollingLayout::default();
        for id in 1..=3 {
            layout.insert(window(id), Some(window(id.saturating_sub(1)))).unwrap();
        }
        let bounds = Rect::new(0.0, 0.0, 1000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };
        layout.focus_and_reveal(window(1)).unwrap();
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();
        for (previous, focused, expected) in [(1, 2, 0.0), (2, 3, 500.0), (3, 2, 500.0), (2, 1, 0.0)] {
            layout.slide_focus_from(window(previous), window(focused)).unwrap();
            layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                .unwrap();
            assert_eq!(layout.viewport_x(), expected);
        }
    }

    #[test]
    fn swipe_focus_slides_one_column_at_a_time_in_paged_layout() {
        let (mut layout, bounds, gaps) = paged_layout(5);
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();
        assert_eq!(layout.viewport_x(), 0.0);

        for (previous, focused, expected) in [(1, 2, 495.0), (2, 3, 990.0), (3, 2, 495.0), (2, 1, 0.0)] {
            layout.focus_and_reveal(window(focused)).unwrap();
            layout.slide_focus_from(window(previous), window(focused)).unwrap();
            let result = layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                .unwrap();

            assert_eq!(layout.viewport_x(), expected);
            assert_eq!(result.geometry[&window(focused)].x, 10.0);
        }
    }

    #[test]
    fn paged_focus_realigns_after_output_resize() {
        let (mut layout, bounds, gaps) = paged_layout(6);
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(5)))
            .unwrap();
        let bounds = Rect::new(20.0, 48.0, 1400.0, 800.0);
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(5)))
            .unwrap();
        assert_eq!(layout.viewport_x(), 2780.0);
        assert_eq!(result.geometry[&window(5)].x, 30.0);
        assert_eq!(result.geometry[&window(6)].x, 725.0);
    }

    #[test]
    fn paged_focus_preserves_explicit_center_until_focus_changes() {
        let (mut layout, bounds, gaps) = paged_layout(4);
        layout.center_window(window(2), bounds, gaps, &HashMap::new()).unwrap();
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        let rect = result.geometry[&window(2)];
        assert_eq!(rect.x + rect.width / 2.0, 500.0);
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();
        assert_eq!(result.geometry[&window(1)].x, 10.0);
    }

    #[test]
    fn full_width_column_occupies_its_own_page() {
        let (mut layout, bounds, gaps) = paged_layout(4);
        layout.columns[0].width = ColumnWidth::Full;
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(3)))
            .unwrap();
        assert_eq!(result.geometry[&window(2)].x, 10.0);
        assert_eq!(result.geometry[&window(3)].x, 505.0);
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(4)))
            .unwrap();
        assert_eq!(result.geometry[&window(4)].x, 10.0);
    }

    #[test]
    fn client_minimums_split_columns_across_pages() {
        let (mut layout, bounds, gaps) = paged_layout(2);
        let constraints = HashMap::from([(
            window(1),
            SizeConstraints {
                min_width: 700.0,
                ..Default::default()
            },
        )]);
        let result = layout
            .geometry_with_constraints(bounds, gaps, &constraints, Some(window(2)))
            .unwrap();
        assert!(layout.viewport_x() > 0.0);
        let rect = result.geometry[&window(2)];
        assert!(rect.x >= 10.0 && rect.x + rect.width <= 990.0);
    }

    #[test]
    fn paged_focus_groups_thirds_in_both_directions_at_fractional_sizes() {
        let (mut layout, _, gaps) = paged_layout(6);
        for column in &mut layout.columns {
            column.width = ColumnWidth::Proportion(1.0 / 3.0);
        }
        let bounds = Rect::new(13.25, 48.5, 1000.5, 800.25);
        for focused in [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1] {
            let result = layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                .unwrap();
            let first = (focused - 1) / 3 * 3 + 1;
            assert!((result.geometry[&window(first)].x - 23.25).abs() < 1e-6);
            let last = result.geometry[&window(first + 2)];
            assert!((last.x + last.width - 1003.75).abs() < 1e-6);
        }
    }

    #[test]
    fn paged_focus_packs_mixed_widths_by_actual_fit() {
        let (mut layout, bounds, gaps) = paged_layout(5);
        let widths = [0.6, 0.4, 0.25, 0.5, 0.25];
        for (column, width) in layout.columns.iter_mut().zip(widths) {
            column.width = ColumnWidth::Proportion(width);
        }
        for (focused, first) in [(1, 1), (2, 1), (3, 3), (4, 3), (5, 3), (2, 1)] {
            let result = layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(focused)))
                .unwrap();
            assert_eq!(result.geometry[&window(first)].x, 10.0);
            let rect = result.geometry[&window(focused)];
            assert!(rect.x >= 10.0 && rect.x + rect.width <= 990.0 + 1e-6);
        }
    }

    #[test]
    fn oversized_page_does_not_absorb_neighbor_and_removal_repacks() {
        let (mut layout, bounds, gaps) = paged_layout(4);
        let constraints = HashMap::from([(
            window(1),
            SizeConstraints {
                min_width: 1200.0,
                ..Default::default()
            },
        )]);
        let result = layout
            .geometry_with_constraints(bounds, gaps, &constraints, Some(window(2)))
            .unwrap();
        assert_eq!(result.geometry[&window(2)].x, 10.0);
        assert_eq!(result.geometry[&window(3)].x, 505.0);
        layout.remove(window(1)).unwrap();
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        assert_eq!(layout.viewport_x(), 0.0);
        assert_eq!(result.geometry[&window(2)].x, 10.0);
        assert_eq!(result.geometry[&window(3)].x, 505.0);
    }

    #[test]
    fn manual_resize_does_not_retarget_the_viewport() {
        let mut layout = ScrollingLayout::default();
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };

        for id in 1..=3 {
            layout.insert(window(id), (id > 1).then(|| window(id - 1))).unwrap();
            layout
                .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(id)))
                .unwrap();
        }
        let before = layout.viewport_x();

        layout.resize_window(window(3), Direction::Right, 0.5).unwrap();
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(3)))
            .unwrap();

        assert_eq!(layout.viewport_x(), before);
    }

    #[test]
    fn minimal_reveal_of_the_first_column_aligns_to_the_strip_start() {
        let mut layout = ScrollingLayout::default();
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };

        for id in 1..=3 {
            layout.insert(window(id), None).unwrap();
        }
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(3)))
            .unwrap();
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 0.0);
    }

    #[test]
    fn closing_non_focused_column_does_not_move_viewport() {
        let mut layout = ScrollingLayout::default();
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };

        for id in 1..=4 {
            layout.insert(window(id), None).unwrap();
        }
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(4)))
            .unwrap();
        let before = layout.viewport_x();

        layout.remove(window(1)).unwrap();
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(4)))
            .unwrap();

        assert_eq!(layout.viewport_x(), before);
    }

    #[test]
    fn grouping_and_extracting_preserve_membership() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        layout.move_into_column(window(2), window(1)).unwrap();

        assert_eq!(layout.columns().len(), 1);
        assert_eq!(layout.columns()[0].windows, vec![window(1), window(2)]);

        layout.extract_to_column(window(2)).unwrap();
        assert_eq!(layout.columns().len(), 2);
        assert_eq!(
            layout.window_ids().collect::<HashSet<_>>(),
            HashSet::from([window(1), window(2)])
        );
    }

    #[test]
    fn later_column_changes_do_not_move_the_first_column() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            smart: false,
            ..GapConfig::default()
        };
        let first = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap()
            .geometry[&window(1)];

        layout.insert(window(2), Some(window(1))).unwrap();
        let second = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap()
            .geometry[&window(1)];

        assert_eq!(first.x, second.x);
        assert_eq!(first.width, second.width);
    }

    #[test]
    fn directional_navigation_follows_columns_and_rows() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        layout.insert(window(3), Some(window(2))).unwrap();
        layout.move_into_column(window(3), window(2)).unwrap();

        assert_eq!(
            layout.directional_neighbor(window(1), Direction::Right),
            Ok(Some(window(3)))
        );
        assert_eq!(
            layout.directional_neighbor(window(3), Direction::Up),
            Ok(Some(window(2)))
        );
        assert_eq!(
            layout.directional_neighbor(window(2), Direction::Down),
            Ok(Some(window(3)))
        );
    }

    #[test]
    fn vertical_moves_reorder_rows_and_horizontal_moves_extract_them() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        layout.insert(window(3), Some(window(2))).unwrap();
        layout.move_into_column(window(3), window(2)).unwrap();

        assert!(layout.move_window(window(3), Direction::Up).unwrap());
        assert_eq!(layout.columns()[1].windows, vec![window(3), window(2)]);
        assert!(layout.move_window(window(3), Direction::Left).unwrap());
        assert_eq!(layout.columns().len(), 3);
        assert_eq!(
            layout.window_ids().collect::<Vec<_>>(),
            vec![window(1), window(3), window(2)]
        );
    }

    #[test]
    fn resize_changes_column_width_and_neighboring_row_weights() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();
        layout.move_into_column(window(2), window(1)).unwrap();

        assert!(layout.resize_window(window(1), Direction::Right, 0.1).unwrap());
        assert_eq!(layout.columns()[0].width, ColumnWidth::Proportion(0.6));

        assert!(layout.resize_window(window(1), Direction::Down, 0.1).unwrap());
        assert_eq!(layout.columns()[0].heights, vec![0.6, 0.4]);
    }

    #[test]
    fn width_cycle_wraps_through_configured_presets() {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        let presets = [
            ColumnWidth::Proportion(0.5),
            ColumnWidth::Proportion(2.0 / 3.0),
            ColumnWidth::Full,
        ];

        assert!(layout.cycle_column_width(window(1), &presets).unwrap());
        assert_eq!(layout.columns()[0].width, ColumnWidth::Proportion(2.0 / 3.0));
        assert!(layout.cycle_column_width(window(1), &presets).unwrap());
        assert_eq!(layout.columns()[0].width, ColumnWidth::Full);
        assert!(layout.cycle_column_width(window(1), &presets).unwrap());
        assert_eq!(layout.columns()[0].width, ColumnWidth::Proportion(0.5));
    }

    #[test]
    fn left_column_zoom_pushes_and_restores_the_right_column() {
        let (mut layout, bounds, gaps) = two_half_width_layout();
        let presets = [ColumnWidth::Proportion(0.5), ColumnWidth::Full];

        layout.focus(window(1)).unwrap();
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();
        layout.cycle_column_width(window(1), &presets).unwrap();
        let zoomed = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 0.0);
        assert_eq!(zoomed.geometry[&window(1)].x, 10.0);
        assert_eq!(zoomed.geometry[&window(1)].width, 980.0);
        assert_eq!(zoomed.geometry[&window(2)].x, 1_000.0);

        layout.cycle_column_width(window(1), &presets).unwrap();
        let restored = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(1)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 0.0);
        assert_eq!(restored.geometry[&window(1)].x, 10.0);
        assert_eq!(restored.geometry[&window(2)].x, 505.0);
    }

    #[test]
    fn right_column_zoom_moves_left_neighbor_out_and_back() {
        let (mut layout, bounds, gaps) = two_half_width_layout();
        let presets = [ColumnWidth::Proportion(0.5), ColumnWidth::Full];

        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        layout.cycle_column_width(window(2), &presets).unwrap();
        let zoomed = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 495.0);
        assert_eq!(zoomed.geometry[&window(1)].x, -485.0);
        assert_eq!(zoomed.geometry[&window(2)].x, 10.0);
        assert_eq!(zoomed.geometry[&window(2)].width, 980.0);

        layout.cycle_column_width(window(2), &presets).unwrap();
        let restored = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();

        assert_eq!(layout.viewport_x(), 0.0);
        assert_eq!(restored.geometry[&window(1)].x, 10.0);
        assert_eq!(restored.geometry[&window(2)].x, 505.0);
    }

    fn two_half_width_layout() -> (ScrollingLayout, Rect, GapConfig) {
        let mut layout = ScrollingLayout::default();
        layout.insert(window(1), None).unwrap();
        layout.insert(window(2), Some(window(1))).unwrap();

        (
            layout,
            Rect::new(0.0, 0.0, 1_000.0, 800.0),
            GapConfig {
                inner: 10.0,
                outer: 10.0,
                smart: false,
            },
        )
    }

    #[test]
    fn explicit_center_places_a_middle_column_in_the_viewport_center() {
        let mut layout = ScrollingLayout::default();
        for id in 1_u64..=4 {
            layout
                .insert(window(id), id.checked_sub(1).filter(|id| *id > 0).map(window))
                .unwrap();
        }
        let bounds = Rect::new(0.0, 0.0, 1_000.0, 800.0);
        let gaps = GapConfig {
            inner: 0.0,
            outer: 0.0,
            smart: false,
        };
        layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(4)))
            .unwrap();

        assert!(layout.center_window(window(2), bounds, gaps, &HashMap::new()).unwrap());
        let result = layout
            .geometry_with_constraints(bounds, gaps, &HashMap::new(), Some(window(2)))
            .unwrap();
        let rect = result.geometry[&window(2)];

        assert_eq!(rect.x + rect.width / 2.0, 500.0);
    }

    #[test]
    fn randomized_scrolling_operations_preserve_invariants() {
        let mut layout = ScrollingLayout::default();
        let mut windows = Vec::new();
        let mut next_window = 1_u64;
        let mut random = 0x5c40_11ab_u64;

        for _ in 0..2_000 {
            random = random
                .wrapping_mul(2_862_933_555_777_941_757)
                .wrapping_add(3_037_000_493);

            match random % 7 {
                0 if windows.len() < 48 => {
                    let new_window = window(next_window);
                    next_window += 1;
                    let focused = windows.get(random as usize % windows.len().max(1)).copied();
                    layout.insert(new_window, focused).unwrap();
                    windows.push(new_window);
                }
                1 if !windows.is_empty() => {
                    let index = random as usize % windows.len();
                    layout.remove(windows.swap_remove(index)).unwrap();
                }
                2 if windows.len() > 1 => {
                    let first = random as usize % windows.len();
                    let mut second = random.rotate_left(17) as usize % windows.len();
                    if first == second {
                        second = (second + 1) % windows.len();
                    }
                    layout.move_into_column(windows[first], windows[second]).unwrap();
                }
                3 if !windows.is_empty() => {
                    let index = random as usize % windows.len();
                    layout.extract_to_column(windows[index]).unwrap();
                }
                4 if !windows.is_empty() => {
                    let index = random as usize % windows.len();
                    let direction = random_direction(random.rotate_left(9));
                    layout.move_window(windows[index], direction).unwrap();
                }
                5 if !windows.is_empty() => {
                    let index = random as usize % windows.len();
                    let direction = random_direction(random.rotate_left(23));
                    layout.resize_window(windows[index], direction, 0.05).unwrap();
                }
                6 if !windows.is_empty() => {
                    let index = random as usize % windows.len();
                    layout.focus(windows[index]).unwrap();
                }
                _ => {}
            }

            layout.validate().unwrap();
            assert_eq!(layout.window_ids().collect::<HashSet<_>>().len(), windows.len());
        }
    }

    fn random_direction(random: u64) -> Direction {
        match random % 4 {
            0 => Direction::Left,
            1 => Direction::Right,
            2 => Direction::Up,
            _ => Direction::Down,
        }
    }
}