// MXL pattern generator feed rendered on the GPU via wgpu (WebGPU/Vulkan).
// Run from the repo root: make wgpu-gen
// (mixing libmxl cgo with wgpu/goffi needs the internal linker)
package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"

	"github.com/qvest-digital/go-mxl/mxl"

	flowdef "mxl-pattern-generator/internal/flow-def"
	"mxl-pattern-generator/internal/generator"
)

func main() {
	var width, height uint = 1920, 1080
	var fpsNum, fpsDen uint = 25, 1
	flowUUID := "8f1d2a4b-6c3e-4f5a-9b2c-1d7e8a3f0b5d"
	domain := "/dev/shm/mxl"

	log.Printf("Go Pattern Gen (wgpu)")
	log.Printf("Video: %dx%dp%d/%d", width, height, fpsNum, fpsDen)
	log.Printf("UUID: %s", flowUUID)

	// gen, err := generator.NewWGPUGenerator(width, height, "kernels/v210_bars.wgsl")
	gen, err := generator.NewWGPUGenerator(width, height, "kernels/v210_bars_move.wgsl")
	if err != nil {
		log.Fatalf("wgpu init failed: %v", err)
	}
	defer gen.Close()

	inst, err := mxl.NewInstance(domain, "")
	if err != nil {
		log.Fatalf("MXL Init Failed: %v", err)
	}
	defer inst.Close()

	flowDef, err := flowdef.NewFlowDefJSON(
		flowdef.TYPE_VIDEO,
		flowUUID,
		width,
		height,
		fpsNum,
		fpsDen,
	)
	if err != nil {
		log.Fatalf("Could not create Flow Definition: %v", err)
	}
	writer, isCreated, err := inst.NewWriter(flowDef)
	if err != nil {
		log.Fatalf("Failed to create MXL writer: %v", err)
	}
	if !isCreated {
		log.Printf("reusing existing flow: %s, domain: %s", flowUUID, domain)
	}
	defer writer.Close()

	flowCfg := writer.Config()
	rate := flowCfg.Common.GrainRate
	idx := mxl.CurrentIndex(rate)
	log.Printf("writing flow grainRate=%d/%d starting at idx=%d", rate.Num, rate.Den, idx)

	stop := make(chan os.Signal, 1)
	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)

	var written int64
	var tick uint32 // animation clock: small counter, not the huge grain index
	for {
		select {
		case <-stop:
			log.Printf("stopping after %d grains", written)
			return
		default:
		}

		gwa, err := writer.OpenGrain(idx)
		if err != nil {
			log.Fatalf("OpenGrain(%d): %v", idx, err)
		}
		if err := gen.GenerateFrame(gwa.Payload, int(tick)); err != nil {
			log.Fatalf("GenerateFrame(%d): %v", idx, err)
		}
		if err := gwa.Commit(gwa.TotalSlices, 0); err != nil {
			log.Fatalf("Commit(%d): %v", idx, err)
		}

		written++
		idx++
		tick++
		if written%100 == 0 {
			log.Printf("grains written=%d, index=%d", written, idx)
		}
		// Pace ourselves to roughly the grain rate
		mxl.SleepNs(mxl.NsUntilIndex(idx, rate))
	}
}