package main

import (
	"image"
	"errors"
	"image/color"

	"hhvn.uk/hbspbar/config"
	"hhvn.uk/hbspbar/status"
	"hhvn.uk/hbspbar/bspc"
	"hhvn.uk/hbspbar/drw"
)

var bars map[int]*bar = make(map[int]*bar)

type bar struct {
	id      int
	w       *drw.Window
	i       *image.RGBA
}

var (
	ErrNoState = errors.New("attempted to create a bar with uninitialized state")
	ErrNoSuchBar = errors.New("attempted to destroy non-existant bar")
) 
 
func (b *bar) init(id int, state *bspc.State) error {
	b.id = id
	b.i  = nil

	mon, err := b.getmon(state)
	if err != nil { return err }

	go mon.TopPadding(config.H)

	geom := mon.Rectangle

	b.w, err = drw.WindowCreate(geom.X, geom.Y, geom.Width, config.H)
	if err != nil { return err }

	rect := image.Rect(0, 0, int(mon.Rectangle.Width), int(config.H))
	b.i = image.NewRGBA(rect)

	return nil
}

func (b *bar) destroy(state *bspc.State) {
	mon, _ := b.getmon(state)
	if (mon != nil) {
		mon.TopPadding(0)
	}
}

func (b bar) getmon(state *bspc.State) (*bspc.Monitor, error) {
	return state.GetMon(b.id)
}

func (b *bar) drawText(x int, col color.Color, text string) (int, error) {
	return drw.DrawText(b.i, x, col, text)
}

func (b *bar) drawRect(x, y, w, h int, c color.Color, fill bool) {
	drw.DrawRect(b.i, x, y, w, h, c, fill)
}

func (b bar) draw(state *bspc.State, blocks []*status.Block) error {
	var bg     color.Color
	var filled bool

	if blocks == nil {
		return nil
	}

	mon, err := b.getmon(state)
	if err != nil {
		return err
	}

	// Dimensions of drawing space
	cx := 0
	w  := int(mon.Rectangle.Width)
	h  := int(config.H)


	// Draw background
	b.drawRect(0, 0, w, h, config.Bg, true)

	// Monitor
	montext := mon.Name
	monw    := 6 + drw.TextWidth(montext) + 8

	if mon.Focused {
		bg = config.Sel
	} else {
		bg = config.UnselMon
	}

	b.drawRect(cx, 0, monw, h, bg, true)
	b.drawText(cx + 6, config.Fg, montext)
	cx += monw

	// Desktops
	boxw := 4
	ds   := len(mon.Desktops)
	dw   := 4 + (4 + boxw + 2 + 3) * ds + 5

	for i := 0; i < ds; i++ {
		dw += drw.TextWidth(mon.Desktops[i].Name)
	}

	cx += 4
	for i := 0; i < ds; i++ {
		d := mon.Desktops[i]

		cx += 5

		if d.Focused {
			bg = config.Sel
		} else {
			bg = config.FgDark
		}

		filled = d.Root != nil

		b.drawRect(cx, 3, boxw, h - 7, bg, filled)
		cx += boxw + 2
		ax, _ := b.drawText(cx, config.Fg, d.Name)
		cx += ax + 2
	}

	cx = int(mon.Rectangle.Width)
	for _, s := range blocks {
		if s != nil {
			cx -= s.W
			cx -= config.StatusPad
		}
	}

	b.drawRect(cx, 0, int(mon.Rectangle.Width) - cx, int(config.H),
		config.Status, true)

	cx += config.StatusPad / 2

	for _, s := range blocks {
		if s != nil {
			drw.AddImg(b.i, cx, s.W, s.I)

			cx += s.W + config.StatusPad
		}
	}

	b.w.Paint(b.i)

	return nil
}

func Create(state *bspc.State, id int) (error) {
	var b bar

	if state == nil {
		return ErrNoState
	}

	if _, ok := bars[id]; ok {
		// Already created, whatever.
		return nil
	}

	if err := b.init(id, state); err != nil {
		return err
	}

	bars[b.id] = &b
	return nil
}

func Redraw(state *bspc.State, blocks []*status.Block) {
	for _, b := range bars {
		b.draw(state, blocks)
	}
}

func Destroy(state *bspc.State, id int) error {
	b, ok := bars[id]
	if !ok {
		return ErrNoSuchBar
	}

	b.destroy(state)
	delete(bars, id)

	return nil
}

func Cleanup(state *bspc.State) {
	if state != nil {
		for _, b := range bars {
			b.destroy(finalstate)
		}
	}
}