oxwm

use crate::Config;

use crate::bar::Bar;

use crate::client::{Client, TagMask};

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::{HashMap, 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;

#[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 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,

    wm_name: Atom,

    net_wm_name: Atom,

    utf8_string: Atom,

    wm_normal_hints: Atom,

    wm_hints: Atom,

    wm_transient_for: Atom,

    net_active_window: 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;

        let wm_name = AtomEnum::WM_NAME.into();

        let net_wm_name = connection.intern_atom(false, b"_NET_WM_NAME")?.reply()?.atom;

        let utf8_string = connection.intern_atom(false, b"UTF8_STRING")?.reply()?.atom;

        let wm_normal_hints = AtomEnum::WM_NORMAL_HINTS.into();

        let wm_hints = AtomEnum::WM_HINTS.into();

        let wm_transient_for = AtomEnum::WM_TRANSIENT_FOR.into();

        let net_active_window = connection.intern_atom(false, b"_NET_ACTIVE_WINDOW")?.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,

            wm_name,

            net_wm_name,

            utf8_string,

            wm_normal_hints,

            wm_hints,

            wm_transient_for,

            net_active_window,

        })

    }

}

pub struct WindowManager {

    config: Config,

    connection: RustConnection,

    screen_number: usize,

    root: Window,

    screen: Screen,

    windows: Vec<Window>,

    clients: HashMap<Window, Client>,

    layout: LayoutBox,

    window_geometry_cache: HashMap<Window, CachedGeometry>,

    gaps_enabled: bool,

    floating_windows: HashSet<Window>,

    fullscreen_windows: HashSet<Window>,

    floating_geometry_before_fullscreen: 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.screen_x as i16,

                monitor.screen_y as i16,

                monitor.screen_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.screen_x + config.gap_outer_horizontal as i32) as i16,

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

                monitor.screen_width.saturating_sub(2 * config.gap_outer_horizontal as i32) 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(),

            clients: HashMap::new(),

            layout: Box::new(TilingLayout),

            window_geometry_cache: HashMap::new(),

            gaps_enabled,

            floating_windows: HashSet::new(),

            fullscreen_windows: HashSet::new(),

            floating_geometry_before_fullscreen: 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 = "We are on version 0.8.0 now.\n\n\

                       Your config file has been deprecated once again.\n\

                       Backup your current config, and run oxwm --init to generate a new one with correct values.\n\n\

                       Please reach out to Tony, or check out the\n\

                       documentation for help with migration.\n\n\

                       We appreciate you testing oxwm!\n\n\

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

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

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

        let monitor_x = monitor.screen_x as i16;

        let monitor_y = monitor.screen_y as i16;

        let screen_width = monitor.screen_width as u16;

        let screen_height = monitor.screen_height as u16;

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

            &self.connection,

            &self.font,

            message,

            monitor_x,

            monitor_y,

            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);

                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);

                }

            }

        }

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

            self.focus(Some(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.tagset[m.selected_tags_index])

            .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<()> {

        let focused = self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.selected_client);

        if focused.is_none() {

            return Ok(());

        }

        let focused = focused.unwrap();

        if let Some(client) = self.clients.get(&focused) {

            if client.is_fullscreen {

                return Ok(());

            }

        }

        let (is_fixed, x, y, w, h) = if let Some(client) = self.clients.get(&focused) {

            (client.is_fixed, client.x_position as i32, client.y_position as i32, client.width as u32, client.height as u32)

        } else {

            return Ok(());

        };

        let was_floating = self.floating_windows.contains(&focused);

        if was_floating {

            self.floating_windows.remove(&focused);

            if let Some(client) = self.clients.get_mut(&focused) {

                client.is_floating = false;

            }

        } else {

            self.floating_windows.insert(focused);

            if let Some(client) = self.clients.get_mut(&focused) {

                client.is_floating = is_fixed || !client.is_floating;

            }

            self.connection.configure_window(

                focused,

                &ConfigureWindowAux::new()

                    .x(x)

                    .y(y)

                    .width(w)

                    .height(h)

                    .stack_mode(StackMode::ABOVE),

            )?;

        }

        self.apply_layout()?;

        Ok(())

    }

    fn set_master_factor(&mut self, delta: f32) -> WmResult<()> {

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

            let new_mfact = (monitor.master_factor + delta).max(0.05).min(0.95);

            monitor.master_factor = new_mfact;

            self.apply_layout()?;

        }

        Ok(())

    }

    fn inc_num_master(&mut self, delta: i32) -> WmResult<()> {

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

            let new_nmaster = (monitor.num_master + delta).max(0);

            monitor.num_master = new_nmaster;

            self.apply_layout()?;

        }

        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 client in self.clients.values() {

                    if client.monitor_index == monitor_index {

                        occupied_tags |= client.tags;

                    }

                }

                let draw_blocks = monitor_index == self.selected_monitor;

                bar.invalidate();

                bar.draw(

                    &self.connection,

                    &self.font,

                    self.display,

                    monitor.tagset[monitor.selected_tags_index],

                    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, String)> = self

                    .windows

                    .iter()

                    .filter_map(|&window| {

                        if let Some(client) = self.clients.get(&window) {

                            if client.monitor_index != monitor_index

                                || self.floating_windows.contains(&window)

                                || self.fullscreen_windows.contains(&window)

                            {

                                return None;

                            }

                            if (client.tags & monitor.tagset[monitor.selected_tags_index]) != 0 {

                                return Some((window, client.name.clone()));

                            }

                        }

                        None

                    })

                    .collect();

                let focused_window = monitor.selected_client;

                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.selected_client)

                {

                    self.kill_client(focused)?;

                }

            }

            KeyAction::ToggleFullScreen => {

                self.fullscreen()?;

                self.restack()?;

            }

            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()?;

                            self.restack()?;

                        }

                        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()?;

                        self.restack()?;

                    }

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

                }

            }

            KeyAction::ToggleFloating => {

                self.toggle_floating()?;

                self.restack()?;

            }

            KeyAction::FocusStack => {

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

                    self.focusstack(*direction)?;

                }

            }

            KeyAction::MoveStack => {

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

                    self.move_stack(*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::ToggleView => {

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

                    self.toggleview(*tag_index as usize)?;

                }

            }

            KeyAction::MoveToTag => {

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

                    self.move_to_tag(*tag_index as usize)?;

                }

            }

            KeyAction::ToggleTag => {

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

                    self.toggletag(*tag_index as usize)?;

                }

            }

            KeyAction::ToggleGaps => {

                self.gaps_enabled = !self.gaps_enabled;

                self.apply_layout()?;

                self.restack()?;

            }

            KeyAction::FocusMonitor => {

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

                    self.focus_monitor(*direction)?;

                }

            }

            KeyAction::TagMonitor => {

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

                    self.send_window_to_adjacent_monitor(*direction)?;

                }

            }

            KeyAction::ShowKeybindOverlay => {

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

                self.keybind_overlay.toggle(

                    &self.connection,

                    &self.font,

                    &self.config.keybindings,

                    monitor.screen_width as u16,

                    monitor.screen_height as u16,

                )?;

            }

            KeyAction::SetMasterFactor => {

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

                    self.set_master_factor(*delta as f32 / 100.0)?;

                }

            }

            KeyAction::IncNumMaster => {

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

                    self.inc_num_master(*delta)?;

                }

            }

            KeyAction::None => {}

        }

        Ok(())

    }

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

        if let Some(client) = self.clients.get(&window) {

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

            let selected_tags = monitor.map(|m| m.tagset[m.selected_tags_index]).unwrap_or(0);

            (client.tags & selected_tags) != 0

        } else {

            false

        }

    }

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

        let mut result = Vec::new();

        for monitor in &self.monitors {

            let mut current = monitor.clients_head;

            while let Some(window) = current {

                if let Some(client) = self.clients.get(&window) {

                    let visible_tags = client.tags & monitor.tagset[monitor.selected_tags_index];

                    if visible_tags != 0 {

                        result.push(window);

                    }

                    current = client.next;

                } else {

                    break;

                }

            }

        }

        result

    }

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

        let mut result = Vec::new();

        if let Some(monitor) = self.monitors.get(monitor_index) {

            let mut current = monitor.clients_head;

            while let Some(window) = current {

                if let Some(client) = self.clients.get(&window) {

                    let visible_tags = client.tags & monitor.tagset[monitor.selected_tags_index];

                    if visible_tags != 0 {

                        result.push(window);

                    }

                    current = client.next;

                } else {

                    break;

                }

            }

        }

        result

    }

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

        self.monitors

            .iter()

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

    }

    fn get_monitor_for_rect(&self, x: i32, y: i32, w: i32, h: i32) -> usize {

        let mut best_monitor = self.selected_monitor;

        let mut max_area = 0;

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

            let intersect_width = 0.max((x + w).min(monitor.window_area_x + monitor.window_area_width) - x.max(monitor.window_area_x));

            let intersect_height = 0.max((y + h).min(monitor.window_area_y + monitor.window_area_height) - y.max(monitor.window_area_y));

            let area = intersect_width * intersect_height;

            if area > max_area {

                max_area = area;

                best_monitor = idx;

            }

        }

        best_monitor

    }

    fn move_window_to_monitor(&mut self, window: Window, target_monitor_index: usize) -> WmResult<()> {

        let current_monitor_index = self.clients

            .get(&window)

            .map(|c| c.monitor_index);

        if let Some(current_idx) = current_monitor_index {

            if current_idx == target_monitor_index {

                return Ok(());

            }

        }

        self.unfocus(window)?;

        self.detach(window);

        self.detach_stack(window);

        if let Some(client) = self.clients.get_mut(&window) {

            client.monitor_index = target_monitor_index;

            if let Some(target_monitor) = self.monitors.get(target_monitor_index) {

                client.tags = target_monitor.tagset[target_monitor.selected_tags_index];

            }

        }

        self.attach_aside(window, target_monitor_index);

        self.attach_stack(window, target_monitor_index);

        self.focus(None)?;

        self.apply_layout()?;

        Ok(())

    }

    fn get_adjacent_monitor(&self, direction: i32) -> Option<usize> {

        if self.monitors.len() <= 1 {

            return None;

        }

        if direction > 0 {

            if self.selected_monitor + 1 < self.monitors.len() {

                Some(self.selected_monitor + 1)

            } else {

                Some(0)

            }

        } else {

            if self.selected_monitor == 0 {

                Some(self.monitors.len() - 1)

            } else {

                Some(self.selected_monitor - 1)

            }

        }

    }

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

        let Some(client) = self.clients.get(&window) else {

            return false;

        };

        let Some(monitor) = self.monitors.get(client.monitor_index) else {

            return false;

        };

        (client.tags & monitor.tagset[monitor.selected_tags_index]) != 0

    }

    fn showhide(&mut self, window: Option<Window>) -> WmResult<()> {

        let Some(window) = window else {

            return Ok(());

        };

        let Some(client) = self.clients.get(&window).cloned() else {

            return Ok(());

        };

        let monitor = match self.monitors.get(client.monitor_index) {

            Some(m) => m,

            None => return Ok(()),

        };

        let is_visible = (client.tags & monitor.tagset[monitor.selected_tags_index]) != 0;

        if is_visible {

            self.connection.configure_window(

                window,

                &ConfigureWindowAux::new()

                    .x(client.x_position as i32)

                    .y(client.y_position as i32),

            )?;

            let is_floating = client.is_floating;

            let is_fullscreen = client.is_fullscreen;

            let has_no_layout = self.layout.name() == LayoutType::Normie.as_str();

            if (has_no_layout || is_floating) && !is_fullscreen {

                self.connection.configure_window(

                    window,

                    &ConfigureWindowAux::new()

                        .x(client.x_position as i32)

                        .y(client.y_position as i32)

                        .width(client.width as u32)

                        .height(client.height as u32),

                )?;

            }

            self.showhide(client.stack_next)?;

        } else {

            self.showhide(client.stack_next)?;

            let width = client.width_with_border() as i32;

            self.connection.configure_window(

                window,

                &ConfigureWindowAux::new()

                    .x(width * -2)

                    .y(client.y_position as i32),

            )?;

        }

        Ok(())

    }

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

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

            return Ok(());

        }

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

            Some(m) => m,

            None => return Ok(()),

        };

        let new_tagset = tag_mask(tag_index);

        if new_tagset == monitor.tagset[monitor.selected_tags_index] {

            return Ok(());

        }

        monitor.selected_tags_index ^= 1;

        monitor.tagset[monitor.selected_tags_index] = new_tagset;

        self.save_selected_tags()?;

        self.focus(None)?;

        self.apply_layout()?;  

        self.update_bar()?;

        Ok(())

    }

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

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

            return Ok(());

        }

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

            Some(m) => m,

            None => return Ok(()),

        };

        let mask = tag_mask(tag_index);

        let new_tagset = monitor.tagset[monitor.selected_tags_index] ^ mask;

        if new_tagset == 0 {

            return Ok(());

        }

        monitor.tagset[monitor.selected_tags_index] = new_tagset;

        self.save_selected_tags()?;

        self.focus(None)?;

        self.apply_layout()?;

        self.update_bar()?;

        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.tagset[m.selected_tags_index])

            .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(());

        }

        let focused = match self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.selected_client)

        {

            Some(win) => win,

            None => return Ok(()),

        };

        let mask = tag_mask(tag_index);

        if let Some(client) = self.clients.get_mut(&focused) {

            client.tags = mask;

        }

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

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

        }

        self.focus(None)?;

        self.apply_layout()?;

        self.update_bar()?;

        Ok(())

    }

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

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

            return Ok(());

        }

        let focused = match self

            .monitors

            .get(self.selected_monitor)

            .and_then(|m| m.selected_client)

        {

            Some(win) => win,

            None => return Ok(()),

        };

        let mask = tag_mask(tag_index);

        let current_tags = self.clients.get(&focused).map(|c| c.tags).unwrap_or(0);

        let new_tags = current_tags ^ mask;

        if new_tags == 0 {

            return Ok(());

        }

        if let Some(client) = self.clients.get_mut(&focused) {

            client.tags = new_tags;

        }

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

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

        }

        self.focus(None)?;

        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.selected_client);

        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.focus(Some(next_window))?;

        if is_tabbed {

            self.update_tab_bars()?;

        }

        Ok(())

    }

    fn grab_next_keys(&self, candidates: &[usize], keys_pressed: usize) -> WmResult<()> {

        use std::collections::HashMap;

        use x11rb::protocol::xproto::Keycode;

        let setup = self.connection.setup();

        let min_keycode = setup.min_keycode;

        let max_keycode = setup.max_keycode;

        let keyboard_mapping = self

            .connection

            .get_keyboard_mapping(min_keycode, max_keycode - min_keycode + 1)?

            .reply()?;

        let mut keysym_to_keycode: HashMap<keyboard::keysyms::Keysym, Vec<Keycode>> =

            HashMap::new();

        let keysyms_per_keycode = keyboard_mapping.keysyms_per_keycode;

        for keycode in min_keycode..=max_keycode {

            let index = (keycode - min_keycode) as usize * keysyms_per_keycode as usize;

            for i in 0..keysyms_per_keycode as usize {

                if let Some(&keysym) = keyboard_mapping.keysyms.get(index + i) {

                    if keysym != 0 {

                        keysym_to_keycode

                            .entry(keysym)

                            .or_insert_with(Vec::new)

                            .push(keycode);

                    }

                }

            }

        }

        let mut grabbed_keys: HashSet<(u16, Keycode)> = HashSet::new();

        let ignore_modifiers = [

            0,

            u16::from(ModMask::LOCK),

            u16::from(ModMask::M2),

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

        ];

        for &candidate_index in candidates {

            let binding = &self.config.keybindings[candidate_index];

            if keys_pressed < binding.keys.len() {

                let next_key = &binding.keys[keys_pressed];

                let modifier_mask = keyboard::handlers::modifiers_to_mask(&next_key.modifiers);

                if let Some(keycodes) = keysym_to_keycode.get(&next_key.keysym) {

                    if let Some(&keycode) = keycodes.first() {

                        for &ignore_mask in &ignore_modifiers {

                            let grab_mask = modifier_mask | ignore_mask;

                            let key_tuple = (grab_mask, keycode);

                            if grabbed_keys.insert(key_tuple) {

                                self.connection.grab_key(

                                    false,

                                    self.root,

                                    grab_mask.into(),

                                    keycode,

                                    GrabMode::ASYNC,

                                    GrabMode::ASYNC,

                                )?;

                            }

                        }

                    }

                }

            }

        }

        if let Some(keycodes) = keysym_to_keycode.get(&keyboard::keysyms::XK_ESCAPE) {

            if let Some(&keycode) = keycodes.first() {

                for &ignore_mask in &ignore_modifiers {

                    self.connection.grab_key(

                        false,

                        self.root,

                        ModMask::from(ignore_mask),