oxwm

use crate::Config;

use crate::bar::Bar;

use crate::errors::WmError;

use crate::keyboard::{self, Arg, KeyAction, handlers};

use crate::layout::GapConfig;

use crate::layout::tiling::TilingLayout;

use crate::layout::{Layout, LayoutBox, LayoutType, layout_from_str, next_layout};

use crate::monitor::{Monitor, detect_monitors};

use crate::overlay::{ErrorOverlay, KeybindOverlay, Overlay};

use std::collections::HashSet;

use std::process::Command;

use x11rb::cursor::Handle as CursorHandle;

use x11rb::connection::Connection;

use x11rb::protocol::Event;

use x11rb::protocol::xproto::*;

use x11rb::rust_connection::RustConnection;

const DEFAULT_FLOAT_WIDTH_RATIO: f32 = 0.5;

const DEFAULT_FLOAT_HEIGHT_RATIO: f32 = 0.5;

const SMART_MOVE_STEP_RATIO_VERTICAL: i32 = 4;

const SMART_MOVE_STEP_RATIO_HORIZONTAL: i32 = 6;

#[derive(Debug, Clone, Copy)]

pub struct CachedGeometry {

    pub x_position: i16,

    pub y_position: i16,

    pub width: u16,

    pub height: u16,

    pub border_width: u16,

}

pub type TagMask = u32;

pub fn tag_mask(tag: usize) -> TagMask {

    1 << tag

}

struct AtomCache {

    net_current_desktop: Atom,

    net_client_info: Atom,

    wm_state: Atom,

    wm_protocols: Atom,

    wm_delete_window: Atom,

    net_wm_state: Atom,

    net_wm_state_fullscreen: Atom,

    net_wm_window_type: Atom,

    net_wm_window_type_dialog: Atom,

}

impl AtomCache {

    fn new(connection: &RustConnection) -> WmResult<Self> {

        let net_current_desktop = connection

            .intern_atom(false, b"_NET_CURRENT_DESKTOP")?

            .reply()?

            .atom;

        let net_client_info = connection

            .intern_atom(false, b"_NET_CLIENT_INFO")?

            .reply()?

            .atom;

        let wm_state = connection.intern_atom(false, b"WM_STATE")?.reply()?.atom;

        let wm_protocols = connection

            .intern_atom(false, b"WM_PROTOCOLS")?

            .reply()?

            .atom;

        let wm_delete_window = connection

            .intern_atom(false, b"WM_DELETE_WINDOW")?

            .reply()?

            .atom;

        let net_wm_state = connection

            .intern_atom(false, b"_NET_WM_STATE")?

            .reply()?

            .atom;

        let net_wm_state_fullscreen = connection

            .intern_atom(false, b"_NET_WM_STATE_FULLSCREEN")?

            .reply()?

            .atom;

        let net_wm_window_type = connection

            .intern_atom(false, b"_NET_WM_WINDOW_TYPE")?

            .reply()?

            .atom;

        let net_wm_window_type_dialog = connection

            .intern_atom(false, b"_NET_WM_WINDOW_TYPE_DIALOG")?

            .reply()?

            .atom;

        Ok(Self {

            net_current_desktop,

            net_client_info,

            wm_state,

            wm_protocols,

            wm_delete_window,

            net_wm_state,

            net_wm_state_fullscreen,

            net_wm_window_type,

            net_wm_window_type_dialog,

        })

    }

}

pub struct WindowManager {

    config: Config,

    connection: RustConnection,

    screen_number: usize,

    root: Window,

    screen: Screen,

    windows: Vec<Window>,

    layout: LayoutBox,

    window_tags: std::collections::HashMap<Window, TagMask>,

    window_monitor: std::collections::HashMap<Window, usize>,

    window_geometry_cache: std::collections::HashMap<Window, CachedGeometry>,

    gaps_enabled: bool,

    floating_windows: HashSet<Window>,

    fullscreen_windows: HashSet<Window>,

    floating_geometry_before_fullscreen: std::collections::HashMap<Window, (i16, i16, u16, u16, u16)>,

    bars: Vec<Bar>,

    tab_bars: Vec<crate::tab_bar::TabBar>,

    show_bar: bool,

    last_layout: Option<&'static str>,

    monitors: Vec<Monitor>,

    selected_monitor: usize,

    atoms: AtomCache,

    previous_focused: Option<Window>,

    display: *mut x11::xlib::Display,

    font: crate::bar::font::Font,

    keychord_state: keyboard::handlers::KeychordState,

    error_message: Option<String>,

    overlay: ErrorOverlay,

    keybind_overlay: KeybindOverlay,

}

type WmResult<T> = Result<T, WmError>;

impl WindowManager {

    pub fn new(config: Config) -> WmResult<Self> {

        let (connection, screen_number) = x11rb::connect(None)?;

        let root = connection.setup().roots[screen_number].root;

        let screen = connection.setup().roots[screen_number].clone();

        let normal_cursor = CursorHandle::new(

            &connection,

            screen_number,

            &x11rb::resource_manager::new_from_default(&connection)?,

        )?

        .reply()?

        .load_cursor(&connection, "left_ptr")?;

        connection

            .change_window_attributes(

                root,

                &ChangeWindowAttributesAux::new()

                    .cursor(normal_cursor)

                    .event_mask(

                        EventMask::SUBSTRUCTURE_REDIRECT

                            | EventMask::SUBSTRUCTURE_NOTIFY

                            | EventMask::PROPERTY_CHANGE

                            | EventMask::KEY_PRESS

                            | EventMask::BUTTON_PRESS

                            | EventMask::POINTER_MOTION,

                    ),

            )?

            .check()?;

        let ignore_modifiers = [

            0,

            u16::from(ModMask::LOCK),

            u16::from(ModMask::M2),

            u16::from(ModMask::LOCK | ModMask::M2),

        ];

        for &ignore_mask in &ignore_modifiers {

            let grab_mask = u16::from(config.modkey) | ignore_mask;

            connection.grab_button(

                false,

                root,

                EventMask::BUTTON_PRESS | EventMask::BUTTON_RELEASE,

                GrabMode::SYNC,

                GrabMode::ASYNC,

                x11rb::NONE,

                x11rb::NONE,

                ButtonIndex::M1,

                grab_mask.into(),

            )?;

            connection.grab_button(

                false,

                root,

                EventMask::BUTTON_PRESS | EventMask::BUTTON_RELEASE,

                GrabMode::SYNC,

                GrabMode::ASYNC,

                x11rb::NONE,

                x11rb::NONE,

                ButtonIndex::M3,

                grab_mask.into(),

            )?;

        }

        let monitors = detect_monitors(&connection, &screen, root)?;

        let display = unsafe { x11::xlib::XOpenDisplay(std::ptr::null()) };

        if display.is_null() {

            return Err(WmError::X11(crate::errors::X11Error::DisplayOpenFailed));

        }

        let font = crate::bar::font::Font::new(display, screen_number as i32, &config.font)?;

        let mut bars = Vec::new();

        for monitor in monitors.iter() {

            let bar = Bar::new(

                &connection,

                &screen,

                screen_number,

                &config,

                display,

                &font,

                monitor.x as i16,

                monitor.y as i16,

                monitor.width as u16,

            )?;

            bars.push(bar);

        }

        let bar_height = font.height() as f32 * 1.4;

        let mut tab_bars = Vec::new();

        for monitor in monitors.iter() {

            let tab_bar = crate::tab_bar::TabBar::new(

                &connection,

                &screen,

                screen_number,

                display,

                &font,

                (monitor.x + config.gap_outer_horizontal as i32) as i16,

                (monitor.y as f32 + bar_height + config.gap_outer_vertical as f32) as i16,

                monitor.width.saturating_sub(2 * config.gap_outer_horizontal) as u16,

                config.scheme_occupied,

                config.scheme_selected,

            )?;

            tab_bars.push(tab_bar);

        }

        let gaps_enabled = config.gaps_enabled;

        let atoms = AtomCache::new(&connection)?;

        let overlay = ErrorOverlay::new(

            &connection,

            &screen,

            screen_number,

            display,

            &font,

            screen.width_in_pixels,

        )?;

        let keybind_overlay =

            KeybindOverlay::new(&connection, &screen, screen_number, display, config.modkey)?;

        let mut window_manager = Self {

            config,

            connection,

            screen_number,

            root,

            screen,

            windows: Vec::new(),

            layout: Box::new(TilingLayout),

            window_tags: std::collections::HashMap::new(),

            window_monitor: std::collections::HashMap::new(),

            window_geometry_cache: std::collections::HashMap::new(),

            gaps_enabled,

            floating_windows: HashSet::new(),

            fullscreen_windows: HashSet::new(),

            floating_geometry_before_fullscreen: std::collections::HashMap::new(),

            bars,

            tab_bars,

            show_bar: true,

            last_layout: None,

            monitors,

            selected_monitor: 0,

            atoms,

            previous_focused: None,

            display,

            font,

            keychord_state: keyboard::handlers::KeychordState::Idle,

            error_message: None,

            overlay,

            keybind_overlay,

        };

        for tab_bar in &window_manager.tab_bars {

            tab_bar.hide(&window_manager.connection)?;

        }

        window_manager.scan_existing_windows()?;

        window_manager.update_bar()?;

        window_manager.run_autostart_commands()?;

        Ok(window_manager)

    }

    pub fn show_migration_overlay(&mut self) {

        let message = "Your config.lua uses legacy syntax or has errors.\n\n\

                       You are now running with default configuration.\n\n\

                       Press Mod+Shift+/ to see default keybinds\n\

                       Press Mod+Shift+R to reload after fixing your config";

        let screen_width = self.screen.width_in_pixels;

        let screen_height = self.screen.height_in_pixels;

        if let Err(e) = self.overlay.show_error(

            &self.connection,

            &self.font,

            message,

            screen_width,

            screen_height,

        ) {

            eprintln!("Failed to show migration overlay: {:?}", e);

        }

    }

    fn try_reload_config(&mut self) -> Result<(), String> {

        let config_dir = if let Some(xdg_config) = std::env::var_os("XDG_CONFIG_HOME") {

            std::path::PathBuf::from(xdg_config).join("oxwm")

        } else if let Some(home) = std::env::var_os("HOME") {

            std::path::PathBuf::from(home).join(".config").join("oxwm")

        } else {

            return Err("Could not find config directory".to_string());

        };

        let lua_path = config_dir.join("config.lua");

        if !lua_path.exists() {

            return Err("No config.lua file found".to_string());

        }

        let config_str = std::fs::read_to_string(&lua_path)

            .map_err(|e| format!("Failed to read config: {}", e))?;

        let new_config = crate::config::parse_lua_config(&config_str, Some(&config_dir))

            .map_err(|e| format!("{}", e))?;

        self.config = new_config;

        self.error_message = None;

        for bar in &mut self.bars {

            bar.update_from_config(&self.config);

        }

        Ok(())

    }

    fn scan_existing_windows(&mut self) -> WmResult<()> {

        let tree = self.connection.query_tree(self.root)?.reply()?;

        let net_client_info = self.atoms.net_client_info;

        let wm_state_atom = self.atoms.wm_state;

        for &window in &tree.children {

            if self.bars.iter().any(|bar| bar.window() == window) {

                continue;

            }

            let Ok(attrs) = self.connection.get_window_attributes(window)?.reply() else {

                continue;

            };

            if attrs.override_redirect {

                continue;

            }

            if attrs.map_state == MapState::VIEWABLE {

                let tag = self.get_saved_tag(window, net_client_info)?;

                self.windows.push(window);

                self.window_tags.insert(window, tag);

                self.window_monitor.insert(window, self.selected_monitor);

                continue;

            }

            if attrs.map_state == MapState::UNMAPPED {

                let has_wm_state = self

                    .connection

                    .get_property(false, window, wm_state_atom, AtomEnum::ANY, 0, 2)?

                    .reply()

                    .is_ok_and(|prop| !prop.value.is_empty());

                if !has_wm_state {

                    continue;

                }

                let has_wm_class = self

                    .connection

                    .get_property(false, window, AtomEnum::WM_CLASS, AtomEnum::STRING, 0, 1024)?

                    .reply()

                    .is_ok_and(|prop| !prop.value.is_empty());

                if has_wm_class {

                    let tag = self.get_saved_tag(window, net_client_info)?;

                    self.connection.map_window(window)?;

                    self.windows.push(window);

                    self.window_tags.insert(window, tag);

                    self.window_monitor.insert(window, self.selected_monitor);

                }

            }

        }

        if let Some(&first) = self.windows.first() {

            self.set_focus(first)?;

        }

        self.apply_layout()?;

        Ok(())

    }

    fn get_saved_tag(&self, window: Window, net_client_info: Atom) -> WmResult<TagMask> {

        match self

            .connection

            .get_property(false, window, net_client_info, AtomEnum::CARDINAL, 0, 2)?

            .reply()

        {

            Ok(prop) if prop.value.len() >= 4 => {

                let tags = u32::from_ne_bytes([

                    prop.value[0],

                    prop.value[1],

                    prop.value[2],

                    prop.value[3],

                ]);

                if tags != 0 && tags < (1 << self.config.tags.len()) {

                    return Ok(tags);

                }

            }

            Ok(_) => {}

            Err(e) => {

                eprintln!("No _NET_CLIENT_INFO property ({})", e);

            }

        }

        Ok(self

            .monitors

            .get(self.selected_monitor)

            .map(|m| m.selected_tags)

            .unwrap_or(tag_mask(0)))

    }

    fn save_client_tag(&self, window: Window, tag: TagMask) -> WmResult<()> {

        let net_client_info = self.atoms.net_client_info;

        let bytes = tag.to_ne_bytes().to_vec();

        self.connection.change_property(

            PropMode::REPLACE,

            window,

            net_client_info,

            AtomEnum::CARDINAL,

            32,

            1,

            &bytes,

        )?;

        self.connection.flush()?;

        Ok(())

    }

    fn set_wm_state(&self, window: Window, state: u32) -> WmResult<()> {

        let wm_state_atom = self.atoms.wm_state;

        let data = [state, 0u32];

        let bytes: Vec<u8> = data.iter().flat_map(|&v| v.to_ne_bytes()).collect();

        self.connection.change_property(

            PropMode::REPLACE,

            window,

            wm_state_atom,

            wm_state_atom,

            32,

            2,

            &bytes,

        )?;

        self.connection.flush()?;

        Ok(())

    }

    pub fn run(&mut self) -> WmResult<bool> {

        println!("oxwm started on display {}", self.screen_number);

        keyboard::setup_keybinds(&self.connection, self.root, &self.config.keybindings)?;

        self.update_bar()?;

        let mut last_bar_update = std::time::Instant::now();

        const BAR_UPDATE_INTERVAL_MS: u64 = 100;

        loop {

            match self.connection.poll_for_event_with_sequence()? {

                Some((event, _sequence)) => {

                    if let Some(should_restart) = self.handle_event(event)? {

                        return Ok(should_restart);

                    }

                }

                None => {

                    if last_bar_update.elapsed().as_millis() >= BAR_UPDATE_INTERVAL_MS as u128 {

                        if let Some(bar) = self.bars.get_mut(self.selected_monitor) {

                            bar.update_blocks();

                        }

                        if self.bars.iter().any(|bar| bar.needs_redraw()) {

                            self.update_bar()?;

                        }

                        last_bar_update = std::time::Instant::now();

                    }

                    self.connection.flush()?;

                    std::thread::sleep(std::time::Duration::from_millis(16));

                }

            }

        }

    }

    fn toggle_floating(&mut self) -> WmResult<()> {

        if let Some(focused) = self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.focused_window)

        {

            if self.floating_windows.contains(&focused) {

                self.floating_windows.remove(&focused);

                let selected_tags = self

                    .monitors

                    .get(self.selected_monitor)

                    .map(|m| m.selected_tags)

                    .unwrap_or(tag_mask(0));

                self.window_tags.insert(focused, selected_tags);

                self.window_monitor.insert(focused, self.selected_monitor);

                if let Err(error) = self.save_client_tag(focused, selected_tags) {

                    eprintln!("Failed to save client tag: {:?}", error);

                }

                self.apply_layout()?;

            } else {

                let float_width = (self.screen.width_in_pixels / 2) as u32;

                let float_height = (self.screen.height_in_pixels / 2) as u32;

                let border_width = self.config.border_width;

                let center_width = ((self.screen.width_in_pixels - float_width as u16) / 2) as i32;

                let center_height =

                    ((self.screen.height_in_pixels - float_height as u16) / 2) as i32;

                self.connection.configure_window(

                    focused,

                    &ConfigureWindowAux::new()

                        .x(center_width)

                        .y(center_height)

                        .width(float_width)

                        .height(float_height)

                        .border_width(border_width)

                        .stack_mode(StackMode::ABOVE),

                )?;

                self.floating_windows.insert(focused);

                self.apply_layout()?;

                self.connection.flush()?;

            }

        }

        Ok(())

    }

    fn collect_visible_floating_geometries(&mut self) -> Vec<(Window, CachedGeometry)> {

        let focused_window = self.monitors.get(self.selected_monitor)

            .and_then(|monitor| monitor.focused_window)

            .unwrap_or(0);

        let selected_monitor_index = self.selected_monitor;

        let candidate_windows: Vec<Window> = self.windows.iter()

            .filter(|&&window| {

                window != focused_window

                    && self.floating_windows.contains(&window)

                    && self.is_window_visible(window)

                    && self.window_monitor.get(&window).copied().unwrap_or(0) == selected_monitor_index

            })

            .copied()

            .collect();

        candidate_windows.into_iter()

            .filter_map(|window| {

                self.get_or_query_geometry(window).ok().map(|geometry| (window, geometry))

            })

            .collect()

    }

    fn calculate_smart_move_position(

        &self,

        current_x: i32,

        current_y: i32,

        current_width: i32,

        current_height: i32,

        direction: i32,

        monitor: &Monitor,

        other_geometries: &[(Window, CachedGeometry)],

    ) -> (i32, i32) {

        let (gap_inner_horizontal, gap_inner_vertical, gap_outer_horizontal, gap_outer_vertical) = if self.gaps_enabled {

            (

                self.config.gap_inner_horizontal as i32,

                self.config.gap_inner_vertical as i32,

                self.config.gap_outer_horizontal as i32,

                self.config.gap_outer_vertical as i32,

            )

        } else {

            (0, 0, 0, 0)

        };

        match direction {

            0 => {

                let mut target_position = i32::MIN;

                let current_top = current_y;

                let mut new_y_position = current_y - (monitor.height as i32 / SMART_MOVE_STEP_RATIO_VERTICAL);

                for (_other_window, other_geometry) in other_geometries {

                    let other_x = other_geometry.x_position as i32;

                    let other_y = other_geometry.y_position as i32;

                    let other_width = other_geometry.width as i32;

                    let other_height = other_geometry.height as i32;

                    if current_x + current_width < other_x || current_x > other_x + other_width {

                        continue;

                    }

                    let other_bottom = other_y + other_height + gap_inner_vertical;

                    if current_top > other_bottom && new_y_position < other_bottom {

                        target_position = target_position.max(other_bottom);

                    }

                }

                if target_position != i32::MIN {

                    new_y_position = target_position;

                }

                new_y_position = new_y_position.max(monitor.y as i32 + gap_outer_vertical);

                (current_x, new_y_position)

            }

            1 => {

                let mut target_position = i32::MAX;

                let current_bottom = current_y + current_height;

                let mut new_y_position = current_y + (monitor.height as i32 / SMART_MOVE_STEP_RATIO_VERTICAL);

                for (_other_window, other_geometry) in other_geometries {

                    let other_x = other_geometry.x_position as i32;

                    let other_y = other_geometry.y_position as i32;

                    let other_width = other_geometry.width as i32;

                    if current_x + current_width < other_x || current_x > other_x + other_width {

                        continue;

                    }

                    let other_top = other_y - gap_inner_vertical;

                    if current_bottom < other_top && (new_y_position + current_height) > other_top {

                        target_position = target_position.min(other_top - current_height);

                    }

                }

                if target_position != i32::MAX {

                    new_y_position = target_position;

                }

                new_y_position = new_y_position.min(monitor.y as i32 + monitor.height as i32 - current_height - gap_outer_vertical);

                (current_x, new_y_position)

            }

            2 => {

                let mut target_position = i32::MIN;

                let current_left = current_x;

                let mut new_x_position = current_x - (monitor.width as i32 / SMART_MOVE_STEP_RATIO_HORIZONTAL);

                for (_other_window, other_geometry) in other_geometries {

                    let other_x = other_geometry.x_position as i32;

                    let other_y = other_geometry.y_position as i32;

                    let other_width = other_geometry.width as i32;

                    let other_height = other_geometry.height as i32;

                    if current_y + current_height < other_y || current_y > other_y + other_height {

                        continue;

                    }

                    let other_right = other_x + other_width + gap_inner_horizontal;

                    if current_left > other_right && new_x_position < other_right {

                        target_position = target_position.max(other_right);

                    }

                }

                if target_position != i32::MIN {

                    new_x_position = target_position;

                }

                new_x_position = new_x_position.max(monitor.x as i32 + gap_outer_horizontal);

                (new_x_position, current_y)

            }

            3 => {

                let mut target_position = i32::MAX;

                let current_right = current_x + current_width;

                let mut new_x_position = current_x + (monitor.width as i32 / SMART_MOVE_STEP_RATIO_HORIZONTAL);

                for (_other_window, other_geometry) in other_geometries {

                    let other_x = other_geometry.x_position as i32;

                    let other_y = other_geometry.y_position as i32;

                    let other_height = other_geometry.height as i32;

                    if current_y + current_height < other_y || current_y > other_y + other_height {

                        continue;

                    }

                    let other_left = other_x - gap_inner_horizontal;

                    if current_right < other_left && (new_x_position + current_width) > other_left {

                        target_position = target_position.min(other_left - current_width);

                    }

                }

                if target_position != i32::MAX {

                    new_x_position = target_position;

                }

                new_x_position = new_x_position.min(monitor.x as i32 + monitor.width as i32 - current_width - gap_outer_horizontal);

                (new_x_position, current_y)

            }

            _ => (current_x, current_y),

        }

    }

    fn smart_move_window(&mut self, direction: i32) -> WmResult<()> {

        let focused = match self

            .monitors

            .get(self.selected_monitor)

            .and_then(|monitor| monitor.focused_window)

        {

            Some(window) => window,

            None => return Ok(()),

        };

        if !self.floating_windows.contains(&focused) {

            let float_width = (self.screen.width_in_pixels as f32 * DEFAULT_FLOAT_WIDTH_RATIO) as u32;

            let float_height = (self.screen.height_in_pixels as f32 * DEFAULT_FLOAT_HEIGHT_RATIO) as u32;

            let border_width = self.config.border_width;

            let center_x_position = ((self.screen.width_in_pixels - float_width as u16) / 2) as i32;

            let center_y_position = ((self.screen.height_in_pixels - float_height as u16) / 2) as i32;

            self.connection.configure_window(

                focused,

                &ConfigureWindowAux::new()

                    .x(center_x_position)

                    .y(center_y_position)

                    .width(float_width)

                    .height(float_height)

                    .border_width(border_width)

                    .stack_mode(StackMode::ABOVE),

            )?;

            self.floating_windows.insert(focused);

        }

        let current_geometry = self.get_or_query_geometry(focused)?;

        let current_x = current_geometry.x_position as i32;

        let current_y = current_geometry.y_position as i32;

        let current_width = current_geometry.width as i32;

        let current_height = current_geometry.height as i32;

        let other_geometries = self.collect_visible_floating_geometries();

        let monitor = match self.monitors.get(self.selected_monitor) {

            Some(monitor) => monitor,

            None => return Ok(()),

        };

        let (new_x_position, new_y_position) = self.calculate_smart_move_position(

            current_x,

            current_y,

            current_width,

            current_height,

            direction,

            monitor,

            &other_geometries,

        );

        self.connection.configure_window(

            focused,

            &ConfigureWindowAux::new()

                .x(new_x_position)

                .y(new_y_position)

                .stack_mode(StackMode::ABOVE),

        )?;

        self.update_geometry_cache(focused, CachedGeometry {

            x_position: new_x_position as i16,

            y_position: new_y_position as i16,

            width: current_width as u16,

            height: current_height as u16,

            border_width: current_geometry.border_width,

        });

        self.connection.flush()?;

        Ok(())

    }

    fn exchange_client(&mut self, direction: i32) -> WmResult<()> {

        let focused = match self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.focused_window)

        {

            Some(win) => win,

            None => return Ok(()),

        };

        if self.floating_windows.contains(&focused) {

            return Ok(());

        }

        let visible = self.visible_windows();

        if visible.len() < 2 {

            return Ok(());

        }

        let current_idx = match visible.iter().position(|&w| w == focused) {

            Some(idx) => idx,

            None => return Ok(()),

        };

        let target_idx = match direction {

            0 | 2 => {

                // UP or LEFT - previous in stack

                if current_idx == 0 {

                    visible.len() - 1

                } else {

                    current_idx - 1

                }

            }

            1 | 3 => {

                // DOWN or RIGHT - next in stack

                (current_idx + 1) % visible.len()

            }

            _ => return Ok(()),

        };

        let target = visible[target_idx];

        let focused_pos = self.windows.iter().position(|&w| w == focused);

        let target_pos = self.windows.iter().position(|&w| w == target);

        if let (Some(f_pos), Some(t_pos)) = (focused_pos, target_pos) {

            self.windows.swap(f_pos, t_pos);

            self.apply_layout()?;

            self.set_focus(focused)?;

            if let Ok(geometry) = self.connection.get_geometry(focused)?.reply() {

                self.connection.warp_pointer(

                    x11rb::NONE,

                    focused,

                    0,

                    0,

                    0,

                    0,

                    geometry.width as i16 / 2,

                    geometry.height as i16 / 2,

                )?;

            }

        }

        Ok(())

    }

    fn get_layout_symbol(&self) -> String {

        let layout_name = self.layout.name();

        self.config

            .layout_symbols

            .iter()

            .find(|l| l.name == layout_name)

            .map(|l| l.symbol.clone())

            .unwrap_or_else(|| self.layout.symbol().to_string())

    }

    fn get_keychord_indicator(&self) -> Option<String> {

        match &self.keychord_state {

            keyboard::handlers::KeychordState::Idle => None,

            keyboard::handlers::KeychordState::InProgress {

                candidates,

                keys_pressed,

            } => {

                if candidates.is_empty() {

                    return None;

                }

                let binding = &self.config.keybindings[candidates[0]];

                let mut indicator = String::new();

                for (i, key_press) in binding.keys.iter().take(*keys_pressed).enumerate() {

                    if i > 0 {

                        indicator.push(' ');

                    }

                    for modifier in &key_press.modifiers {

                        indicator.push_str(Self::format_modifier(*modifier));

                        indicator.push('+');

                    }

                    indicator.push_str(&keyboard::keysyms::format_keysym(key_press.keysym));

                }

                indicator.push('-');

                Some(indicator)

            }

        }

    }

    fn format_modifier(modifier: KeyButMask) -> &'static str {

        match modifier {

            KeyButMask::MOD1 => "Alt",

            KeyButMask::MOD4 => "Super",

            KeyButMask::SHIFT => "Shift",

            KeyButMask::CONTROL => "Ctrl",

            _ => "Mod",

        }

    }

    fn update_bar(&mut self) -> WmResult<()> {

        let layout_symbol = self.get_layout_symbol();

        let keychord_indicator = self.get_keychord_indicator();

        for (monitor_index, monitor) in self.monitors.iter().enumerate() {

            if let Some(bar) = self.bars.get_mut(monitor_index) {

                let mut occupied_tags: TagMask = 0;

                for (&window, &tags) in &self.window_tags {

                    if self.window_monitor.get(&window).copied().unwrap_or(0) == monitor_index {

                        occupied_tags |= tags;

                    }

                }

                let draw_blocks = monitor_index == self.selected_monitor;

                bar.invalidate();

                bar.draw(

                    &self.connection,

                    &self.font,

                    self.display,

                    monitor.selected_tags,

                    occupied_tags,

                    draw_blocks,

                    &layout_symbol,

                    keychord_indicator.as_deref(),

                )?;

            }

        }

        Ok(())

    }

    fn update_tab_bars(&mut self) -> WmResult<()> {

        for (monitor_index, monitor) in self.monitors.iter().enumerate() {

            if let Some(tab_bar) = self.tab_bars.get_mut(monitor_index) {

                let visible_windows: Vec<Window> = self

                    .windows

                    .iter()

                    .filter(|&&window| {

                        let window_monitor_index = self.window_monitor.get(&window).copied().unwrap_or(0);

                        if window_monitor_index != monitor_index

                            || self.floating_windows.contains(&window)

                            || self.fullscreen_windows.contains(&window)

                        {

                            return false;

                        }

                        if let Some(&tags) = self.window_tags.get(&window) {

                            (tags & monitor.selected_tags) != 0

                        } else {

                            false

                        }

                    })

                    .copied()

                    .collect();

                let focused_window = monitor.focused_window;

                tab_bar.draw(

                    &self.connection,

                    &self.font,

                    &visible_windows,

                    focused_window,

                )?;

            }

        }

        Ok(())

    }

    fn handle_key_action(&mut self, action: KeyAction, arg: &Arg) -> WmResult<()> {

        match action {

            KeyAction::Spawn => handlers::handle_spawn_action(action, arg, self.selected_monitor)?,

            KeyAction::SpawnTerminal => {

                use std::process::Command;

                let terminal = &self.config.terminal;

                if let Err(error) = Command::new(terminal).spawn() {

                    eprintln!("Failed to spawn terminal {}: {:?}", terminal, error);

                }

            }

            KeyAction::KillClient => {

                if let Some(focused) = self

                    .monitors

                    .get(self.selected_monitor)

                    .and_then(|m| m.focused_window)

                {

                    self.kill_client(focused)?;

                }

            }

            KeyAction::ToggleFullScreen => {

                self.fullscreen()?;

            }

            KeyAction::ChangeLayout => {

                if let Arg::Str(layout_name) = arg {

                    match layout_from_str(layout_name) {

                        Ok(layout) => {

                            self.layout = layout;

                            if layout_name != "normie" && layout_name != "floating" {

                                self.floating_windows.clear();

                            }

                            self.apply_layout()?;

                            self.update_bar()?;

                        }

                        Err(e) => eprintln!("Failed to change layout: {}", e),

                    }

                }

            }

            KeyAction::CycleLayout => {

                let current_name = self.layout.name();

                let next_name = next_layout(current_name);

                match layout_from_str(next_name) {

                    Ok(layout) => {

                        self.layout = layout;

                        if next_name != "normie" && next_name != "floating" {

                            self.floating_windows.clear();

                        }

                        self.apply_layout()?;

                        self.update_bar()?;

                    }

                    Err(e) => eprintln!("Failed to cycle layout: {}", e),

                }

            }

            KeyAction::ToggleFloating => {

                self.toggle_floating()?;

            }

            KeyAction::SmartMoveWin => {

                if let Arg::Int(direction) = arg {

                    self.smart_move_window(*direction)?;

                }

            }

            KeyAction::ExchangeClient => {

                if let Arg::Int(direction) = arg {

                    self.exchange_client(*direction)?;

                }

            }

            KeyAction::FocusStack => {

                if let Arg::Int(direction) = arg {

                    self.cycle_focus(*direction)?;

                }

            }

            KeyAction::FocusDirection => {

                if let Arg::Int(direction) = arg {

                    self.focus_direction(*direction)?;

                }

            }

            KeyAction::SwapDirection => {

                if let Arg::Int(direction) = arg {

                    self.swap_direction(*direction)?;

                }

            }

            KeyAction::Quit | KeyAction::Restart => {

                // Handled in handle_event

            }

            KeyAction::Recompile => {

                match std::process::Command::new("oxwm")

                    .arg("--recompile")

                    .spawn()

                {

                    Ok(_) => eprintln!("Recompiling in background"),

                    Err(e) => eprintln!("Failed to spawn recompile: {}", e),

                }

            }

            KeyAction::ViewTag => {

                if let Arg::Int(tag_index) = arg {

                    self.view_tag(*tag_index as usize)?;

                }

            }

            KeyAction::MoveToTag => {

                if let Arg::Int(tag_index) = arg {

                    self.move_to_tag(*tag_index as usize)?;

                }

            }

            KeyAction::ToggleGaps => {

                self.gaps_enabled = !self.gaps_enabled;

                self.apply_layout()?;

            }

            KeyAction::FocusMonitor => {

                if let Arg::Int(direction) = arg {

                    self.focus_monitor(*direction)?;

                }

            }

            KeyAction::ShowKeybindOverlay => {

                let monitor = &self.monitors[self.selected_monitor];

                self.keybind_overlay.toggle(

                    &self.connection,

                    &self.font,

                    &self.config.keybindings,

                    monitor.width as u16,

                    monitor.height as u16,

                )?;

            }

            KeyAction::None => {}

        }

        Ok(())

    }

    fn focus_monitor(&mut self, direction: i32) -> WmResult<()> {

        if self.monitors.is_empty() {

            return Ok(());

        }

        let new_monitor = if direction > 0 {

            (self.selected_monitor + 1) % self.monitors.len()

        } else {

            (self.selected_monitor + self.monitors.len() - 1) % self.monitors.len()

        };

        if new_monitor == self.selected_monitor {

            return Ok(());

        }

        self.selected_monitor = new_monitor;

        self.update_bar()?;

        let visible = self.visible_windows_on_monitor(new_monitor);

        if let Some(&win) = visible.first() {

            self.set_focus(win)?;

        }

        Ok(())

    }

    fn is_window_visible(&self, window: Window) -> bool {

        let window_mon = self.window_monitor.get(&window).copied().unwrap_or(0);

        if let Some(&tags) = self.window_tags.get(&window) {

            let monitor = self.monitors.get(window_mon);

            let selected_tags = monitor.map(|m| m.selected_tags).unwrap_or(0);

            (tags & selected_tags) != 0

        } else {

            false

        }

    }

    fn visible_windows(&self) -> Vec<Window> {

        self.windows

            .iter()

            .filter(|&&w| self.is_window_visible(w))

            .copied()

            .collect()

    }

    fn visible_windows_on_monitor(&self, monitor_index: usize) -> Vec<Window> {

        self.windows

            .iter()

            .filter(|&&w| {

                let window_mon = self.window_monitor.get(&w).copied().unwrap_or(0);

                if window_mon != monitor_index {

                    return false;

                }

                if let Some(&tags) = self.window_tags.get(&w) {

                    let monitor = self.monitors.get(monitor_index);

                    let selected_tags = monitor.map(|m| m.selected_tags).unwrap_or(0);

                    (tags & selected_tags) != 0

                } else {

                    false

                }

            })

            .copied()

            .collect()

    }

    fn get_monitor_at_point(&self, x: i32, y: i32) -> Option<usize> {

        self.monitors

            .iter()

            .position(|mon| mon.contains_point(x, y))

    }

    // Dwm's g-loaded approach to handling the spam alternating crash.

    fn update_window_visibility(&self) -> WmResult<()> {

        for &window in &self.windows {

            if !self.is_window_visible(window) {

                if let Ok(geom) = self.connection.get_geometry(window)?.reply() {

                    self.connection.configure_window(

                        window,

                        &ConfigureWindowAux::new()

                            .x(-(geom.width as i32 * 2))

                            .y(geom.y as i32),

                    )?;

                }

            }

        }

        self.connection.flush()?;

        Ok(())

    }

    pub fn view_tag(&mut self, tag_index: usize) -> WmResult<()> {

        if tag_index >= self.config.tags.len() {

            return Ok(());

        }

        if let Some(monitor) = self.monitors.get_mut(self.selected_monitor) {

            monitor.selected_tags = tag_mask(tag_index);

        }

        self.save_selected_tags()?;

        self.update_window_visibility()?;

        self.apply_layout()?;

        self.update_bar()?;

        let visible = self.visible_windows_on_monitor(self.selected_monitor);

        if let Some(&win) = visible.first() {

            self.set_focus(win)?;

        }

        Ok(())

    }

    fn save_selected_tags(&self) -> WmResult<()> {

        let net_current_desktop = self.atoms.net_current_desktop;

        let selected_tags = self

            .monitors

            .get(self.selected_monitor)

            .map(|m| m.selected_tags)

            .unwrap_or(tag_mask(0));

        let desktop = selected_tags.trailing_zeros();

        let bytes = (desktop as u32).to_ne_bytes();

        self.connection.change_property(

            PropMode::REPLACE,

            self.root,

            net_current_desktop,

            AtomEnum::CARDINAL,

            32,

            1,

            &bytes,

        )?;

        self.connection.flush()?;

        Ok(())

    }

    pub fn move_to_tag(&mut self, tag_index: usize) -> WmResult<()> {

        if tag_index >= self.config.tags.len() {

            return Ok(());

        }

        if let Some(focused) = self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.focused_window)

        {

            let mask = tag_mask(tag_index);

            self.window_tags.insert(focused, mask);

            if let Err(error) = self.save_client_tag(focused, mask) {

                eprintln!("Failed to save client tag: {:?}", error);

            }

            self.update_window_visibility()?;

            self.apply_layout()?;

            self.update_bar()?;

        }

        Ok(())

    }

    pub fn cycle_focus(&mut self, direction: i32) -> WmResult<()> {

        let visible = self.visible_windows();

        if visible.is_empty() {

            return Ok(());

        }

        let current = self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.focused_window);

        let next_window = if let Some(current) = current {

            if let Some(current_index) = visible.iter().position(|&w| w == current) {

                let next_index = if direction > 0 {

                    (current_index + 1) % visible.len()

                } else {

                    (current_index + visible.len() - 1) % visible.len()

                };

                visible[next_index]

            } else {

                visible[0]

            }

        } else {

            visible[0]

        };

        let is_tabbed = self.layout.name() == "tabbed";

        if is_tabbed {

            self.connection.configure_window(

                next_window,

                &ConfigureWindowAux::new().stack_mode(StackMode::ABOVE),

            )?;

        }

        self.set_focus(next_window)?;

        if is_tabbed {

            self.update_tab_bars()?;

        }

        Ok(())

    }

    fn find_directional_window_candidate(&mut self, focused_window: Window, direction: i32) -> Option<Window> {

        let visible_windows = self.visible_windows();

        if visible_windows.len() < 2 {