path: root/lib/compiler/resinator/res.zig

const std = @import("std");
const assert = std.debug.assert;
const rc = @import("rc.zig");
const ResourceType = rc.ResourceType;
const CommonResourceAttributes = rc.CommonResourceAttributes;
const Allocator = std.mem.Allocator;
const windows1252 = @import("windows1252.zig");
const SupportedCodePage = @import("code_pages.zig").SupportedCodePage;
const literals = @import("literals.zig");
const SourceBytes = literals.SourceBytes;
const Codepoint = @import("code_pages.zig").Codepoint;
const lang = @import("lang.zig");
const isNonAsciiDigit = @import("utils.zig").isNonAsciiDigit;

/// https://learn.microsoft.com/en-us/windows/win32/menurc/resource-types
pub const RT = enum(u8) {
    ACCELERATOR = 9,
    ANICURSOR = 21,
    ANIICON = 22,
    BITMAP = 2,
    CURSOR = 1,
    DIALOG = 5,
    DLGINCLUDE = 17,
    DLGINIT = 240,
    FONT = 8,
    FONTDIR = 7,
    GROUP_CURSOR = 1 + 11, // CURSOR + 11
    GROUP_ICON = 3 + 11, // ICON + 11
    HTML = 23,
    ICON = 3,
    MANIFEST = 24,
    MENU = 4,
    MESSAGETABLE = 11,
    PLUGPLAY = 19,
    RCDATA = 10,
    STRING = 6,
    TOOLBAR = 241,
    VERSION = 16,
    VXD = 20,
    _,

    /// Returns null if the resource type is user-defined
    /// Asserts that the resource is not `stringtable`
    pub fn fromResource(resource: ResourceType) ?RT {
        return switch (resource) {
            .accelerators => .ACCELERATOR,
            .bitmap => .BITMAP,
            .cursor => .GROUP_CURSOR,
            .dialog => .DIALOG,
            .dialogex => .DIALOG,
            .dlginclude => .DLGINCLUDE,
            .dlginit => .DLGINIT,
            .font => .FONT,
            .html => .HTML,
            .icon => .GROUP_ICON,
            .menu => .MENU,
            .menuex => .MENU,
            .messagetable => .MESSAGETABLE,
            .plugplay => .PLUGPLAY,
            .rcdata => .RCDATA,
            .stringtable => unreachable,
            .toolbar => .TOOLBAR,
            .user_defined => null,
            .versioninfo => .VERSION,
            .vxd => .VXD,

            .cursor_num => .CURSOR,
            .icon_num => .ICON,
            .string_num => .STRING,
            .anicursor_num => .ANICURSOR,
            .aniicon_num => .ANIICON,
            .fontdir_num => .FONTDIR,
            .manifest_num => .MANIFEST,
        };
    }
};

/// https://learn.microsoft.com/en-us/windows/win32/menurc/common-resource-attributes
/// https://learn.microsoft.com/en-us/windows/win32/menurc/resourceheader
pub const MemoryFlags = packed struct(u16) {
    value: u16,

    pub const MOVEABLE: u16 = 0x10;
    // TODO: SHARED and PURE seem to be the same thing? Testing seems to confirm this but
    //       would like to find mention of it somewhere.
    pub const SHARED: u16 = 0x20;
    pub const PURE: u16 = 0x20;
    pub const PRELOAD: u16 = 0x40;
    pub const DISCARDABLE: u16 = 0x1000;

    /// Note: The defaults can have combinations that are not possible to specify within
    ///       an .rc file, as the .rc attributes imply other values (i.e. specifying
    ///       DISCARDABLE always implies MOVEABLE and PURE/SHARED, and yet RT_ICON
    ///       has a default of only MOVEABLE | DISCARDABLE).
    pub fn defaults(predefined_resource_type: ?RT) MemoryFlags {
        if (predefined_resource_type == null) {
            return MemoryFlags{ .value = MOVEABLE | SHARED };
        } else {
            return switch (predefined_resource_type.?) {
                // zig fmt: off
                .RCDATA, .BITMAP, .HTML, .MANIFEST,
                .ACCELERATOR, .VERSION, .MESSAGETABLE,
                .DLGINIT, .TOOLBAR, .PLUGPLAY,
                .VXD, => MemoryFlags{ .value = MOVEABLE | SHARED },

                .GROUP_ICON, .GROUP_CURSOR,
                .STRING, .FONT, .DIALOG, .MENU,
                .DLGINCLUDE, => MemoryFlags{ .value = MOVEABLE | SHARED | DISCARDABLE },

                .ICON, .CURSOR, .ANIICON, .ANICURSOR => MemoryFlags{ .value = MOVEABLE | DISCARDABLE },
                .FONTDIR => MemoryFlags{ .value = MOVEABLE | PRELOAD },
                // zig fmt: on
                // Same as predefined_resource_type == null
                _ => return MemoryFlags{ .value = MOVEABLE | SHARED },
            };
        }
    }

    pub fn set(self: *MemoryFlags, attribute: CommonResourceAttributes) void {
        switch (attribute) {
            .preload => self.value |= PRELOAD,
            .loadoncall => self.value &= ~PRELOAD,
            .moveable => self.value |= MOVEABLE,
            .fixed => self.value &= ~(MOVEABLE | DISCARDABLE),
            .shared => self.value |= SHARED,
            .nonshared => self.value &= ~(SHARED | DISCARDABLE),
            .pure => self.value |= PURE,
            .impure => self.value &= ~(PURE | DISCARDABLE),
            .discardable => self.value |= DISCARDABLE | MOVEABLE | PURE,
        }
    }

    pub fn setGroup(self: *MemoryFlags, attribute: CommonResourceAttributes, implied_shared_or_pure: bool) void {
        switch (attribute) {
            .preload => {
                self.value |= PRELOAD;
                if (implied_shared_or_pure) self.value &= ~SHARED;
            },
            .loadoncall => {
                self.value &= ~PRELOAD;
                if (implied_shared_or_pure) self.value |= SHARED;
            },
            else => self.set(attribute),
        }
    }
};

/// https://learn.microsoft.com/en-us/windows/win32/intl/language-identifiers
pub const Language = packed struct(u16) {
    // Note: This is the default no matter what locale the current system is set to,
    //       e.g. even if the system's locale is en-GB, en-US will still be the
    //       default language for resources in the Win32 rc compiler.
    primary_language_id: u10 = lang.LANG_ENGLISH,
    sublanguage_id: u6 = lang.SUBLANG_ENGLISH_US,

    /// Default language ID as a u16
    pub const default: u16 = (Language{}).asInt();

    pub fn fromInt(int: u16) Language {
        return @bitCast(int);
    }

    pub fn asInt(self: Language) u16 {
        return @bitCast(self);
    }

    pub fn format(language: Language, w: *std.Io.Writer) std.Io.Writer.Error!void {
        const language_id = language.asInt();
        const language_name = language_name: {
            if (std.enums.fromInt(lang.LanguageId, language_id)) |lang_enum_val| {
                break :language_name @tagName(lang_enum_val);
            }
            if (language_id == lang.LOCALE_CUSTOM_UNSPECIFIED) {
                break :language_name "LOCALE_CUSTOM_UNSPECIFIED";
            }
            break :language_name "<UNKNOWN>";
        };
        try w.print("{s} (0x{X})", .{ language_name, language_id });
    }
};

/// https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-dlgitemtemplate#remarks
pub const ControlClass = enum(u16) {
    button = 0x80,
    edit = 0x81,
    static = 0x82,
    listbox = 0x83,
    scrollbar = 0x84,
    combobox = 0x85,

    pub fn fromControl(control: rc.Control) ?ControlClass {
        return switch (control) {
            // zig fmt: off
            .auto3state, .autocheckbox, .autoradiobutton,
            .checkbox, .defpushbutton, .groupbox, .pushbox,
            .pushbutton, .radiobutton, .state3, .userbutton => .button,
            // zig fmt: on
            .combobox => .combobox,
            .control => null,
            .ctext, .icon, .ltext, .rtext => .static,
            .edittext, .hedit, .iedit => .edit,
            .listbox => .listbox,
            .scrollbar => .scrollbar,
        };
    }

    pub fn getImpliedStyle(control: rc.Control) u32 {
        var style = WS.CHILD | WS.VISIBLE;
        switch (control) {
            .auto3state => style |= BS.AUTO3STATE | WS.TABSTOP,
            .autocheckbox => style |= BS.AUTOCHECKBOX | WS.TABSTOP,
            .autoradiobutton => style |= BS.AUTORADIOBUTTON,
            .checkbox => style |= BS.CHECKBOX | WS.TABSTOP,
            .combobox => {},
            .control => {},
            .ctext => style |= SS.CENTER | WS.GROUP,
            .defpushbutton => style |= BS.DEFPUSHBUTTON | WS.TABSTOP,
            .edittext, .hedit, .iedit => style |= WS.TABSTOP | WS.BORDER,
            .groupbox => style |= BS.GROUPBOX,
            .icon => style |= SS.ICON,
            .listbox => style |= LBS.NOTIFY | WS.BORDER,
            .ltext => style |= WS.GROUP,
            .pushbox => style |= BS.PUSHBOX | WS.TABSTOP,
            .pushbutton => style |= WS.TABSTOP,
            .radiobutton => style |= BS.RADIOBUTTON,
            .rtext => style |= SS.RIGHT | WS.GROUP,
            .scrollbar => {},
            .state3 => style |= BS.@"3STATE" | WS.TABSTOP,
            .userbutton => style |= BS.USERBUTTON | WS.TABSTOP,
        }
        return style;
    }
};

pub const NameOrOrdinal = union(enum) {
    // UTF-16 LE
    name: [:0]const u16,
    ordinal: u16,

    pub fn deinit(self: NameOrOrdinal, allocator: Allocator) void {
        switch (self) {
            .name => |name| {
                allocator.free(name);
            },
            .ordinal => {},
        }
    }

    /// Returns the full length of the amount of bytes that would be written by `write`
    /// (e.g. for an ordinal it will return the length including the 0xFFFF indicator)
    pub fn byteLen(self: NameOrOrdinal) usize {
        switch (self) {
            .name => |name| {
                // + 1 for 0-terminated
                return (name.len + 1) * @sizeOf(u16);
            },
            .ordinal => return 4,
        }
    }

    pub fn write(self: NameOrOrdinal, writer: *std.Io.Writer) !void {
        switch (self) {
            .name => |name| {
                try writer.writeAll(std.mem.sliceAsBytes(name[0 .. name.len + 1]));
            },
            .ordinal => |ordinal| {
                try writer.writeInt(u16, 0xffff, .little);
                try writer.writeInt(u16, ordinal, .little);
            },
        }
    }

    pub fn writeEmpty(writer: *std.Io.Writer) !void {
        try writer.writeInt(u16, 0, .little);
    }

    pub fn fromString(allocator: Allocator, bytes: SourceBytes) !NameOrOrdinal {
        if (maybeOrdinalFromString(bytes)) |ordinal| {
            return ordinal;
        }
        return nameFromString(allocator, bytes);
    }

    pub fn nameFromString(allocator: Allocator, bytes: SourceBytes) !NameOrOrdinal {
        // Names have a limit of 256 UTF-16 code units + null terminator
        var buf = try std.ArrayList(u16).initCapacity(allocator, @min(257, bytes.slice.len));
        errdefer buf.deinit(allocator);

        var i: usize = 0;
        while (bytes.code_page.codepointAt(i, bytes.slice)) |codepoint| : (i += codepoint.byte_len) {
            if (buf.items.len == 256) break;

            const c = codepoint.value;
            if (c == Codepoint.invalid) {
                try buf.append(allocator, std.mem.nativeToLittle(u16, '�'));
            } else if (c < 0x7F) {
                // ASCII chars in names are always converted to uppercase
                try buf.append(allocator, std.mem.nativeToLittle(u16, std.ascii.toUpper(@intCast(c))));
            } else if (c < 0x10000) {
                const short: u16 = @intCast(c);
                try buf.append(allocator, std.mem.nativeToLittle(u16, short));
            } else {
                const high = @as(u16, @intCast((c - 0x10000) >> 10)) + 0xD800;
                try buf.append(allocator, std.mem.nativeToLittle(u16, high));

                // Note: This can cut-off in the middle of a UTF-16 surrogate pair,
                //       i.e. it can make the string end with an unpaired high surrogate
                if (buf.items.len == 256) break;

                const low = @as(u16, @intCast(c & 0x3FF)) + 0xDC00;
                try buf.append(allocator, std.mem.nativeToLittle(u16, low));
            }
        }

        return NameOrOrdinal{ .name = try buf.toOwnedSliceSentinel(allocator, 0) };
    }

    /// Returns `null` if the bytes do not form a valid number.
    /// Does not allow non-ASCII digits (which the Win32 RC compiler does allow
    /// in base 10 numbers, see `maybeNonAsciiOrdinalFromString`).
    pub fn maybeOrdinalFromString(bytes: SourceBytes) ?NameOrOrdinal {
        var buf = bytes.slice;
        var radix: u8 = 10;
        if (buf.len > 2 and buf[0] == '0') {
            switch (buf[1]) {
                '0'...'9' => {},
                'x', 'X' => {
                    radix = 16;
                    buf = buf[2..];
                    // only the first 4 hex digits matter, anything else is ignored
                    // i.e. 0x12345 is treated as if it were 0x1234
                    buf.len = @min(buf.len, 4);
                },
                else => return null,
            }
        }

        var i: usize = 0;
        var result: u16 = 0;
        while (bytes.code_page.codepointAt(i, buf)) |codepoint| : (i += codepoint.byte_len) {
            const c = codepoint.value;
            const digit: u8 = switch (c) {
                0x00...0x7F => std.fmt.charToDigit(@intCast(c), radix) catch switch (radix) {
                    10 => return null,
                    // non-hex-digits are treated as a terminator rather than invalidating
                    // the number (note: if there are no valid hex digits then the result
                    // will be zero which is not treated as a valid number)
                    16 => break,
                    else => unreachable,
                },
                else => if (radix == 10) return null else break,
            };

            if (result != 0) {
                result *%= radix;
            }
            result +%= digit;
        }

        // Anything that resolves to zero is not interpretted as a number
        if (result == 0) return null;
        return NameOrOrdinal{ .ordinal = result };
    }

    /// The Win32 RC compiler uses `iswdigit` for digit detection for base 10
    /// numbers, which means that non-ASCII digits are 'accepted' but handled
    /// in a totally unintuitive manner, leading to arbitrary results.
    ///
    /// This function will return the value that such an ordinal 'would' have
    /// if it was run through the Win32 RC compiler. This allows us to disallow
    /// non-ASCII digits in number literals but still detect when the Win32
    /// RC compiler would have allowed them, so that a proper warning/error
    /// can be emitted.
    pub fn maybeNonAsciiOrdinalFromString(bytes: SourceBytes) ?NameOrOrdinal {
        const buf = bytes.slice;
        const radix = 10;
        if (buf.len > 2 and buf[0] == '0') {
            switch (buf[1]) {
                // We only care about base 10 numbers here
                'x', 'X' => return null,
                else => {},
            }
        }

        var i: usize = 0;
        var result: u16 = 0;
        while (bytes.code_page.codepointAt(i, buf)) |codepoint| : (i += codepoint.byte_len) {
            const c = codepoint.value;
            const digit: u16 = digit: {
                const is_digit = (c >= '0' and c <= '9') or isNonAsciiDigit(c);
                if (!is_digit) return null;
                break :digit @intCast(c - '0');
            };

            if (result != 0) {
                result *%= radix;
            }
            result +%= digit;
        }

        // Anything that resolves to zero is not interpretted as a number
        if (result == 0) return null;
        return NameOrOrdinal{ .ordinal = result };
    }

    pub fn predefinedResourceType(self: NameOrOrdinal) ?RT {
        switch (self) {
            .ordinal => |ordinal| {
                if (ordinal >= 256) return null;
                switch (@as(RT, @enumFromInt(ordinal))) {
                    .ACCELERATOR,
                    .ANICURSOR,
                    .ANIICON,
                    .BITMAP,
                    .CURSOR,
                    .DIALOG,
                    .DLGINCLUDE,
                    .DLGINIT,
                    .FONT,
                    .FONTDIR,
                    .GROUP_CURSOR,
                    .GROUP_ICON,
                    .HTML,
                    .ICON,
                    .MANIFEST,
                    .MENU,
                    .MESSAGETABLE,
                    .PLUGPLAY,
                    .RCDATA,
                    .STRING,
                    .TOOLBAR,
                    .VERSION,
                    .VXD,
                    => |rt| return rt,
                    _ => return null,
                }
            },
            .name => return null,
        }
    }

    pub fn format(self: NameOrOrdinal, w: *std.Io.Writer) !void {
        switch (self) {
            .name => |name| {
                try w.print("{f}", .{std.unicode.fmtUtf16Le(name)});
            },
            .ordinal => |ordinal| {
                try w.print("{d}", .{ordinal});
            },
        }
    }

    fn formatResourceType(self: NameOrOrdinal, w: *std.Io.Writer) std.Io.Writer.Error!void {
        switch (self) {
            .name => |name| {
                try w.print("{f}", .{std.unicode.fmtUtf16Le(name)});
            },
            .ordinal => |ordinal| {
                if (std.enums.tagName(RT, @enumFromInt(ordinal))) |predefined_type_name| {
                    try w.print("{s}", .{predefined_type_name});
                } else {
                    try w.print("{d}", .{ordinal});
                }
            },
        }
    }

    pub fn fmtResourceType(type_value: NameOrOrdinal) std.fmt.Alt(NameOrOrdinal, formatResourceType) {
        return .{ .data = type_value };
    }
};

fn expectNameOrOrdinal(expected: NameOrOrdinal, actual: NameOrOrdinal) !void {
    switch (expected) {
        .name => {
            if (actual != .name) return error.TestExpectedEqual;
            try std.testing.expectEqualSlices(u16, expected.name, actual.name);
        },
        .ordinal => {
            if (actual != .ordinal) return error.TestExpectedEqual;
            try std.testing.expectEqual(expected.ordinal, actual.ordinal);
        },
    }
}

test "NameOrOrdinal" {
    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena.deinit();

    const allocator = arena.allocator();

    // zero is treated as a string
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("0") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0", .code_page = .windows1252 }),
    );
    // any non-digit byte invalidates the number
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("1A") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "1a", .code_page = .windows1252 }),
    );
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("1ÿ") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "1\xff", .code_page = .windows1252 }),
    );
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("1€") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "1€", .code_page = .utf8 }),
    );
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("1�") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "1\x80", .code_page = .utf8 }),
    );
    // same with overflow that resolves to 0
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("65536") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "65536", .code_page = .windows1252 }),
    );
    // hex zero is also treated as a string
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("0X0") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0x0", .code_page = .windows1252 }),
    );
    // hex numbers work
    try expectNameOrOrdinal(
        NameOrOrdinal{ .ordinal = 0x100 },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0x100", .code_page = .windows1252 }),
    );
    // only the first 4 hex digits matter
    try expectNameOrOrdinal(
        NameOrOrdinal{ .ordinal = 0x1234 },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0X12345", .code_page = .windows1252 }),
    );
    // octal is not supported so it gets treated as a string
    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("0O1234") },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0o1234", .code_page = .windows1252 }),
    );
    // overflow wraps
    try expectNameOrOrdinal(
        NameOrOrdinal{ .ordinal = @truncate(65635) },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "65635", .code_page = .windows1252 }),
    );
    // non-hex-digits in a hex literal are treated as a terminator
    try expectNameOrOrdinal(
        NameOrOrdinal{ .ordinal = 0x4 },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0x4n", .code_page = .windows1252 }),
    );
    try expectNameOrOrdinal(
        NameOrOrdinal{ .ordinal = 0xFA },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "0xFAZ92348", .code_page = .windows1252 }),
    );
    // 0 at the start is allowed
    try expectNameOrOrdinal(
        NameOrOrdinal{ .ordinal = 50 },
        try NameOrOrdinal.fromString(allocator, .{ .slice = "050", .code_page = .windows1252 }),
    );
    // limit of 256 UTF-16 code units, can cut off between a surrogate pair
    {
        var expected = blk: {
            // the input before the 𐐷 character, but uppercased
            const expected_u8_bytes = "00614982008907933748980730280674788429543776231864944218790698304852300002973622122844631429099469274282385299397783838528QFFL7SHNSIETG0QKLR1UYPBTUV1PMFQRRA0VJDG354GQEDJMUPGPP1W1EXVNTZVEIZ6K3IPQM1AWGEYALMEODYVEZGOD3MFMGEY8FNR4JUETTB1PZDEWSNDRGZUA8SNXP3NGO";
            var buf: [256:0]u16 = undefined;
            for (expected_u8_bytes, 0..) |byte, i| {
                buf[i] = std.mem.nativeToLittle(u16, byte);
            }
            // surrogate pair that is now orphaned
            buf[255] = std.mem.nativeToLittle(u16, 0xD801);
            break :blk buf;
        };
        try expectNameOrOrdinal(
            NameOrOrdinal{ .name = &expected },
            try NameOrOrdinal.fromString(allocator, .{
                .slice = "00614982008907933748980730280674788429543776231864944218790698304852300002973622122844631429099469274282385299397783838528qffL7ShnSIETg0qkLr1UYpbtuv1PMFQRRa0VjDG354GQedJmUPgpp1w1ExVnTzVEiz6K3iPqM1AWGeYALmeODyvEZGOD3MfmGey8fnR4jUeTtB1PzdeWsNDrGzuA8Snxp3NGO𐐷",
                .code_page = .utf8,
            }),
        );
    }
}

test "NameOrOrdinal code page awareness" {
    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena.deinit();

    const allocator = arena.allocator();

    try expectNameOrOrdinal(
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("��𐐷") },
        try NameOrOrdinal.fromString(allocator, .{
            .slice = "\xF0\x80\x80𐐷",
            .code_page = .utf8,
        }),
    );
    try expectNameOrOrdinal(
        // The UTF-8 representation of 𐐷 is 0xF0 0x90 0x90 0xB7. In order to provide valid
        // UTF-8 to utf8ToUtf16LeStringLiteral, it uses the UTF-8 representation of the codepoint
        // <U+0x90> which is 0xC2 0x90. The code units in the expected UTF-16 string are:
        // { 0x00F0, 0x20AC, 0x20AC, 0x00F0, 0x0090, 0x0090, 0x00B7 }
        NameOrOrdinal{ .name = std.unicode.utf8ToUtf16LeStringLiteral("ð€€ð\xC2\x90\xC2\x90·") },
        try NameOrOrdinal.fromString(allocator, .{
            .slice = "\xF0\x80\x80𐐷",
            .code_page = .windows1252,
        }),
    );
}

/// https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-accel#members
/// https://devblogs.microsoft.com/oldnewthing/20070316-00/?p=27593
pub const AcceleratorModifiers = struct {
    value: u8 = 0,
    explicit_ascii_or_virtkey: bool = false,

    pub const ASCII = 0;
    pub const VIRTKEY = 1;
    pub const NOINVERT = 1 << 1;
    pub const SHIFT = 1 << 2;
    pub const CONTROL = 1 << 3;
    pub const ALT = 1 << 4;
    /// Marker for the last accelerator in an accelerator table
    pub const last_accelerator_in_table = 1 << 7;

    pub fn apply(self: *AcceleratorModifiers, modifier: rc.AcceleratorTypeAndOptions) void {
        if (modifier == .ascii or modifier == .virtkey) self.explicit_ascii_or_virtkey = true;
        self.value |= modifierValue(modifier);
    }

    pub fn isSet(self: AcceleratorModifiers, modifier: rc.AcceleratorTypeAndOptions) bool {
        // ASCII is set whenever VIRTKEY is not
        if (modifier == .ascii) return self.value & modifierValue(.virtkey) == 0;
        return self.value & modifierValue(modifier) != 0;
    }

    fn modifierValue(modifier: rc.AcceleratorTypeAndOptions) u8 {
        return switch (modifier) {
            .ascii => ASCII,
            .virtkey => VIRTKEY,
            .noinvert => NOINVERT,
            .shift => SHIFT,
            .control => CONTROL,
            .alt => ALT,
        };
    }

    pub fn markLast(self: *AcceleratorModifiers) void {
        self.value |= last_accelerator_in_table;
    }
};

const AcceleratorKeyCodepointTranslator = struct {
    string_type: literals.StringType,
    output_code_page: SupportedCodePage,

    pub fn translate(self: @This(), maybe_parsed: ?literals.IterativeStringParser.ParsedCodepoint) ?u21 {
        const parsed = maybe_parsed orelse return null;
        if (parsed.codepoint == Codepoint.invalid) return 0xFFFD;
        if (parsed.from_escaped_integer) {
            switch (self.string_type) {
                .ascii => {
                    const truncated: u8 = @truncate(parsed.codepoint);
                    switch (self.output_code_page) {
                        .utf8 => switch (truncated) {
                            0...0x7F => return truncated,
                            else => return 0xFFFD,
                        },
                        .windows1252 => return windows1252.toCodepoint(truncated),
                    }
                },
                .wide => {
                    const truncated: u16 = @truncate(parsed.codepoint);
                    return truncated;
                },
            }
        }
        if (parsed.escaped_surrogate_pair) {
            // The codepoint of only the low surrogate
            const low = @as(u16, @intCast(parsed.codepoint & 0x3FF)) + 0xDC00;
            return low;
        }
        return parsed.codepoint;
    }
};

pub const ParseAcceleratorKeyStringError = error{ EmptyAccelerator, AcceleratorTooLong, InvalidControlCharacter, ControlCharacterOutOfRange };

/// Expects bytes to be the full bytes of a string literal token (e.g. including the "" or L"").
pub fn parseAcceleratorKeyString(bytes: SourceBytes, is_virt: bool, options: literals.StringParseOptions) (ParseAcceleratorKeyStringError || Allocator.Error)!u16 {
    if (bytes.slice.len == 0) {
        return error.EmptyAccelerator;
    }

    var parser = literals.IterativeStringParser.init(bytes, options);
    var translator = AcceleratorKeyCodepointTranslator{
        .string_type = parser.declared_string_type,
        .output_code_page = options.output_code_page,
    };

    const first_codepoint = translator.translate(try parser.next()) orelse return error.EmptyAccelerator;
    // 0 is treated as a terminator, so this is equivalent to an empty string
    if (first_codepoint == 0) return error.EmptyAccelerator;

    if (first_codepoint == '^') {
        // Note: Emitting this warning unconditionally whenever ^ is the first character
        //       matches the Win32 RC behavior, but it's questionable whether or not
        //       the warning should be emitted for ^^ since that results in the ASCII
        //       character ^ being written to the .res.
        if (is_virt and options.diagnostics != null) {
            try options.diagnostics.?.diagnostics.append(.{
                .err = .ascii_character_not_equivalent_to_virtual_key_code,
                .type = .warning,
                .code_page = bytes.code_page,
                .token = options.diagnostics.?.token,
            });
        }

        const c = translator.translate(try parser.next()) orelse return error.InvalidControlCharacter;

        const third_codepoint = translator.translate(try parser.next());
        // 0 is treated as a terminator, so a 0 in the third position is fine but
        // anything else is too many codepoints for an accelerator
        if (third_codepoint != null and third_codepoint.? != 0) return error.InvalidControlCharacter;

        switch (c) {
            '^' => return '^', // special case
            'a'...'z', 'A'...'Z' => return std.ascii.toUpper(@intCast(c)) - 0x40,
            // Note: The Windows RC compiler allows more than just A-Z, but what it allows
            //       seems to be tied to some sort of Unicode-aware 'is character' function or something.
            //       The full list of codepoints that trigger an out-of-range error can be found here:
            //       https://gist.github.com/squeek502/2e9d0a4728a83eed074ad9785a209fd0
            //       For codepoints >= 0x80 that don't trigger the error, the Windows RC compiler takes the
            //       codepoint and does the `- 0x40` transformation as if it were A-Z which couldn't lead
            //       to anything useable, so there's no point in emulating that behavior--erroring for
            //       all non-[a-zA-Z] makes much more sense and is what was probably intended by the
            //       Windows RC compiler.
            else => return error.ControlCharacterOutOfRange,
        }
        @compileError("this should be unreachable");
    }

    const second_codepoint = translator.translate(try parser.next());

    var result: u32 = initial_value: {
        if (first_codepoint >= 0x10000) {
            if (second_codepoint != null and second_codepoint.? != 0) return error.AcceleratorTooLong;
            // No idea why it works this way, but this seems to match the Windows RC
            // behavior for codepoints >= 0x10000
            const low = @as(u16, @intCast(first_codepoint & 0x3FF)) + 0xDC00;
            const extra = (first_codepoint - 0x10000) / 0x400;
            break :initial_value low + extra * 0x100;
        }
        break :initial_value first_codepoint;
    };

    // 0 is treated as a terminator
    if (second_codepoint != null and second_codepoint.? == 0) return @truncate(result);

    const third_codepoint = translator.translate(try parser.next());
    // 0 is treated as a terminator, so a 0 in the third position is fine but
    // anything else is too many codepoints for an accelerator
    if (third_codepoint != null and third_codepoint.? != 0) return error.AcceleratorTooLong;

    if (second_codepoint) |c| {
        if (c >= 0x10000) return error.AcceleratorTooLong;
        result <<= 8;
        result += c;
    } else if (is_virt) {
        switch (result) {
            'a'...'z' => result -= 0x20, // toUpper
            else => {},
        }
    }
    return @truncate(result);
}

test "accelerator keys" {
    try std.testing.expectEqual(@as(u16, 1), try parseAcceleratorKeyString(
        .{ .slice = "\"^a\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 1), try parseAcceleratorKeyString(
        .{ .slice = "\"^A\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 26), try parseAcceleratorKeyString(
        .{ .slice = "\"^Z\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, '^'), try parseAcceleratorKeyString(
        .{ .slice = "\"^^\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    try std.testing.expectEqual(@as(u16, 'a'), try parseAcceleratorKeyString(
        .{ .slice = "\"a\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0x6162), try parseAcceleratorKeyString(
        .{ .slice = "\"ab\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    try std.testing.expectEqual(@as(u16, 'C'), try parseAcceleratorKeyString(
        .{ .slice = "\"c\"", .code_page = .windows1252 },
        true,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0x6363), try parseAcceleratorKeyString(
        .{ .slice = "\"cc\"", .code_page = .windows1252 },
        true,
        .{ .output_code_page = .windows1252 },
    ));

    // \x00 or any escape that evaluates to zero acts as a terminator, everything past it
    // is ignored
    try std.testing.expectEqual(@as(u16, 'a'), try parseAcceleratorKeyString(
        .{ .slice = "\"a\\0bcdef\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    // \x80 is € in Windows-1252, which is Unicode codepoint 20AC
    try std.testing.expectEqual(@as(u16, 0x20AC), try parseAcceleratorKeyString(
        .{ .slice = "\"\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // This depends on the code page, though, with codepage 65001, \x80
    // on its own is invalid UTF-8 so it gets converted to the replacement character
    try std.testing.expectEqual(@as(u16, 0xFFFD), try parseAcceleratorKeyString(
        .{ .slice = "\"\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0xCCAC), try parseAcceleratorKeyString(
        .{ .slice = "\"\x80\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // This also behaves the same with escaped characters
    try std.testing.expectEqual(@as(u16, 0x20AC), try parseAcceleratorKeyString(
        .{ .slice = "\"\\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // Even with utf8 code page
    try std.testing.expectEqual(@as(u16, 0x20AC), try parseAcceleratorKeyString(
        .{ .slice = "\"\\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0xCCAC), try parseAcceleratorKeyString(
        .{ .slice = "\"\\x80\\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // Wide string with the actual characters behaves like the ASCII string version
    try std.testing.expectEqual(@as(u16, 0xCCAC), try parseAcceleratorKeyString(
        .{ .slice = "L\"\x80\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // But wide string with escapes behaves differently
    try std.testing.expectEqual(@as(u16, 0x8080), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\x80\\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // and invalid escapes within wide strings get skipped
    try std.testing.expectEqual(@as(u16, 'z'), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\Hz\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    // any non-A-Z codepoints are illegal
    try std.testing.expectError(error.ControlCharacterOutOfRange, parseAcceleratorKeyString(
        .{ .slice = "\"^\x83\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectError(error.ControlCharacterOutOfRange, parseAcceleratorKeyString(
        .{ .slice = "\"^1\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectError(error.InvalidControlCharacter, parseAcceleratorKeyString(
        .{ .slice = "\"^\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectError(error.EmptyAccelerator, parseAcceleratorKeyString(
        .{ .slice = "\"\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectError(error.AcceleratorTooLong, parseAcceleratorKeyString(
        .{ .slice = "\"hello\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectError(error.ControlCharacterOutOfRange, parseAcceleratorKeyString(
        .{ .slice = "\"^\x80\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    // Invalid UTF-8 gets converted to 0xFFFD, multiple invalids get shifted and added together
    // The behavior is the same for ascii and wide strings
    try std.testing.expectEqual(@as(u16, 0xFCFD), try parseAcceleratorKeyString(
        .{ .slice = "\"\x80\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0xFCFD), try parseAcceleratorKeyString(
        .{ .slice = "L\"\x80\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    // Codepoints >= 0x10000
    try std.testing.expectEqual(@as(u16, 0xDD00), try parseAcceleratorKeyString(
        .{ .slice = "\"\xF0\x90\x84\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0xDD00), try parseAcceleratorKeyString(
        .{ .slice = "L\"\xF0\x90\x84\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectEqual(@as(u16, 0x9C01), try parseAcceleratorKeyString(
        .{ .slice = "\"\xF4\x80\x80\x81\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    // anything before or after a codepoint >= 0x10000 causes an error
    try std.testing.expectError(error.AcceleratorTooLong, parseAcceleratorKeyString(
        .{ .slice = "\"a\xF0\x90\x80\x80\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));
    try std.testing.expectError(error.AcceleratorTooLong, parseAcceleratorKeyString(
        .{ .slice = "\"\xF0\x90\x80\x80a\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .windows1252 },
    ));

    // Misc special cases
    try std.testing.expectEqual(@as(u16, 0xFFFD), try parseAcceleratorKeyString(
        .{ .slice = "\"\\777\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .utf8 },
    ));
    try std.testing.expectEqual(@as(u16, 0xFFFF), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\7777777\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .utf8 },
    ));
    try std.testing.expectEqual(@as(u16, 0x01), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\200001\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .utf8 },
    ));
    // Escape of a codepoint >= 0x10000 omits the high surrogate pair
    try std.testing.expectEqual(@as(u16, 0xDF48), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\𐍈\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .utf8 },
    ));
    // Invalid escape code is skipped, allows for 2 codepoints afterwards
    try std.testing.expectEqual(@as(u16, 0x7878), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\kxx\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .utf8 },
    ));
    // Escape of a codepoint >= 0x10000 allows for a codepoint afterwards
    try std.testing.expectEqual(@as(u16, 0x4878), try parseAcceleratorKeyString(
        .{ .slice = "L\"\\𐍈x\"", .code_page = .utf8 },
        false,
        .{ .output_code_page = .utf8 },
    ));
    // Input code page of 1252, output code page of utf-8
    try std.testing.expectEqual(@as(u16, 0xFFFD), try parseAcceleratorKeyString(
        .{ .slice = "\"\\270\"", .code_page = .windows1252 },
        false,
        .{ .output_code_page = .utf8 },
    ));
}

pub const ForcedOrdinal = struct {
    pub fn fromBytes(bytes: SourceBytes) u16 {
        var i: usize = 0;
        var result: u21 = 0;
        while (bytes.code_page.codepointAt(i, bytes.slice)) |codepoint| : (i += codepoint.byte_len) {
            const c = switch (codepoint.value) {
                // Codepoints that would need a surrogate pair in UTF-16 are
                // broken up into their UTF-16 code units and each code unit
                // is interpreted as a digit.
                0x10000...0x10FFFF => {
                    const high = @as(u16, @intCast((codepoint.value - 0x10000) >> 10)) + 0xD800;
                    if (result != 0) result *%= 10;
                    result +%= high -% '0';

                    const low = @as(u16, @intCast(codepoint.value & 0x3FF)) + 0xDC00;
                    if (result != 0) result *%= 10;
                    result +%= low -% '0';
                    continue;
                },
                Codepoint.invalid => 0xFFFD,
                else => codepoint.value,
            };
            if (result != 0) result *%= 10;
            result +%= c -% '0';
        }
        return @truncate(result);
    }

    pub fn fromUtf16Le(utf16: [:0]const u16) u16 {
        var result: u16 = 0;
        for (utf16) |code_unit| {
            if (result != 0) result *%= 10;
            result +%= std.mem.littleToNative(u16, code_unit) -% '0';
        }
        return result;
    }
};

test "forced ordinal" {
    try std.testing.expectEqual(@as(u16, 3200), ForcedOrdinal.fromBytes(.{ .slice = "3200", .code_page = .windows1252 }));
    try std.testing.expectEqual(@as(u16, 0x33), ForcedOrdinal.fromBytes(.{ .slice = "1+1", .code_page = .windows1252 }));
    try std.testing.expectEqual(@as(u16, 65531), ForcedOrdinal.fromBytes(.{ .slice = "1!", .code_page = .windows1252 }));

    try std.testing.expectEqual(@as(u16, 0x122), ForcedOrdinal.fromBytes(.{ .slice = "0\x8C", .code_page = .windows1252 }));
    try std.testing.expectEqual(@as(u16, 0x122), ForcedOrdinal.fromBytes(.{ .slice = "0Œ", .code_page = .utf8 }));

    // invalid UTF-8 gets converted to 0xFFFD (replacement char) and then interpreted as a digit
    try std.testing.expectEqual(@as(u16, 0xFFCD), ForcedOrdinal.fromBytes(.{ .slice = "0\x81", .code_page = .utf8 }));
    // codepoints >= 0x10000
    try std.testing.expectEqual(@as(u16, 0x49F2), ForcedOrdinal.fromBytes(.{ .slice = "0\u{10002}", .code_page = .utf8 }));
    try std.testing.expectEqual(@as(u16, 0x4AF0), ForcedOrdinal.fromBytes(.{ .slice = "0\u{10100}", .code_page = .utf8 }));

    // From UTF-16
    try std.testing.expectEqual(@as(u16, 0x122), ForcedOrdinal.fromUtf16Le(&[_:0]u16{ std.mem.nativeToLittle(u16, '0'), std.mem.nativeToLittle(u16, 'Œ') }));
    try std.testing.expectEqual(@as(u16, 0x4AF0), ForcedOrdinal.fromUtf16Le(std.unicode.utf8ToUtf16LeStringLiteral("0\u{10100}")));
}

/// https://learn.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo
pub const FixedFileInfo = struct {
    file_version: Version = .{},
    product_version: Version = .{},
    file_flags_mask: u32 = 0,
    file_flags: u32 = 0,
    file_os: u32 = 0,
    file_type: u32 = 0,
    file_subtype: u32 = 0,
    file_date: Version = .{}, // TODO: I think this is always all zeroes?

    pub const signature = 0xFEEF04BD;
    // Note: This corresponds to a version of 1.0
    pub const version = 0x00010000;

    pub const byte_len = 0x34;
    pub const key = std.unicode.utf8ToUtf16LeStringLiteral("VS_VERSION_INFO");

    pub const Version = struct {
        parts: [4]u16 = [_]u16{0} ** 4,

        pub fn mostSignificantCombinedParts(self: Version) u32 {
            return (@as(u32, self.parts[0]) << 16) + self.parts[1];
        }

        pub fn leastSignificantCombinedParts(self: Version) u32 {
            return (@as(u32, self.parts[2]) << 16) + self.parts[3];
        }
    };

    pub fn write(self: FixedFileInfo, writer: *std.Io.Writer) !void {
        try writer.writeInt(u32, signature, .little);
        try writer.writeInt(u32, version, .little);
        try writer.writeInt(u32, self.file_version.mostSignificantCombinedParts(), .little);
        try writer.writeInt(u32, self.file_version.leastSignificantCombinedParts(), .little);
        try writer.writeInt(u32, self.product_version.mostSignificantCombinedParts(), .little);
        try writer.writeInt(u32, self.product_version.leastSignificantCombinedParts(), .little);
        try writer.writeInt(u32, self.file_flags_mask, .little);
        try writer.writeInt(u32, self.file_flags, .little);
        try writer.writeInt(u32, self.file_os, .little);
        try writer.writeInt(u32, self.file_type, .little);
        try writer.writeInt(u32, self.file_subtype, .little);
        try writer.writeInt(u32, self.file_date.mostSignificantCombinedParts(), .little);
        try writer.writeInt(u32, self.file_date.leastSignificantCombinedParts(), .little);
    }
};

test "FixedFileInfo.Version" {
    const version = FixedFileInfo.Version{
        .parts = .{ 1, 2, 3, 4 },
    };
    try std.testing.expectEqual(@as(u32, 0x00010002), version.mostSignificantCombinedParts());
    try std.testing.expectEqual(@as(u32, 0x00030004), version.leastSignificantCombinedParts());
}

pub const VersionNode = struct {
    pub const type_string: u16 = 1;
    pub const type_binary: u16 = 0;
};

pub const MenuItemFlags = struct {
    value: u16 = 0,

    pub fn apply(self: *MenuItemFlags, option: rc.MenuItem.Option) void {
        self.value |= optionValue(option);
    }

    pub fn isSet(self: MenuItemFlags, option: rc.MenuItem.Option) bool {
        return self.value & optionValue(option) != 0;
    }

    fn optionValue(option: rc.MenuItem.Option) u16 {
        return @intCast(switch (option) {
            .checked => MF.CHECKED,
            .grayed => MF.GRAYED,
            .help => MF.HELP,
            .inactive => MF.DISABLED,
            .menubarbreak => MF.MENUBARBREAK,
            .menubreak => MF.MENUBREAK,
        });
    }

    pub fn markLast(self: *MenuItemFlags) void {
        self.value |= @intCast(MF.END);
    }
};

/// Menu Flags from WinUser.h
/// This is not complete, it only contains what is needed
pub const MF = struct {
    pub const GRAYED: u32 = 0x00000001;
    pub const DISABLED: u32 = 0x00000002;
    pub const CHECKED: u32 = 0x00000008;
    pub const POPUP: u32 = 0x00000010;
    pub const MENUBARBREAK: u32 = 0x00000020;
    pub const MENUBREAK: u32 = 0x00000040;
    pub const HELP: u32 = 0x00004000;
    pub const END: u32 = 0x00000080;
};

/// Window Styles from WinUser.h
pub const WS = struct {
    pub const OVERLAPPED: u32 = 0x00000000;
    pub const POPUP: u32 = 0x80000000;
    pub const CHILD: u32 = 0x40000000;
    pub const MINIMIZE: u32 = 0x20000000;
    pub const VISIBLE: u32 = 0x10000000;
    pub const DISABLED: u32 = 0x08000000;
    pub const CLIPSIBLINGS: u32 = 0x04000000;
    pub const CLIPCHILDREN: u32 = 0x02000000;
    pub const MAXIMIZE: u32 = 0x01000000;
    pub const CAPTION: u32 = BORDER | DLGFRAME;
    pub const BORDER: u32 = 0x00800000;
    pub const DLGFRAME: u32 = 0x00400000;
    pub const VSCROLL: u32 = 0x00200000;
    pub const HSCROLL: u32 = 0x00100000;
    pub const SYSMENU: u32 = 0x00080000;
    pub const THICKFRAME: u32 = 0x00040000;
    pub const GROUP: u32 = 0x00020000;
    pub const TABSTOP: u32 = 0x00010000;

    pub const MINIMIZEBOX: u32 = 0x00020000;
    pub const MAXIMIZEBOX: u32 = 0x00010000;

    pub const TILED: u32 = OVERLAPPED;
    pub const ICONIC: u32 = MINIMIZE;
    pub const SIZEBOX: u32 = THICKFRAME;
    pub const TILEDWINDOW: u32 = OVERLAPPEDWINDOW;

    // Common Window Styles
    pub const OVERLAPPEDWINDOW: u32 = OVERLAPPED | CAPTION | SYSMENU | THICKFRAME | MINIMIZEBOX | MAXIMIZEBOX;
    pub const POPUPWINDOW: u32 = POPUP | BORDER | SYSMENU;
    pub const CHILDWINDOW: u32 = CHILD;
};

/// Dialog Box Template Styles from WinUser.h
pub const DS = struct {
    pub const SETFONT: u32 = 0x40;
};

/// Button Control Styles from WinUser.h
/// This is not complete, it only contains what is needed
pub const BS = struct {
    pub const PUSHBUTTON: u32 = 0x00000000;
    pub const DEFPUSHBUTTON: u32 = 0x00000001;
    pub const CHECKBOX: u32 = 0x00000002;
    pub const AUTOCHECKBOX: u32 = 0x00000003;
    pub const RADIOBUTTON: u32 = 0x00000004;
    pub const @"3STATE": u32 = 0x00000005;
    pub const AUTO3STATE: u32 = 0x00000006;
    pub const GROUPBOX: u32 = 0x00000007;
    pub const USERBUTTON: u32 = 0x00000008;
    pub const AUTORADIOBUTTON: u32 = 0x00000009;
    pub const PUSHBOX: u32 = 0x0000000A;
    pub const OWNERDRAW: u32 = 0x0000000B;
    pub const TYPEMASK: u32 = 0x0000000F;
    pub const LEFTTEXT: u32 = 0x00000020;
};

/// Static Control Constants from WinUser.h
/// This is not complete, it only contains what is needed
pub const SS = struct {
    pub const LEFT: u32 = 0x00000000;
    pub const CENTER: u32 = 0x00000001;
    pub const RIGHT: u32 = 0x00000002;
    pub const ICON: u32 = 0x00000003;
};

/// Listbox Styles from WinUser.h
/// This is not complete, it only contains what is needed
pub const LBS = struct {
    pub const NOTIFY: u32 = 0x0001;
};