package main

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

	"dev.sum7.eu/genofire/golang-lib/worker"
	log "github.com/Sirupsen/logrus"

	"github.com/influxdata/influxdb/client/v2"
	models "github.com/influxdata/influxdb/models"

	"github.com/graarh/golang-socketio"
	"github.com/graarh/golang-socketio/transport"
)

func main() {
	r2pURL := ""
	influxAddr := ""
	influxUser := ""
	influxPassword := ""
	influxDB := ""
	silenceLog := false
	verboseLog := false

	flag.BoolVar(&silenceLog, "s", false, "silence")
	flag.BoolVar(&verboseLog, "v", false, "verbose")

	flag.StringVar(&r2pURL, "url", "http://192.168.1.110:8080", "weburl")

	flag.StringVar(&influxAddr, "influx-addr", "http://127.0.0.1/influxdb", "influxdb")
	flag.StringVar(&influxUser, "influx-user", "r2puser", "")
	flag.StringVar(&influxPassword, "influx-pw", "PASSWORD", "")
	flag.StringVar(&influxDB, "influx-db", "r2p", "")

	flag.Parse()

	if silenceLog {
		log.SetLevel(log.WarnLevel)
	} else if verboseLog {
		log.SetLevel(log.DebugLevel)
	}

	api, err := gosocketio.Dial(
		strings.Replace(r2pURL, "http", "ws", 1)+"/socket.io/?EIO=3&transport=websocket",
		transport.GetDefaultWebsocketTransport(),
	)
	if err != nil {
		log.Errorf("not connected to r2p: %s", err.Error())
		return
	}
	defer api.Close()

	influx, err := InfluxDBConnect(client.HTTPConfig{
		Addr:     influxAddr,
		Username: influxUser,
		Password: influxPassword,
	}, influxDB)
	if err != nil {
		log.Errorf("not connected to influxdb: %s", err.Error())
		return
	}
	defer influx.Close()

	log.Info("startup")

	api.On("current", func(c *gosocketio.Channel, args interface{}) {
		log.Debug("notified by websocket")
		currentFloat := args.(float64)
		log.Debugf("notified by websocket, get value: %d", currentFloat)
		current := int(currentFloat)

		log.WithFields(map[string]interface{}{"source": "websocket", "current": current}).Info("notified")

		tags := models.Tags{}
		tags.SetString("source", "websocket")
		influx.addPoint("r2p_point", tags, models.Fields{
			"current": args,
		})
	})

	jsonWorker := worker.NewWorker(time.Second*2, func() {
		result := R2PAPIAll{}
		err := JSONRequest(r2pURL+"/GetAll", &result)
		if err != nil {
			log.Error("error on http-request r2p: ", err)
			return
		}

		log.WithFields(map[string]interface{}{"source": "http", "current": result.CountCurrent, "in": result.CountIn, "out": result.CountOut}).Info("requested")

		tags := models.Tags{}
		tags.SetString("source", "http")
		influx.addPoint("r2p_point", tags, models.Fields{
			"out":     result.CountOut,
			"in":      result.CountIn,
			"current": result.CountCurrent,
		})
	})
	defer jsonWorker.Close()
	go jsonWorker.Start()

	// Wait for INT/TERM
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	sig := <-sigs
	log.Info("quit by recieving: ", sig)
}