package xturbo_test

import (
	"errors"
	"log"

	"golang.org/x/sys/unix"

	"bnema.dev/xturbo"
	"bnema.dev/xturbo/xproto"
)

// Replies registered with Expect carry this kind (16 and above are free).
const kindGeometry uint16 = 16

func Example() {
	c, err := xturbo.Dial("") // "" means $DISPLAY
	if err != nil {
		log.Fatal(err)
	}
	defer c.Close()

	// Startup: blocking calls, bounded by a 5 s deadline.
	var atoms [1]uint32
	if err := c.InternAtoms([]string{"WM_DELETE_WINDOW"}, false, atoms[:]); err != nil {
		log.Fatal(err)
	}

	// Queue requests; they return a Seq (0 on failure, see c.Buf().Err()).
	b := c.Buf()
	win, err := c.NewXID()
	if err != nil {
		log.Fatal(err)
	}
	var v xproto.CreateWindowValues
	v.SetEventMask(xproto.EventMaskExposure | xproto.EventMaskStructureNotify)
	xproto.CreateWindow(b, 0, xproto.Window(win), xproto.Window(c.Root()),
		0, 0, 640, 480, 0, xproto.WindowClassInputOutput, 0, &v)
	xproto.MapWindow(b, xproto.Window(win))
	if seq := xproto.GetGeometry(b, xproto.Drawable(win)); seq != 0 {
		if err := c.Expect(seq, kindGeometry, win, 0, 0, 0); err != nil {
			log.Fatal(err)
		}
	}

	// Callbacks run inside Dispatch. Events, replies and errors are borrowed:
	// copy what you keep.
	h := &xturbo.Handler{
		OnEvent: func(ev *xturbo.Event) {
			switch ev.Kind {
			case xproto.KindExpose:
				e := xproto.ExposeOf(ev)
				log.Printf("expose %dx%d", e.Width(), e.Height())
			}
		},
		OnReply: func(r *xturbo.Reply) {
			if r.Kind == kindGeometry {
				if g, ok := xproto.ParseGetGeometryReply(r.Raw); ok {
					log.Printf("window %#x is %dx%d", r.Args[0], g.Width(), g.Height())
				}
			}
		},
		OnError: func(e *xturbo.XError) { log.Print(e) },
	}

	for {
		// Flush never blocks. On ErrWouldBlock, also wait for POLLOUT.
		events := int16(unix.POLLIN)
		if err := c.Flush(); errors.Is(err, xturbo.ErrWouldBlock) {
			events |= unix.POLLOUT
		} else if err != nil {
			log.Fatal(err)
		}
		fds := []unix.PollFd{{Fd: int32(c.Fd()), Events: events}}
		if _, err := unix.Poll(fds, -1); err != nil && err != unix.EINTR {
			log.Fatal(err)
		}
		if err := c.Dispatch(h); err != nil { // io.EOF: server closed
			log.Fatal(err)
		}
		// Keep the XID pool topped up without blocking later.
		if c.XIDsLow() {
			_ = c.PrefetchXIDs()
		}
	}
}