package main

import "core:fmt"
import win "../window"

// Store window pointer globally for the callback
g_window: ^win.Window

main :: proc() {
    loop, err := win.create_event_loop()
    if err != .None {
        fmt.println("Failed to create event loop:", err)
        return
    }
    defer win.destroy_event_loop(loop)

    window, err2 := win.create_window(loop, {
        title     = "Input Test - Press keys to test features",
        size      = {800, 600},
        resizable = true,
        visible   = true,
        decorated = true,
    })
    if err2 != .None {
        fmt.println("Failed to create window:", err2)
        return
    }
    defer win.destroy_window(window)

    g_window = window

    fmt.println("=== Input Feature Test ===")
    fmt.println("Keys:")
    fmt.println("  1-9,0: Change cursor shape")
    fmt.println("  H: Toggle hidden cursor")
    fmt.println("  C: Toggle confined cursor")
    fmt.println("  G: Toggle grabbed cursor")
    fmt.println("  R: Toggle raw mouse motion")
    fmt.println("  SPACE: Query pressed keys")
    fmt.println("  ESC: Exit")
    fmt.println()
    fmt.printfln("Raw motion supported: %v", win.supports_raw_mouse_motion(loop))
    fmt.println()

    win.run(loop, proc(event: win.Event, loop: ^win.Event_Loop) -> win.Control_Flow {
        window := g_window

        #partial switch e in event {
        case win.Window_Event_Data:
            #partial switch we in e.event {
            case win.Close_Requested:
                return nil  // Exit

            case win.Key_Input:
                if we.state == .Pressed {
                    #partial switch we.key {
                    case .Key_1: win.set_cursor_shape(window, .Arrow); fmt.println("Cursor: Arrow")
                    case .Key_2: win.set_cursor_shape(window, .IBeam); fmt.println("Cursor: IBeam")
                    case .Key_3: win.set_cursor_shape(window, .Crosshair); fmt.println("Cursor: Crosshair")
                    case .Key_4: win.set_cursor_shape(window, .Hand); fmt.println("Cursor: Hand")
                    case .Key_5: win.set_cursor_shape(window, .Resize_EW); fmt.println("Cursor: Resize_EW")
                    case .Key_6: win.set_cursor_shape(window, .Resize_NS); fmt.println("Cursor: Resize_NS")
                    case .Key_7: win.set_cursor_shape(window, .Resize_NWSE); fmt.println("Cursor: Resize_NWSE")
                    case .Key_8: win.set_cursor_shape(window, .Resize_NESW); fmt.println("Cursor: Resize_NESW")
                    case .Key_9: win.set_cursor_shape(window, .Resize_All); fmt.println("Cursor: Resize_All")
                    case .Key_0: win.set_cursor_shape(window, .Not_Allowed); fmt.println("Cursor: Not_Allowed")

                    case .H:
                        if win.get_cursor_mode(window) == .Hidden {
                            win.set_cursor_mode(window, .Normal)
                            fmt.println("Cursor mode: Normal")
                        } else {
                            win.set_cursor_mode(window, .Hidden)
                            fmt.println("Cursor mode: Hidden")
                        }

                    case .C:
                        if win.get_cursor_mode(window) == .Confined {
                            win.set_cursor_mode(window, .Normal)
                            fmt.println("Cursor mode: Normal")
                        } else {
                            win.set_cursor_mode(window, .Confined)
                            fmt.println("Cursor mode: Confined")
                        }

                    case .G:
                        if win.get_cursor_mode(window) == .Grabbed {
                            win.set_cursor_mode(window, .Normal)
                            fmt.println("Cursor mode: Normal")
                        } else {
                            win.set_cursor_mode(window, .Grabbed)
                            fmt.println("Cursor mode: Grabbed (press G again to release)")
                        }

                    case .R:
                        raw_enabled := win.is_raw_mouse_motion_enabled(window)
                        win.set_raw_mouse_motion(window, !raw_enabled)
                        if !raw_enabled {
                            fmt.println("Raw mouse motion: ENABLED")
                        } else {
                            fmt.println("Raw mouse motion: DISABLED")
                        }

                    case .Space:
                        fmt.println("--- Key State Polling ---")
                        mods := win.get_modifiers(loop)
                        fmt.printfln("Modifiers: Shift=%v Ctrl=%v Alt=%v Super=%v",
                            mods.shift, mods.ctrl, mods.alt, mods.super)

                        // Check some common keys
                        if win.is_key_pressed(loop, .W) do fmt.println("  W is pressed")
                        if win.is_key_pressed(loop, .A) do fmt.println("  A is pressed")
                        if win.is_key_pressed(loop, .S) do fmt.println("  S is pressed")
                        if win.is_key_pressed(loop, .D) do fmt.println("  D is pressed")

                        // Check mouse buttons
                        if win.is_mouse_button_pressed(loop, .Left) do fmt.println("  Left mouse button pressed")
                        if win.is_mouse_button_pressed(loop, .Right) do fmt.println("  Right mouse button pressed")
                        if win.is_mouse_button_pressed(loop, .Middle) do fmt.println("  Middle mouse button pressed")

                    case .Escape:
                        return nil  // Exit
                    }
                }
            }

        case win.Device_Event_Data:
            #partial switch de in e.event {
            case win.Pointer_Motion:
                fmt.printfln("Raw motion: dx=%.2f dy=%.2f", de.delta_x, de.delta_y)
            }

        case win.Loop_Exiting:
            fmt.println("Exiting...")
        }

        return win.Wait{}
    })
}