package main

import (
	"cli-mon/can"
	"cli-mon/ui"
	"cli-mon/yabl"
	flag "flag"
	"fmt"
	"golang.org/x/sys/unix"
	"os"
	"time"
)

func main() {
	filename := flag.String("f", "", "Candump filename")
	canbus := flag.String("i", "can0", "CAN bus interface")
	stdin := flag.Bool("s", false, "Read from stdin")
	gui := flag.Bool("gui", false, "Pseudo-GUI CLI interface")
	amqp := flag.String("amqp", "", "Run output to AMQP broker url")
	interval := time.Duration(*flag.Uint("t", 50, "Override data loss check interval, ms"))
	flag.Parse()

	var frames <-chan *can.CanFrame

	switch {
	case *stdin:
		frames = can.ReadStdin(os.Stdin)
	case len(*filename) > 0:
		frames = can.Readfile(filename)
	case len(*canbus) > 0:
		filter := []unix.CanFilter{
			{Id: yabl.CanIdContIntState, Mask: 0xFFF},
			{Id: yabl.CanIdContIntErr, Mask: 0xFFF},
			{Id: yabl.CanIdContIntForce, Mask: 0xFFF},
			{Id: yabl.CanIdContIntDebug, Mask: 0xFFF},
			{Id: yabl.CanIdPuPresentEnergy, Mask: 0xFFF},
			{Id: yabl.CanIdPuPeriphery, Mask: 0xFFF},
			{Id: yabl.CanIdCpuPresentEnergy, Mask: 0xFFF},
			{Id: yabl.CanIdCpuPeriphery, Mask: 0xFFF},
			{Id: yabl.CanIdCpuEnergySettings, Mask: 0xFFF},
			{Id: yabl.CanIdCpuErrors, Mask: 0xFFF},
			{Id: yabl.CanIdCpuDebug, Mask: 0xFFF},
			{Id: yabl.CanIdPuErrors, Mask: 0xFFF},
			{Id: yabl.CanIdPuDebug, Mask: 0xFFF},
			{Id: yabl.CanIdSeccTargetEnergy, Mask: 0xFFF},
			{Id: yabl.CanIdSeccErrors, Mask: 0xFFF},
			{Id: yabl.CanIdLogicAuth, Mask: 0xFFF},
			{Id: yabl.CanIdLogicEnergyMode, Mask: 0xFFF},
			{Id: yabl.CanIdLogicErrors, Mask: 0xFFF},
			{Id: yabl.CanIdLogicWorkingMode, Mask: 0xFFF},
			{Id: yabl.CanIdPeripheryState, Mask: 0xFFF},
			{Id: yabl.CanIdPeripheryInfo, Mask: 0xFFF},
			{Id: yabl.CanIdPeripheryDebug, Mask: 0xFFF},
			{Id: yabl.CanIdConverterPresentEnergy, Mask: 0xFFF},
			{Id: yabl.CanIdConverterErrors, Mask: 0xFFF},
			{Id: yabl.CanIdConverterDebug, Mask: 0xFFF},
		}

		var err error
		frames, err = can.StartCan(*canbus, filter)
		if err != nil {
			fmt.Println(err)
			return
		}
	default:
		flag.Usage()
	}

	if frames == nil {
		fmt.Println("Get no data")
		os.Exit(0)
	}

	converter := yabl.NewProtocolConverter("")

	var display ui.UI

	if *gui {
		display = ui.NewUI()
	} else if len(*amqp) > 0 {
		display = ui.NewAmqp(*amqp)
	} else {
		display = ui.NewLog()
	}

	display.Start()

	updates := make(chan *yabl.Event, 1000)

	isOffline := len(*filename) > 0 || *stdin

	var f func()
	f = func() {
		if events, ok := converter.CheckTimeouts(isOffline); ok {
			for _, event := range events {
				updates <- event
			}
		}
		time.AfterFunc(interval*time.Millisecond, f)
	}

	time.AfterFunc(5*time.Second, f)

	go func() {
		for frame := range frames {
			if events, ok := converter.EventsFromFrame(frame); ok {
				for _, event := range events {
					updates <- event
				}
			}
		}
		close(updates)
	}()

	for event := range updates {
		display.Consume(event)
	}

	display.Stop()
}