package main

import (
	"context"
	"errors"
	"fmt"
	"io"
	"log"
	"mxl-player/internal/imgui"
	"mxl-player/internal/playback"
	"mxl-player/internal/renderer"
	"mxl-player/internal/sdl"
	"os"
	"runtime"
	"time"
	"unsafe"

	cimgui "github.com/AllenDang/cimgui-go/imgui"
	vk "github.com/christerso/vulkan-go/vk"
	pflag "github.com/spf13/pflag"
)

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

const (
	placeholderWidth  uint32 = 1
	placeholderHeight uint32 = 1
	placeholderStride uint32 = 4
)

const (
	initialRetryDelay = 500 * time.Millisecond
	maxRetryDelay     = 5 * time.Second
)

type appArgs struct {
	ShowHelp      bool
	Domain        string
	VideoDomain   string
	AudioDomain   string
	VideoFlowId   string
	AudioFlowId   string
	IsFullscreen  bool
	PlaybackId    uint32
	GpuId         uint32
	IsVerbose     bool
	ListAudio     bool
	ListGPU       bool
	SyncRequested bool
	MaxAttempts   int
	PlaylistPath  string
}

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>] [options]")
	fmt.Println("                  [-g <gpu-id>] [-p <playback-id>] [--verbose]")
	fmt.Println("   or: mxl-player [--playlist <playlist.json]")
	fmt.Println("   or: mxl-player [--list-playback] [--list-gpu]")
	fmt.Println("   or: mxl-player (and set everything in GUI)")
	fmt.Println()
	fs.PrintDefaults()
}

func printUsage(w io.Writer) {
	fmt.Fprintln(w, "Usage: mxl-player [-d <domain>] [-v <uuid>] [-a <uuid>] [options]")
	fmt.Fprintln(w, "Try 'mxl-player -h' for more information.")
}

func checkMXLargs(args appArgs) {
	checkDomain := func(label, domain string) {
		if domain == "" {
			fmt.Fprintf(os.Stderr, "%s domain is required when its UUID is configured\n", label)
			printUsage(os.Stderr)
			os.Exit(2)
		}
		info, err := os.Stat(domain)
		if err != nil || !info.IsDir() {
			fmt.Fprintf(os.Stderr, "Invalid %s MXL domain: %s\n", label, domain)
			fmt.Fprintln(os.Stderr, "Domain must be a directory in tmpfs")
			printUsage(os.Stderr)
			os.Exit(2)
		}
	}

	if args.VideoFlowId != "" {
		checkDomain("video", args.VideoDomain)
	}
	if args.AudioFlowId != "" {
		checkDomain("audio", args.AudioDomain)
	}
}

func main() {
	// timelapse video: 5fbec3b1-1b0f-417d-9059-8b94a47197ed
	// timelapse audio: 5fbec3b1-1b0f-417d-9059-8b94a47197ec
	// f1 video: 5fbec3b1-1b0f-417d-9059-8b94a47197ef
	// f1 audio: 5fbec3b1-1b0f-417d-9059-8b94a47197eb
	// sync video: 2618979d-76a5-45e0-83cb-0f192978d1cd
	// sync audio: 9d2a041b-01cf-4ee4-bffa-188fe093c99b
	var args appArgs
	flagSet := pflag.NewFlagSet(APP_NAME, pflag.ContinueOnError)
	flagSet.SortFlags = false
	flagSet.Usage = func() { printUsage(os.Stderr) }
	flagSet.BoolVarP(&args.ShowHelp, "help", "h", false, "Show help message and exit")
	flagSet.StringVarP(
		&args.Domain,
		"domain",
		"d",
		"",
		"Default MXL domain for feeds without a specific domain",
	)
	flagSet.StringVar(&args.VideoDomain, "video-domain", "", "MXL domain for the video feed")
	flagSet.StringVar(&args.AudioDomain, "audio-domain", "", "MXL domain for the audio feed")
	flagSet.StringVarP(&args.VideoFlowId, "video", "v", "", "Video flow UUID")
	flagSet.StringVarP(&args.AudioFlowId, "audio", "a", "", "Audio flow UUID")
	flagSet.BoolVarP(
		&args.SyncRequested,
		"sync", "s",
		false,
		"Start configured audio and video as a synchronized group",
	)
	flagSet.IntVar(
		&args.MaxAttempts,
		"max-attempts",
		0,
		"Maximum connection attempts per playback lifecycle; 0 retries indefinitely",
	)
	flagSet.StringVar(
		&args.PlaylistPath,
		"playlist",
		"",
		"Load playlist from a JSON file",
	)
	flagSet.BoolVarP(&args.IsFullscreen, "fullscreen", "f", false, "Run app in fullscreen mode")
	flagSet.Uint32VarP(&args.GpuId, "gpu-id", "g", 0, "GPU id [TODO]")
	flagSet.Uint32VarP(&args.PlaybackId, "playback-id", "p", 0, "Playback audio device id")
	flagSet.BoolVar(&args.IsVerbose, "verbose", false, "Verbose output [TODO]")
	flagSet.BoolVar(&args.ListAudio, "list-playback", false, "List audio playback devices and exit")
	flagSet.BoolVar(&args.ListGPU, "list-gpu", false, "List GPUs and exit")

	if err := flagSet.Parse(os.Args[1:]); err != nil {
		fmt.Fprintln(os.Stderr, err)
		printUsage(os.Stderr)
		os.Exit(2)
	}
	if args.ShowHelp {
		printCliHelp(flagSet)
		return
	}
	if args.MaxAttempts < 0 {
		fmt.Fprintln(os.Stderr, "--max-attempts cannot be negative")
		printUsage(os.Stderr)
		os.Exit(2)
	}
	retryPolicy := playback.RetryPolicy{
		MaxAttempts:  args.MaxAttempts,
		InitialDelay: initialRetryDelay,
		MaxDelay:     maxRetryDelay,
	}
	if err := retryPolicy.Validate(); err != nil {
		fmt.Fprintln(os.Stderr, "invalid retry configuration:", err)
		os.Exit(2)
	}
	configuredPlaylist := playback.Playlist{}
	hasPlaylist := args.PlaylistPath != ""
	if hasPlaylist {
		playlist, err := loadPlaylistFile(args.PlaylistPath)
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(2)
		}
		configuredPlaylist = playlist
		retryPolicy = resolveRetryPolicy(
			retryPolicy,
			flagSet.Changed("max-attempts"),
			configuredPlaylist,
		)
	}
	if args.VideoDomain == "" {
		args.VideoDomain = args.Domain
	}
	if args.AudioDomain == "" {
		args.AudioDomain = args.Domain
	}
	if !args.ListAudio && !args.ListGPU {
		checkMXLargs(args)
	}
	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
	}

	sdlAudioDevice := sdl.AudioDeviceDefaultPlayback
	if args.PlaybackId != 0 {
		sdlAudioDevice = args.PlaybackId
	}
	// List audio playback devices and exit
	if args.ListAudio {
		devs := sdl.GetAudioPlaybackDevices()
		fmt.Println("Available playback audio devices")
		fmt.Println("id name")
		for _, d := range devs {
			fmt.Println(d.ID, d.Name)
		}
		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
	}

	// ImGui init
	gui := imgui.New()
	defer gui.Destroy()
	fontConfig := cimgui.NewFontConfig()
	font := gui.IO().Fonts().AddFontFromFileTTFV(
		"/home/itten/Downloads/JetBrainsMono/JetBrainsMonoNLNerdFontMono-Regular.ttf",
		18,
		fontConfig,
		nil,
	)
	fontConfig.Destroy()
	if font == nil || font.CData == nil {
		log.Fatal("failed to load ImGui font")
	}
	gui.IO().SetFontDefault(font)
	// sdl keys handler
	sdl.StartTextInput(windowHandler)
	defer sdl.StopTextInput(windowHandler)
	// fin on ImGui init

	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("%s", err)
		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")
	}
	// List GPU's and exit
	if args.ListGPU {
		fmt.Println("Available Vulkan physical devices:")
		fmt.Println("id name (type)")
		for i, pd := range devices {
			info := pd.Info()
			fmt.Printf("%2d %s (%s)\n", i, info.Name, info.Type)
		}
		return
	}
	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()

	// Create renderer
	r, err := renderer.New(renderer.Config{
		PhysDevice:     vkPhysDevice,
		Device:         vkDevice,
		Queue:          vkQueue,
		Surface:        vkSurf,
		Window:         windowHandler,
		GraphicsFamily: gfx,
		VideoWidth:     placeholderWidth,
		VideoHeight:    placeholderHeight,
		VideoStride:    placeholderStride,
	})
	if err != nil {
		panic(err)
	}
	defer r.Destroy()
	// Create GUI backend
	guiBackend, err := imgui.NewVulkanBackend(
		vkPhysDevice,
		vkDevice,
		vkQueue,
		r.CmdPool(),
		r.RenderPass(),
	)
	if err != nil {
		panic(err)
	}
	defer guiBackend.Destroy()
	r.ImGuiDraw = func(cmd vk.CommandBuffer) {
		guiBackend.RecordDraw(cmd, gui.LastDrawData())
	}
	if err := r.StageFrame(
		[]byte{0, 0, 0, 255},
		placeholderWidth,
		placeholderHeight,
		placeholderStride,
	); err != nil {
		panic(err)
	}
	defer vkDevice.WaitIdle()

	// GUI state (accessible from doReconnect + goroutine)
	var (
		videoDomainStr string = args.VideoDomain
		audioDomainStr string = args.AudioDomain
		videoStr       string = args.VideoFlowId
		audioStr       string = args.AudioFlowId
		showStats      bool   = false
	)
	videoActive := args.VideoFlowId != ""
	audioActive := args.AudioFlowId != ""

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	player, err := newPlayerPlayback(sdlAudioDevice, retryPolicy)
	if err != nil {
		panic(err)
	}
	videoBridge := player.Video
	statusStore := player.Status
	syncRequested := args.SyncRequested

	enqueueCommand := func(command playback.SessionCommand) {
		select {
		case player.Commands <- command:
		default:
			log.Printf("playback command queue is full; ignoring command %d", command.Kind)
		}
	}
	doReconnect := func() {
		videoActive = videoStr != ""
		audioActive = audioStr != ""

		videoConfig := playback.FeedConfig{}
		if videoActive {
			videoConfig = playback.FeedConfig{
				Domain: videoDomainStr,
				UUID:   videoStr,
				Active: true,
			}
		}
		audioConfig := playback.FeedConfig{}
		if audioActive {
			audioConfig = playback.FeedConfig{
				Domain: audioDomainStr,
				UUID:   audioStr,
				Active: true,
			}
		}

		enqueueCommand(playback.SessionCommand{
			Kind: playback.CommandSetSession,
			Session: playback.SessionConfig{
				Video:         videoConfig,
				Audio:         audioConfig,
				SyncRequested: syncRequested,
			},
		})
	}
	drawUnitStatus := func(label string, unit playback.Unit) {
		status, ok := statusStore.Snapshot(unit)
		if !ok {
			cimgui.Text(fmt.Sprintf("%s: not started", label))
			return
		}
		cimgui.Text(fmt.Sprintf("%s: %s", label, status.State))
		cimgui.Text(fmt.Sprintf(
			"Attempt: %d, failed: %d",
			status.Attempt,
			status.FailedAttempts,
		))
		if status.RetryIn > 0 {
			cimgui.Text(fmt.Sprintf(
				"Retry in: %s",
				status.RetryIn.Round(time.Millisecond),
			))
		}
		if status.Err != nil {
			cimgui.TextWrapped(status.Err.Error())
		}
	}

	playbackDone := make(chan error, 1)
	go func() {
		playbackDone <- player.Controller.Run(
			ctx,
			args.playbackConfig(),
			player.Commands,
		)
	}()

	var playlistRuntime *playerPlaylist
	var playlistDone chan error
	if hasPlaylist {
		playlistRuntime, err = newPlayerPlaylist(
			configuredPlaylist,
			retryPolicy,
			player,
		)
		if err != nil {
			panic(err)
		}
		playlistDone = make(chan error, 1)
		go func() {
			playlistDone <- playlistRuntime.Run(ctx)
		}()

		if shouldAutoStartPlaylist(args, configuredPlaylist) &&
			!playlistRuntime.Select(0) {
			log.Print("playlist command queue is full")
		}
	}

	running := true
	resized := false
	fullscreen := args.IsFullscreen
	if fullscreen {
		sdl.SetWindowFullscreen(windowHandler, true)
	}
	var (
		displayedVideoWidth  uint32 = placeholderWidth
		displayedVideoHeight uint32 = placeholderHeight
		displayedVideoStride uint32 = placeholderStride

		fps          float64
		dropTracker  videoDropTracker
		dropped      uint64
		droppedTotal uint64
		frameCount   uint64
		lastReport   time.Time
		lastFrame    time.Time
		renderLoopDT time.Duration
	)
	lastFrame = time.Now()
	lastReport = lastFrame

	// ImGui
	var (
		settingWindowWidth  float32 = 700
		settingsWindowState bool    = true
	)

	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:
				if gui.IO().WantCaptureKeyboard() {
					break
				}
				key := *(*int32)(unsafe.Pointer(&event[28]))
				switch uint32(key) {
				case sdl.KeyQ:
					fallthrough
				case sdl.KeyEscape:
					running = false
				case sdl.KeyF:
					fullscreen = !fullscreen
					sdl.SetWindowFullscreen(windowHandler, fullscreen)
					resized = true
				case sdl.KeyF1:
					settingsWindowState = !settingsWindowState
				case sdl.KeyF2:
					showStats = !showStats
				}
			}
			gui.ProcessEvent(&event)
		}
		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
		}
		var shownIndex uint64
		var shownGeneration uint64
		var shownSource playback.FeedConfig
		hasFrame := false

		frameCtx, frameCancel := context.WithTimeout(ctx, 100*time.Millisecond)
		pendingFrame, frameErr := videoBridge.Next(frameCtx)
		frameCancel()

		if pendingFrame != nil {
			var stageErr error
			if r != nil {
				stageErr = r.StageFrame(
					pendingFrame.Frame.Payload,
					pendingFrame.Frame.Width,
					pendingFrame.Frame.Height,
					pendingFrame.Frame.Stride,
				)
			}

			// Release the borrowed payload before reacting to a staging error
			pendingFrame.Complete(stageErr)

			if stageErr != nil {
				panic(stageErr)
			}

			shownIndex = pendingFrame.Frame.Index
			shownGeneration = pendingFrame.Generation
			shownSource = pendingFrame.Source
			displayedVideoWidth = pendingFrame.Frame.Width
			displayedVideoHeight = pendingFrame.Frame.Height
			displayedVideoStride = pendingFrame.Frame.Stride
			hasFrame = true
		} else if frameErr != nil &&
			!errors.Is(frameErr, context.DeadlineExceeded) &&
			!errors.Is(frameErr, context.Canceled) {
			panic(frameErr)
		}

		snapshot, hasSnapshot := player.Controller.Snapshot()

		// stats
		if hasFrame {
			if gap := dropTracker.Observe(shownGeneration, shownSource, shownIndex); gap > 0 {
				dropped += gap
				droppedTotal += gap
			}
			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
			}
		}
		// end of stats
		if r != nil {
			gui.BeginFrame(time.Since(lastFrame), int32(r.Extent().Width), int32(r.Extent().Height))
			if showStats {
				cimgui.SetNextWindowPos(cimgui.Vec2{X: 0, Y: 0})
				cimgui.SetNextWindowSize(cimgui.Vec2{X: 460, Y: 510})
				cimgui.BeginV("Stats", &showStats, cimgui.WindowFlagsNoResize|cimgui.WindowFlagsNoScrollbar)
				mediaStats := player.MediaStats.Snapshot()
				cimgui.SeparatorText("Video")
				if mediaStats.Video.Available {
					label := mediaStats.Video.Label
					if label == "" {
						label = "(no label)"
					}
					cimgui.TextWrapped(fmt.Sprintf("Label: %s", label))
					if hasSnapshot && snapshot.Desired.Video.IsConfigured() {
						cimgui.TextWrapped(fmt.Sprintf("Domain: %s", snapshot.Desired.Video.Domain))
						cimgui.TextWrapped(fmt.Sprintf("UUID: %s", snapshot.Desired.Video.UUID))
					}
					cimgui.Text(fmt.Sprintf(
						"Resolution: %dx%d (stride %d)",
						mediaStats.Video.Width,
						mediaStats.Video.Height,
						mediaStats.Video.Stride,
					))
					cimgui.Text(fmt.Sprintf(
						"FPS: flow %.2f | received %.1f | displayed %.1f",
						mediaStats.Video.DeclaredFPS,
						mediaStats.Video.ReceivedFPS,
						fps,
					))
					cimgui.Text(fmt.Sprintf(
						"Frame dt: source %.1f ms | render loop %.1f ms",
						float64(mediaStats.Video.FrameDT.Microseconds())/1000,
						float64(renderLoopDT.Microseconds())/1000,
					))
					cimgui.Text(fmt.Sprintf(
						"Index: %d | payload: %d bytes",
						mediaStats.Video.Index,
						mediaStats.Video.PayloadSize,
					))
					cimgui.Text(fmt.Sprintf(
						"Dropped: %d | invalid: %d",
						droppedTotal,
						mediaStats.Video.Invalid,
					))
				} else {
					cimgui.Text("No video frames received")
				}

				cimgui.SeparatorText("Audio")
				if mediaStats.Audio.Available {
					label := mediaStats.Audio.Label
					if label == "" {
						label = "(no label)"
					}
					cimgui.TextWrapped(fmt.Sprintf("Label: %s", label))
					if hasSnapshot && snapshot.Desired.Audio.IsConfigured() {
						cimgui.TextWrapped(fmt.Sprintf("Domain: %s", snapshot.Desired.Audio.Domain))
						cimgui.TextWrapped(fmt.Sprintf("UUID: %s", snapshot.Desired.Audio.UUID))
					}
					cimgui.Text(fmt.Sprintf(
						"Format: %.3f kHz, %d channels",
						mediaStats.Audio.SampleRateHz/1000,
						mediaStats.Audio.Channels,
					))
					cimgui.Text(fmt.Sprintf(
						"Batch: %d samples (%.3f ms)",
						mediaStats.Audio.SampleCount,
						float64(mediaStats.Audio.BatchDuration.Microseconds())/1000,
					))
					cimgui.Text(fmt.Sprintf("Index: %d", mediaStats.Audio.Index))
				} else {
					cimgui.Text("No audio batches received")
				}

				cimgui.SeparatorText("Runtime")
				if hasSnapshot {
					cimgui.Text(fmt.Sprintf(
						"Topology: %s | generation %d",
						snapshot.Plan.Topology,
						snapshot.Generation,
					))
					drawCompactStatus := func(label string, unit playback.Unit) {
						status, ok := statusStore.Snapshot(unit)
						if !ok {
							cimgui.Text(fmt.Sprintf("%s: not started", label))
							return
						}
						cimgui.Text(fmt.Sprintf(
							"%s: %s (attempt %d, failed %d)",
							label,
							status.State,
							status.Attempt,
							status.FailedAttempts,
						))
					}
					switch snapshot.Plan.Topology {
					case playback.TopologySynchronized:
						drawCompactStatus("Sync", playback.UnitSync)
					case playback.TopologyIndependent:
						if snapshot.Plan.Video.Active {
							drawCompactStatus("Video", playback.UnitVideo)
						}
						if snapshot.Plan.Audio.Active {
							drawCompactStatus("Audio", playback.UnitAudio)
						}
					}
				} else {
					cimgui.Text("Playback controller is starting")
				}
				cimgui.End()
			}
			// settings & info window
			videoConfigured := videoStr != ""
			audioConfigured := audioStr != ""
			if hasSnapshot {
				videoActive = snapshot.Desired.Video.Active
				audioActive = snapshot.Desired.Audio.Active
				videoConfigured = snapshot.Desired.Video.IsConfigured()
				audioConfigured = snapshot.Desired.Audio.IsConfigured()
				syncRequested = snapshot.Desired.SyncRequested
			}

			drawSettingsContents := func() {
				var collapsingHeaderFlags cimgui.TreeNodeFlags = cimgui.TreeNodeFlagsDefaultOpen
				drawFeedsSections := func() {
					cimgui.SeparatorText("Video")
					cimgui.InputTextWithHint("Video domain", "/dev/shm/mxl", &videoDomainStr, 0, nil)
					cimgui.InputTextWithHint("Video UUID", "", &videoStr, 0, nil)
					if videoActive {
						cimgui.SameLine()
						if cimgui.Button("Stop##video") {
							videoActive = false
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandStopVideo})
						}
					}
					if !videoActive && videoConfigured {
						cimgui.SameLine()
						if cimgui.Button("Resume##video") {
							videoActive = true
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandResumeVideo})
						}
					}
					if videoConfigured {
						cimgui.SameLine()
						if cimgui.Button("Remove##video") {
							videoActive = false
							videoStr = ""
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandRemoveVideo})
						}
					}
					cimgui.SeparatorText("Audio")
					cimgui.InputTextWithHint("Audio domain", "/dev/shm/mxl", &audioDomainStr, 0, nil)
					cimgui.InputTextWithHint("Audio UUID", "", &audioStr, 0, nil)
					if audioActive {
						cimgui.SameLine()
						if cimgui.Button("Stop##audio") {
							audioActive = false
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandStopAudio})
						}
					}

					if !audioActive && audioConfigured {
						cimgui.SameLine()
						if cimgui.Button("Resume##audio") {
							audioActive = true
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandResumeAudio})
						}
					}
					if audioConfigured {
						cimgui.SameLine()
						if cimgui.Button("Remove##audio") {
							audioActive = false
							audioStr = ""
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandRemoveAudio})
						}
					}
					cimgui.SeparatorText("Controls")
					if cimgui.Button("Apply feeds") {
						doReconnect()
					}
					cimgui.SameLine()
					if videoActive || audioActive {
						if cimgui.Button("Stop all") {
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandStopAll})
						}
					}
					if (videoConfigured && !videoActive) || (audioConfigured && !audioActive) {
						if videoActive || audioActive {
							cimgui.SameLine()
						}
						if cimgui.Button("Resume all") {
							enqueueCommand(playback.SessionCommand{Kind: playback.CommandResumeAll})
						}
					}
					cimgui.SameLine()
					if cimgui.Checkbox("Synchronize", &syncRequested) {
						kind := playback.CommandDisableSync
						if syncRequested {
							kind = playback.CommandEnableSync
						}
						enqueueCommand(playback.SessionCommand{Kind: kind})
					}
					cimgui.SeparatorText("Feeds stats")
					cimgui.Checkbox("Show stats", &showStats)
				}
				if cimgui.CollapsingHeaderTreeNodeFlagsV("Feeds", collapsingHeaderFlags) {
					drawFeedsSections()
				}

				if playlistRuntime != nil &&
					cimgui.CollapsingHeaderTreeNodeFlagsV("Playlist", collapsingHeaderFlags) {
					playlistSnapshot, hasPlaylistSnapshot :=
						playlistRuntime.Controller.Snapshot()

					cimgui.TextWrapped(fmt.Sprintf("File: %s", args.PlaylistPath))
					cimgui.Text(fmt.Sprintf("Entries: %d", len(configuredPlaylist.Entries)))
					if configuredPlaylist.Loop {
						cimgui.Text("End behavior: loop")
					} else {
						cimgui.Text("End behavior: stop")
					}
					cimgui.Text(fmt.Sprintf(
						"Failure behavior: %s",
						configuredPlaylist.OnFailure,
					))
					if retryPolicy.MaxAttempts == 0 {
						cimgui.Text("Retries: infinite")
					} else {
						cimgui.Text(fmt.Sprintf(
							"Attempts per entry: %d",
							retryPolicy.MaxAttempts,
						))
					}
					cimgui.Text(fmt.Sprintf(
						"Retry delay: %s to %s",
						retryPolicy.InitialDelay,
						retryPolicy.MaxDelay,
					))

					if hasPlaylistSnapshot && playlistSnapshot.HasFailure {
						failure := playlistSnapshot.Failure
						name := failure.EntryName
						if name == "" {
							name = fmt.Sprintf("Entry %d", failure.EntryIndex+1)
						}
						cimgui.SeparatorText("Last failure")
						cimgui.TextWrapped(fmt.Sprintf(
							"%s: %s failed",
							name,
							failure.Status.Unit,
						))
						cimgui.Text(fmt.Sprintf(
							"Attempts: %d | failed attempts: %d",
							failure.Status.Attempt,
							failure.Status.FailedAttempts,
						))
						cimgui.Text(fmt.Sprintf("Policy: %s", failure.Policy))
						if failure.Status.Err != nil {
							cimgui.TextWrapped(failure.Status.Err.Error())
						}
					}

					preview := "No entry selected"
					if hasPlaylistSnapshot && playlistSnapshot.State.HasSelection {
						preview = playlistEntryDisplayName(
							playlistSnapshot.Entry,
							playlistSnapshot.State.CurrentIndex,
						)
					}
					if cimgui.BeginCombo("Entry##playlist", preview) {
						for index, entry := range configuredPlaylist.Entries {
							selected := hasPlaylistSnapshot &&
								playlistSnapshot.State.HasSelection &&
								playlistSnapshot.State.CurrentIndex == index
							label := fmt.Sprintf(
								"%s##playlist-entry-%d",
								playlistEntryDisplayName(entry, index),
								index,
							)
							if cimgui.SelectableBoolV(
								label,
								selected,
								cimgui.SelectableFlagsNone,
								cimgui.Vec2{},
							) && !playlistRuntime.Select(index) {
								log.Print("playlist command queue is full")
							}
							if selected {
								cimgui.SetItemDefaultFocus()
							}
						}
						cimgui.EndCombo()
					}

					if cimgui.Button("Previous##playlist") && !playlistRuntime.Previous() {
						log.Print("playlist command queue is full")
					}
					cimgui.SameLine()
					if cimgui.Button("Next##playlist") && !playlistRuntime.Next() {
						log.Print("playlist command queue is full")
					}
					if hasPlaylistSnapshot &&
						playlistSnapshot.State.HasSelection &&
						playlistSnapshot.Entry.Duration > 0 &&
						!playlistSnapshot.Timing.Expired {
						cimgui.SameLine()
						if playlistSnapshot.Timing.Paused {
							if cimgui.Button("Resume timer##playlist") &&
								!playlistRuntime.Resume() {
								log.Print("playlist command queue is full")
							}
						} else if cimgui.Button("Pause timer##playlist") &&
							!playlistRuntime.Pause() {
							log.Print("playlist command queue is full")
						}
					}

					if hasPlaylistSnapshot && playlistSnapshot.State.HasSelection {
						entry := playlistSnapshot.Entry
						cimgui.SeparatorText("Current entry")
						cimgui.Text(fmt.Sprintf(
							"%d of %d: %s",
							playlistSnapshot.State.CurrentIndex+1,
							len(configuredPlaylist.Entries),
							playlistEntryDisplayName(entry, playlistSnapshot.State.CurrentIndex),
						))
						if entry.Video.IsConfigured() {
							cimgui.TextWrapped(fmt.Sprintf(
								"Video: %s (%s)",
								entry.Video.UUID,
								entry.Video.Domain,
							))
						}
						if entry.Audio.IsConfigured() {
							cimgui.TextWrapped(fmt.Sprintf(
								"Audio: %s (%s)",
								entry.Audio.UUID,
								entry.Audio.Domain,
							))
						}
						if entry.SyncRequested {
							cimgui.Text("Synchronization: requested")
						} else {
							cimgui.Text("Synchronization: independent")
						}

						switch {
						case entry.Duration == 0:
							cimgui.Text("Timing: manual advance")
						case playlistSnapshot.Timing.Paused:
							fraction, remaining := playlistTimingProgress(
								playlistSnapshot.Timing,
								time.Now(),
							)
							cimgui.Text("Timing: paused")
							cimgui.ProgressBarV(
								fraction,
								cimgui.Vec2{X: -1, Y: 0},
								remaining.Round(time.Second).String(),
							)
						case playlistSnapshot.Timing.Started:
							fraction, remaining := playlistTimingProgress(
								playlistSnapshot.Timing,
								time.Now(),
							)
							cimgui.Text(fmt.Sprintf("Duration: %s", entry.Duration))
							cimgui.ProgressBarV(
								fraction,
								cimgui.Vec2{X: -1, Y: 0},
								remaining.Round(time.Second).String(),
							)
						case playlistSnapshot.Timing.Expired:
							cimgui.Text("Timing: finished")
						default:
							cimgui.Text("Timing: waiting for playback")
						}
					}
				}

				drawHotkeysSection := func() {
					cimgui.Text("F1 - show/hide settings")
					cimgui.Text("F2 - show/hide stats")
					cimgui.Text("F - toggle fullscreen")
					cimgui.Text("Q or Esc - quit")
				}
				if cimgui.CollapsingHeaderTreeNodeFlagsV("Hotkeys", collapsingHeaderFlags) {
					drawHotkeysSection()
				}

				drawDebugSection := func() {
					if hasSnapshot {
						cimgui.Text(fmt.Sprintf(
							"Topology: %s (generation %d)",
							snapshot.Plan.Topology,
							snapshot.Generation,
						))
					} else {
						cimgui.Text("Topology: starting")
					}
					if hasSnapshot && syncRequested && snapshot.Plan.Topology != playback.TopologySynchronized {
						switch {
						case !videoConfigured || !audioConfigured:
							cimgui.TextWrapped("Sync requested: waiting for both feeds to be configured.")
						case !videoActive || !audioActive:
							cimgui.TextWrapped("Sync requested: waiting for both feeds to be active.")
						case snapshot.Desired.Video.Domain != snapshot.Desired.Audio.Domain:
							cimgui.TextWrapped("Sync requested, but native MXL sync requires matching domains. Playing independently.")
						default:
							cimgui.TextWrapped("Sync requested but currently unavailable. Playing independently.")
						}
					}
					cimgui.Separator()
					cimgui.Text("Current playback")
					if hasSnapshot {
						switch snapshot.Plan.Topology {
						case playback.TopologySynchronized:
							drawUnitStatus("Synchronized group", playback.UnitSync)
						case playback.TopologyIndependent:
							if snapshot.Plan.Video.Active {
								drawUnitStatus("Video", playback.UnitVideo)
							}
							if snapshot.Plan.Audio.Active {
								drawUnitStatus("Audio", playback.UnitAudio)
							}
						case playback.TopologyIdle:
							cimgui.Text("No active feeds")
						}
					} else {
						cimgui.Text("Playback controller is starting")
					}
					cimgui.Separator()
					if videoActive {
						cimgui.Text("Video desired: active")
					} else if videoConfigured {
						cimgui.Text("Video desired: stopped")
					} else {
						cimgui.Text("Video desired: not configured")
					}
					if audioActive {
						cimgui.Text("Audio desired: active")
					} else if audioConfigured {
						cimgui.Text("Audio desired: stopped")
					} else {
						cimgui.Text("Audio desired: not configured")
					}

				}
				if cimgui.CollapsingHeaderTreeNodeFlagsV("Debug Info", cimgui.TreeNodeFlagsNone) {
					drawDebugSection()
				}
			}

			if settingsWindowState {
				cimgui.SetNextWindowPos(cimgui.Vec2{X: float32(r.Extent().Width) - settingWindowWidth, Y: 0})
				cimgui.SetNextWindowSize(cimgui.Vec2{X: settingWindowWidth, Y: float32(r.Extent().Height)})
				if cimgui.BeginV("Settings & Info", &settingsWindowState, cimgui.WindowFlagsNone) {
					drawSettingsContents()
				}
				cimgui.End()
			}
			gui.EndFrame()
			lastFrame = time.Now()
			// end of test widget
			err := r.DrawFrame(
				displayedVideoWidth,
				displayedVideoHeight,
				displayedVideoStride,
			)
			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)
			}
			renderLoopDT = time.Since(frameStart)

		} else {
			time.Sleep(10 * time.Millisecond)
		}
	}

	cancel()
	if err := <-playbackDone; err != nil && !errors.Is(err, context.Canceled) {
		log.Printf("playback controller: %v", err)
	}
	if playlistDone != nil {
		if err := <-playlistDone; err != nil && !errors.Is(err, context.Canceled) {
			log.Printf("playlist runtime: %v", err)
		}
	}
	if err := player.Close(); err != nil {
		log.Printf("close playback: %v", err)
	}
}