module sapp

// Wayland backend implementation for sokol_app.
// Ports the C _sapp_wl_* functions from sokol_app.h to V.
// This file is only compiled when -d sokol_wayland is used.

$if sokol_wayland ? {
    const fallback_default_window_width = 640
    const fallback_default_window_height = 480

    // XKB keysym constants
    const xkb_key_space = u32(0x0020)
    const xkb_key_apostrophe = u32(0x0027)
    const xkb_key_comma = u32(0x002c)
    const xkb_key_minus = u32(0x002d)
    const xkb_key_period = u32(0x002e)
    const xkb_key_slash = u32(0x002f)
    const xkb_key_0 = u32(0x0030)
    const xkb_key_1 = u32(0x0031)
    const xkb_key_2 = u32(0x0032)
    const xkb_key_3 = u32(0x0033)
    const xkb_key_4 = u32(0x0034)
    const xkb_key_5 = u32(0x0035)
    const xkb_key_6 = u32(0x0036)
    const xkb_key_7 = u32(0x0037)
    const xkb_key_8 = u32(0x0038)
    const xkb_key_9 = u32(0x0039)
    const xkb_key_semicolon = u32(0x003b)
    const xkb_key_equal = u32(0x003d)
    const xkb_key_bracketleft = u32(0x005b)
    const xkb_key_backslash = u32(0x005c)
    const xkb_key_bracketright = u32(0x005d)
    const xkb_key_grave = u32(0x0060)
    const xkb_key_a = u32(0x0061)
    const xkb_key_b = u32(0x0062)
    const xkb_key_c = u32(0x0063)
    const xkb_key_d = u32(0x0064)
    const xkb_key_e = u32(0x0065)
    const xkb_key_f = u32(0x0066)
    const xkb_key_g = u32(0x0067)
    const xkb_key_h = u32(0x0068)
    const xkb_key_i = u32(0x0069)
    const xkb_key_j = u32(0x006a)
    const xkb_key_k = u32(0x006b)
    const xkb_key_l = u32(0x006c)
    const xkb_key_m = u32(0x006d)
    const xkb_key_n = u32(0x006e)
    const xkb_key_o = u32(0x006f)
    const xkb_key_p = u32(0x0070)
    const xkb_key_q = u32(0x0071)
    const xkb_key_r = u32(0x0072)
    const xkb_key_s = u32(0x0073)
    const xkb_key_t = u32(0x0074)
    const xkb_key_u = u32(0x0075)
    const xkb_key_v = u32(0x0076)
    const xkb_key_w = u32(0x0077)
    const xkb_key_x = u32(0x0078)
    const xkb_key_y = u32(0x0079)
    const xkb_key_z = u32(0x007a)
    const xkb_key_backspace = u32(0xff08)
    const xkb_key_tab = u32(0xff09)
    const xkb_key_return = u32(0xff0d)
    const xkb_key_pause = u32(0xff13)
    const xkb_key_scroll_lock = u32(0xff14)
    const xkb_key_escape = u32(0xff1b)
    const xkb_key_home = u32(0xff50)
    const xkb_key_left = u32(0xff51)
    const xkb_key_up = u32(0xff52)
    const xkb_key_right = u32(0xff53)
    const xkb_key_down = u32(0xff54)
    const xkb_key_page_up = u32(0xff55)
    const xkb_key_page_down = u32(0xff56)
    const xkb_key_end = u32(0xff57)
    const xkb_key_print = u32(0xff61)
    const xkb_key_insert = u32(0xff63)
    const xkb_key_menu = u32(0xff67)
    const xkb_key_num_lock = u32(0xff7f)
    const xkb_key_kp_enter = u32(0xff8d)
    const xkb_key_kp_multiply = u32(0xffaa)
    const xkb_key_kp_add = u32(0xffab)
    const xkb_key_kp_subtract = u32(0xffad)
    const xkb_key_kp_decimal = u32(0xffae)
    const xkb_key_kp_divide = u32(0xffaf)
    const xkb_key_kp_0 = u32(0xffb0)
    const xkb_key_kp_1 = u32(0xffb1)
    const xkb_key_kp_2 = u32(0xffb2)
    const xkb_key_kp_3 = u32(0xffb3)
    const xkb_key_kp_4 = u32(0xffb4)
    const xkb_key_kp_5 = u32(0xffb5)
    const xkb_key_kp_6 = u32(0xffb6)
    const xkb_key_kp_7 = u32(0xffb7)
    const xkb_key_kp_8 = u32(0xffb8)
    const xkb_key_kp_9 = u32(0xffb9)
    const xkb_key_kp_equal = u32(0xffbd)
    const xkb_key_f1 = u32(0xffbe)
    const xkb_key_f2 = u32(0xffbf)
    const xkb_key_f3 = u32(0xffc0)
    const xkb_key_f4 = u32(0xffc1)
    const xkb_key_f5 = u32(0xffc2)
    const xkb_key_f6 = u32(0xffc3)
    const xkb_key_f7 = u32(0xffc4)
    const xkb_key_f8 = u32(0xffc5)
    const xkb_key_f9 = u32(0xffc6)
    const xkb_key_f10 = u32(0xffc7)
    const xkb_key_f11 = u32(0xffc8)
    const xkb_key_f12 = u32(0xffc9)
    const xkb_key_f13 = u32(0xffca)
    const xkb_key_f14 = u32(0xffcb)
    const xkb_key_f15 = u32(0xffcc)
    const xkb_key_f16 = u32(0xffcd)
    const xkb_key_f17 = u32(0xffce)
    const xkb_key_f18 = u32(0xffcf)
    const xkb_key_f19 = u32(0xffd0)
    const xkb_key_f20 = u32(0xffd1)
    const xkb_key_f21 = u32(0xffd2)
    const xkb_key_f22 = u32(0xffd3)
    const xkb_key_f23 = u32(0xffd4)
    const xkb_key_f24 = u32(0xffd5)
    const xkb_key_f25 = u32(0xffd6)
    const xkb_key_shift_l = u32(0xffe1)
    const xkb_key_shift_r = u32(0xffe2)
    const xkb_key_control_l = u32(0xffe3)
    const xkb_key_control_r = u32(0xffe4)
    const xkb_key_caps_lock = u32(0xffe5)
    const xkb_key_alt_l = u32(0xffe9)
    const xkb_key_alt_r = u32(0xffea)
    const xkb_key_super_l = u32(0xffeb)
    const xkb_key_delete = u32(0xffff)

    // === Key translation ===

    fn wl_translate_key(keysym Xkb_keysym_t) KeyCode {
        key := linux_translate_navigation_or_keypad_keysym(u32(keysym))
        if key != .invalid {
            return key
        }
        return match keysym {
            xkb_key_space { .space }
            xkb_key_apostrophe { .apostrophe }
            xkb_key_comma { .comma }
            xkb_key_minus { .minus }
            xkb_key_period { .period }
            xkb_key_slash { .slash }
            xkb_key_0 { ._0 }
            xkb_key_1 { ._1 }
            xkb_key_2 { ._2 }
            xkb_key_3 { ._3 }
            xkb_key_4 { ._4 }
            xkb_key_5 { ._5 }
            xkb_key_6 { ._6 }
            xkb_key_7 { ._7 }
            xkb_key_8 { ._8 }
            xkb_key_9 { ._9 }
            xkb_key_semicolon { .semicolon }
            xkb_key_equal { .equal }
            xkb_key_a { .a }
            xkb_key_b { .b }
            xkb_key_c { .c }
            xkb_key_d { .d }
            xkb_key_e { .e }
            xkb_key_f { .f }
            xkb_key_g { .g }
            xkb_key_h { .h }
            xkb_key_i { .i }
            xkb_key_j { .j }
            xkb_key_k { .k }
            xkb_key_l { .l }
            xkb_key_m { .m }
            xkb_key_n { .n }
            xkb_key_o { .o }
            xkb_key_p { .p }
            xkb_key_q { .q }
            xkb_key_r { .r }
            xkb_key_s { .s }
            xkb_key_t { .t }
            xkb_key_u { .u }
            xkb_key_v { .v }
            xkb_key_w { .w }
            xkb_key_x { .x }
            xkb_key_y { .y }
            xkb_key_z { .z }
            xkb_key_bracketleft { .left_bracket }
            xkb_key_backslash { .backslash }
            xkb_key_bracketright { .right_bracket }
            xkb_key_grave { .grave_accent }
            xkb_key_escape { .escape }
            xkb_key_return { .enter }
            xkb_key_tab { .tab }
            xkb_key_backspace { .backspace }
            xkb_key_caps_lock { .caps_lock }
            xkb_key_scroll_lock { .scroll_lock }
            xkb_key_num_lock { .num_lock }
            xkb_key_print { .print_screen }
            xkb_key_pause { .pause }
            xkb_key_f1 { .f1 }
            xkb_key_f2 { .f2 }
            xkb_key_f3 { .f3 }
            xkb_key_f4 { .f4 }
            xkb_key_f5 { .f5 }
            xkb_key_f6 { .f6 }
            xkb_key_f7 { .f7 }
            xkb_key_f8 { .f8 }
            xkb_key_f9 { .f9 }
            xkb_key_f10 { .f10 }
            xkb_key_f11 { .f11 }
            xkb_key_f12 { .f12 }
            xkb_key_f13 { .f13 }
            xkb_key_f14 { .f14 }
            xkb_key_f15 { .f15 }
            xkb_key_f16 { .f16 }
            xkb_key_f17 { .f17 }
            xkb_key_f18 { .f18 }
            xkb_key_f19 { .f19 }
            xkb_key_f20 { .f20 }
            xkb_key_f21 { .f21 }
            xkb_key_f22 { .f22 }
            xkb_key_f23 { .f23 }
            xkb_key_f24 { .f24 }
            xkb_key_f25 { .f25 }
            xkb_key_shift_l { .left_shift }
            xkb_key_control_l { .left_control }
            xkb_key_alt_l { .left_alt }
            xkb_key_super_l { .left_super }
            xkb_key_shift_r { .right_shift }
            xkb_key_control_r { .right_control }
            xkb_key_alt_r { .right_alt }
            xkb_key_menu { .menu }
            else { .invalid }
        }
    }

    // === Modifier helpers ===

    fn wl_get_modifiers() u32 {
        mut mods := u32(0)
        if g_sapp_state.wl.xkb_state != unsafe { nil } {
            if C.xkb_state_mod_name_is_active(g_sapp_state.wl.xkb_state, xkb_mod_name_shift,
                xkb_state_mods_effective) > 0 {
                mods |= u32(Modifier.shift)
            }
            if C.xkb_state_mod_name_is_active(g_sapp_state.wl.xkb_state, xkb_mod_name_ctrl,
                xkb_state_mods_effective) > 0 {
                mods |= u32(Modifier.ctrl)
            }
            if C.xkb_state_mod_name_is_active(g_sapp_state.wl.xkb_state, xkb_mod_name_alt,
                xkb_state_mods_effective) > 0 {
                mods |= u32(Modifier.alt)
            }
            if C.xkb_state_mod_name_is_active(g_sapp_state.wl.xkb_state, xkb_mod_name_logo,
                xkb_state_mods_effective) > 0 {
                mods |= u32(Modifier.super)
            }
        }
        return mods
    }

    fn wl_app_event(etype EventType) {
        if g_sapp_state.desc.event_cb != unsafe { nil }
            || g_sapp_state.desc.event_userdata_cb != unsafe { nil } {
            init_sapp_event(etype)
            call_sapp_event(&g_sapp_state.event)
        }
    }

    // === UTF-8 decoding ===

    fn utf8_decode(buf &u8, count int) u32 {
        if count <= 0 {
            return 0
        }
        b0 := unsafe { buf[0] }
        if (b0 & 0x80) == 0 {
            return u32(b0)
        } else if (b0 & 0xE0) == 0xC0 && count >= 2 {
            return (u32(b0 & 0x1F) << 6) | u32(unsafe { buf[1] } & 0x3F)
        } else if (b0 & 0xF0) == 0xE0 && count >= 3 {
            return (u32(b0 & 0x0F) << 12) | (u32(unsafe { buf[1] } & 0x3F) << 6) | u32(unsafe { buf[2] } & 0x3F)
        } else if (b0 & 0xF8) == 0xF0 && count >= 4 {
            return (u32(b0 & 0x07) << 18) | (u32(unsafe { buf[1] } & 0x3F) << 12) | (u32(unsafe { buf[2] } & 0x3F) << 6) | u32(unsafe { buf[3] } & 0x3F)
        }
        return 0
    }

    // === Key repeat ===

    fn wl_setup_key_repeat_timer() {
        if g_sapp_state.wl.key_repeat_timer_fd >= 0 {
            C.close(g_sapp_state.wl.key_repeat_timer_fd)
        }
        g_sapp_state.wl.key_repeat_timer_fd = C.timerfd_create(clock_monotonic,
            tfd_cloexec | tfd_nonblock)
    }

    fn wl_start_key_repeat(scancode u32) {
        if g_sapp_state.wl.key_repeat_timer_fd < 0 || g_sapp_state.wl.key_repeat_rate <= 0 {
            return
        }
        g_sapp_state.wl.key_repeat_keycode = scancode

        delay_ms := g_sapp_state.wl.key_repeat_delay
        rate := g_sapp_state.wl.key_repeat_rate
        repeat_interval_ns := i64(1000000000) / i64(rate)

        timer := C.itimerspec{
            it_value:    C.timespec{
                tv_sec:  i64(delay_ms / 1000)
                tv_nsec: i64((delay_ms % 1000)) * 1000000
            }
            it_interval: C.timespec{
                tv_sec:  repeat_interval_ns / i64(1000000000)
                tv_nsec: repeat_interval_ns % i64(1000000000)
            }
        }
        C.timerfd_settime(g_sapp_state.wl.key_repeat_timer_fd, 0, &timer, unsafe { nil })
    }

    fn wl_stop_key_repeat() {
        if g_sapp_state.wl.key_repeat_timer_fd < 0 {
            return
        }
        timer := C.itimerspec{}
        C.timerfd_settime(g_sapp_state.wl.key_repeat_timer_fd, 0, &timer, unsafe { nil })
        g_sapp_state.wl.key_repeat_keycode = 0
    }

    fn wl_handle_key_repeat() {
        if g_sapp_state.wl.key_repeat_timer_fd < 0 || g_sapp_state.wl.key_repeat_keycode == 0 {
            return
        }
        mut expirations := u64(0)
        if C.read(g_sapp_state.wl.key_repeat_timer_fd, &expirations, sizeof(expirations)) > 0
            && expirations > 0 {
            if g_sapp_state.wl.xkb_state == unsafe { nil } {
                return
            }
            keysym := C.xkb_state_key_get_one_sym(g_sapp_state.wl.xkb_state,
                g_sapp_state.wl.key_repeat_keycode)
            sapp_key := wl_translate_key(keysym)

            if sapp_key != .invalid {
                init_sapp_event(.key_down)
                g_sapp_state.event.key_code = sapp_key
                g_sapp_state.event.key_repeat = true
                g_sapp_state.event.modifiers = wl_get_modifiers()
                call_sapp_event(&g_sapp_state.event)
            }

            mut buf := [8]u8{}
            count := C.xkb_state_key_get_utf8(g_sapp_state.wl.xkb_state,
                g_sapp_state.wl.key_repeat_keycode, &char(&buf[0]), usize(buf.len))
            if count > 0 && count < buf.len {
                codepoint := utf8_decode(&buf[0], count)
                if codepoint > 0 && codepoint < 0x110000 {
                    init_sapp_event(.char)
                    g_sapp_state.event.char_code = codepoint
                    g_sapp_state.event.key_repeat = true
                    g_sapp_state.event.modifiers = wl_get_modifiers()
                    call_sapp_event(&g_sapp_state.event)
                }
            }
        }
    }

    // === Keyboard listener callbacks ===

    fn wl_keyboard_handle_keymap(data voidptr, keyboard &C.wl_keyboard, format u32, fd int, size u32) {
        if format != wl_keyboard_keymap_format_xkb_v1 {
            C.close(fd)
            return
        }
        map_str := C.mmap(unsafe { nil }, usize(size), prot_read, map_private, fd, 0)
        if map_str == map_failed {
            C.close(fd)
            return
        }
        if g_sapp_state.wl.xkb_keymap != unsafe { nil } {
            C.xkb_keymap_unref(g_sapp_state.wl.xkb_keymap)
        }
        g_sapp_state.wl.xkb_keymap = C.xkb_keymap_new_from_string(g_sapp_state.wl.xkb_context,
            map_str, xkb_keymap_format_text_v1, xkb_keymap_compile_no_flags)
        C.munmap(map_str, usize(size))
        C.close(fd)

        if g_sapp_state.wl.xkb_keymap == unsafe { nil } {
            return
        }
        if g_sapp_state.wl.xkb_state != unsafe { nil } {
            C.xkb_state_unref(g_sapp_state.wl.xkb_state)
        }
        g_sapp_state.wl.xkb_state = C.xkb_state_new(g_sapp_state.wl.xkb_keymap)
    }

    fn wl_keyboard_handle_enter(data voidptr, keyboard &C.wl_keyboard, serial u32, surface &C.wl_surface, keys &C.wl_array) {
        g_sapp_state.wl.focused = true
        wl_app_event(.focused)
    }

    fn wl_keyboard_handle_leave(data voidptr, keyboard &C.wl_keyboard, serial u32, surface &C.wl_surface) {
        g_sapp_state.wl.focused = false
        wl_app_event(.unfocused)
    }

    fn wl_keyboard_handle_key(data voidptr, keyboard &C.wl_keyboard, serial u32, time u32, key u32, state u32) {
        if g_sapp_state.wl.xkb_state == unsafe { nil } {
            return
        }
        // Wayland key codes are Linux input codes + 8
        keycode := key + 8
        keysym := C.xkb_state_key_get_one_sym(g_sapp_state.wl.xkb_state, keycode)
        sapp_key := wl_translate_key(keysym)

        if sapp_key != .invalid {
            etype := if state == wl_keyboard_key_state_pressed {
                EventType.key_down
            } else {
                EventType.key_up
            }
            init_sapp_event(etype)
            g_sapp_state.event.key_code = sapp_key
            g_sapp_state.event.key_repeat = false
            g_sapp_state.event.modifiers = wl_get_modifiers()
            call_sapp_event(&g_sapp_state.event)

            if state == wl_keyboard_key_state_pressed {
                wl_start_key_repeat(keycode)
            } else {
                if g_sapp_state.wl.key_repeat_keycode == keycode {
                    wl_stop_key_repeat()
                }
            }
        }

        // Generate CHAR event for key press
        if state == wl_keyboard_key_state_pressed {
            mut buf := [8]u8{}
            count := C.xkb_state_key_get_utf8(g_sapp_state.wl.xkb_state, keycode, &char(&buf[0]),
                usize(buf.len))
            if count > 0 && count < buf.len {
                codepoint := utf8_decode(&buf[0], count)
                if codepoint > 0 && codepoint < 0x110000 {
                    init_sapp_event(.char)
                    g_sapp_state.event.char_code = codepoint
                    g_sapp_state.event.key_repeat = false
                    g_sapp_state.event.modifiers = wl_get_modifiers()
                    call_sapp_event(&g_sapp_state.event)
                }
            }
        }
    }

    fn wl_keyboard_handle_modifiers(data voidptr, keyboard &C.wl_keyboard, serial u32, mods_depressed u32, mods_latched u32, mods_locked u32, group u32) {
        if g_sapp_state.wl.xkb_state != unsafe { nil } {
            C.xkb_state_update_mask(g_sapp_state.wl.xkb_state, mods_depressed, mods_latched,
                mods_locked, 0, 0, group)
        }
    }

    fn wl_keyboard_handle_repeat_info(data voidptr, keyboard &C.wl_keyboard, rate int, delay int) {
        g_sapp_state.wl.key_repeat_rate = rate
        g_sapp_state.wl.key_repeat_delay = delay
    }

    // === Pointer listener callbacks ===

    fn wl_pointer_handle_enter(data voidptr, pointer &C.wl_pointer, serial u32, surface &C.wl_surface, sx i32, sy i32) {
        mut x := f32(C.wl_fixed_to_double(sx))
        mut y := f32(C.wl_fixed_to_double(sy))
        if g_sapp_state.wl.viewport != unsafe { nil } && g_sapp_state.wl.scale > 1.0 {
            x *= g_sapp_state.wl.scale
            y *= g_sapp_state.wl.scale
        }
        g_sapp_state.mouse.x = x
        g_sapp_state.mouse.y = y
        g_sapp_state.wl.pointer_enter_serial = serial

        init_sapp_event(.mouse_enter)
        g_sapp_state.event.mouse_x = g_sapp_state.mouse.x
        g_sapp_state.event.mouse_y = g_sapp_state.mouse.y
        call_sapp_event(&g_sapp_state.event)
    }

    fn wl_pointer_handle_leave(data voidptr, pointer &C.wl_pointer, serial u32, surface &C.wl_surface) {
        init_sapp_event(.mouse_leave)
        call_sapp_event(&g_sapp_state.event)
    }

    fn wl_pointer_handle_motion(data voidptr, pointer &C.wl_pointer, time u32, sx i32, sy i32) {
        mut new_x := f32(C.wl_fixed_to_double(sx))
        mut new_y := f32(C.wl_fixed_to_double(sy))
        if g_sapp_state.wl.viewport != unsafe { nil } && g_sapp_state.wl.scale > 1.0 {
            new_x *= g_sapp_state.wl.scale
            new_y *= g_sapp_state.wl.scale
        }
        g_sapp_state.mouse.dx = new_x - g_sapp_state.mouse.x
        g_sapp_state.mouse.dy = new_y - g_sapp_state.mouse.y
        g_sapp_state.mouse.x = new_x
        g_sapp_state.mouse.y = new_y

        init_sapp_event(.mouse_move)
        g_sapp_state.event.mouse_x = g_sapp_state.mouse.x
        g_sapp_state.event.mouse_y = g_sapp_state.mouse.y
        g_sapp_state.event.mouse_dx = g_sapp_state.mouse.dx
        g_sapp_state.event.mouse_dy = g_sapp_state.mouse.dy
        call_sapp_event(&g_sapp_state.event)
    }

    fn wl_pointer_handle_button(data voidptr, pointer &C.wl_pointer, serial u32, time u32, button u32, state u32) {
        sapp_btn := match button {
            u32(btn_left) { MouseButton.left }
            u32(btn_right) { MouseButton.right }
            u32(btn_middle) { MouseButton.middle }
            else { MouseButton.invalid }
        }

        if sapp_btn != .invalid {
            etype := if state == wl_pointer_button_state_pressed {
                EventType.mouse_down
            } else {
                EventType.mouse_up
            }
            init_sapp_event(etype)
            g_sapp_state.event.mouse_button = sapp_btn
            g_sapp_state.event.modifiers = wl_get_modifiers()
            call_sapp_event(&g_sapp_state.event)
        }
    }

    fn wl_pointer_handle_axis(data voidptr, pointer &C.wl_pointer, time u32, axis u32, value i32) {
        scroll_value := f32(C.wl_fixed_to_double(value))
        init_sapp_event(.mouse_scroll)
        if axis == wl_pointer_axis_vertical_scroll {
            g_sapp_state.event.scroll_y = -scroll_value / 10.0
        } else if axis == wl_pointer_axis_horizontal_scroll {
            g_sapp_state.event.scroll_x = scroll_value / 10.0
        }
        g_sapp_state.event.modifiers = wl_get_modifiers()
        call_sapp_event(&g_sapp_state.event)
    }

    fn wl_pointer_handle_frame(data voidptr, pointer &C.wl_pointer) {}

    fn wl_pointer_handle_axis_source(data voidptr, pointer &C.wl_pointer, axis_source u32) {}

    fn wl_pointer_handle_axis_stop(data voidptr, pointer &C.wl_pointer, time u32, axis u32) {}

    fn wl_pointer_handle_axis_discrete(data voidptr, pointer &C.wl_pointer, axis u32, discrete i32) {}

    fn wl_pointer_handle_axis_value120(data voidptr, pointer &C.wl_pointer, axis u32, value120 i32) {}

    fn wl_pointer_handle_axis_relative_direction(data voidptr, pointer &C.wl_pointer, axis u32, direction u32) {}

    // === Seat listener callbacks ===

    fn wl_seat_handle_capabilities(data voidptr, seat &C.wl_seat, caps u32) {
        // Keyboard
        if (caps & wl_seat_capability_keyboard) != 0 && g_sapp_state.wl.keyboard == unsafe { nil } {
            g_sapp_state.wl.keyboard = C.wl_seat_get_keyboard(seat)
            C.wl_keyboard_add_listener(g_sapp_state.wl.keyboard, &wl_keyboard_listener,
                unsafe { nil })
        } else if (caps & wl_seat_capability_keyboard) == 0
            && g_sapp_state.wl.keyboard != unsafe { nil } {
            C.wl_keyboard_destroy(g_sapp_state.wl.keyboard)
            g_sapp_state.wl.keyboard = unsafe { nil }
        }

        // Pointer
        if (caps & wl_seat_capability_pointer) != 0 && g_sapp_state.wl.pointer == unsafe { nil } {
            g_sapp_state.wl.pointer = C.wl_seat_get_pointer(seat)
            C.wl_pointer_add_listener(g_sapp_state.wl.pointer, &wl_pointer_listener, unsafe { nil })

            if g_sapp_state.wl.cursor_shape_manager != unsafe { nil }
                && g_sapp_state.wl.cursor_shape_device == unsafe { nil } {
                g_sapp_state.wl.cursor_shape_device = C.wp_cursor_shape_manager_v1_get_pointer(g_sapp_state.wl.cursor_shape_manager,
                    g_sapp_state.wl.pointer)
            }
            if g_sapp_state.wl.relative_pointer_mgr != unsafe { nil }
                && g_sapp_state.wl.relative_pointer == unsafe { nil } {
                g_sapp_state.wl.relative_pointer = C.zwp_relative_pointer_manager_v1_get_relative_pointer(g_sapp_state.wl.relative_pointer_mgr,
                    g_sapp_state.wl.pointer)
            }
            if g_sapp_state.wl.data_device_manager != unsafe { nil }
                && g_sapp_state.wl.data_device == unsafe { nil } {
                g_sapp_state.wl.data_device =
                    C.wl_data_device_manager_get_data_device(g_sapp_state.wl.data_device_manager, seat)
                C.wl_data_device_add_listener(g_sapp_state.wl.data_device,
                    &wl_data_device_listener, unsafe { nil })
            }
        } else if (caps & wl_seat_capability_pointer) == 0
            && g_sapp_state.wl.pointer != unsafe { nil } {
            if g_sapp_state.wl.cursor_shape_device != unsafe { nil } {
                C.wp_cursor_shape_device_v1_destroy(g_sapp_state.wl.cursor_shape_device)
                g_sapp_state.wl.cursor_shape_device = unsafe { nil }
            }
            if g_sapp_state.wl.relative_pointer != unsafe { nil } {
                C.zwp_relative_pointer_v1_destroy(g_sapp_state.wl.relative_pointer)
                g_sapp_state.wl.relative_pointer = unsafe { nil }
            }
            if g_sapp_state.wl.data_device != unsafe { nil } {
                C.wl_data_device_destroy(g_sapp_state.wl.data_device)
                g_sapp_state.wl.data_device = unsafe { nil }
            }
            C.wl_pointer_destroy(g_sapp_state.wl.pointer)
            g_sapp_state.wl.pointer = unsafe { nil }
        }

        // Touch
        if (caps & wl_seat_capability_touch) != 0 && g_sapp_state.wl.touch == unsafe { nil } {
            g_sapp_state.wl.touch = C.wl_seat_get_touch(seat)
        } else if (caps & wl_seat_capability_touch) == 0 && g_sapp_state.wl.touch != unsafe { nil } {
            C.wl_touch_destroy(g_sapp_state.wl.touch)
            g_sapp_state.wl.touch = unsafe { nil }
        }
    }

    fn wl_seat_handle_name(data voidptr, seat &C.wl_seat, name &char) {
    }

    // === Registry listener callbacks ===

    fn wl_registry_handle_global(data voidptr, registry &C.wl_registry, name u32, iface &char, version u32) {
        unsafe {
            if C.strcmp(iface, c'wl_compositor') == 0 {
                g_sapp_state.wl.compositor = &C.wl_compositor(C.wl_registry_bind(registry, name,
                    &C.wl_compositor_interface, 4))
            } else if C.strcmp(iface, c'xdg_wm_base') == 0 {
                g_sapp_state.wl.xdg_wm_base = &C.xdg_wm_base(C.wl_registry_bind(registry, name,
                    &C.xdg_wm_base_interface, 1))
            } else if C.strcmp(iface, c'wl_seat') == 0 {
                g_sapp_state.wl.seat = &C.wl_seat(C.wl_registry_bind(registry, name,
                    &C.wl_seat_interface, 5))
                C.wl_seat_add_listener(g_sapp_state.wl.seat, &wl_seat_listener, nil)
            } else if C.strcmp(iface, c'wl_shm') == 0 {
                g_sapp_state.wl.shm = &C.wl_shm(C.wl_registry_bind(registry, name,
                    &C.wl_shm_interface, 1))
            } else if C.strcmp(iface, c'wl_data_device_manager') == 0 {
                g_sapp_state.wl.data_device_manager = &C.wl_data_device_manager(C.wl_registry_bind(registry,
                    name, &C.wl_data_device_manager_interface, 3))
            } else if C.strcmp(iface, c'wp_fractional_scale_manager_v1') == 0 {
                g_sapp_state.wl.fractional_scale_mgr = &C.wp_fractional_scale_manager_v1(C.wl_registry_bind(registry,
                    name, &C.wp_fractional_scale_manager_v1_interface, 1))
            } else if C.strcmp(iface, c'wp_viewporter') == 0 {
                g_sapp_state.wl.viewporter = &C.wp_viewporter(C.wl_registry_bind(registry, name,
                    &C.wp_viewporter_interface, 1))
            } else if C.strcmp(iface, c'wp_cursor_shape_manager_v1') == 0 {
                g_sapp_state.wl.cursor_shape_manager = &C.wp_cursor_shape_manager_v1(C.wl_registry_bind(registry,
                    name, &C.wp_cursor_shape_manager_v1_interface, 1))
            } else if C.strcmp(iface, c'zwp_pointer_constraints_v1') == 0 {
                g_sapp_state.wl.pointer_constraints = &C.zwp_pointer_constraints_v1(C.wl_registry_bind(registry,
                    name, &C.zwp_pointer_constraints_v1_interface, 1))
            } else if C.strcmp(iface, c'zwp_relative_pointer_manager_v1') == 0 {
                g_sapp_state.wl.relative_pointer_mgr = &C.zwp_relative_pointer_manager_v1(C.wl_registry_bind(registry,
                    name, &C.zwp_relative_pointer_manager_v1_interface, 1))
            } else if C.strcmp(iface, c'zxdg_decoration_manager_v1') == 0 {
                g_sapp_state.wl.decoration_manager = &C.zxdg_decoration_manager_v1(C.wl_registry_bind(registry,
                    name, &C.zxdg_decoration_manager_v1_interface, 1))
            }
        }
    }

    fn wl_registry_handle_global_remove(data voidptr, registry &C.wl_registry, name u32) {
    }

    // === XDG surface / toplevel callbacks ===

    fn wl_xdg_surface_configure(data voidptr, xdg_surface &C.xdg_surface, serial u32) {
        C.xdg_surface_ack_configure(xdg_surface, serial)
    }

    fn wl_xdg_toplevel_configure(data voidptr, xdg_toplevel &C.xdg_toplevel, width int, height int, states &C.wl_array) {
        // Iterate wl_array of uint32_t states
        mut is_fullscreen := false
        mut is_maximized := false
        if states.size > 0 {
            state_ptr := &u32(states.data)
            num_states := int(states.size / sizeof(u32))
            for i in 0 .. num_states {
                s := unsafe { state_ptr[i] }
                if s == xdg_toplevel_state_fullscreen {
                    is_fullscreen = true
                }
                if s == xdg_toplevel_state_maximized {
                    is_maximized = true
                }
            }
        }
        g_sapp_state.fullscreen = is_fullscreen
        _ = is_maximized

        if width > 0 && height > 0 {
            size_changed := g_sapp_state.wl.width != width || g_sapp_state.wl.height != height

            g_sapp_state.wl.width = width
            g_sapp_state.wl.height = height

            // Apply fractional scale if available and high_dpi is enabled
            if g_sapp_state.wl.scale_numerator > 0 && g_sapp_state.desc.high_dpi {
                g_sapp_state.wl.scale = f32(g_sapp_state.wl.scale_numerator) / 120.0
                g_sapp_state.dpi_scale = if g_sapp_state.wl.viewport != unsafe { nil } {
                    f32(1.0)
                } else {
                    g_sapp_state.wl.scale
                }
            }

            g_sapp_state.wl.fb_width = int(f32(g_sapp_state.wl.width) * g_sapp_state.wl.scale)
            g_sapp_state.wl.fb_height = int(f32(g_sapp_state.wl.height) * g_sapp_state.wl.scale)

            g_sapp_state.window_width = width
            g_sapp_state.window_height = height
            g_sapp_state.framebuffer_width = g_sapp_state.wl.fb_width
            g_sapp_state.framebuffer_height = g_sapp_state.wl.fb_height

            if g_sapp_state.wl.egl_window != unsafe { nil } {
                C.wl_egl_window_resize(g_sapp_state.wl.egl_window, g_sapp_state.wl.fb_width,
                    g_sapp_state.wl.fb_height, 0, 0)
            }
            if g_sapp_state.wl.viewport != unsafe { nil } {
                C.wp_viewport_set_destination(g_sapp_state.wl.viewport, width, height)
            }
            if size_changed && !g_sapp_state.first_frame {
                wl_app_event(.resized)
            }
        }
    }

    fn wl_xdg_toplevel_close(data voidptr, xdg_toplevel &C.xdg_toplevel) {
        g_sapp_state.quit_requested = true
    }

    // === Fractional scale callback ===

    fn wl_fractional_scale_preferred_scale(data voidptr, fractional_scale &C.wp_fractional_scale_v1, scale u32) {
        g_sapp_state.wl.scale_numerator = scale

        if g_sapp_state.desc.high_dpi {
            g_sapp_state.wl.scale = f32(scale) / 120.0
            g_sapp_state.dpi_scale = if g_sapp_state.wl.viewport != unsafe { nil } {
                f32(1.0)
            } else {
                g_sapp_state.wl.scale
            }
        } else {
            g_sapp_state.wl.scale = 1.0
            g_sapp_state.dpi_scale = 1.0
        }

        g_sapp_state.wl.fb_width = int(f32(g_sapp_state.wl.width) * g_sapp_state.wl.scale)
        g_sapp_state.wl.fb_height = int(f32(g_sapp_state.wl.height) * g_sapp_state.wl.scale)
        g_sapp_state.framebuffer_width = g_sapp_state.wl.fb_width
        g_sapp_state.framebuffer_height = g_sapp_state.wl.fb_height

        if g_sapp_state.wl.egl_window != unsafe { nil } {
            C.wl_egl_window_resize(g_sapp_state.wl.egl_window, g_sapp_state.wl.fb_width,
                g_sapp_state.wl.fb_height, 0, 0)
        }
        if g_sapp_state.wl.viewport != unsafe { nil } {
            C.wp_viewport_set_destination(g_sapp_state.wl.viewport, g_sapp_state.wl.width,
                g_sapp_state.wl.height)
        }
    }

    // === Data device callbacks (drag and drop) ===

    fn wl_data_offer_offer(data voidptr, offer &C.wl_data_offer, mime_type &char) {
        if C.strcmp(mime_type, c'text/uri-list') == 0 {
            g_sapp_state.wl.data_offer = unsafe { offer }
        }
    }

    fn wl_data_offer_source_actions(data voidptr, offer &C.wl_data_offer, source_actions u32) {
    }

    fn wl_data_offer_action(data voidptr, offer &C.wl_data_offer, dnd_action u32) {
    }

    fn wl_data_device_data_offer(data voidptr, device &C.wl_data_device, offer &C.wl_data_offer) {
        C.wl_data_offer_add_listener(offer, &wl_data_offer_listener, unsafe { nil })
    }

    fn wl_data_device_enter(data voidptr, device &C.wl_data_device, serial u32, surface &C.wl_surface, x i32, y i32, offer &C.wl_data_offer) {
        if offer != unsafe { nil } && g_sapp_state.wl.data_offer == offer {
            C.wl_data_offer_accept(offer, serial, c'text/uri-list')
            C.wl_data_offer_set_actions(offer, wl_data_device_manager_dnd_action_copy,
                wl_data_device_manager_dnd_action_copy)
        }
    }

    fn wl_data_device_leave(data voidptr, device &C.wl_data_device) {
        if g_sapp_state.wl.data_offer != unsafe { nil } {
            C.wl_data_offer_destroy(g_sapp_state.wl.data_offer)
            g_sapp_state.wl.data_offer = unsafe { nil }
        }
    }

    fn wl_data_device_motion(data voidptr, device &C.wl_data_device, time u32, x i32, y i32) {
    }

    fn wl_data_device_drop(data voidptr, device &C.wl_data_device) {
        if g_sapp_state.wl.data_offer == unsafe { nil } {
            return
        }
        mut fds := [2]int{}
        if C.pipe(&fds[0]) == -1 {
            C.wl_data_offer_destroy(g_sapp_state.wl.data_offer)
            g_sapp_state.wl.data_offer = unsafe { nil }
            return
        }
        C.wl_data_offer_receive(g_sapp_state.wl.data_offer, c'text/uri-list', fds[1])
        C.close(fds[1])
        C.wl_display_flush(g_sapp_state.wl.display)

        mut buffer := [8192]u8{}
        mut total_read := isize(0)
        for {
            n := C.read(fds[0], unsafe { &buffer[0] + total_read }, usize(buffer.len -
                int(total_read) - 1))
            if n <= 0 {
                break
            }
            total_read += n
            if total_read >= isize(buffer.len - 1) {
                break
            }
        }
        C.close(fds[0])

        if total_read > 0 && g_sapp_state.drop.enabled {
            unsafe {
                buffer[total_read] = 0
            }
            // Clear drop buffer
            if g_sapp_state.drop.buffer != unsafe { nil } {
                unsafe { C.memset(g_sapp_state.drop.buffer, 0, usize(g_sapp_state.drop.buf_size)) }
            }
            g_sapp_state.drop.num_files = 0

            mut line := C.strtok(&char(&buffer[0]), c'\r\n')
            for line != unsafe { nil } && g_sapp_state.drop.num_files < g_sapp_state.drop.max_files {
                if C.strlen(line) == 0 {
                    line = C.strtok(unsafe { nil }, c'\r\n')
                    continue
                }
                mut file_path := line
                if C.strncmp(line, c'file://', 7) == 0 {
                    file_path = unsafe { line + 7 }
                }
                // URL decode into drop buffer
                mut dst := sapp_dropped_file_path_ptr(g_sapp_state.drop.num_files)
                dst_end := unsafe { dst + (g_sapp_state.drop.max_path_length - 1) }
                mut i := usize(0)
                for unsafe { file_path[i] } != 0 && dst < dst_end {
                    ch := unsafe { u8(file_path[i]) }
                    if ch == `%` && unsafe { file_path[i + 1] } != 0
                        && unsafe { file_path[i + 2] } != 0 {
                        mut hex := [3]u8{}
                        hex[0] = unsafe { u8(file_path[i + 1]) }
                        hex[1] = unsafe { u8(file_path[i + 2]) }
                        hex[2] = 0
                        unsafe {
                            *dst = u8(C.strtol(&char(&hex[0]), nil, 16))
                        }
                        dst = unsafe { dst + 1 }
                        i += 3
                    } else {
                        unsafe {
                            *dst = ch
                        }
                        dst = unsafe { dst + 1 }
                        i++
                    }
                }
                unsafe {
                    *dst = 0
                }
                g_sapp_state.drop.num_files++
                line = C.strtok(unsafe { nil }, c'\r\n')
            }

            if g_sapp_state.drop.num_files > 0 {
                C.wl_data_offer_finish(g_sapp_state.wl.data_offer)
                init_sapp_event(.files_dropped)
                g_sapp_state.event.modifiers = wl_get_modifiers()
                call_sapp_event(&g_sapp_state.event)
            }
        }

        C.wl_data_offer_destroy(g_sapp_state.wl.data_offer)
        g_sapp_state.wl.data_offer = unsafe { nil }
    }

    fn wl_data_device_selection(data voidptr, device &C.wl_data_device, offer &C.wl_data_offer) {
    }

    // === Listener struct definitions ===
    // These are arrays of function pointers matching the C listener struct layouts.

    const wl_keyboard_listener = [
        voidptr(wl_keyboard_handle_keymap),
        voidptr(wl_keyboard_handle_enter),
        voidptr(wl_keyboard_handle_leave),
        voidptr(wl_keyboard_handle_key),
        voidptr(wl_keyboard_handle_modifiers),
        voidptr(wl_keyboard_handle_repeat_info),
    ]!

    const wl_pointer_listener = [
        voidptr(wl_pointer_handle_enter),
        voidptr(wl_pointer_handle_leave),
        voidptr(wl_pointer_handle_motion),
        voidptr(wl_pointer_handle_button),
        voidptr(wl_pointer_handle_axis),
        voidptr(wl_pointer_handle_frame),
        voidptr(wl_pointer_handle_axis_source),
        voidptr(wl_pointer_handle_axis_stop),
        voidptr(wl_pointer_handle_axis_discrete),
        voidptr(wl_pointer_handle_axis_value120),
        voidptr(wl_pointer_handle_axis_relative_direction),
    ]!

    const wl_seat_listener = [
        voidptr(wl_seat_handle_capabilities),
        voidptr(wl_seat_handle_name),
    ]!

    const wl_registry_listener = [
        voidptr(wl_registry_handle_global),
        voidptr(wl_registry_handle_global_remove),
    ]!

    const wl_xdg_surface_listener = [
        voidptr(wl_xdg_surface_configure),
    ]!

    const wl_xdg_toplevel_listener = [
        voidptr(wl_xdg_toplevel_configure),
        voidptr(wl_xdg_toplevel_close),
    ]!

    const wl_fractional_scale_listener = [
        voidptr(wl_fractional_scale_preferred_scale),
    ]!

    const wl_data_offer_listener = [
        voidptr(wl_data_offer_offer),
        voidptr(wl_data_offer_source_actions),
        voidptr(wl_data_offer_action),
    ]!

    const wl_data_device_listener = [
        voidptr(wl_data_device_data_offer),
        voidptr(wl_data_device_enter),
        voidptr(wl_data_device_leave),
        voidptr(wl_data_device_motion),
        voidptr(wl_data_device_drop),
        voidptr(wl_data_device_selection),
    ]!
    // === Main Wayland run function ===

    fn wl_set_resizable(resizable bool) {
        if g_sapp_state.wl.xdg_toplevel == unsafe { nil }
            || g_sapp_state.wl.surface == unsafe { nil } {
            return
        }
        if resizable {
            C.xdg_toplevel_set_min_size(g_sapp_state.wl.xdg_toplevel, 0, 0)
            C.xdg_toplevel_set_max_size(g_sapp_state.wl.xdg_toplevel, 0, 0)
        } else {
            width := if g_sapp_state.window_width > 0 {
                g_sapp_state.window_width
            } else if g_sapp_state.wl.width > 0 {
                g_sapp_state.wl.width
            } else {
                fallback_default_window_width
            }
            height := if g_sapp_state.window_height > 0 {
                g_sapp_state.window_height
            } else if g_sapp_state.wl.height > 0 {
                g_sapp_state.wl.height
            } else {
                fallback_default_window_height
            }
            C.xdg_toplevel_set_min_size(g_sapp_state.wl.xdg_toplevel, i32(width), i32(height))
            C.xdg_toplevel_set_max_size(g_sapp_state.wl.xdg_toplevel, i32(width), i32(height))
        }
        C.wl_surface_commit(g_sapp_state.wl.surface)
        if g_sapp_state.wl.display != unsafe { nil } {
            C.wl_display_flush(g_sapp_state.wl.display)
        }
    }

    pub fn wl_run(desc &Desc) {
        sapp_init_state(desc)

        // Initialize key repeat
        g_sapp_state.wl.key_repeat_timer_fd = -1
        g_sapp_state.wl.key_repeat_rate = 25
        g_sapp_state.wl.key_repeat_delay = 600

        // Connect to Wayland display
        g_sapp_state.wl.display = C.wl_display_connect(unsafe { nil })
        if g_sapp_state.wl.display == unsafe { nil } {
            eprintln('sokol_app: failed to connect to Wayland display')
            return
        }

        // Get registry and bind global objects
        g_sapp_state.wl.registry = C.wl_display_get_registry(g_sapp_state.wl.display)
        C.wl_registry_add_listener(g_sapp_state.wl.registry, &wl_registry_listener, unsafe { nil })
        C.wl_display_roundtrip(g_sapp_state.wl.display)

        if g_sapp_state.wl.compositor == unsafe { nil }
            || g_sapp_state.wl.xdg_wm_base == unsafe { nil } {
            eprintln('sokol_app: Wayland compositor or xdg_wm_base not available')
            C.wl_display_disconnect(g_sapp_state.wl.display)
            return
        }

        // Create surface
        g_sapp_state.wl.surface = C.wl_compositor_create_surface(g_sapp_state.wl.compositor)

        // Initialize XKB
        g_sapp_state.wl.xkb_context = C.xkb_context_new(xkb_context_no_flags)
        if g_sapp_state.wl.xkb_context == unsafe { nil } {
            eprintln('sokol_app: failed to create XKB context')
            return
        }

        // Setup key repeat timer
        wl_setup_key_repeat_timer()

        g_sapp_state.wl.width = g_sapp_state.window_width
        g_sapp_state.wl.height = g_sapp_state.window_height
        if g_sapp_state.wl.width == 0 {
            g_sapp_state.wl.width = fallback_default_window_width
        }
        if g_sapp_state.wl.height == 0 {
            g_sapp_state.wl.height = fallback_default_window_height
        }

        g_sapp_state.wl.scale = 1.0
        g_sapp_state.dpi_scale = 1.0
        g_sapp_state.wl.fb_width = int(f32(g_sapp_state.wl.width) * g_sapp_state.wl.scale)
        g_sapp_state.wl.fb_height = int(f32(g_sapp_state.wl.height) * g_sapp_state.wl.scale)

        // Create EGL window
        g_sapp_state.wl.egl_window = C.wl_egl_window_create(g_sapp_state.wl.surface,
            g_sapp_state.wl.fb_width, g_sapp_state.wl.fb_height)
        if g_sapp_state.wl.egl_window == unsafe { nil } {
            eprintln('sokol_app: failed to create Wayland EGL window')
            return
        }

        // Create XDG surface and toplevel
        g_sapp_state.wl.xdg_surface = C.xdg_wm_base_get_xdg_surface(g_sapp_state.wl.xdg_wm_base,
            g_sapp_state.wl.surface)
        C.xdg_surface_add_listener(g_sapp_state.wl.xdg_surface, &wl_xdg_surface_listener,
            unsafe { nil })

        g_sapp_state.wl.xdg_toplevel = C.xdg_surface_get_toplevel(g_sapp_state.wl.xdg_surface)
        C.xdg_toplevel_add_listener(g_sapp_state.wl.xdg_toplevel, &wl_xdg_toplevel_listener,
            unsafe { nil })
        C.xdg_toplevel_set_title(g_sapp_state.wl.xdg_toplevel, &char(&g_sapp_state.window_title[0]))

        // Request server-side decorations if available
        if g_sapp_state.wl.decoration_manager != unsafe { nil } {
            g_sapp_state.wl.toplevel_decoration = C.zxdg_decoration_manager_v1_get_toplevel_decoration(g_sapp_state.wl.decoration_manager,
                g_sapp_state.wl.xdg_toplevel)
            if g_sapp_state.wl.toplevel_decoration != unsafe { nil } {
                C.zxdg_toplevel_decoration_v1_set_mode(g_sapp_state.wl.toplevel_decoration,
                    zxdg_toplevel_decoration_v1_mode_server_side)
            }
        }

        // Enable fractional scaling if available and high_dpi is enabled
        if g_sapp_state.desc.high_dpi && g_sapp_state.wl.fractional_scale_mgr != unsafe { nil } {
            g_sapp_state.wl.fractional_scale = C.wp_fractional_scale_manager_v1_get_fractional_scale(g_sapp_state.wl.fractional_scale_mgr,
                g_sapp_state.wl.surface)
            if g_sapp_state.wl.fractional_scale != unsafe { nil } {
                C.wp_fractional_scale_v1_add_listener(g_sapp_state.wl.fractional_scale,
                    &wl_fractional_scale_listener, unsafe { nil })
            }
        }

        // Create viewport for setting logical size with fractional scaling
        if g_sapp_state.desc.high_dpi && g_sapp_state.wl.viewporter != unsafe { nil } {
            g_sapp_state.wl.viewport = C.wp_viewporter_get_viewport(g_sapp_state.wl.viewporter,
                g_sapp_state.wl.surface)
            if g_sapp_state.wl.viewport != unsafe { nil } {
                C.wp_viewport_set_destination(g_sapp_state.wl.viewport, g_sapp_state.wl.width,
                    g_sapp_state.wl.height)
            }
        }

        // Set initial fullscreen state if requested
        if g_sapp_state.desc.fullscreen {
            C.xdg_toplevel_set_fullscreen(g_sapp_state.wl.xdg_toplevel, unsafe { nil })
        }

        // Commit the surface to trigger initial configure
        C.wl_surface_commit(g_sapp_state.wl.surface)
        C.wl_display_roundtrip(g_sapp_state.wl.display)

        // Initialize EGL
        sapp_egl_init_wayland()
        sapp_egl_create_surface(voidptr(g_sapp_state.wl.egl_window))
        sapp_egl_make_current()

        // Update public API values
        g_sapp_state.window_width = g_sapp_state.wl.width
        g_sapp_state.window_height = g_sapp_state.wl.height
        g_sapp_state.framebuffer_width = g_sapp_state.wl.fb_width
        g_sapp_state.framebuffer_height = g_sapp_state.wl.fb_height

        g_sapp_state.valid = true

        // Main event loop
        for !g_sapp_state.quit_ordered {
            C.wl_display_dispatch_pending(g_sapp_state.wl.display)

            wl_handle_key_repeat()

            // Handle quit requested
            if g_sapp_state.quit_requested && !g_sapp_state.quit_ordered {
                wl_app_event(.quit_requested)
                if g_sapp_state.quit_requested {
                    g_sapp_state.quit_ordered = true
                }
            }

            sapp_do_frame()

            C.eglSwapBuffers(g_sapp_state.egl.display, g_sapp_state.egl.surface)
            C.wl_display_flush(g_sapp_state.wl.display)
        }

        sapp_call_cleanup()

        // Cleanup
        sapp_egl_destroy()

        if g_sapp_state.wl.egl_window != unsafe { nil } {
            C.wl_egl_window_destroy(g_sapp_state.wl.egl_window)
        }
        if g_sapp_state.wl.toplevel_decoration != unsafe { nil } {
            C.zxdg_toplevel_decoration_v1_destroy(g_sapp_state.wl.toplevel_decoration)
        }
        if g_sapp_state.wl.fractional_scale != unsafe { nil } {
            C.wp_fractional_scale_v1_destroy(g_sapp_state.wl.fractional_scale)
        }
        if g_sapp_state.wl.viewport != unsafe { nil } {
            C.wp_viewport_destroy(g_sapp_state.wl.viewport)
        }
        if g_sapp_state.wl.viewporter != unsafe { nil } {
            C.wp_viewporter_destroy(g_sapp_state.wl.viewporter)
        }
        if g_sapp_state.wl.xdg_toplevel != unsafe { nil } {
            C.xdg_toplevel_destroy(g_sapp_state.wl.xdg_toplevel)
        }
        if g_sapp_state.wl.xdg_surface != unsafe { nil } {
            C.xdg_surface_destroy(g_sapp_state.wl.xdg_surface)
        }
        if g_sapp_state.wl.surface != unsafe { nil } {
            C.wl_surface_destroy(g_sapp_state.wl.surface)
        }
        if g_sapp_state.wl.xkb_state != unsafe { nil } {
            C.xkb_state_unref(g_sapp_state.wl.xkb_state)
        }
        if g_sapp_state.wl.xkb_keymap != unsafe { nil } {
            C.xkb_keymap_unref(g_sapp_state.wl.xkb_keymap)
        }
        if g_sapp_state.wl.xkb_context != unsafe { nil } {
            C.xkb_context_unref(g_sapp_state.wl.xkb_context)
        }
        if g_sapp_state.wl.key_repeat_timer_fd >= 0 {
            C.close(g_sapp_state.wl.key_repeat_timer_fd)
            g_sapp_state.wl.key_repeat_timer_fd = -1
        }
        if g_sapp_state.wl.locked_pointer != unsafe { nil } {
            C.zwp_locked_pointer_v1_destroy(g_sapp_state.wl.locked_pointer)
        }
        if g_sapp_state.wl.relative_pointer != unsafe { nil } {
            C.zwp_relative_pointer_v1_destroy(g_sapp_state.wl.relative_pointer)
        }
        if g_sapp_state.wl.cursor_shape_device != unsafe { nil } {
            C.wp_cursor_shape_device_v1_destroy(g_sapp_state.wl.cursor_shape_device)
        }
        if g_sapp_state.wl.data_device != unsafe { nil } {
            C.wl_data_device_destroy(g_sapp_state.wl.data_device)
        }
        if g_sapp_state.wl.data_offer != unsafe { nil } {
            C.wl_data_offer_destroy(g_sapp_state.wl.data_offer)
        }
        if g_sapp_state.wl.data_source != unsafe { nil } {
            C.wl_data_source_destroy(g_sapp_state.wl.data_source)
        }
        if g_sapp_state.wl.data_device_manager != unsafe { nil } {
            C.wl_data_device_manager_destroy(g_sapp_state.wl.data_device_manager)
        }
        if g_sapp_state.wl.pointer_constraints != unsafe { nil } {
            C.zwp_pointer_constraints_v1_destroy(g_sapp_state.wl.pointer_constraints)
        }
        if g_sapp_state.wl.relative_pointer_mgr != unsafe { nil } {
            C.zwp_relative_pointer_manager_v1_destroy(g_sapp_state.wl.relative_pointer_mgr)
        }
        if g_sapp_state.wl.cursor_shape_manager != unsafe { nil } {
            C.wp_cursor_shape_manager_v1_destroy(g_sapp_state.wl.cursor_shape_manager)
        }
        if g_sapp_state.wl.fractional_scale_mgr != unsafe { nil } {
            C.wp_fractional_scale_manager_v1_destroy(g_sapp_state.wl.fractional_scale_mgr)
        }
        if g_sapp_state.wl.decoration_manager != unsafe { nil } {
            C.zxdg_decoration_manager_v1_destroy(g_sapp_state.wl.decoration_manager)
        }
        if g_sapp_state.wl.compositor != unsafe { nil } {
            C.wl_compositor_destroy(g_sapp_state.wl.compositor)
        }
        if g_sapp_state.wl.registry != unsafe { nil } {
            C.wl_registry_destroy(g_sapp_state.wl.registry)
        }
        if g_sapp_state.wl.display != unsafe { nil } {
            C.wl_display_disconnect(g_sapp_state.wl.display)
        }

        sapp_discard_state()
    }
}