package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"log"
	"mxl-player/internal/renderer"
	"mxl-player/internal/sdl"
	"mxl-player/internal/source"
	"runtime"
	"time"
	"unsafe"

	vk "github.com/christerso/vulkan-go/vk"
	"github.com/qvest-digital/go-mxl/mxl"
)

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

func main() {
	videoFlowId := "5fbec3b1-1b0f-417d-9059-8b94a47197ed"
	audioFlowId := "5fbec3b1-1b0f-417d-9059-8b94a47197ec"
	mxlDomain := flag.String("d", "/dev/shm/mxl", "MXL domain")
	mxlVideoFlowID := flag.String("v", videoFlowId, "MXL video flow UUID")
	mxlAudioFlowID := flag.String("a", audioFlowId, "MXL audio flow UUID")
	fmt.Println(*mxlAudioFlowID)
	flag.Parse()

	runtime.LockOSThread()
	if err := sdl.Load(); err != nil {
		panic(err)
	}
	if !sdl.Init(sdl.InitVideo) {
		log.Fatalf("SDL_Init: %s", sdl.GetError())
		return
	}

	windowHandler := sdl.CreateWindow(fmt.Sprintf("%s %s", APP_NAME, APP_VER), WIN_WIDTH, WIN_HEIGHT, sdl.WindowVulkan|sdl.WindowResizable)
	if windowHandler == 0 {
		sdl.Quit()
		log.Fatalf("SDL_CreateWindow: %s", sdl.GetError())
		return
	}

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

	sdlExtensions := sdl.VulkanGetInstanceExtensions()
	if len(sdlExtensions) == 0 {
		log.Fatal("sdlVulkanGetInstanceExtensions is 0")
		return
	}
	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()

	var vkSurface uint64
	if !sdl.VulkanCreateSurface(windowHandler, uintptr(vkInstance), 0, &vkSurface) {
		log.Fatalf("SDL_Vulkan_CreateSurface: %s", sdl.GetError())
		return
	}
	vkSurf := vk.SurfaceKHR(vkSurface)
	defer vkInstance.DestroySurface(vkSurf)

	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]

	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"},
	})
	if err != nil {
		panic(err)
	}
	defer vkDevice.Destroy()

	mxlSrc, err := source.Open(*mxlDomain, *mxlVideoFlowID)
	if err != nil {
		log.Fatalf("source: %v", err)
	}
	defer func() { _ = mxlSrc.Close() }()
	fmt.Printf("source: %dx%d stride=%d\n", mxlSrc.Width(), mxlSrc.Height(), mxlSrc.Stride())

	r, err := renderer.New(renderer.Config{
		PhysDevice:     vkPhysDevice,
		Device:         vkDevice,
		Queue:          vkQueue,
		Surface:        vkSurf,
		Window:         windowHandler,
		GraphicsFamily: gfx,
		VideoWidth:     mxlSrc.Width(),
		VideoHeight:    mxlSrc.Height(),
		VideoStride:    mxlSrc.Stride(),
	})
	if err != nil {
		panic(err)
	}
	defer r.Destroy()
	defer vkDevice.WaitIdle()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	grant := make(chan struct{}, 1)
	staged := make(chan uint64)
	failed := make(chan struct{})

	reopen := func() error {
		if err := mxlSrc.Close(); err != nil {
			return fmt.Errorf("close old source: %w", err)
		}
		for {
			select {
			case <-ctx.Done():
				return ctx.Err()
			default:
			}
			s, err := source.Open(*mxlDomain, *mxlVideoFlowID)
			if err == nil {
				newSize := vk.DeviceSize(s.Stride()) * vk.DeviceSize(s.Height())
				if newSize != r.FrameSize() {
					if err := r.RecreateBuffers(newSize); err != nil {
						return err
					}
					fmt.Printf("source: resolution changed, frameSize=%d\n", newSize)
				}
				mxlSrc = s
				return nil
			}
			log.Printf("source: reopen retry: %v", err)
			time.Sleep(500 * time.Millisecond)
		}
	}

	go func() {
		for {
			select {
			case <-grant:
			case <-ctx.Done():
				return
			}
			f, err := mxlSrc.NextCtx(ctx, 200*time.Millisecond)
			if err != nil {
				if errors.Is(err, context.Canceled) {
					return
				}
				if errors.Is(err, mxl.ErrFlowInvalid) {
					log.Printf("source: flow invalid, reopening")
					if rerr := reopen(); rerr != nil {
						log.Printf("source: reopen failed: %v", rerr)
						cancel()
						return
					}
					select {
					case failed <- struct{}{}:
					case <-ctx.Done():
						return
					}
					continue
				}
				log.Printf("source: %v", err)
				cancel()
				return
			}
			vk.CopyToMapped(r.StagingMapped(), f.Payload)
			select {
			case staged <- f.Index:
			case <-ctx.Done():
				return
			}
		}
	}()

	running := true
	resized := false
	granted := false
	fullscreen := false
	var (
		lastIndex  uint64
		dropped    uint64
		frameCount uint64
		lastReport time.Time
	)
	for running {
		frameStart := time.Now()
		var event [128]byte
		for sdl.PollEvent(unsafe.Pointer(&event[0])) {
			eventType := *(*uint32)(unsafe.Pointer(&event[0]))
			switch eventType {
			case sdl.EventQuit:
				running = false
			case sdl.EventWindowResized, sdl.EventPixelSizeChanged:
				resized = true
			case sdl.EventKeyDown:
				key := *(*int32)(unsafe.Pointer(&event[28]))
				switch uint32(key) {
				case sdl.KeyEscape:
					running = false
				case sdl.KeyF:
					fullscreen = !fullscreen
					sdl.SetWindowFullscreen(windowHandler, fullscreen)
					resized = true
				}
			}
		}
		if !running {
			break
		}
		if resized {
			if err := r.RecreateSwapchain(); err != nil {
				if errors.Is(err, renderer.ErrMinimized) {
					resized = true
					continue
				}
				panic(err)
			}
			resized = false
		}
		if !granted {
			select {
			case grant <- struct{}{}:
				granted = true
			case <-ctx.Done():
				running = false
				continue
			}
		}
		var shownIndex uint64
		select {
		case shownIndex = <-staged:
			granted = false
		case <-failed:
			granted = false
			continue
		case <-ctx.Done():
			running = false
			continue
		case <-time.After(100 * time.Millisecond):
			continue
		}

		err := r.DrawFrame(mxlSrc.Width(), mxlSrc.Height(), mxlSrc.Stride())
		if errors.Is(err, renderer.ErrOutOfDate) {
			if rerr := r.RecreateSwapchain(); rerr != nil {
				if errors.Is(rerr, renderer.ErrMinimized) {
					resized = true
					continue
				}
				panic(rerr)
			}
			continue
		}
		if err != nil {
			panic(err)
		}

		if lastIndex != 0 && shownIndex > lastIndex {
			if g := shownIndex - lastIndex - 1; g > 0 {
				dropped += g
			}
		}
		lastIndex = shownIndex
		frameCount++
		if now := time.Now(); now.Sub(lastReport) >= time.Second {
			dt := now.Sub(lastReport).Seconds()
			fps := float64(frameCount) / dt
			fmt.Printf("fps=%.1f dropped=%d idx=%d frameTime=%.2fms\n",
				fps, dropped, shownIndex, float64(now.Sub(frameStart).Microseconds())/1000.0)
			frameCount = 0
			dropped = 0
			lastReport = now
		}
	}
}