package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"path/filepath"
	"syscall"

	"github.com/gorilla/mux"
	"github.com/rs/cors"
	"github.com/spf13/cobra"

	"gemma.intevation.de/gemma/auth"
	"gemma.intevation.de/gemma/config"
	"gemma.intevation.de/gemma/controllers"
)

func prepareConnectionPool() {
	// Install connection pool
	cp, err := auth.NewConnectionPool(config.SessionStore())
	if err != nil {
		log.Fatalf("Error with session store: %v\n", err)
	}
	auth.ConnPool = cp
}

func start(cmd *cobra.Command, args []string) {

	web, err := filepath.Abs(config.Web())
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}

	prepareConnectionPool()

	m := mux.NewRouter()
	controllers.BindRoutes(m)

	m.PathPrefix("/").Handler(http.FileServer(http.Dir(web)))

	addr := fmt.Sprintf("%s:%d", config.WebHost(), config.WebPort())
	log.Printf("listen on %s\n", addr)

	var h http.Handler

	if al := config.AllowedOrigins(); len(al) > 0 {
		c := cors.New(cors.Options{
			AllowedOrigins: al,
			Debug:          true,
		})
		h = c.Handler(m)
	} else {
		h = m
	}

	server := http.Server{Addr: addr, Handler: h}

	done := make(chan error)

	go func() {
		defer close(done)
		done <- server.ListenAndServe()
	}()

	sigChan := make(chan os.Signal)
	signal.Notify(sigChan, os.Interrupt, os.Kill, syscall.SIGTERM)

	select {
	case err := <-done:
		if err != nil && err != http.ErrServerClosed {
			log.Fatalf("error: %v\n", err)
		}
	case <-sigChan:
	}

	server.Shutdown(context.Background())

	<-done

	if err := auth.ConnPool.Shutdown(); err != nil {
		log.Fatalf("error: %v\n", err)
	}
}

func main() {
	config.RootCmd.Run = start
	if err := config.RootCmd.Execute(); err != nil {
		log.Fatalln(err)
	}
}