use super::{GapConfig, Layout, WindowGeometry};
use x11rb::protocol::xproto::Window;

pub struct GridLayout;

impl Layout for GridLayout {
    fn name(&self) -> &'static str {
        super::LayoutType::Grid.as_str()
    }

    fn symbol(&self) -> &'static str {
        "[#]"
    }

    fn arrange(
        &self,
        windows: &[Window],
        screen_width: u32,
        screen_height: u32,
        gaps: &GapConfig,
        _master_factor: f32,
        _num_master: i32,
        _smartgaps_enabled: bool,
    ) -> 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);

            return vec![WindowGeometry {
                x_coordinate: x,
                y_coordinate: y,
                width,
                height,
            }];
        }

        let cols = (window_count as f64).sqrt().ceil() as usize;
        let rows = (window_count as f64 / cols as f64).ceil() as usize;

        let mut geometries = Vec::new();

        let total_horizontal_gaps =
            gaps.outer_horizontal * 2 + gaps.inner_horizontal * (cols as u32 - 1);
        let total_vertical_gaps = gaps.outer_vertical * 2 + gaps.inner_vertical * (rows as u32 - 1);

        let cell_width = screen_width.saturating_sub(total_horizontal_gaps) / cols as u32;
        let cell_height = screen_height.saturating_sub(total_vertical_gaps) / rows as u32;

        for (index, _window) in windows.iter().enumerate() {
            let row = index / cols;
            let col = index % cols;

            let is_last_row = row == rows - 1;
            let windows_in_last_row = window_count - (rows - 1) * cols;

            let (x, y, width, height) = if is_last_row && windows_in_last_row < cols {
                let last_row_col = index % cols;
                let last_row_cell_width =
                    screen_width.saturating_sub(total_horizontal_gaps.saturating_sub(
                        gaps.inner_horizontal * (cols as u32 - windows_in_last_row as u32),
                    )) / windows_in_last_row as u32;

                let x = gaps.outer_horizontal
                    + last_row_col as u32 * (last_row_cell_width + gaps.inner_horizontal);
                let y = gaps.outer_vertical + row as u32 * (cell_height + gaps.inner_vertical);

                (x as i32, y as i32, last_row_cell_width, cell_height)
            } else {
                let x = gaps.outer_horizontal + col as u32 * (cell_width + gaps.inner_horizontal);
                let y = gaps.outer_vertical + row as u32 * (cell_height + gaps.inner_vertical);

                (x as i32, y as i32, cell_width, cell_height)
            };

            geometries.push(WindowGeometry {
                x_coordinate: x,
                y_coordinate: y,
                width,
                height,
            });
        }

        geometries
    }
}