package drw // import "hhvn.uk/hbspbar/drw"

import (
	"os"
	"image"
	"image/color"

	"hhvn.uk/hbspbar/config"
	"hhvn.uk/hbspbar/common"

	"github.com/jezek/xgb"
	"github.com/jezek/xgb/xproto"
	"github.com/jezek/xgbutil"
	"github.com/jezek/xgbutil/icccm"
	"github.com/jezek/xgbutil/ewmh"
	"github.com/jezek/xgbutil/xgraphics"
	"github.com/BurntSushi/freetype-go/freetype"
	"github.com/BurntSushi/freetype-go/freetype/truetype"
)

type eventwrap struct {
	Ev  xgb.Event
	Err error
}

var InitErr error
var Events  chan *eventwrap

var xc      *xgb.Conn
var xu      *xgbutil.XUtil
var screen  *xproto.ScreenInfo
var font    *truetype.Font
var ft      *freetype.Context

func init() {
	var err error

	xc, err = xgb.NewConn()
	if err != nil {
		InitErr = err
		return
	}

	xu, err = xgbutil.NewConnXgb(xc)
	if err != nil {
		InitErr = err
		return
	}

	setup := xproto.Setup(xc)
	screen = setup.DefaultScreen(xc)

	read, err := os.Open(config.Font)
	if err != nil {
		InitErr = common.Perror("os.Open", err)
		return
	}

	font, err = xgraphics.ParseFont(read)
	if err != nil {
		InitErr = common.Perror("xgraphics.ParseFont", err)
		return
	}

	ft = freetype.NewContext()
	ft.SetDPI(72)
	ft.SetFont(font)
	ft.SetFontSize(config.FontSize)

	Events := make(chan *eventwrap)

	go func() { for {
		ev, err := xc.WaitForEvent()
		w := eventwrap{ev, err}

		select {
		default:
			Events <- &w
		}
	}}()
}

func int2rgb(argb uint32) (color.RGBA) {
	return color.RGBA{
		B: uint8( argb & 0x000000ff),
		G: uint8((argb & 0x0000ff00) >> 8),
		R: uint8((argb & 0x00ff0000) >> 16),
		A: uint8((argb & 0xff000000) >> 24) }
}

type Window struct {
	id xproto.Window
}

func WindowCreate(x, y, w, h uint) (*Window, error) {
	var win Window
	var err error

	win.id, err = xproto.NewWindowId(xc)
	if err != nil {
		return nil, common.Perror("xproto.NewWindowId", err)
	}

	xproto.CreateWindow(xc, screen.RootDepth, win.id, screen.Root,
		int16(x), int16(y), uint16(w), uint16(h), 0,
		xproto.WindowClassInputOutput, screen.RootVisual,
		xproto.CwBackPixel|xproto.CwEventMask, []uint32{
			config.Bg,
			xproto.EventMaskStructureNotify })

	class := icccm.WmClass{"hbspbar", "hbspbar"}
	icccm.WmClassSet(xu, win.id, &class)

	ewmh.WmWindowTypeSet(xu, win.id, []string{"_NET_WM_WINDOW_TYPE_DOCK"})
	ewmh.WmStateSet(xu, win.id, []string{"_NET_WM_STATE_STICKY", "_NET_WM_STATE_ABOVE"})

	err = xproto.MapWindowChecked(xc, win.id).Check()
	if err != nil {
		return nil, common.Perror("xproto.MapWindow", err)
	}

	return &win, nil
}

func (w *Window) Paint(i image.Image) {
	xgr := xgraphics.NewConvert(xu, i)

	xgr.XSurfaceSet(w.id)
	xgr.XDraw()
	xgr.XPaint(w.id)
}

func (w *Window) Destroy() {
	xproto.DestroyWindow(xc, w.id)
}