// SPDX-FileCopyrightText: V <v@anomalous.eu>
// SPDX-FileCopyrightText: edef <edef@edef.eu>
// SPDX-License-Identifier: OSL-3.0

package main // import "go.anomalous.eu/loxy"

import (
	"context"
	"crypto/tls"
	"flag"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"os"
	"os/signal"
	"syscall"
)

var dbpath, certpath string
var addr interface {
	flag.Value
	Listeners() ([]net.Listener, error)
}

func init() {
	if os.Getenv("LISTEN_FDS") == "" {
		a := listenAddress(net.JoinHostPort("::1", "3893"))
		addr = &a
	} else {
		addr = activationSocket{}
	}

	flag.Var(addr, "addr", "listen address")
	flag.StringVar(&dbpath, "db", "loxy.db", "`path` to database")
	flag.StringVar(&certpath, "cert", "", "`path` to client certificate")
	log.SetFlags(log.Lshortfile)
}

func main() {
	flag.Parse()
	if flag.NArg() != 0 {
		flag.Usage()
		os.Exit(1)
	}

	tlsConfig := &tls.Config{}
	if certpath != "" {
		pem, err := ioutil.ReadFile(certpath)
		if err != nil {
			log.Fatal(err)
		}

		cert, err := tls.X509KeyPair(pem, pem)
		if err != nil {
			log.Fatal(err)
		}

		tlsConfig.Certificates = []tls.Certificate{cert}
	}

	proxy := NewProxy(OpenStore(dbpath), tlsConfig)
	server := &http.Server{Handler: proxy}

	ctx, cancel := context.WithCancel(context.Background())
	server.BaseContext = func(net.Listener) context.Context { return ctx }
	server.RegisterOnShutdown(cancel)

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)

	listeners, err := addr.Listeners()
	if err != nil {
		log.Fatal(err)
	}

	serve := make(chan error, len(listeners))
	for _, ln := range listeners {
		go func(ln net.Listener) { serve <- server.Serve(ln) }(ln)
	}

	select {
	case err = <-serve:
		log.Printf("http.ListenAndServe: %v", err)
	case sig := <-sig:
		log.Printf("caught %v, shutting down", sig)
		server.Shutdown(context.Background())
	}
	proxy.Shutdown()

	if err != nil {
		os.Exit(1)
	}
}