// This is Free Software under GNU Affero General Public License v >= 3.0
// without warranty, see README.md and license for details.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
// License-Filename: LICENSES/AGPL-3.0.txt
//
// Copyright (C) 2018 by via donau
//   – Österreichische Wasserstraßen-Gesellschaft mbH
// Software engineering by Intevation GmbH
//
// Author(s):
//  * Sascha L. Teichmann <sascha.teichmann@intevation.de>

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/pkg/auth"
	"gemma.intevation.de/gemma/pkg/config"
	"gemma.intevation.de/gemma/pkg/controllers"
	"gemma.intevation.de/gemma/pkg/geoserver"
	"gemma.intevation.de/gemma/pkg/imports"
	"gemma.intevation.de/gemma/pkg/scheduler"
)

func prepareSessionStore() {
	// Install session store
	ss, err := auth.NewSessionStore(config.SessionStore())
	if err != nil {
		log.Fatalf("Error with session store: %v\n", err)
	}
	auth.Sessions = ss
}

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

	config.Ready()

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

	prepareSessionStore()

	// Do GeoServer setup in background.
	geoserver.Reconfigure(geoserver.PrepareGeoServer)

	// Log what's registered to the import queue and scheduler.
	imports.LogImportKindNames()
	scheduler.LogActionNames()

	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("info: 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, 1)
	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.Sessions.Shutdown(); err != nil {
		log.Fatalf("error: %v\n", err)
	}
}

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