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"
	pflag "github.com/spf13/pflag"
)

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

type CliArgs struct {
	ShowHelp     bool
	Domain       string
	VideoFlowId  string
	AudioFlowId  string
	IsFullscreen bool
	PlaybackId   uint32
	GpuId        uint32
	IsVerbose    bool
	ListAudio    bool
	ListGPU      bool
}

func printCliHelp(fs *pflag.FlagSet) {
	fmt.Printf("%s %s\n", APP_NAME, APP_VER)
	fmt.Println("Usage: mxl-player -d <domain> (-v <uuid> | -a <uuid>) [-f] [-h]...")
	fmt.Println("                  [-g <gpu-id>] [-p <playback-id>] [--verbose]")
	fmt.Println("   or: mxl-player [--list-playback] [--list-gpu]")
	fmt.Println("   or: mxl-player (and set everything in GUI)")
	fmt.Println()
	fs.PrintDefaults()
}

func main() {
	// CLI args TODO:
	// help + sample of good usage
	// domain (-d, --domain)
	// video flow UUID (-v, --video)
	// audio flow UUID (-a, --audio)
	// list-audio for list audio playback devices (-la, --list-playback)
	// list-video fpr list video playback devices (-lg, --list-gpu)
	// gpu-id for GPU selection (-p, --playback-id)
	// playback-id for playback id selection (-g, --gpu-id)
	// verbose flag, which turn on logs (-vb,--verbose)
	//
	// video: 5fbec3b1-1b0f-417d-9059-8b94a47197ed
	// audio: 5fbec3b1-1b0f-417d-9059-8b94a47197ec

	var args CliArgs
	flagSet := pflag.NewFlagSet(APP_NAME, pflag.ExitOnError)
	flagSet.BoolVarP(&args.ShowHelp, "help", "h", false, "Show help message and exit")
	flagSet.StringVarP(&args.Domain, "domain", "d", "", "MXL domain directory")
	flagSet.StringVarP(&args.VideoFlowId, "video", "v", "", "Video flow UUID")
	flagSet.StringVarP(&args.AudioFlowId, "audio", "a", "", "Audio flow UUID")
	flagSet.BoolVarP(&args.IsFullscreen, "fullscreen", "f", false, "Run app in fullscreen mode")
	flagSet.Uint32VarP(&args.GpuId, "gpu-id", "g", 0, "GPU id")
	flagSet.Uint32VarP(&args.PlaybackId, "playback-id", "p", 0, "Playback audio device id")
	flagSet.BoolVar(&args.IsVerbose, "verbose", false, "Verbose output")
	flagSet.BoolVar(&args.ListAudio, "list-playback", false, "List audio playback devices and exit")
	flagSet.BoolVar(&args.ListGPU, "list-gpu", false, "List GPU's and exit")
	pflag.Parse()

	if args.Domain == "" || args.ShowHelp {
		// TODO. Fix after polishing GUI
		// Cause required/optional will be changed
		printCliHelp(flagSet)
	}
	return

	var videoFlowId, audioFlowId string
	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")
	flag.Parse()
	if *mxlVideoFlowID == "" && *mxlAudioFlowID == "" {
		log.Fatal("need at least -v <video-flow> or -a <audio-flow>")
	}

	runtime.LockOSThread()
	if err := sdl.Load(); err != nil {
		panic(err)
	}
	if !sdl.Init(sdl.InitVideo | sdl.InitAudio) {
		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()

	var (
		syncSrc     *source.SyncSource
		videoSrc    *source.Source
		audioSrc    *source.AudioSource
		audioStream uintptr
		audioBatch  uint64
		aChans      uint64
	)

	interleaveAudio := func(samples [][]byte) []byte {
		frameBytes := int(audioBatch) * int(aChans) * 4
		out := make([]byte, frameBytes)
		for ch := uint64(0); ch < aChans; ch++ {
			srcBytes := samples[ch]
			for i := uint64(0); i < audioBatch; i++ {
				srcOff := i * 4
				dstOff := (i*aChans + ch) * 4
				if srcOff+4 <= uint64(len(srcBytes)) {
					copy(out[dstOff:dstOff+4], srcBytes[srcOff:srcOff+4])
				}
			}
		}
		return out
	}

	switch {
	case *mxlVideoFlowID != "" && *mxlAudioFlowID != "":
		syncSrc, err = source.OpenSync(*mxlDomain, *mxlVideoFlowID, *mxlAudioFlowID)
		if err != nil {
			log.Fatalf("sync source: %v", err)
		}
		aChans = syncSrc.Channels()
		audioBatch = uint64(syncSrc.AudioRate().Num) / uint64(syncSrc.Rate().Num)
		if audioBatch == 0 {
			audioBatch = 1
		}
		audioStream = sdl.OpenAudioDeviceStream(sdl.AudioDeviceDefaultPlayback, sdl.AudioSpec{
			Format:   sdl.AudioF32,
			Channels: int32(aChans),
			Freq:     int32(syncSrc.AudioRate().Num / syncSrc.AudioRate().Den),
		})
		if audioStream == 0 {
			log.Fatalf("audio: %s", sdl.GetError())
		}
		sdl.ResumeAudioStreamDevice(audioStream)
		fmt.Printf("sync: video %dx%d audio %dch batch=%d\n",
			syncSrc.Width(), syncSrc.Height(), aChans, audioBatch)

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

	default:
		audioSrc, err = source.OpenAudio(*mxlDomain, *mxlAudioFlowID)
		if err != nil {
			log.Fatalf("audio source: %v", err)
		}
		aChans = audioSrc.Channels()
		audioBatch = uint64(audioSrc.Rate().Num) / (100 * uint64(audioSrc.Rate().Den))
		if audioBatch == 0 {
			audioBatch = 1
		}
		audioStream = sdl.OpenAudioDeviceStream(sdl.AudioDeviceDefaultPlayback, sdl.AudioSpec{
			Format:   sdl.AudioF32,
			Channels: int32(aChans),
			Freq:     int32(audioSrc.Rate().Num / audioSrc.Rate().Den),
		})
		if audioStream == 0 {
			log.Fatalf("audio: %s", sdl.GetError())
		}
		sdl.ResumeAudioStreamDevice(audioStream)
		fmt.Printf("audio: %dch %d/%d Hz\n", aChans, audioSrc.Rate().Num, audioSrc.Rate().Den)
	}

	defer func() {
		if syncSrc != nil {
			_ = syncSrc.Close()
		}
		if videoSrc != nil {
			_ = videoSrc.Close()
		}
		if audioSrc != nil {
			_ = audioSrc.Close()
		}
	}()
	if audioStream != 0 {
		defer sdl.DestroyAudioStream(audioStream)
	}

	var r *renderer.Renderer
	if *mxlVideoFlowID != "" {
		var w, h, stride uint32
		if syncSrc != nil {
			w, h, stride = syncSrc.Width(), syncSrc.Height(), syncSrc.Stride()
		} else {
			w, h, stride = videoSrc.Width(), videoSrc.Height(), videoSrc.Stride()
		}
		r, err = renderer.New(renderer.Config{
			PhysDevice:     vkPhysDevice,
			Device:         vkDevice,
			Queue:          vkQueue,
			Surface:        vkSurf,
			Window:         windowHandler,
			GraphicsFamily: gfx,
			VideoWidth:     w,
			VideoHeight:    h,
			VideoStride:    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 syncSrc != nil {
			_ = syncSrc.Close()
		}
		if videoSrc != nil {
			_ = videoSrc.Close()
		}
		if audioSrc != nil {
			_ = audioSrc.Close()
		}
		for {
			select {
			case <-ctx.Done():
				return ctx.Err()
			default:
			}
			if syncSrc != nil {
				s, e := source.OpenSync(*mxlDomain, *mxlVideoFlowID, *mxlAudioFlowID)
				if e == nil {
					if r != nil {
						newSize := vk.DeviceSize(s.Stride()) * vk.DeviceSize(s.Height())
						if newSize != r.FrameSize() {
							if e = r.RecreateBuffers(newSize); e != nil {
								return e
							}
						}
					}
					syncSrc = s
					return nil
				}
				log.Printf("source: reopen retry: %v", e)
			} else if videoSrc != nil {
				s, e := source.Open(*mxlDomain, *mxlVideoFlowID)
				if e == nil {
					if r != nil {
						newSize := vk.DeviceSize(s.Stride()) * vk.DeviceSize(s.Height())
						if newSize != r.FrameSize() {
							if e = r.RecreateBuffers(newSize); e != nil {
								return e
							}
						}
					}
					videoSrc = s
					return nil
				}
				log.Printf("source: reopen retry: %v", e)
			} else if audioSrc != nil {
				s, e := source.OpenAudio(*mxlDomain, *mxlAudioFlowID)
				if e == nil {
					audioSrc = s
					return nil
				}
				log.Printf("source: reopen retry: %v", e)
			}
			time.Sleep(500 * time.Millisecond)
		}
	}

	go func() {
		// Audio-only mode: independent loop, no grant/staged handshake.
		if audioSrc != nil && syncSrc == nil && videoSrc == nil {
			for {
				select {
				case <-ctx.Done():
					return
				default:
				}
				queued := sdl.GetAudioStreamQueued(audioStream)
				maxQueued := int32(audioBatch) * int32(aChans) * 4 * 20
				if queued > maxQueued {
					select {
					case <-time.After(10 * time.Millisecond):
					case <-ctx.Done():
						return
					}
					continue
				}
				f, err := audioSrc.NextAudio(ctx, audioBatch, 20*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
						}
						continue
					}
					log.Printf("source: %v", err)
					cancel()
					return
				}
				if f.Samples != nil && audioStream != 0 {
					sdl.PutAudioStreamData(audioStream, interleaveAudio(f.Samples))
				}
			}
		}

		// Video (with or without sync) mode: grant/staged handshake.
		for {
			select {
			case <-grant:
			case <-ctx.Done():
				return
			}

			var payload []byte
			var grainIdx uint64

			if syncSrc != nil {
				vFrame, aFrame, err := syncSrc.NextSync(ctx, audioBatch, 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
				}
				payload = vFrame.Payload
				grainIdx = vFrame.Index
				if aFrame.Samples != nil && audioStream != 0 {
					sdl.PutAudioStreamData(audioStream, interleaveAudio(aFrame.Samples))
				}

			} else if videoSrc != nil {
				f, err := videoSrc.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
				}
				payload = f.Payload
				grainIdx = f.Index

			}

			if r != nil {
				vk.CopyToMapped(r.StagingMapped(), payload)
			}
			select {
			case staged <- grainIdx:
			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 && r != nil {
			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
		}

		if r != nil {
			var w, h, stride uint32
			if syncSrc != nil {
				w, h, stride = syncSrc.Width(), syncSrc.Height(), syncSrc.Stride()
			} else if videoSrc != nil {
				w, h, stride = videoSrc.Width(), videoSrc.Height(), videoSrc.Stride()
			}
			err := r.DrawFrame(w, h, 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
			}
		} else {
			time.Sleep(10 * time.Millisecond)
		}
	}
}