const std = @import("std");
const xlib = @import("x11/xlib.zig");
const config_mod = @import("config/config.zig");

const padding: i32 = 32;
const line_spacing: i32 = 12;
const key_action_spacing: i32 = 32;
const border_width: i32 = 4;
const border_color: c_ulong = 0x7fccff;
const bg_color: c_ulong = 0x1a1a1a;
const fg_color: c_ulong = 0xffffff;
const key_bg_color: c_ulong = 0x2a2a2a;

const max_lines: usize = 12;

pub const Keybind_Overlay = struct {
    window: xlib.Window = 0,
    pixmap: xlib.Pixmap = 0,
    gc: xlib.GC = null,
    xft_draw: ?*xlib.XftDraw = null,
    font: ?*xlib.XftFont = null,
    font_height: i32 = 0,
    width: i32 = 0,
    height: i32 = 0,
    visible: bool = false,
    display: ?*xlib.Display = null,
    root: xlib.Window = 0,
    screen: c_int = 0,

    key_bufs: [max_lines][64]u8 = undefined,
    key_lens: [max_lines]usize = undefined,
    descs: [max_lines][]const u8 = undefined,
    line_count: usize = 0,

    pub fn init(display: *xlib.Display, screen: c_int, root: xlib.Window, font_name: []const u8, allocator: std.mem.Allocator) ?*Keybind_Overlay {
        const overlay = allocator.create(Keybind_Overlay) catch return null;

        const font_name_z = allocator.dupeZ(u8, font_name) catch {
            allocator.destroy(overlay);
            return null;
        };
        defer allocator.free(font_name_z);

        const font = xlib.XftFontOpenName(display, screen, font_name_z);
        if (font == null) {
            allocator.destroy(overlay);
            return null;
        }

        const font_height = font.*.ascent + font.*.descent;

        overlay.* = .{
            .display = display,
            .root = root,
            .font = font,
            .font_height = font_height,
            .screen = screen,
        };

        return overlay;
    }

    pub fn deinit(self: *Keybind_Overlay, allocator: std.mem.Allocator) void {
        if (self.display) |display| {
            self.destroy_window(display);
            if (self.font) |font| {
                xlib.XftFontClose(display, font);
            }
        }
        allocator.destroy(self);
    }

    fn destroy_window(self: *Keybind_Overlay, display: *xlib.Display) void {
        if (self.xft_draw) |xft_draw| {
            xlib.XftDrawDestroy(xft_draw);
            self.xft_draw = null;
        }
        if (self.gc) |gc| {
            _ = xlib.XFreeGC(display, gc);
            self.gc = null;
        }
        if (self.pixmap != 0) {
            _ = xlib.XFreePixmap(display, self.pixmap);
            self.pixmap = 0;
        }
        if (self.window != 0) {
            _ = xlib.c.XDestroyWindow(display, self.window);
            self.window = 0;
        }
    }

    pub fn toggle(self: *Keybind_Overlay, mon_x: i32, mon_y: i32, mon_w: i32, mon_h: i32) void {
        if (self.visible) {
            self.hide();
        } else {
            self.show(mon_x, mon_y, mon_w, mon_h);
        }
    }

    pub fn show(self: *Keybind_Overlay, mon_x: i32, mon_y: i32, mon_w: i32, mon_h: i32) void {
        const display = self.display orelse return;
        const cfg = config_mod.get_config() orelse return;

        self.collect_keybinds(cfg);
        if (self.line_count == 0) return;

        var max_key_width: i32 = 0;
        var max_desc_width: i32 = 0;

        for (0..self.line_count) |i| {
            const key_slice = self.key_bufs[i][0..self.key_lens[i]];
            const key_w = self.text_width(display, key_slice);
            const desc_w = self.text_width(display, self.descs[i]);
            if (key_w > max_key_width) max_key_width = key_w;
            if (desc_w > max_desc_width) max_desc_width = desc_w;
        }

        const title = "Keybindings";
        const title_width = self.text_width(display, title);

        const content_width = max_key_width + key_action_spacing + max_desc_width;
        const min_width = @max(title_width, content_width);

        self.width = min_width + padding * 2;
        const line_height = self.font_height + line_spacing;
        const title_height = self.font_height + 20;
        self.height = title_height + @as(i32, @intCast(self.line_count)) * line_height + padding * 2;

        self.destroy_window(display);

        const x: i32 = mon_x + @divTrunc(mon_w - self.width, 2);
        const y: i32 = mon_y + @divTrunc(mon_h - self.height, 2);

        const visual = xlib.XDefaultVisual(display, self.screen);
        const colormap = xlib.XDefaultColormap(display, self.screen);
        const depth = xlib.XDefaultDepth(display, self.screen);

        self.window = xlib.c.XCreateSimpleWindow(
            display,
            self.root,
            x,
            y,
            @intCast(self.width),
            @intCast(self.height),
            @intCast(border_width),
            border_color,
            bg_color,
        );

        var attrs: xlib.c.XSetWindowAttributes = undefined;
        attrs.override_redirect = xlib.True;
        attrs.event_mask = xlib.c.ExposureMask | xlib.c.KeyPressMask | xlib.c.ButtonPressMask;
        _ = xlib.c.XChangeWindowAttributes(display, self.window, xlib.c.CWOverrideRedirect | xlib.c.CWEventMask, &attrs);

        self.pixmap = xlib.XCreatePixmap(display, self.window, @intCast(self.width), @intCast(self.height), @intCast(depth));
        self.gc = xlib.XCreateGC(display, self.pixmap, 0, null);
        self.xft_draw = xlib.XftDrawCreate(display, self.pixmap, visual, colormap);

        _ = xlib.XMapWindow(display, self.window);
        _ = xlib.XRaiseWindow(display, self.window);

        self.draw(display, max_key_width, title);

        _ = xlib.XGrabKeyboard(display, self.window, xlib.True, xlib.GrabModeAsync, xlib.GrabModeAsync, xlib.CurrentTime);

        _ = xlib.XSync(display, xlib.False);

        self.visible = true;
    }

    pub fn hide(self: *Keybind_Overlay) void {
        if (!self.visible) return;
        if (self.display) |display| {
            _ = xlib.XUngrabKeyboard(display, xlib.CurrentTime);
            if (self.window != 0) {
                _ = xlib.c.XUnmapWindow(display, self.window);
            }
        }
        self.visible = false;
    }

    pub fn handle_key(self: *Keybind_Overlay, keysym: u64) bool {
        if (!self.visible) return false;
        if (keysym == 0xff1b or keysym == 'q' or keysym == 'Q') {
            self.hide();
            return true;
        }
        return false;
    }

    pub fn is_overlay_window(self: *Keybind_Overlay, win: xlib.Window) bool {
        return self.visible and self.window != 0 and self.window == win;
    }

    fn draw(self: *Keybind_Overlay, display: *xlib.Display, max_key_width: i32, title: []const u8) void {
        self.fill_rect(display, 0, 0, self.width, self.height, bg_color);

        const title_x = @divTrunc(self.width - self.text_width(display, title), 2);
        const title_y = padding + self.font.?.*.ascent;
        self.draw_text(display, title_x, title_y, title, fg_color);

        const line_height = self.font_height + line_spacing;
        var y = padding + self.font_height + 20 + self.font.?.*.ascent;

        for (0..self.line_count) |i| {
            const key_slice = self.key_bufs[i][0..self.key_lens[i]];
            const key_w = self.text_width(display, key_slice);
            self.fill_rect(display, padding - 4, y - self.font.?.*.ascent - 2, key_w + 8, self.font_height + 4, key_bg_color);
            self.draw_text(display, padding, y, key_slice, fg_color);

            const desc_x = padding + max_key_width + key_action_spacing;
            self.draw_text(display, desc_x, y, self.descs[i], fg_color);

            y += line_height;
        }

        _ = xlib.c.XCopyArea(display, self.pixmap, self.window, self.gc, 0, 0, @intCast(self.width), @intCast(self.height), 0, 0);
        _ = xlib.c.XFlush(display);
    }

    fn fill_rect(self: *Keybind_Overlay, display: *xlib.Display, x: i32, y: i32, w: i32, h: i32, color: c_ulong) void {
        _ = xlib.XSetForeground(display, self.gc, color);
        _ = xlib.XFillRectangle(display, self.pixmap, self.gc, x, y, @intCast(w), @intCast(h));
    }

    fn draw_text(self: *Keybind_Overlay, display: *xlib.Display, x: i32, y: i32, text: []const u8, color: c_ulong) void {
        if (self.xft_draw == null or self.font == null) return;
        if (text.len == 0) return;

        var xft_color: xlib.XftColor = undefined;
        var render_color: xlib.XRenderColor = undefined;
        render_color.red = @intCast((color >> 16 & 0xff) * 257);
        render_color.green = @intCast((color >> 8 & 0xff) * 257);
        render_color.blue = @intCast((color & 0xff) * 257);
        render_color.alpha = 0xffff;

        const visual = xlib.XDefaultVisual(display, self.screen);
        const colormap = xlib.XDefaultColormap(display, self.screen);

        _ = xlib.XftColorAllocValue(display, visual, colormap, &render_color, &xft_color);
        xlib.XftDrawStringUtf8(self.xft_draw, &xft_color, self.font, x, y, text.ptr, @intCast(text.len));
        xlib.XftColorFree(display, visual, colormap, &xft_color);
    }

    fn text_width(self: *Keybind_Overlay, display: *xlib.Display, text: []const u8) i32 {
        if (self.font == null or text.len == 0) return 0;
        var extents: xlib.XGlyphInfo = undefined;
        xlib.XftTextExtentsUtf8(display, self.font, text.ptr, @intCast(text.len), &extents);
        return extents.xOff;
    }

    fn collect_keybinds(self: *Keybind_Overlay, cfg: *config_mod.Config) void {
        const priority_actions = [_]config_mod.Action{
            .show_keybinds,
            .quit,
            .reload_config,
            .kill_client,
            .spawn_terminal,
            .toggle_fullscreen,
            .toggle_floating,
            .cycle_layout,
            .focus_next,
            .focus_prev,
            .view_tag,
            .move_to_tag,
        };

        self.line_count = 0;

        for (priority_actions) |action| {
            if (self.line_count >= max_lines) break;

            for (cfg.keybinds.items) |kb| {
                if (kb.action == action and kb.key_count > 0) {
                    self.format_key_to_buf(self.line_count, &kb.keys[0]);
                    self.descs[self.line_count] = action_desc(action);
                    self.line_count += 1;
                    break;
                }
            }
        }
    }

    fn format_key_to_buf(self: *Keybind_Overlay, idx: usize, key: *const config_mod.Key_Press) void {
        var len: usize = 0;
        var buf = &self.key_bufs[idx];

        if (key.mod_mask & (1 << 6) != 0) {
            const s = "Mod + ";
            @memcpy(buf[len .. len + s.len], s);
            len += s.len;
        }
        if (key.mod_mask & (1 << 0) != 0) {
            const s = "Shift + ";
            @memcpy(buf[len .. len + s.len], s);
            len += s.len;
        }
        if (key.mod_mask & (1 << 2) != 0) {
            const s = "Ctrl + ";
            @memcpy(buf[len .. len + s.len], s);
            len += s.len;
        }

        const key_name = keysym_to_name(key.keysym);
        if (len + key_name.len < buf.len) {
            @memcpy(buf[len .. len + key_name.len], key_name);
            len += key_name.len;
        }

        self.key_lens[idx] = len;
    }

    fn keysym_to_name(keysym: u64) []const u8 {
        const upper_letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        const digits = "0123456789";

        return switch (keysym) {
            0xff0d => "Return",
            0x0020 => "Space",
            0xff1b => "Escape",
            0xff08 => "BackSpace",
            0xff09 => "Tab",
            0xffbe => "F1",
            0xffbf => "F2",
            0xffc0 => "F3",
            0xffc1 => "F4",
            0xffc2 => "F5",
            0xffc3 => "F6",
            0xffc4 => "F7",
            0xffc5 => "F8",
            0xffc6 => "F9",
            0xffc7 => "F10",
            0xffc8 => "F11",
            0xffc9 => "F12",
            0xff51 => "Left",
            0xff52 => "Up",
            0xff53 => "Right",
            0xff54 => "Down",
            0x002c => ",",
            0x002e => ".",
            0x002f => "/",
            'a'...'z' => |c| upper_letters[c - 'a' ..][0..1],
            'A'...'Z' => |c| upper_letters[c - 'A' ..][0..1],
            '0'...'9' => |c| digits[c - '0' ..][0..1],
            else => "?",
        };
    }

    fn action_desc(action: config_mod.Action) []const u8 {
        return switch (action) {
            .show_keybinds => "Show Keybinds",
            .quit => "Quit WM",
            .reload_config => "Reload Config",
            .restart => "Restart WM",
            .kill_client => "Close Window",
            .spawn_terminal => "Open Terminal",
            .spawn => "Launch Program",
            .toggle_fullscreen => "Toggle Fullscreen",
            .toggle_floating => "Toggle Floating",
            .toggle_gaps => "Toggle Gaps",
            .cycle_layout => "Cycle Layout",
            .set_layout => "Set Layout",
            .focus_next => "Focus Next",
            .focus_prev => "Focus Previous",
            .move_next => "Move Next",
            .move_prev => "Move Previous",
            .view_tag => "View Tag",
            .move_to_tag => "Move to Tag",
            .focus_monitor => "Focus Monitor",
            .send_to_monitor => "Send to Monitor",
            else => "Action",
        };
    }
};