oxwm

use super::{Overlay, OverlayBase};

use crate::bar::font::Font;

use crate::errors::X11Error;

use crate::keyboard::KeyAction;

use crate::keyboard::handlers::{KeyBinding, KeyPress};

use std::time::Instant;

use x11rb::connection::Connection;

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

use x11rb::rust_connection::RustConnection;

const PADDING: i16 = 24;

const KEY_ACTION_SPACING: i16 = 20;

const LINE_SPACING: i16 = 8;

const BORDER_WIDTH: u16 = 4;

const BORDER_COLOR: u32 = 0x7fccff;

const TITLE_BOTTOM_MARGIN: i16 = 20;

const INPUT_SUPPRESS_MS: u128 = 200;

pub struct KeybindOverlay {

    base: OverlayBase,

    keybindings: Vec<(String, String)>,

    key_bg_color: u32,

    modkey: KeyButMask,

    last_shown_at: Option<Instant>,

    max_key_width: u16,

}

impl KeybindOverlay {

    pub fn new(

        connection: &RustConnection,

        screen: &Screen,

        screen_num: usize,

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

        modkey: KeyButMask,

    ) -> Result<Self, X11Error> {

        let base = OverlayBase::new(

            connection,

            screen,

            screen_num,

            display,

            800,

            600,

            BORDER_WIDTH,

            BORDER_COLOR,

            0x1a1a1a,

            0xffffff,

        )?;

        Ok(KeybindOverlay {

            base,

            keybindings: Vec::new(),

            key_bg_color: 0x2a2a2a,

            modkey,

            last_shown_at: None,

            max_key_width: 0,

        })

    }

    pub fn show(

        &mut self,

        connection: &RustConnection,

        font: &Font,

        keybindings: &[KeyBinding],

        screen_width: u16,

        screen_height: u16,

    ) -> Result<(), X11Error> {

        self.keybindings = self.collect_keybindings(keybindings);

        let title = "Important Keybindings";

        let title_width = font.text_width(title);

        let mut max_key_width = 0u16;

        let mut max_action_width = 0u16;

        for (key, action) in &self.keybindings {

            let key_width = font.text_width(key);

            let action_width = font.text_width(action);

            if key_width > max_key_width {

                max_key_width = key_width;

            }

            if action_width > max_action_width {

                max_action_width = action_width;

            }

        }

        let content_width = max_key_width + KEY_ACTION_SPACING as u16 + max_action_width;

        let min_width = title_width.max(content_width);

        let width = min_width + (PADDING as u16 * 2);

        let line_height = font.height() + LINE_SPACING as u16;

        let title_height = font.height() + TITLE_BOTTOM_MARGIN as u16;

        let height =

            title_height + (self.keybindings.len() as u16 * line_height) + (PADDING as u16 * 2);

        let x = ((screen_width - width) / 2) as i16;

        let y = ((screen_height - height) / 2) as i16;

        self.base.configure(connection, x, y, width, height)?;

        self.last_shown_at = Some(Instant::now());

        self.max_key_width = max_key_width;

        self.base.show(connection)?;

        self.draw(connection, font)?;

        Ok(())

    }

    pub fn toggle(

        &mut self,

        connection: &RustConnection,

        font: &Font,

        keybindings: &[KeyBinding],

        screen_width: u16,

        screen_height: u16,

    ) -> Result<(), X11Error> {

        if self.base.is_visible {

            self.hide(connection)?;

        } else {

            self.show(connection, font, keybindings, screen_width, screen_height)?;

        }

        Ok(())

    }

    pub fn should_suppress_input(&self) -> bool {

        if let Some(shown_at) = self.last_shown_at {

            shown_at.elapsed().as_millis() < INPUT_SUPPRESS_MS

        } else {

            false

        }

    }

    fn collect_keybindings(&self, keybindings: &[KeyBinding]) -> Vec<(String, String)> {

        let mut result = Vec::new();

        let priority_actions = [

            KeyAction::ShowKeybindOverlay,

            KeyAction::Quit,

            KeyAction::Restart,

            KeyAction::KillClient,

            KeyAction::Spawn,

            KeyAction::SpawnTerminal,

            KeyAction::ToggleFullScreen,

            KeyAction::ToggleFloating,

            KeyAction::CycleLayout,

            KeyAction::FocusStack,

            KeyAction::ViewTag,

        ];

        for &action in &priority_actions {

            let binding = keybindings

                .iter()

                .filter(|kb| kb.func == action)

                .min_by_key(|kb| kb.keys.len());

            if let Some(binding) = binding {

                if !binding.keys.is_empty() {

                    let key_str = self.format_key_combo(&binding.keys[0]);

                    let action_str = self.action_description(binding);

                    result.push((key_str, action_str));

                }

            }

        }

        result

    }

    fn format_key_combo(&self, key: &KeyPress) -> String {

        let mut parts = Vec::new();

        for modifier in &key.modifiers {

            let mod_str = match *modifier {

                m if m == self.modkey => "Mod",

                KeyButMask::SHIFT => "Shift",

                KeyButMask::CONTROL => "Ctrl",

                KeyButMask::MOD1 => "Alt",

                KeyButMask::MOD4 => "Super",

                _ => continue,

            };

            parts.push(mod_str.to_string());

        }

        parts.push(crate::keyboard::keysyms::format_keysym(key.keysym));

        parts.join(" + ")

    }

    fn action_description(&self, binding: &KeyBinding) -> String {

        use crate::keyboard::Arg;

        match binding.func {

            KeyAction::ShowKeybindOverlay => "Show This Keybind Help".to_string(),

            KeyAction::Quit => "Quit Window Manager".to_string(),

            KeyAction::Restart => "Restart Window Manager".to_string(),

            KeyAction::Recompile => "Recompile Window Manager".to_string(),

            KeyAction::KillClient => "Close Focused Window".to_string(),

            KeyAction::Spawn => match &binding.arg {

                Arg::Str(cmd) => format!("Launch: {}", cmd),

                Arg::Array(arr) if !arr.is_empty() => format!("Launch: {}", arr[0]),

                _ => "Launch Program".to_string(),

            },

            KeyAction::SpawnTerminal => "Launch Terminal".to_string(),

            KeyAction::FocusStack => "Focus Next/Previous Window".to_string(),

            KeyAction::FocusDirection => "Focus Window in Direction".to_string(),

            KeyAction::SwapDirection => "Swap Window in Direction".to_string(),

            KeyAction::ViewTag => match &binding.arg {

                Arg::Int(n) => format!("View Workspace {}", n),

                _ => "View Workspace".to_string(),

            },

            KeyAction::MoveToTag => "Move Window to Workspace".to_string(),

            KeyAction::ToggleGaps => "Toggle Window Gaps".to_string(),

            KeyAction::ToggleFullScreen => "Toggle Fullscreen Mode".to_string(),

            KeyAction::ToggleFloating => "Toggle Floating Mode".to_string(),

            KeyAction::ChangeLayout => "Change Layout".to_string(),

            KeyAction::CycleLayout => "Cycle Through Layouts".to_string(),

            KeyAction::FocusMonitor => "Focus Next Monitor".to_string(),

            KeyAction::SmartMoveWin => "Smart Move Window".to_string(),

            KeyAction::ExchangeClient => "Exchange Client Windows".to_string(),

            KeyAction::None => "No Action".to_string(),

        }

    }

}

impl Overlay for KeybindOverlay {

    fn window(&self) -> Window {

        self.base.window

    }

    fn is_visible(&self) -> bool {

        self.base.is_visible

    }

    fn hide(&mut self, connection: &RustConnection) -> Result<(), X11Error> {

        self.base.hide(connection)?;

        self.last_shown_at = None;

        self.keybindings.clear();

        Ok(())

    }

    fn draw(&self, connection: &RustConnection, font: &Font) -> Result<(), X11Error> {

        if !self.base.is_visible {

            return Ok(());

        }

        self.base.draw_background(connection)?;

        let title = "Important Keybindings";

        let title_width = font.text_width(title);

        let title_x = ((self.base.width - title_width) / 2) as i16;

        let title_y = PADDING + font.ascent();

        self.base

            .font_draw

            .draw_text(font, self.base.foreground_color, title_x, title_y, title);

        let line_height = font.height() + LINE_SPACING as u16;

        let mut y = PADDING + font.height() as i16 + TITLE_BOTTOM_MARGIN + font.ascent();

        for (key, action) in &self.keybindings {

            let key_width = font.text_width(key);

            let key_x = PADDING;

            connection.change_gc(

                self.base.graphics_context,

                &ChangeGCAux::new().foreground(self.key_bg_color),

            )?;

            connection.poly_fill_rectangle(

                self.base.window,

                self.base.graphics_context,

                &[Rectangle {

                    x: key_x - 4,

                    y: y - font.ascent() - 2,

                    width: key_width + 8,

                    height: font.height() + 4,

                }],

            )?;

            self.base

                .font_draw

                .draw_text(font, self.base.foreground_color, key_x, y, key);

            let action_x = PADDING + self.max_key_width as i16 + KEY_ACTION_SPACING;

            self.base

                .font_draw

                .draw_text(font, self.base.foreground_color, action_x, y, action);

            y += line_height as i16;

        }

        self.base.font_draw.flush();

        connection.flush()?;

        Ok(())

    }

}