package main

import (
	"os"
	"strings"
	"syscall"
	"os/signal"

	"hhvn.uk/hbspbar/common"
	"hhvn.uk/hbspbar/bspc"
	"hhvn.uk/hbspbar/bar"
)

var reloadEvents = []string{
	"monitor_rename",
	"monitor_swap",
	"monitor_focus",
	"desktop_add",
	"desktop_rename",
	"desktop_remove",
	"desktop_swap",
	"desktop_transfer",
	"desktop_focus",
	"desktop_activate",
	"desktop_layout",
	"node_add",
	"node_remove",
	"node_swap",
	"node_transfer" }

func reloadState(current *bspc.State) (*bspc.State, error) {
	state, err := bspc.LoadState()

	if err != nil {
		return current, err
	} else {
		return state, nil
	}
}

func handleEvents(events *bspc.Subscriber, bar *bar.Handle) (chan error, chan bool) {
	var event *bspc.Event

	errors := make(chan error)
	reload := make(chan bool)

	go func(){ for {
		select {
		case err := <-events.Err:
			errors <- err
			return
		case event = <- events.Event:
		}

		if strings.HasPrefix(event.Name, "monitor_") {
			id, err := common.Intify(event.Tokens[0])
			if err == nil {
				switch (event.Name) {
				case "monitor_add": bar.Create <- id
				case "monitor_remove": bar.Destroy <- id
				}
			}
		}

		for i := 0; i < len(reloadEvents); i++ {
			if event.Name == reloadEvents[i] {
				reload <- true
			}
		}
	}}()

	return errors, reload
}

func main() {
	signals := make(chan os.Signal, 1)
	signal.Notify(signals,
		syscall.SIGINT,
		syscall.SIGHUP,
		syscall.SIGTERM)

	state, err := bspc.LoadState()
	if err != nil {
		common.Error("Couldn't load bspwm state: %s\n", err)
		return
	}

	events, err := bspc.Subscribe()
	if err != nil {
		common.Error("Couldn't subscribe to bspwm: %s\n", err)
		return
	}
	defer events.Close()

	barhandle, err := bar.Init(state)
	if err != nil {
		common.Error("Couldn't initialize X: %s\n", err)
		return
	}

	for _, m := range state.Monitors {
		barhandle.Create <- m.ID
	}
	defer bar.Cleanup()

	everr, evreload := handleEvents(events, barhandle)

	for {

		select {
		case <- evreload:
			state, err = reloadState(state)
			if err != nil {
				common.Error("Couldn't reload bspwm state: %s\n", err)
			}

			barhandle.NewState <- state
		case err := <- everr:
			common.Error("Couldn't read event: %s\n", err)
			return
		case s := <- signals:
			common.Error("%s\n", s)
			return
		case err := <- barhandle.Err:
			common.Error("%s\n", err)
			return
		}
	}
}