const std = @import("std");
const testing = std.testing;

const Mod4Mask: u32 = 1 << 6;
const Mod1Mask: u32 = 1 << 3;
const ShiftMask: u32 = 1 << 0;
const ControlMask: u32 = 1 << 2;

fn parse_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 Mod4Mask;
    } else if (std.mem.eql(u8, name, "Mod1") or std.mem.eql(u8, name, "mod1") or std.mem.eql(u8, name, "alt")) {
        return Mod1Mask;
    } else if (std.mem.eql(u8, name, "Shift") or std.mem.eql(u8, name, "shift")) {
        return ShiftMask;
    } else if (std.mem.eql(u8, name, "Control") or std.mem.eql(u8, name, "control") or std.mem.eql(u8, name, "ctrl")) {
        return ControlMask;
    }
    return 0;
}

fn parse_modifiers(names: []const []const u8) u32 {
    var mask: u32 = 0;
    for (names) |name| {
        mask |= parse_modifier(name);
    }
    return mask;
}

test "parse_modifier: Mod4 variants" {
    try testing.expectEqual(Mod4Mask, parse_modifier("Mod4"));
    try testing.expectEqual(Mod4Mask, parse_modifier("mod4"));
    try testing.expectEqual(Mod4Mask, parse_modifier("super"));
}

test "parse_modifier: Mod1 (Alt) variants" {
    try testing.expectEqual(Mod1Mask, parse_modifier("Mod1"));
    try testing.expectEqual(Mod1Mask, parse_modifier("mod1"));
    try testing.expectEqual(Mod1Mask, parse_modifier("alt"));
}

test "parse_modifier: Shift variants" {
    try testing.expectEqual(ShiftMask, parse_modifier("Shift"));
    try testing.expectEqual(ShiftMask, parse_modifier("shift"));
}

test "parse_modifier: Control variants" {
    try testing.expectEqual(ControlMask, parse_modifier("Control"));
    try testing.expectEqual(ControlMask, parse_modifier("control"));
    try testing.expectEqual(ControlMask, parse_modifier("ctrl"));
}

test "parse_modifier: unknown returns 0" {
    try testing.expectEqual(@as(u32, 0), parse_modifier("Unknown"));
    try testing.expectEqual(@as(u32, 0), parse_modifier(""));
}

test "parse_modifiers: combines multiple modifiers" {
    const mods = &[_][]const u8{ "Mod4", "Shift" };
    try testing.expectEqual(Mod4Mask | ShiftMask, parse_modifiers(mods));
}

test "parse_modifiers: triple combination" {
    const mods = &[_][]const u8{ "super", "shift", "ctrl" };
    try testing.expectEqual(Mod4Mask | ShiftMask | ControlMask, parse_modifiers(mods));
}

test "parse_modifiers: empty list returns 0" {
    const mods = &[_][]const u8{};
    try testing.expectEqual(@as(u32, 0), parse_modifiers(mods));
}

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 },
    };

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

    return null;
}

test "key_name_to_keysym: special keys" {
    try testing.expectEqual(@as(?u64, 0xff0d), key_name_to_keysym("Return"));
    try testing.expectEqual(@as(?u64, 0xff0d), key_name_to_keysym("Enter"));
    try testing.expectEqual(@as(?u64, 0xff09), key_name_to_keysym("Tab"));
    try testing.expectEqual(@as(?u64, 0xff1b), key_name_to_keysym("Escape"));
}

test "key_name_to_keysym: lowercase letters" {
    try testing.expectEqual(@as(?u64, 'a'), key_name_to_keysym("a"));
    try testing.expectEqual(@as(?u64, 'z'), key_name_to_keysym("z"));
}

test "key_name_to_keysym: uppercase converts to lowercase" {
    try testing.expectEqual(@as(?u64, 'a'), key_name_to_keysym("A"));
    try testing.expectEqual(@as(?u64, 'z'), key_name_to_keysym("Z"));
}

test "key_name_to_keysym: numbers" {
    try testing.expectEqual(@as(?u64, '0'), key_name_to_keysym("0"));
    try testing.expectEqual(@as(?u64, '9'), key_name_to_keysym("9"));
}

test "key_name_to_keysym: unknown returns null" {
    try testing.expectEqual(@as(?u64, null), key_name_to_keysym("UnknownKey"));
    try testing.expectEqual(@as(?u64, null), key_name_to_keysym(""));
}

test "key_name_to_keysym: space variants" {
    try testing.expectEqual(@as(?u64, 0x0020), key_name_to_keysym("space"));
    try testing.expectEqual(@as(?u64, 0x0020), key_name_to_keysym("Space"));
}