aimux_server/

layout.rs

use crate::session::Layout;

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PanePosition {
    pub x: u16,
    pub y: u16,
    pub width: u16,
    pub height: u16,
}

pub fn compute_layout(
    layout: &Layout,
    pane_count: usize,
    area_width: u16,
    area_height: u16,
) -> Vec<PanePosition> {
    if pane_count == 0 {
        return Vec::new();
    }
    if pane_count == 1 {
        return vec![PanePosition {
            x: 0,
            y: 0,
            width: area_width,
            height: area_height,
        }];
    }

    match layout {
        Layout::Single => vec![PanePosition {
            x: 0,
            y: 0,
            width: area_width,
            height: area_height,
        }],
        Layout::EvenHorizontal => compute_even_horizontal(pane_count, area_width, area_height),
        Layout::EvenVertical => compute_even_vertical(pane_count, area_width, area_height),
        Layout::MainVertical => compute_main_vertical(pane_count, area_width, area_height),
        Layout::Tiled => compute_tiled(pane_count, area_width, area_height),
        Layout::Custom(ref tree) => crate::layout_dsl::compute_tree_layout(tree, area_width, area_height),
    }
}

fn compute_even_horizontal(
    pane_count: usize,
    area_width: u16,
    area_height: u16,
) -> Vec<PanePosition> {
    let n = pane_count as u16;
    let borders = n - 1;
    let usable = area_width.saturating_sub(borders);
    let base_width = usable / n;
    let remainder = usable % n;

    let mut positions = Vec::with_capacity(pane_count);
    let mut x = 0u16;
    for i in 0..n {
        // Last pane absorbs remainder.
        let w = if i == n - 1 {
            base_width + remainder
        } else {
            base_width
        };
        positions.push(PanePosition {
            x,
            y: 0,
            width: w,
            height: area_height,
        });
        x += w + 1; // +1 for border gap
    }
    positions
}

fn compute_even_vertical(
    pane_count: usize,
    area_width: u16,
    area_height: u16,
) -> Vec<PanePosition> {
    let n = pane_count as u16;
    let borders = n - 1;
    let usable = area_height.saturating_sub(borders);
    let base_height = usable / n;
    let remainder = usable % n;

    let mut positions = Vec::with_capacity(pane_count);
    let mut y = 0u16;
    for i in 0..n {
        let h = if i == n - 1 {
            base_height + remainder
        } else {
            base_height
        };
        positions.push(PanePosition {
            x: 0,
            y,
            width: area_width,
            height: h,
        });
        y += h + 1;
    }
    positions
}

fn compute_main_vertical(
    pane_count: usize,
    area_width: u16,
    area_height: u16,
) -> Vec<PanePosition> {
    let left_width = area_width / 2;
    let right_width = area_width.saturating_sub(left_width).saturating_sub(1);

    let mut positions = Vec::with_capacity(pane_count);

    // Main pane on the left.
    positions.push(PanePosition {
        x: 0,
        y: 0,
        width: left_width,
        height: area_height,
    });

    // Remaining panes stacked on the right.
    let right_count = (pane_count - 1) as u16;
    if right_count == 0 {
        return positions;
    }

    let right_x = left_width + 1; // +1 for vertical border
    let borders = right_count - 1;
    let usable_height = area_height.saturating_sub(borders);
    let base_height = usable_height / right_count;
    let remainder = usable_height % right_count;

    let mut y = 0u16;
    for i in 0..right_count {
        let h = if i == right_count - 1 {
            base_height + remainder
        } else {
            base_height
        };
        positions.push(PanePosition {
            x: right_x,
            y,
            width: right_width,
            height: h,
        });
        y += h + 1;
    }
    positions
}

fn compute_tiled(pane_count: usize, area_width: u16, area_height: u16) -> Vec<PanePosition> {
    let n = pane_count;
    let cols = (n as f64).sqrt().ceil() as usize;
    let rows = n.div_ceil(cols);

    let row_borders = (rows as u16).saturating_sub(1);
    let usable_height = area_height.saturating_sub(row_borders);
    let base_row_height = usable_height / rows as u16;

    let mut positions = Vec::with_capacity(n);
    let mut pane_idx = 0;
    let mut y = 0u16;

    for row in 0..rows {
        let panes_in_row = if row == rows - 1 {
            n - pane_idx // last row gets remaining panes
        } else {
            cols
        };

        let row_height = if row == rows - 1 {
            // Last row absorbs height remainder.
            area_height.saturating_sub(y)
        } else {
            base_row_height
        };

        // Compute widths for this row (last row may have fewer panes, so wider).
        let row_col_borders = (panes_in_row as u16).saturating_sub(1);
        let row_usable_width = area_width.saturating_sub(row_col_borders);
        let col_width = row_usable_width / panes_in_row as u16;
        let width_remainder = row_usable_width % panes_in_row as u16;

        let mut x = 0u16;
        for col in 0..panes_in_row {
            let w = if col == panes_in_row - 1 {
                col_width + width_remainder
            } else {
                col_width
            };
            positions.push(PanePosition {
                x,
                y,
                width: w,
                height: row_height,
            });
            x += w + 1;
            pane_idx += 1;
        }

        y += row_height + 1; // +1 for horizontal border
    }
    positions
}

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

    #[test]
    fn single_fills_area() {
        let result = compute_layout(&Layout::Single, 1, 80, 24);
        assert_eq!(result.len(), 1);
        assert_eq!(
            result[0],
            PanePosition {
                x: 0,
                y: 0,
                width: 80,
                height: 24,
            }
        );
    }

    #[test]
    fn even_horizontal_two_panes() {
        let result = compute_layout(&Layout::EvenHorizontal, 2, 81, 24);
        assert_eq!(result.len(), 2);
        assert_eq!(
            result[0],
            PanePosition {
                x: 0,
                y: 0,
                width: 40,
                height: 24,
            }
        );
        assert_eq!(
            result[1],
            PanePosition {
                x: 41,
                y: 0,
                width: 40,
                height: 24,
            }
        );
    }

    #[test]
    fn even_horizontal_three_panes() {
        let result = compute_layout(&Layout::EvenHorizontal, 3, 80, 24);
        assert_eq!(result.len(), 3);
        // 2 borders, usable = 78, base = 26, last gets 26
        let total_width: u16 = result.iter().map(|p| p.width).sum();
        assert_eq!(total_width, 80 - 2); // area_width minus 2 borders
        assert_eq!(result[0].x, 0);
        assert_eq!(result[1].x, result[0].width + 1);
        assert_eq!(result[2].x, result[1].x + result[1].width + 1);
    }

    #[test]
    fn even_vertical_two_panes() {
        let result = compute_layout(&Layout::EvenVertical, 2, 80, 25);
        assert_eq!(result.len(), 2);
        assert_eq!(
            result[0],
            PanePosition {
                x: 0,
                y: 0,
                width: 80,
                height: 12,
            }
        );
        assert_eq!(
            result[1],
            PanePosition {
                x: 0,
                y: 13,
                width: 80,
                height: 12,
            }
        );
    }

    #[test]
    fn main_vertical_three_panes() {
        let result = compute_layout(&Layout::MainVertical, 3, 80, 24);
        assert_eq!(result.len(), 3);
        // Left pane: 50% = 40 cols
        assert_eq!(result[0].x, 0);
        assert_eq!(result[0].width, 40);
        assert_eq!(result[0].height, 24);
        // Right panes: x = 41, width = 80 - 40 - 1 = 39
        assert_eq!(result[1].x, 41);
        assert_eq!(result[1].width, 39);
        assert_eq!(result[2].x, 41);
        assert_eq!(result[2].width, 39);
        // Stacked vertically with 1 border: usable = 23, each 11, last 12
        assert_eq!(result[1].y, 0);
        assert_eq!(result[1].height, 11);
        assert_eq!(result[2].y, 12);
        assert_eq!(result[2].height, 12);
    }

    #[test]
    fn tiled_four_panes() {
        // sqrt(4) = 2 cols, 2 rows
        let result = compute_layout(&Layout::Tiled, 4, 81, 25);
        assert_eq!(result.len(), 4);
        // 2 cols: usable_w = 81-1 = 80, each 40
        // 2 rows: usable_h = 25-1 = 24, each 12
        assert_eq!(
            result[0],
            PanePosition {
                x: 0,
                y: 0,
                width: 40,
                height: 12,
            }
        );
        assert_eq!(
            result[1],
            PanePosition {
                x: 41,
                y: 0,
                width: 40,
                height: 12,
            }
        );
        assert_eq!(
            result[2],
            PanePosition {
                x: 0,
                y: 13,
                width: 40,
                height: 12,
            }
        );
        assert_eq!(
            result[3],
            PanePosition {
                x: 41,
                y: 13,
                width: 40,
                height: 12,
            }
        );
    }

    #[test]
    fn tiled_five_panes() {
        // ceil(sqrt(5)) = 3 cols, ceil(5/3) = 2 rows
        let result = compute_layout(&Layout::Tiled, 5, 80, 25);
        assert_eq!(result.len(), 5);
        // Row 0: 3 panes, border gaps = 2, usable = 78, each 26
        assert_eq!(result[0].y, 0);
        assert_eq!(result[1].y, 0);
        assert_eq!(result[2].y, 0);
        assert_eq!(result[0].width, 26);
        assert_eq!(result[1].width, 26);
        assert_eq!(result[2].width, 26);
        // Row 1: 2 panes (fills full width), border gaps = 1, usable = 79, each 39, last 40
        let row1_y = result[3].y;
        assert_eq!(result[3].y, row1_y);
        assert_eq!(result[4].y, row1_y);
        assert_eq!(result[3].width, 39);
        assert_eq!(result[4].width, 40);
    }

    #[test]
    fn zero_panes_returns_empty() {
        let result = compute_layout(&Layout::EvenHorizontal, 0, 80, 24);
        assert!(result.is_empty());
    }

    #[test]
    fn one_pane_any_layout_fills_area() {
        for layout in [
            Layout::Single,
            Layout::EvenHorizontal,
            Layout::EvenVertical,
            Layout::MainVertical,
            Layout::Tiled,
        ] {
            let result = compute_layout(&layout, 1, 120, 40);
            assert_eq!(result.len(), 1, "layout: {:?}", layout);
            assert_eq!(
                result[0],
                PanePosition {
                    x: 0,
                    y: 0,
                    width: 120,
                    height: 40,
                },
                "layout: {:?}",
                layout,
            );
        }
    }

    #[test]
    fn small_terminal_no_overflow() {
        // 3x3 with 3 panes horizontal: usable = 1, each pane 0 wide — degenerate but no panic
        let result = compute_layout(&Layout::EvenHorizontal, 3, 3, 3);
        assert_eq!(result.len(), 3);
        // No position should overflow u16
        for pos in &result {
            assert!(pos.x <= 3);
            assert!(pos.y <= 3);
        }
    }

    #[test]
    fn small_terminal_tiled() {
        let result = compute_layout(&Layout::Tiled, 4, 5, 5);
        assert_eq!(result.len(), 4);
        for pos in &result {
            assert!(pos.x < 10);
            assert!(pos.y < 10);
        }
    }

    #[test]
    fn even_horizontal_widths_contiguous() {
        // Verify panes + borders exactly fill the width.
        for pane_count in 2..=6 {
            let width = 100u16;
            let result = compute_layout(&Layout::EvenHorizontal, pane_count, width, 24);
            let total: u16 = result.iter().map(|p| p.width).sum::<u16>()
                + (pane_count as u16 - 1); // borders
            assert_eq!(total, width, "pane_count={}", pane_count);
        }
    }

    #[test]
    fn even_vertical_heights_contiguous() {
        for pane_count in 2..=6 {
            let height = 50u16;
            let result = compute_layout(&Layout::EvenVertical, pane_count, 80, height);
            let total: u16 = result.iter().map(|p| p.height).sum::<u16>()
                + (pane_count as u16 - 1);
            assert_eq!(total, height, "pane_count={}", pane_count);
        }
    }
}