oxwm

use super::{GapConfig, Layout, WindowGeometry};

use x11rb::protocol::xproto::Window;

pub struct TilingLayout;

impl Layout for TilingLayout {

    fn arrange(

        &self,

        windows: &[Window],

        screen_width: u32,

        screen_height: u32,

        gaps: &GapConfig,

    ) -> Vec<WindowGeometry> {

        let window_count = windows.len();

        if window_count == 0 {

            return Vec::new();

        }

        if window_count == 1 {

            let x = gaps.outer_horizontal as i32;

            let y = gaps.outer_vertical as i32;

            let width = screen_width.saturating_sub(2 * gaps.outer_horizontal);

            let height = screen_height.saturating_sub(2 * gaps.outer_vertical);

            vec![WindowGeometry {

                x_coordinate: x,

                y_coordinate: y,

                width,

                height,

            }]

        } else {

            let mut geometries = Vec::new();

            let master_width = (screen_width / 2)

                .saturating_sub(gaps.outer_horizontal)

                .saturating_sub(gaps.inner_horizontal / 2);

            let master_x = gaps.outer_horizontal as i32;

            let master_y = gaps.outer_vertical as i32;

            let master_height = screen_height.saturating_sub(2 * gaps.outer_vertical);

            geometries.push(WindowGeometry {

                x_coordinate: master_x,

                y_coordinate: master_y,

                width: master_width,

                height: master_height,

            });

            let stack_count = window_count - 1;

            let stack_x = (screen_width / 2 + gaps.inner_horizontal / 2) as i32;

            let stack_width = (screen_width / 2)

                .saturating_sub(gaps.outer_horizontal)

                .saturating_sub(gaps.inner_horizontal / 2);

            let total_stack_height = screen_height.saturating_sub(2 * gaps.outer_vertical);

            let total_inner_gaps = gaps.inner_vertical * (stack_count as u32 - 1);

            let stack_height =

                total_stack_height.saturating_sub(total_inner_gaps) / stack_count as u32;

            for i in 1..window_count {

                let stack_index = i - 1;

                let y_offset = gaps.outer_vertical

                    + (stack_index as u32) * (stack_height + gaps.inner_vertical);

                geometries.push(WindowGeometry {

                    x_coordinate: stack_x,

                    y_coordinate: y_offset as i32,

                    width: stack_width,

                    height: stack_height,

                });

            }

            return geometries;

        }

    }

}