oxwm

const std = @import("std");

pub const config_mod = @import("config.zig");

const Config = config_mod.Config;

const Keybind = config_mod.Keybind;

const Action = config_mod.Action;

const Rule = config_mod.Rule;

const Block = config_mod.Block;

const Block_Type = config_mod.Block_Type;

const Mouse_Button = config_mod.Mouse_Button;

const Click_Target = config_mod.Click_Target;

const Mouse_Action = config_mod.Mouse_Action;

const Color_Scheme = config_mod.Color_Scheme;

const c = @cImport({

    @cInclude("lua.h");

    @cInclude("lauxlib.h");

    @cInclude("lualib.h");

});

var L: ?*c.lua_State = null;

var config: ?*Config = null;

pub fn init(cfg: *Config) bool {

    config = cfg;

    L = c.luaL_newstate();

    if (L == null) return false;

    c.luaL_openlibs(L);

    register_api();

    return true;

}

pub fn deinit() void {

    if (L) |state| {

        c.lua_close(state);

    }

    L = null;

    config = null;

}

pub fn load_file(path: []const u8) bool {

    const state = L orelse return false;

    var path_buf: [512]u8 = undefined;

    if (path.len >= path_buf.len) return false;

    @memcpy(path_buf[0..path.len], path);

    path_buf[path.len] = 0;

    if (std.mem.lastIndexOfScalar(u8, path, '/')) |last_slash| {

        const dir = path[0..last_slash];

        var setup_buf: [600]u8 = undefined;

        const setup_code = std.fmt.bufPrint(&setup_buf, "package.path = '{s}/?.lua;' .. package.path\x00", .{dir}) catch return false;

        if (c.luaL_loadstring(state, setup_code.ptr) != 0 or c.lua_pcallk(state, 0, 0, 0, 0, null) != 0) {

            c.lua_settop(state, -2);

            return false;

        }

    }

    if (c.luaL_loadfilex(state, &path_buf, null) != 0) {

        const err = c.lua_tolstring(state, -1, null);

        if (err != null) {

            std.debug.print("lua load error: {s}\n", .{std.mem.span(err)});

        }

        c.lua_settop(state, -2);

        return false;

    }

    if (c.lua_pcallk(state, 0, 0, 0, 0, null) != 0) {

        const err = c.lua_tolstring(state, -1, null);

        if (err != null) {

            std.debug.print("lua runtime error: {s}\n", .{std.mem.span(err)});

        }

        c.lua_settop(state, -2);

        return false;

    }

    return true;

}

pub fn load_config() bool {

    const home = std.posix.getenv("HOME") orelse return false;

    var path_buf: [512]u8 = undefined;

    const path = std.fmt.bufPrint(&path_buf, "{s}/.config/oxwm/config.lua", .{home}) catch return false;

    return load_file(path);

}

fn register_api() void {

    const state = L orelse return;

    c.lua_createtable(state, 0, 16);

    register_spawn_functions(state);

    register_key_module(state);

    register_gaps_module(state);

    register_border_module(state);

    register_client_module(state);

    register_layout_module(state);

    register_tag_module(state);

    register_monitor_module(state);

    register_rule_module(state);

    register_bar_module(state);

    register_misc_functions(state);

    c.lua_setglobal(state, "oxwm");

}

fn register_spawn_functions(state: *c.lua_State) void {

    c.lua_pushcfunction(state, lua_spawn);

    c.lua_setfield(state, -2, "spawn");

    c.lua_pushcfunction(state, lua_spawn_terminal);

    c.lua_setfield(state, -2, "spawn_terminal");

}

fn register_key_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 2);

    c.lua_pushcfunction(state, lua_key_bind);

    c.lua_setfield(state, -2, "bind");

    c.lua_pushcfunction(state, lua_key_chord);

    c.lua_setfield(state, -2, "chord");

    c.lua_setfield(state, -2, "key");

}

fn register_gaps_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 6);

    c.lua_pushcfunction(state, lua_gaps_set_enabled);

    c.lua_setfield(state, -2, "set_enabled");

    c.lua_pushcfunction(state, lua_gaps_enable);

    c.lua_setfield(state, -2, "enable");

    c.lua_pushcfunction(state, lua_gaps_disable);

    c.lua_setfield(state, -2, "disable");

    c.lua_pushcfunction(state, lua_gaps_set_inner);

    c.lua_setfield(state, -2, "set_inner");

    c.lua_pushcfunction(state, lua_gaps_set_outer);

    c.lua_setfield(state, -2, "set_outer");

    c.lua_pushcfunction(state, lua_gaps_set_smart);

    c.lua_setfield(state, -2, "set_smart");

    c.lua_setfield(state, -2, "gaps");

}

fn register_border_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 3);

    c.lua_pushcfunction(state, lua_border_set_width);

    c.lua_setfield(state, -2, "set_width");

    c.lua_pushcfunction(state, lua_border_set_focused_color);

    c.lua_setfield(state, -2, "set_focused_color");

    c.lua_pushcfunction(state, lua_border_set_unfocused_color);

    c.lua_setfield(state, -2, "set_unfocused_color");

    c.lua_setfield(state, -2, "border");

}

fn register_client_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 5);

    c.lua_pushcfunction(state, lua_client_kill);

    c.lua_setfield(state, -2, "kill");

    c.lua_pushcfunction(state, lua_client_toggle_fullscreen);

    c.lua_setfield(state, -2, "toggle_fullscreen");

    c.lua_pushcfunction(state, lua_client_toggle_floating);

    c.lua_setfield(state, -2, "toggle_floating");

    c.lua_pushcfunction(state, lua_client_focus_stack);

    c.lua_setfield(state, -2, "focus_stack");

    c.lua_pushcfunction(state, lua_client_move_stack);

    c.lua_setfield(state, -2, "move_stack");

    c.lua_setfield(state, -2, "client");

}

fn register_layout_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 4);

    c.lua_pushcfunction(state, lua_layout_cycle);

    c.lua_setfield(state, -2, "cycle");

    c.lua_pushcfunction(state, lua_layout_set);

    c.lua_setfield(state, -2, "set");

    c.lua_pushcfunction(state, lua_layout_scroll_left);

    c.lua_setfield(state, -2, "scroll_left");

    c.lua_pushcfunction(state, lua_layout_scroll_right);

    c.lua_setfield(state, -2, "scroll_right");

    c.lua_setfield(state, -2, "layout");

}

fn register_tag_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 10);

    c.lua_pushcfunction(state, lua_tag_view);

    c.lua_setfield(state, -2, "view");

    c.lua_pushcfunction(state, lua_tag_view_next);

    c.lua_setfield(state, -2, "view_next");

    c.lua_pushcfunction(state, lua_tag_view_previous);

    c.lua_setfield(state, -2, "view_previous");

    c.lua_pushcfunction(state, lua_tag_view_next_nonempty);

    c.lua_setfield(state, -2, "view_next_nonempty");

    c.lua_pushcfunction(state, lua_tag_view_previous_nonempty);

    c.lua_setfield(state, -2, "view_previous_nonempty");

    c.lua_pushcfunction(state, lua_tag_toggleview);

    c.lua_setfield(state, -2, "toggleview");

    c.lua_pushcfunction(state, lua_tag_move_to);

    c.lua_setfield(state, -2, "move_to");

    c.lua_pushcfunction(state, lua_tag_toggletag);

    c.lua_setfield(state, -2, "toggletag");

    c.lua_pushcfunction(state, lua_tag_set_back_and_forth);

    c.lua_setfield(state, -2, "set_back_and_forth");

    c.lua_setfield(state, -2, "tag");

}

fn register_monitor_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 2);

    c.lua_pushcfunction(state, lua_monitor_focus);

    c.lua_setfield(state, -2, "focus");

    c.lua_pushcfunction(state, lua_monitor_tag);

    c.lua_setfield(state, -2, "tag");

    c.lua_setfield(state, -2, "monitor");

}

fn register_rule_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 1);

    c.lua_pushcfunction(state, lua_rule_add);

    c.lua_setfield(state, -2, "add");

    c.lua_setfield(state, -2, "rule");

}

fn register_bar_module(state: *c.lua_State) void {

    c.lua_createtable(state, 0, 10);

    c.lua_pushcfunction(state, lua_bar_set_font);

    c.lua_setfield(state, -2, "set_font");

    c.lua_pushcfunction(state, lua_bar_set_blocks);

    c.lua_setfield(state, -2, "set_blocks");

    c.lua_pushcfunction(state, lua_bar_set_scheme_normal);

    c.lua_setfield(state, -2, "set_scheme_normal");

    c.lua_pushcfunction(state, lua_bar_set_scheme_selected);

    c.lua_setfield(state, -2, "set_scheme_selected");

    c.lua_pushcfunction(state, lua_bar_set_scheme_occupied);

    c.lua_setfield(state, -2, "set_scheme_occupied");

    c.lua_pushcfunction(state, lua_bar_set_scheme_urgent);

    c.lua_setfield(state, -2, "set_scheme_urgent");

    c.lua_pushcfunction(state, lua_bar_set_hide_vacant_tags);

    c.lua_setfield(state, -2, "set_hide_vacant_tags");

    c.lua_createtable(state, 0, 6);

    c.lua_pushcfunction(state, lua_bar_block_ram);

    c.lua_setfield(state, -2, "ram");

    c.lua_pushcfunction(state, lua_bar_block_datetime);

    c.lua_setfield(state, -2, "datetime");

    c.lua_pushcfunction(state, lua_bar_block_shell);

    c.lua_setfield(state, -2, "shell");

    c.lua_pushcfunction(state, lua_bar_block_static);

    c.lua_setfield(state, -2, "static");

    c.lua_pushcfunction(state, lua_bar_block_battery);

    c.lua_setfield(state, -2, "battery");

    c.lua_setfield(state, -2, "block");

    c.lua_setfield(state, -2, "bar");

}

fn register_misc_functions(state: *c.lua_State) void {

    c.lua_pushcfunction(state, lua_set_terminal);

    c.lua_setfield(state, -2, "set_terminal");

    c.lua_pushcfunction(state, lua_set_modkey);

    c.lua_setfield(state, -2, "set_modkey");

    c.lua_pushcfunction(state, lua_set_tags);

    c.lua_setfield(state, -2, "set_tags");

    c.lua_pushcfunction(state, lua_set_layout_symbol);

    c.lua_setfield(state, -2, "set_layout_symbol");

    c.lua_pushcfunction(state, lua_autostart);

    c.lua_setfield(state, -2, "autostart");

    c.lua_pushcfunction(state, lua_auto_tile);

    c.lua_setfield(state, -2, "auto_tile");

    c.lua_pushcfunction(state, lua_quit);

    c.lua_setfield(state, -2, "quit");

    c.lua_pushcfunction(state, lua_restart);

    c.lua_setfield(state, -2, "restart");

    c.lua_pushcfunction(state, lua_toggle_gaps);

    c.lua_setfield(state, -2, "toggle_gaps");

    c.lua_pushcfunction(state, lua_show_keybinds);

    c.lua_setfield(state, -2, "show_keybinds");

    c.lua_pushcfunction(state, lua_set_master_factor);

    c.lua_setfield(state, -2, "set_master_factor");

    c.lua_pushcfunction(state, lua_inc_num_master);

    c.lua_setfield(state, -2, "inc_num_master");

}

fn create_action_table(state: *c.lua_State, action_name: [*:0]const u8) void {

    c.lua_createtable(state, 0, 2);

    _ = c.lua_pushstring(state, action_name);

    c.lua_setfield(state, -2, "__action");

}

fn create_action_table_with_int(state: *c.lua_State, action_name: [*:0]const u8, arg: i32) void {

    c.lua_createtable(state, 0, 2);

    _ = c.lua_pushstring(state, action_name);

    c.lua_setfield(state, -2, "__action");

    c.lua_pushinteger(state, arg);

    c.lua_setfield(state, -2, "__arg");

}

fn create_action_table_with_string(state: *c.lua_State, action_name: [*:0]const u8) void {

    c.lua_createtable(state, 0, 2);

    _ = c.lua_pushstring(state, action_name);

    c.lua_setfield(state, -2, "__action");

    c.lua_pushvalue(state, 1);

    c.lua_setfield(state, -2, "__arg");

}

fn lua_spawn(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table_with_string(s, "Spawn");

    return 1;

}

fn lua_spawn_terminal(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "SpawnTerminal");

    return 1;

}

fn lua_key_bind(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const cfg = config orelse return 0;

    const mod_mask = parse_modifiers(s, 1);

    const key_str = get_string_arg(s, 2) orelse return 0;

    const keysym = key_name_to_keysym(key_str) orelse return 0;

    if (c.lua_type(s, 3) != c.LUA_TTABLE) return 0;

    _ = c.lua_getfield(s, 3, "__action");

    const action_str = get_lua_string(s, -1) orelse {

        c.lua_settop(s, -2);

        return 0;

    };

    c.lua_settop(s, -2);

    const action = parse_action(action_str) orelse return 0;

    var int_arg: i32 = 0;

    var str_arg: ?[]const u8 = null;

    _ = c.lua_getfield(s, 3, "__arg");

    if (c.lua_type(s, -1) == c.LUA_TNUMBER) {

        int_arg = @intCast(c.lua_tointegerx(s, -1, null));

    } else if (c.lua_type(s, -1) == c.LUA_TSTRING) {

        str_arg = get_lua_string(s, -1);

    } else if (c.lua_type(s, -1) == c.LUA_TTABLE) {

        str_arg = extract_spawn_command(s, -1);

    }

    c.lua_settop(s, -2);

    var keybind: config_mod.Keybind = .{

        .action = action,

        .int_arg = int_arg,

        .str_arg = str_arg,

    };

    keybind.keys[0] = .{ .mod_mask = mod_mask, .keysym = keysym };

    keybind.key_count = 1;

    cfg.add_keybind(keybind) catch return 0;

    return 0;

}

fn lua_key_chord(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const cfg = config orelse return 0;

    if (c.lua_type(s, 1) != c.LUA_TTABLE) return 0;

    if (c.lua_type(s, 2) != c.LUA_TTABLE) return 0;

    var keybind: config_mod.Keybind = .{

        .action = .quit,

        .int_arg = 0,

        .str_arg = null,

    };

    keybind.key_count = 0;

    const num_keys = c.lua_rawlen(s, 1);

    if (num_keys == 0 or num_keys > 4) return 0;

    var i: usize = 1;

    while (i <= num_keys) : (i += 1) {

        _ = c.lua_rawgeti(s, 1, @intCast(i));

        if (c.lua_type(s, -1) != c.LUA_TTABLE) {

            c.lua_settop(s, -2);

            return 0;

        }

        _ = c.lua_rawgeti(s, -1, 1);

        const mod_mask = parse_modifiers_at_top(s);

        c.lua_settop(s, -2);

        _ = c.lua_rawgeti(s, -1, 2);

        const key_str = get_lua_string(s, -1) orelse {

            c.lua_settop(s, -3);

            return 0;

        };

        c.lua_settop(s, -2);

        const keysym = key_name_to_keysym(key_str) orelse {

            c.lua_settop(s, -2);

            return 0;

        };

        keybind.keys[keybind.key_count] = .{ .mod_mask = mod_mask, .keysym = keysym };

        keybind.key_count += 1;

        c.lua_settop(s, -2);

    }

    _ = c.lua_getfield(s, 2, "__action");

    const action_str = get_lua_string(s, -1) orelse {

        c.lua_settop(s, -2);

        return 0;

    };

    c.lua_settop(s, -2);

    keybind.action = parse_action(action_str) orelse return 0;

    _ = c.lua_getfield(s, 2, "__arg");

    if (c.lua_type(s, -1) == c.LUA_TNUMBER) {

        keybind.int_arg = @intCast(c.lua_tointegerx(s, -1, null));

    } else if (c.lua_type(s, -1) == c.LUA_TSTRING) {

        keybind.str_arg = get_lua_string(s, -1);

    }

    c.lua_settop(s, -2);

    cfg.add_keybind(keybind) catch return 0;

    return 0;

}

fn lua_gaps_set_enabled(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.gaps_enabled = c.lua_toboolean(s, 1) != 0;

    return 0;

}

fn lua_gaps_enable(state: ?*c.lua_State) callconv(.c) c_int {

    _ = state;

    const cfg = config orelse return 0;

    cfg.gaps_enabled = true;

    return 0;

}

fn lua_gaps_disable(state: ?*c.lua_State) callconv(.c) c_int {

    _ = state;

    const cfg = config orelse return 0;

    cfg.gaps_enabled = false;

    return 0;

}

fn lua_gaps_set_inner(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.gap_inner_h = @intCast(c.lua_tointegerx(s, 1, null));

    cfg.gap_inner_v = @intCast(c.lua_tointegerx(s, 2, null));

    return 0;

}

fn lua_gaps_set_outer(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.gap_outer_h = @intCast(c.lua_tointegerx(s, 1, null));

    cfg.gap_outer_v = @intCast(c.lua_tointegerx(s, 2, null));

    return 0;

}

fn lua_gaps_set_smart(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.smartgaps_enabled = c.lua_toboolean(s, 1) != 0;

    return 0;

}

fn lua_border_set_width(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.border_width = @intCast(c.lua_tointegerx(s, 1, null));

    return 0;

}

fn lua_border_set_focused_color(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.border_focused = parse_color(s, 1);

    return 0;

}

fn lua_border_set_unfocused_color(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.border_unfocused = parse_color(s, 1);

    return 0;

}

fn lua_client_kill(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "KillClient");

    return 1;

}

fn lua_client_toggle_fullscreen(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ToggleFullScreen");

    return 1;

}

fn lua_client_toggle_floating(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ToggleFloating");

    return 1;

}

fn lua_client_focus_stack(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const dir: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "FocusStack", dir);

    return 1;

}

fn lua_client_move_stack(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const dir: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "MoveStack", dir);

    return 1;

}

fn lua_layout_cycle(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "CycleLayout");

    return 1;

}

fn lua_layout_set(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table_with_string(s, "ChangeLayout");

    return 1;

}

fn lua_layout_scroll_left(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ScrollLeft");

    return 1;

}

fn lua_layout_scroll_right(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ScrollRight");

    return 1;

}

fn lua_tag_view(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const idx: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "ViewTag", idx);

    return 1;

}

fn lua_tag_view_next(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ViewNextTag");

    return 1;

}

fn lua_tag_view_previous(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ViewPreviousTag");

    return 1;

}

fn lua_tag_view_next_nonempty(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ViewNextNonEmptyTag");

    return 1;

}

fn lua_tag_view_previous_nonempty(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ViewPreviousNonEmptyTag");

    return 1;

}

fn lua_tag_toggleview(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const idx: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "ToggleView", idx);

    return 1;

}

fn lua_tag_move_to(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const idx: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "MoveToTag", idx);

    return 1;

}

fn lua_tag_toggletag(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const idx: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "ToggleTag", idx);

    return 1;

}

fn lua_tag_set_back_and_forth(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.tag_back_and_forth = c.lua_toboolean(s, 1) != 0;

    return 0;

}

fn lua_monitor_focus(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const dir: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "FocusMonitor", dir);

    return 1;

}

fn lua_monitor_tag(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const dir: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "TagMonitor", dir);

    return 1;

}

fn lua_rule_add(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (c.lua_type(s, 1) != c.LUA_TTABLE) return 0;

    var rule = Rule{

        .class = null,

        .instance = null,

        .title = null,

        .tags = 0,

        .is_floating = false,

        .monitor = -1,

    };

    _ = c.lua_getfield(s, 1, "class");

    if (c.lua_type(s, -1) == c.LUA_TSTRING) {

        rule.class = get_lua_string(s, -1);

    }

    c.lua_settop(s, -2);

    _ = c.lua_getfield(s, 1, "instance");

    if (c.lua_type(s, -1) == c.LUA_TSTRING) {

        rule.instance = get_lua_string(s, -1);

    }

    c.lua_settop(s, -2);

    _ = c.lua_getfield(s, 1, "title");

    if (c.lua_type(s, -1) == c.LUA_TSTRING) {

        rule.title = get_lua_string(s, -1);

    }

    c.lua_settop(s, -2);

    _ = c.lua_getfield(s, 1, "tag");

    if (c.lua_type(s, -1) == c.LUA_TNUMBER) {

        const tag_idx: i32 = @intCast(c.lua_tointegerx(s, -1, null));

        if (tag_idx > 0) {

            rule.tags = @as(u32, 1) << @intCast(tag_idx - 1);

        }

    }

    c.lua_settop(s, -2);

    _ = c.lua_getfield(s, 1, "floating");

    if (c.lua_type(s, -1) == c.LUA_TBOOLEAN) {

        rule.is_floating = c.lua_toboolean(s, -1) != 0;

    }

    c.lua_settop(s, -2);

    _ = c.lua_getfield(s, 1, "monitor");

    if (c.lua_type(s, -1) == c.LUA_TNUMBER) {

        rule.monitor = @intCast(c.lua_tointegerx(s, -1, null));

    }

    c.lua_settop(s, -2);

    cfg.add_rule(rule) catch return 0;

    return 0;

}

fn lua_bar_set_font(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (get_string_arg(s, 1)) |font| {

        cfg.font = font;

    }

    return 0;

}

fn lua_bar_set_blocks(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (c.lua_type(s, 1) != c.LUA_TTABLE) return 0;

    const len = c.lua_rawlen(s, 1);

    var i: usize = 1;

    while (i <= len) : (i += 1) {

        _ = c.lua_rawgeti(s, 1, @intCast(i));

        if (c.lua_type(s, -1) != c.LUA_TTABLE) {

            c.lua_settop(s, -2);

            continue;

        }

        if (parse_block_config(s, -1)) |block| {

            cfg.add_block(block) catch {};

        }

        c.lua_settop(s, -2);

    }

    return 0;

}

fn parse_block_config(state: *c.lua_State, idx: c_int) ?Block {

    _ = c.lua_getfield(state, idx, "__block_type");

    const block_type_str = get_lua_string(state, -1) orelse {

        c.lua_settop(state, -2);

        return null;

    };

    c.lua_settop(state, -2);

    _ = c.lua_getfield(state, idx, "format");

    const format = get_lua_string(state, -1) orelse "";

    c.lua_settop(state, -2);

    _ = c.lua_getfield(state, idx, "interval");

    const interval: u32 = @intCast(c.lua_tointegerx(state, -1, null));

    c.lua_settop(state, -2);

    _ = c.lua_getfield(state, idx, "color");

    const color = parse_color(state, -1);

    c.lua_settop(state, -2);

    _ = c.lua_getfield(state, idx, "underline");

    const underline = c.lua_toboolean(state, -1) != 0;

    c.lua_settop(state, -2);

    var block = Block{

        .block_type = .static,

        .format = format,

        .interval = interval,

        .color = color,

        .underline = underline,

    };

    if (std.mem.eql(u8, block_type_str, "Ram")) {

        block.block_type = .ram;

    } else if (std.mem.eql(u8, block_type_str, "DateTime")) {

        block.block_type = .datetime;

        _ = c.lua_getfield(state, idx, "__arg");

        block.datetime_format = get_lua_string(state, -1);

        c.lua_settop(state, -2);

    } else if (std.mem.eql(u8, block_type_str, "Shell")) {

        block.block_type = .shell;

        _ = c.lua_getfield(state, idx, "__arg");

        block.command = get_lua_string(state, -1);

        c.lua_settop(state, -2);

    } else if (std.mem.eql(u8, block_type_str, "Static")) {

        block.block_type = .static;

        _ = c.lua_getfield(state, idx, "__arg");

        if (get_lua_string(state, -1)) |text| {

            block.format = text;

        }

        c.lua_settop(state, -2);

    } else if (std.mem.eql(u8, block_type_str, "Battery")) {

        block.block_type = .battery;

        _ = c.lua_getfield(state, idx, "__arg");

        if (c.lua_type(state, -1) == c.LUA_TTABLE) {

            _ = c.lua_getfield(state, -1, "charging");

            block.format_charging = get_lua_string(state, -1);

            c.lua_settop(state, -2);

            _ = c.lua_getfield(state, -1, "discharging");

            block.format_discharging = get_lua_string(state, -1);

            c.lua_settop(state, -2);

            _ = c.lua_getfield(state, -1, "full");

            block.format_full = get_lua_string(state, -1);

            c.lua_settop(state, -2);

            _ = c.lua_getfield(state, -1, "battery_name");

            block.battery_name = get_lua_string(state, -1);

            c.lua_settop(state, -2);

        }

        c.lua_settop(state, -2);

    } else {

        return null;

    }

    return block;

}

fn lua_bar_set_scheme_normal(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.scheme_normal = parse_scheme(s);

    return 0;

}

fn lua_bar_set_scheme_selected(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.scheme_selected = parse_scheme(s);

    return 0;

}

fn lua_bar_set_scheme_occupied(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.scheme_occupied = parse_scheme(s);

    return 0;

}

fn lua_bar_set_scheme_urgent(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.scheme_urgent = parse_scheme(s);

    return 0;

}

fn lua_bar_set_hide_vacant_tags(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.hide_vacant_tags = c.lua_toboolean(s, 1) != 0;

    return 0;

}

fn lua_bar_block_ram(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_block_table(s, "Ram", null);

    return 1;

}

fn lua_bar_block_datetime(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    _ = c.lua_getfield(s, 1, "date_format");

    const date_format = get_lua_string(s, -1);

    c.lua_settop(s, -2);

    create_block_table(s, "DateTime", date_format);

    return 1;

}

fn lua_bar_block_shell(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    _ = c.lua_getfield(s, 1, "command");

    const command = get_lua_string(s, -1);

    c.lua_settop(s, -2);

    create_block_table(s, "Shell", command);

    return 1;

}

fn lua_bar_block_static(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    _ = c.lua_getfield(s, 1, "text");

    const text = get_lua_string(s, -1);

    c.lua_settop(s, -2);

    create_block_table(s, "Static", text);

    return 1;

}

fn lua_bar_block_battery(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    c.lua_createtable(s, 0, 6);

    _ = c.lua_pushstring(s, "Battery");

    c.lua_setfield(s, -2, "__block_type");

    _ = c.lua_getfield(s, 1, "format");

    c.lua_setfield(s, -2, "format");

    _ = c.lua_getfield(s, 1, "interval");

    c.lua_setfield(s, -2, "interval");

    _ = c.lua_getfield(s, 1, "color");

    c.lua_setfield(s, -2, "color");

    _ = c.lua_getfield(s, 1, "underline");

    c.lua_setfield(s, -2, "underline");

    c.lua_createtable(s, 0, 4);

    _ = c.lua_getfield(s, 1, "charging");

    c.lua_setfield(s, -2, "charging");

    _ = c.lua_getfield(s, 1, "discharging");

    c.lua_setfield(s, -2, "discharging");

    _ = c.lua_getfield(s, 1, "full");

    c.lua_setfield(s, -2, "full");

    _ = c.lua_getfield(s, 1, "battery_name");

    c.lua_setfield(s, -2, "battery_name");

    c.lua_setfield(s, -2, "__arg");

    return 1;

}

fn create_block_table(state: *c.lua_State, block_type: [*:0]const u8, arg: ?[]const u8) void {

    c.lua_createtable(state, 0, 6);

    _ = c.lua_pushstring(state, block_type);

    c.lua_setfield(state, -2, "__block_type");

    _ = c.lua_getfield(state, 1, "format");

    c.lua_setfield(state, -2, "format");

    _ = c.lua_getfield(state, 1, "interval");

    c.lua_setfield(state, -2, "interval");

    _ = c.lua_getfield(state, 1, "color");

    c.lua_setfield(state, -2, "color");

    _ = c.lua_getfield(state, 1, "underline");

    c.lua_setfield(state, -2, "underline");

    if (arg) |a| {

        var buf: [256]u8 = undefined;

        if (a.len < buf.len) {

            @memcpy(buf[0..a.len], a);

            buf[a.len] = 0;

            _ = c.lua_pushstring(state, &buf);

            c.lua_setfield(state, -2, "__arg");

        }

    }

}

fn lua_set_terminal(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (get_string_arg(s, 1)) |term| {

        cfg.terminal = term;

    }

    return 0;

}

fn lua_set_modkey(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (get_string_arg(s, 1)) |modkey_str| {

        cfg.modkey = parse_single_modifier(modkey_str);

        cfg.add_button(.{

            .click = .client_win,

            .mod_mask = cfg.modkey,

            .button = 1,

            .action = .move_mouse,

        }) catch {};

        cfg.add_button(.{

            .click = .client_win,

            .mod_mask = cfg.modkey,

            .button = 3,

            .action = .resize_mouse,

        }) catch {};

    }

    return 0;

}

fn lua_set_tags(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (c.lua_type(s, 1) != c.LUA_TTABLE) return 0;

    const len = c.lua_rawlen(s, 1);

    var i: usize = 0;

    while (i < len and i < 9) : (i += 1) {

        _ = c.lua_rawgeti(s, 1, @intCast(i + 1));

        if (get_lua_string(s, -1)) |tag_str| {

            cfg.tags[i] = tag_str;

        }

        c.lua_settop(s, -2);

    }

    return 0;

}

fn lua_autostart(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    if (get_string_arg(s, 1)) |cmd| {

        cfg.add_autostart(cmd) catch return 0;

    }

    return 0;

}

fn lua_auto_tile(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    cfg.auto_tile = c.lua_toboolean(s, 1) != 0;

    return 0;

}

fn lua_set_layout_symbol(state: ?*c.lua_State) callconv(.c) c_int {

    const cfg = config orelse return 0;

    const s = state orelse return 0;

    const name = get_string_arg(s, 1) orelse return 0;

    const symbol = get_string_arg(s, 2) orelse return 0;

    const layout_map = .{

        .{ "tiling", &cfg.layout_tile_symbol },

        .{ "tile", &cfg.layout_tile_symbol },

        .{ "normie", &cfg.layout_floating_symbol },

        .{ "floating", &cfg.layout_floating_symbol },

        .{ "float", &cfg.layout_floating_symbol },

        .{ "monocle", &cfg.layout_monocle_symbol },

        .{ "scrolling", &cfg.layout_scrolling_symbol },

        .{ "scroll", &cfg.layout_scrolling_symbol },

    };

    inline for (layout_map) |entry| {

        if (std.mem.eql(u8, name, entry[0])) {

            entry[1].* = symbol;

            return 0;

        }

    }

    return 0;

}

fn lua_quit(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "Quit");

    return 1;

}

fn lua_restart(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "Restart");

    return 1;

}

fn lua_toggle_gaps(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ToggleGaps");

    return 1;

}

fn lua_show_keybinds(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    create_action_table(s, "ShowKeybinds");

    return 1;

}

fn lua_set_master_factor(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const delta: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    create_action_table_with_int(s, "ResizeMaster", delta);

    return 1;

}

fn lua_inc_num_master(state: ?*c.lua_State) callconv(.c) c_int {

    const s = state orelse return 0;

    const delta: i32 = @intCast(c.lua_tointegerx(s, 1, null));

    if (delta > 0) {

        create_action_table(s, "IncMaster");

    } else {

        create_action_table(s, "DecMaster");

    }

    return 1;

}

fn get_string_arg(state: *c.lua_State, idx: c_int) ?[]const u8 {

    if (c.lua_type(state, idx) != c.LUA_TSTRING) return null;

    return get_lua_string(state, idx);

}

fn extract_spawn_command(state: *c.lua_State, idx: c_int) ?[]const u8 {

    const len = c.lua_rawlen(state, idx);

    if (len == 0) return null;

    if (len >= 3) {

        _ = c.lua_rawgeti(state, idx, 1);

        const first = get_lua_string(state, -1);

        c.lua_settop(state, -2);

        _ = c.lua_rawgeti(state, idx, 2);

        const second = get_lua_string(state, -1);

        c.lua_settop(state, -2);

        if (first != null and second != null and

            std.mem.eql(u8, first.?, "sh") and std.mem.eql(u8, second.?, "-c"))

        {

            _ = c.lua_rawgeti(state, idx, 3);

            const cmd = get_lua_string(state, -1);

            c.lua_settop(state, -2);

            return cmd;

        }

    }

    _ = c.lua_rawgeti(state, idx, 1);

    const first_elem = get_lua_string(state, -1);

    c.lua_settop(state, -2);

    return first_elem;

}

fn get_lua_string(state: *c.lua_State, idx: c_int) ?[]const u8 {

    const cstr = c.lua_tolstring(state, idx, null);

    if (cstr == null) return null;

    return std.mem.span(cstr);

}

fn parse_color(state: *c.lua_State, idx: c_int) u32 {

    const lua_type = c.lua_type(state, idx);

    if (lua_type == c.LUA_TNUMBER) {

        return @intCast(c.lua_tointegerx(state, idx, null));

    }

    if (lua_type == c.LUA_TSTRING) {

        const str = get_lua_string(state, idx) orelse return 0;

        if (str.len > 0 and str[0] == '#') {

            return std.fmt.parseInt(u32, str[1..], 16) catch return 0;

        }

        if (str.len > 2 and str[0] == '0' and str[1] == 'x') {

            return std.fmt.parseInt(u32, str[2..], 16) catch return 0;

        }

        return std.fmt.parseInt(u32, str, 16) catch return 0;

    }

    return 0;

}

fn parse_scheme(state: *c.lua_State) Color_Scheme {

    return Color_Scheme{

        .fg = parse_color(state, 1),

        .bg = parse_color(state, 2),

        .border = parse_color(state, 3),

    };

}

fn parse_modifiers(state: *c.lua_State, idx: c_int) u32 {

    var mod_mask: u32 = 0;

    if (c.lua_type(state, idx) != c.LUA_TTABLE) return mod_mask;

    const len = c.lua_rawlen(state, idx);

    var i: usize = 1;

    while (i <= len) : (i += 1) {

        _ = c.lua_rawgeti(state, idx, @intCast(i));

        if (get_lua_string(state, -1)) |mod_str| {

            const parsed = parse_single_modifier(mod_str);

            mod_mask |= parsed;

        }

        c.lua_settop(state, -2);

    }

    return mod_mask;

}

fn parse_modifiers_at_top(state: *c.lua_State) u32 {

    return parse_modifiers(state, -1);

}

fn parse_single_modifier(name: []const u8) u32 {

    if (std.mem.eql(u8, name, "Mod4") or std.mem.eql(u8, name, "mod4") or std.mem.eql(u8, name, "super")) {

        return (1 << 6);

    } else if (std.mem.eql(u8, name, "Mod1") or std.mem.eql(u8, name, "mod1") or std.mem.eql(u8, name, "alt")) {

        return (1 << 3);

    } else if (std.mem.eql(u8, name, "Shift") or std.mem.eql(u8, name, "shift")) {

        return (1 << 0);

    } else if (std.mem.eql(u8, name, "Control") or std.mem.eql(u8, name, "control") or std.mem.eql(u8, name, "ctrl")) {

        return (1 << 2);

    }

    return 0;

}

fn parse_action(name: []const u8) ?Action {

    const action_map = .{

        .{ "Spawn", Action.spawn },

        .{ "SpawnTerminal", Action.spawn_terminal },

        .{ "KillClient", Action.kill_client },

        .{ "Quit", Action.quit },

        .{ "Restart", Action.restart },

        .{ "ShowKeybinds", Action.show_keybinds },

        .{ "FocusStack", Action.focus_next },

        .{ "MoveStack", Action.move_next },

        .{ "ResizeMaster", Action.resize_master },

        .{ "IncMaster", Action.inc_master },

        .{ "DecMaster", Action.dec_master },

        .{ "ToggleFloating", Action.toggle_floating },

        .{ "ToggleFullScreen", Action.toggle_fullscreen },

        .{ "ToggleGaps", Action.toggle_gaps },

        .{ "CycleLayout", Action.cycle_layout },

        .{ "ChangeLayout", Action.set_layout },

        .{ "ViewTag", Action.view_tag },

        .{ "ViewNextTag", Action.view_next_tag },

        .{ "ViewPreviousTag", Action.view_prev_tag },

        .{ "ViewNextNonEmptyTag", Action.view_next_nonempty_tag },

        .{ "ViewPreviousNonEmptyTag", Action.view_prev_nonempty_tag },

        .{ "MoveToTag", Action.move_to_tag },

        .{ "ToggleView", Action.toggle_view_tag },

        .{ "ToggleTag", Action.toggle_tag },

        .{ "FocusMonitor", Action.focus_monitor },

        .{ "TagMonitor", Action.send_to_monitor },

        .{ "ScrollLeft", Action.scroll_left },

        .{ "ScrollRight", Action.scroll_right },

    };

    inline for (action_map) |entry| {

        if (std.mem.eql(u8, name, entry[0])) {

            return entry[1];

        }

    }

    return null;

}

fn key_name_to_keysym(name: []const u8) ?u64 {

    const key_map = .{

        .{ "Return", 0xff0d },

        .{ "Enter", 0xff0d },

        .{ "Tab", 0xff09 },

        .{ "Escape", 0xff1b },

        .{ "BackSpace", 0xff08 },

        .{ "Delete", 0xffff },

        .{ "space", 0x0020 },

        .{ "Space", 0x0020 },

        .{ "comma", 0x002c },

        .{ "Comma", 0x002c },

        .{ "period", 0x002e },

        .{ "Period", 0x002e },

        .{ "slash", 0x002f },

        .{ "Slash", 0x002f },

        .{ "minus", 0x002d },

        .{ "Minus", 0x002d },

        .{ "equal", 0x003d },

        .{ "Equal", 0x003d },

        .{ "bracketleft", 0x005b },

        .{ "bracketright", 0x005d },

        .{ "backslash", 0x005c },

        .{ "semicolon", 0x003b },

        .{ "apostrophe", 0x0027 },

        .{ "grave", 0x0060 },

        .{ "Left", 0xff51 },

        .{ "Up", 0xff52 },

        .{ "Right", 0xff53 },

        .{ "Down", 0xff54 },

        .{ "F1", 0xffbe },

        .{ "F2", 0xffbf },

        .{ "F3", 0xffc0 },

        .{ "F4", 0xffc1 },

        .{ "F5", 0xffc2 },

        .{ "F6", 0xffc3 },

        .{ "F7", 0xffc4 },

        .{ "F8", 0xffc5 },

        .{ "F9", 0xffc6 },

        .{ "F10", 0xffc7 },

        .{ "F11", 0xffc8 },

        .{ "F12", 0xffc9 },

        .{ "Print", 0xff61 },

        .{ "XF86AudioRaiseVolume", 0x1008ff13 },

        .{ "XF86AudioLowerVolume", 0x1008ff11 },

        .{ "XF86AudioMute", 0x1008ff12 },

        .{ "XF86AudioPlay", 0x1008ff14 },

        .{ "XF86AudioPause", 0x1008ff31 },

        .{ "XF86AudioNext", 0x1008ff17 },

        .{ "XF86AudioPrev", 0x1008ff16 },

        .{ "XF86MonBrightnessUp", 0x1008ff02 },

        .{ "XF86MonBrightnessDown", 0x1008ff03 },

    };

    inline for (key_map) |entry| {

        if (std.mem.eql(u8, name, entry[0])) {

            return entry[1];

        }

    }

    if (name.len == 1) {

        const char = name[0];

        if (char >= 'a' and char <= 'z') {

            return char;

        }

        if (char >= 'A' and char <= 'Z') {

            return char + 32;

        }

        if (char >= '0' and char <= '9') {

            return char;