package sdl

import (
	"fmt"
	"runtime"
	"unsafe"

	"github.com/ebitengine/purego"
)

const (
	InitVideo       uint32 = 0x00000020
	WindowVulkan    uint64 = 0x0000000010000000
	WindowResizable uint64 = 0x0000000000000020

	EventQuit             uint32 = 0x100
	EventWindowResized    uint32 = 0x206
	EventPixelSizeChanged uint32 = 0x207
	EventKeyDown          uint32 = 0x300

	KeyEscape uint32 = 0x1B
	KeyF      uint32 = 0x66
)

var (
	sdlInit                        func(flags uint32) bool
	sdlQuit                        func()
	sdlGetError                    func() uintptr
	sdlCreateWindow                func(title *byte, w, h int32, flags uint64) uintptr
	sdlDestroyWindow               func(window uintptr)
	sdlVulkanGetInstanceExtensions func(count *uint32) uintptr
	sdlVulkanCreateSurface         func(window, instance, allocator uintptr, surface *uint64) bool
	sdlPollEvent                   func(event unsafe.Pointer) bool
	sdlGetWindowSizeInPixels       func(window uintptr, w, h *int32) bool
	sdlSetWindowFullscreen         func(window uintptr, fullscreen bool) bool
)

var loaded = false

func Load() error {
	if loaded {
		return nil
	}
	h, err := purego.Dlopen("libSDL3.so.0", purego.RTLD_NOW|purego.RTLD_GLOBAL)
	if err != nil {
		return fmt.Errorf("win: load SDL3: %w", err)
	}
	purego.RegisterLibFunc(&sdlInit, h, "SDL_Init")
	purego.RegisterLibFunc(&sdlQuit, h, "SDL_Quit")
	purego.RegisterLibFunc(&sdlGetError, h, "SDL_GetError")
	purego.RegisterLibFunc(&sdlCreateWindow, h, "SDL_CreateWindow")
	purego.RegisterLibFunc(&sdlDestroyWindow, h, "SDL_DestroyWindow")
	purego.RegisterLibFunc(&sdlVulkanGetInstanceExtensions, h, "SDL_Vulkan_GetInstanceExtensions")
	purego.RegisterLibFunc(&sdlVulkanCreateSurface, h, "SDL_Vulkan_CreateSurface")
	purego.RegisterLibFunc(&sdlPollEvent, h, "SDL_PollEvent")
	purego.RegisterLibFunc(&sdlGetWindowSizeInPixels, h, "SDL_GetWindowSizeInPixels")
	purego.RegisterLibFunc(&sdlSetWindowFullscreen, h, "SDL_SetWindowFullscreen")
	loaded = true
	return nil
}

func Init(flags uint32) bool { return sdlInit(flags) }
func Quit()                  { sdlQuit() }
func GetError() string       { return cstr(sdlGetError()) }

func CreateWindow(title string, w, h int32, flags uint64) uintptr {
	return sdlCreateWindow(cbytes(title), w, h, flags)
}
func DestroyWindow(window uintptr) { sdlDestroyWindow(window) }

func VulkanGetInstanceExtensions() []string {
	var count uint32
	vkExts := sdlVulkanGetInstanceExtensions(&count)
	if vkExts == 0 {
		return nil
	}
	exts := make([]string, count)
	for i := uint32(0); i < count; i++ {
		p := *(*uintptr)(unsafe.Pointer(vkExts + uintptr(i)*unsafe.Sizeof(uintptr(0))))
		exts[i] = cstr(p)
	}
	return exts
}
func VulkanCreateSurface(window, instance, allocator uintptr, surface *uint64) bool {
	return sdlVulkanCreateSurface(window, instance, allocator, surface)
}

func PollEvent(event unsafe.Pointer) bool { return sdlPollEvent(event) }

func GetWindowSizeInPixels(window uintptr, w, h *int32) bool {
	return sdlGetWindowSizeInPixels(window, w, h)
}
func SetWindowFullscreen(window uintptr, fullscreen bool) bool {
	return sdlSetWindowFullscreen(window, fullscreen)
}

// cstr reads a NUL-terminated C string at p.
func cstr(p uintptr) string {
	if p == 0 {
		return ""
	}
	var n int
	for *(*byte)(unsafe.Pointer(p + uintptr(n))) != 0 {
		n++
	}
	return string(unsafe.Slice((*byte)(unsafe.Pointer(p)), n))
}

// cbytes returns a NUL-terminated copy of s as *byte, kept alive by the caller.
func cbytes(s string) *byte {
	b := make([]byte, len(s)+1)
	copy(b, s)
	runtime.KeepAlive(b)
	return &b[0]
}