package main

import (
	"fmt"
	"log"
	"runtime"
	"unsafe"

	vk "github.com/christerso/vulkan-go/vk"
	"github.com/ebitengine/purego"
)

const (
	APP_NAME         = "MXL Player"
	APP_VER          = "0.0.1"
	WIN_WIDTH  int32 = 1280
	WIN_HEIGHT int32 = 720
)

const (
	initVideo       uint32 = 0x00000020
	windowVulkan    uint64 = 0x0000000010000000
	windowResizable uint64 = 0x0000000000000020

	sdlEventQuit    uint32 = 0x100
	sdlEventKeyDown uint32 = 0x300
	keyEscape       uint32 = 0x1B
)

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
)

func sdlError() string { return cstr(sdlGetError()) }

var loaded = false

func loadSDLMissing() 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")
	loaded = true
	return nil
}

// 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]
}

func main() {
	runtime.LockOSThread()
	if err := loadSDLMissing(); err != nil {
		panic(err)
	}
	if !sdlInit(initVideo) {
		log.Fatalf("SDL_Init: %s", sdlError())
		return
	}

	windowHandler := sdlCreateWindow(cbytes(APP_NAME), WIN_WIDTH, WIN_HEIGHT, windowVulkan|windowResizable)
	if windowHandler == 0 {
		sdlQuit()
		log.Fatalf("SDL_CreateWindow: %s", sdlError())
		return
	}

	// Vulkan init
	if err := vk.Load(); err != nil {
		panic(err)
	}

	// Vulkan instance extensions SDL needs.
	var sdlExtCount uint32
	arr := sdlVulkanGetInstanceExtensions(&sdlExtCount)
	if arr == 0 {
		log.Fatal("sdlVulkanGetInstanceExtensions is 0")
		return
	}
	sdlExtensions := make([]string, sdlExtCount)
	for i := uint32(0); i < sdlExtCount; i++ {
		p := *(*uintptr)(unsafe.Pointer(arr + uintptr(i)*unsafe.Sizeof(uintptr(0))))
		sdlExtensions[i] = cstr(p)
	}
	// Vulkan Instance creation
	var vkLayers []string
	vkExtensions := append(sdlExtensions, vk.ExtDebugUtils)
	vkInstance, err := vk.CreateInstance(vk.InstanceConfig{
		ApplicationName: APP_NAME,
		EngineName:      "no engine",
		Extensions:      vkExtensions,
		Layers:          vkLayers,
	})
	if err != nil {
		log.Fatalf(err.Error())
		panic(err)
	}
	defer vkInstance.Destroy()
	// Vulkan surface
	var vkSurface uint64
	if !sdlVulkanCreateSurface(windowHandler, uintptr(vkInstance), 0, &vkSurface) {
		log.Fatalf("SDL_Vulkan_CreateSurface: %s", sdlError())
		return
	}
	vkSurf := vk.SurfaceKHR(vkSurface)
	defer vkInstance.DestroySurface(vkSurf)

	// Vulkan Physical Device
	devices, err := vkInstance.EnumeratePhysicalDevices()
	if err != nil || len(devices) == 0 {
		panic("No Vulkan devices")
	}
	for _, pd := range devices {
		info := pd.Info()
		fmt.Printf("%s (%s)\n", info.Name, info.Type)
	}
	vkPhysDevice := devices[0]
	// Vulkan Surface & Graphics Queue
	gfx, err := vkPhysDevice.GraphicsFamily()
	if err != nil {
		panic(err.Error())
	}
	if !vkPhysDevice.SurfaceSupport(gfx, vkSurf) {
		log.Fatalf("graphics queue cannot present")
		return
	}
	vkDevice, vkQueue, err := vkPhysDevice.CreateDevice(vk.DeviceConfig{
		GraphicsFamily: gfx,
		Extensions:     []string{"VK_KHR_swapchain"},
	})
	fmt.Println("vkQueue=", vkQueue)
	if err != nil {
		panic(err)
	}
	defer vkDevice.Destroy()
	// TODO: colorspace & render pass
	var vkFormat vk.Format = vk.FormatUndefined
	var vkColorSpace uint32
	formats, _ := vkPhysDevice.SurfaceFormats(vkSurf)
	for _, f := range formats {
		if f.Format == vk.FormatB8G8R8A8Srgb && f.ColorSpace == vk.ColorSpaceSRGBNonlinear {
			vkFormat = f.Format
			vkColorSpace = f.ColorSpace
		}
	}
	if vkFormat == vk.FormatUndefined {
		vkFormat = formats[0].Format
		vkColorSpace = formats[0].ColorSpace
	}

	var vkPresentMode vk.PresentMode = vk.PresentModeFIFO
	modes, _ := vkPhysDevice.SurfacePresentModes(vkSurf)
	for _, m := range modes {
		if m == vk.PresentModeMailbox {
			vkPresentMode = m
		}
	}

	vkRenderPass, err := vkDevice.CreateColorDepthRenderPass(vkFormat, vk.FormatD32Sfloat)
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroyRenderPass(vkRenderPass)

	// Vulkan Command Pool
	vkCommandPool, err := vkDevice.CreateCommandPool(gfx)
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroyCommandPool(vkCommandPool)
	vkCommands, err := vkDevice.AllocateCommandBuffers(vkCommandPool, 1)
	if err != nil {
		panic(err.Error())
	}
	fmt.Println(vkCommands)
	defer vkDevice.WaitIdle()
	// Vulkan Surface Capabilities
	caps, err := vkPhysDevice.SurfaceCapabilities(vkSurf)
	if err != nil {
		panic(err.Error())
	}
	//compute swapchain extent
	var w, h int32 = WIN_WIDTH, WIN_HEIGHT
	if !sdlGetWindowSizeInPixels(windowHandler, &w, &h) {
		log.Fatalf("SDL_GetWindowSizeInPixels: %s", sdlError())
	}
	if w < int32(caps.MinImageExtent.Width) {
		w = int32(caps.MinImageExtent.Width)
	}
	if h < int32(caps.MinImageExtent.Height) {
		h = int32(caps.MinImageExtent.Height)
	}
	if w > int32(caps.MaxImageExtent.Width) {
		w = int32(caps.MaxImageExtent.Width)
	}
	if h > int32(caps.MaxImageExtent.Height) {
		h = int32(caps.MaxImageExtent.Height)
	}
	vkExtent := vk.Extent2D{Width: uint32(w), Height: uint32(h)}
	// Vulkan swapchain (pool of presentable images, that OS and GPU share)
	vkSwapchain, err := vkDevice.CreateSwapchain(vk.SwapchainConfig{
		Surface:       vkSurf,
		MinImageCount: caps.MinImageCount,
		Format:        vkFormat,
		ColorSpace:    vkColorSpace,
		Extent:        vkExtent,
		PresentMode:   vkPresentMode,
		PreTransform:  caps.CurrentTransform,
	})
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroySwapchain(vkSwapchain)

	swapImages, err := vkDevice.SwapchainImages(vkSwapchain)
	if err != nil {
		panic(err.Error())
	}
	// one image view per swapchain. Image = raw GPU memory with a format
	swapViews := make([]vk.ImageView, len(swapImages))
	for i, img := range swapImages {
		v, err := vkDevice.CreateImageView(img, vkFormat, vk.AspectColor)
		if err != nil {
			panic(err.Error())
		}
		swapViews[i] = v
	}
	defer func() {
		for _, v := range swapViews {
			vkDevice.DestroyImageView(v)
		}
	}()
	// depth image + view
	depthImg, err := vkDevice.CreateImage2D(
		vkPhysDevice, vk.FormatD32Sfloat, vkExtent, vk.ImageUsageDepthStencilAttachment)
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroyImage(depthImg)

	depthView, err := vkDevice.CreateImageView(depthImg.Image, vk.FormatD32Sfloat, vk.AspectDepth)
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroyImageView(depthView)

	// frame buffer i.e. binding between RenderPass and actual ImageViews
	fbs := make([]vk.Framebuffer, len(swapViews))
	for i, cv := range swapViews {
		fb, err := vkDevice.CreateFramebuffer(vkRenderPass, []vk.ImageView{cv, depthView}, vkExtent)
		if err != nil {
			panic(err.Error())
		}
		fbs[i] = fb
	}
	defer func() {
		for _, fb := range fbs {
			vkDevice.DestroyFramebuffer(fb)
		}
	}()
	// syncs
	// Semaphores sync GPU work to GPU work (you never wait on these from the CPU). You need two:
	// - imageAvailable — AcquireNextImage signals it when a swapchain image is ready to render into.
	// Your draw submission waits on it before touching color.
	// - renderFinished — your draw submission signals it when rendering is done.
	// Present waits on it before showing the frame.
	// Fences sync GPU work to CPU. You need one:
	// - inFlight — your submission signals it when the GPU is done with the command buffer.
	// Your CPU waits on it before re-recording that same command buffer.
	// It's created signaled so the very first frame's wait returns immediately
	// (otherwise you'd deadlock waiting for work that hasn't been submitted yet).
	imageAvailable, err := vkDevice.CreateSemaphore()
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroySemaphore(imageAvailable)

	renderFinished, err := vkDevice.CreateSemaphore()
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroySemaphore(renderFinished)

	inFlight, err := vkDevice.CreateFence(true)
	if err != nil {
		panic(err.Error())
	}
	defer vkDevice.DestroyFence(inFlight)

	// Core Loop
	running := true
	for running {
		var event [128]byte
		for sdlPollEvent(unsafe.Pointer(&event[0])) {
			eventType := *(*uint32)(unsafe.Pointer(&event[0]))
			if eventType == sdlEventQuit {
				running = false
			}
		}
		if !running {
			break
		}
		// Acquire the next swapchain image
		imageIndex, r := vkDevice.AcquireNextImage(vkSwapchain, imageAvailable, ^uint64(0))
		if !r.Ok() {
			panic(fmt.Errorf("acquire: %v", r))
		}
		// Wait until GPU is done with our command buffer, then reset fence
		if err := vkDevice.WaitFence(inFlight, ^uint64(0)); err != nil {
			panic(err)
		}
		if err := vkDevice.ResetFence(inFlight); err != nil {
			panic(err)
		}

		// Record: clear color & depth attachments
		cmd := vkCommands[0]
		if err := cmd.Reset(); err != nil {
			panic(err)
		}
		if err := cmd.Begin(vk.CommandBufferOneTimeSubmit); err != nil {
			panic(err)
		}
		cmd.BeginRenderPass(
			vkRenderPass,
			fbs[imageIndex],
			vk.Rect2D{Offset: vk.Offset2D{X: 0, Y: 0}, Extent: vkExtent},
			[]vk.ClearValue{
				vk.ClearColor(0.0, 0.4, 0.7, 1.0),
				vk.ClearDepthStencil(1.0, 0),
			},
		)
		cmd.EndRenderPass()
		if err := cmd.End(); err != nil {
			panic(err)
		}
		// Submit: wait on imageAvailable, signal RenderFinished + inFlight
		if err := vkQueue.Submit(vk.SubmitConfig{
			Wait:      imageAvailable,
			WaitStage: vk.StageColorAttachmentOutput,
			Command:   cmd,
			Signal:    renderFinished,
			Fence:     inFlight,
		}); err != nil {
			panic(err)
		}
		// Present. Wait on renderFinished
		r = vkQueue.Present(vkSwapchain, imageIndex, renderFinished)
		if r == vk.ErrorOutOfDateKHR || r == vk.SuboptimalKHR {
			break
		}
		if !r.Ok() {
			panic(fmt.Errorf("present: %v", r))
		}
		// Make sure GPU is idle before any deferred destruction runs
		if err := vkDevice.WaitIdle(); err != nil {
			panic(err)
		}
	}
}