package main

import (
    "image"
    "image/png"
    "os"
    "time"

    "github.com/audergonv/mgba-go/pkg/mgba"
)

func main() {
    // 1. Open the ROM file.
    vf, err := mgba.VFileFromPath("game.gba")
    if err != nil {
        panic(err)
    }
    defer vf.Close()

    // 2. Detect the core type (GBA / GB / GBC) and create it.
    core, err := mgba.NewCore(vf)
    if err != nil {
        panic(err)
    }

    // 3. Initialise: allocates the internal framebuffer and wires up the
    //    software renderer.  Must be called before LoadROM or Reset.
    if err := core.Init(); err != nil {
        panic(err)
    }
    defer core.Deinit()

    // 4. Load the ROM. The core takes ownership of the VFile from this point.
    if err := core.LoadROM(vf); err != nil {
        panic(err)
    }

    // 5. Reset the hardware to its power-on state.
    core.Reset()

    // 6. Get a slice that always reflects the latest rendered frame.
    //    Layout: BGRA (little-endian 0x00RRGGBB), 4 bytes per pixel.
    width, height, _ := core.BaseVideoSize()
    buf, _ := core.VideoBuffer()

    // 7. Run frames at ~59.73 fps (GBA native rate).
    const frameDuration = time.Duration(16742706) // ns
    deadline := time.Now().Add(frameDuration)

    for frame := 0; frame < 300; frame++ {
        if err := core.RunFrame(); err != nil {
            panic(err)
        }

        // buf is updated in-place after every RunFrame call.
        _ = buf // use it here — render to terminal, encode as PNG, etc.

        if now := time.Now(); now.Before(deadline) {
            time.Sleep(deadline.Sub(now))
        }
        deadline = deadline.Add(frameDuration)
    }

    // Example: save the last frame as a PNG.
    img := image.NewRGBA(image.Rect(0, 0, width, height))
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            base := (y*width + x) * 4
            // mGBA byte order: [B, G, R, 0]
            img.Pix[(y*width+x)*4+0] = buf[base+2] // R
            img.Pix[(y*width+x)*4+1] = buf[base+1] // G
            img.Pix[(y*width+x)*4+2] = buf[base+0] // B
            img.Pix[(y*width+x)*4+3] = 0xFF         // A
        }
    }
    f, _ := os.Create("frame.png")
    defer f.Close()
    png.Encode(f, img)
}