package main

import (
	"flag"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"

	"git.fromouter.space/Artificiale/consulconf"
	"git.fromouter.space/Artificiale/moa/sd"

	"github.com/go-kit/kit/log"

	svc "git.abbiamoundominio.org/hamcha/bacheca"
	"git.abbiamoundominio.org/hamcha/bacheca/storage"
	boltbackend "git.abbiamoundominio.org/hamcha/bacheca/storage/bolt"
	filebackend "git.abbiamoundominio.org/hamcha/bacheca/storage/file"
)

type bachecaConfig struct {
	Bind        string
	Advertise   string
	StorageType string
	StorageFile string
}

func main() {
	consulAddr := flag.String("consul.addr", "consul:8500", "Consul address")
	consulConf := flag.String("consul.conf", "bacheca/config", "Consul KV prefix with configuration")
	flag.Parse()

	err := consulconf.UseDefaultClient(*consulAddr)
	if err != nil {
		panic(err)
	}

	var config bachecaConfig
	err = consulconf.Get(*consulConf, &config)
	if err != nil {
		panic(err)
	}

	var backend storage.Backend
	switch config.StorageType {
	case "bolt":
		boltdb, err := boltbackend.MakeBoltBackend(config.StorageFile)
		if err != nil {
			panic(err)
		}
		defer boltdb.Close()
		backend = boltdb
	case "file":
		filebackend, err := filebackend.MakeFileBackend(config.StorageFile)
		if err != nil {
			panic(err)
		}
		backend = filebackend
	default:
		panic("unknown storage backend type (-storage.type), check help for supported backends")
	}

	var logger log.Logger
	{
		logger = log.NewLogfmtLogger(os.Stderr)
		logger = log.With(logger, "ts", log.DefaultTimestampUTC)
		logger = log.With(logger, "caller", log.DefaultCaller)
	}

	s := svc.MakeService(backend)
	handler := svc.MakeHTTPHandler(s, logger)

	// Register with consul
	registrar := sd.Register(*consulAddr, sd.Options{
		Name:      "bacheca",
		Advertise: config.Advertise,
		Tags: []string{
			"http",              // Expose via HTTP
			"match-path:events", // Publish at /events/*
			"private",           // All APIs are private..
			"public:/feed",      // ..except /feed
		},
	}, logger)
	defer registrar.Deregister()

	errs := make(chan error)
	go func() {
		c := make(chan os.Signal)
		signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
		errs <- fmt.Errorf("%s", <-c)
	}()

	go func() {
		logger.Log("transport", "HTTP", "addr", config.Bind)
		errs <- http.ListenAndServe(config.Bind, handler)
	}()

	logger.Log("exit", <-errs)
}