package server

import (
	"context"
	"fmt"
	"net/http"
	"time"

	cfg "go.alanpearce.eu/website/internal/config"
	"go.alanpearce.eu/x/log"

	"gitlab.com/tozd/go/errors"
)

var (
	CommitSHA    = "local"
	ShortSHA     = "local"
	serverHeader = fmt.Sprintf("website (%s)", ShortSHA)

	ReadHeaderTimeout = 10 * time.Second
	ReadTimeout       = 1 * time.Minute
	WriteTimeout      = 2 * time.Minute
	IdleTimeout       = 10 * time.Minute
)

type Options struct {
	Development   bool
	ListenAddress string
	Port          int
	TLSPort       int
	TLS           bool

	ACMEIssuer     string
	ACMEIssuerCert string

	Config *cfg.Config
}

type Server struct {
	mux     *http.ServeMux
	options *Options
	log     *log.Logger
	server  *http.Server
}

func serverHeaderHandler(wrappedHandler http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Server", serverHeader)
		wrappedHandler.ServeHTTP(w, r)
	})
}

func New(options *Options, log *log.Logger) (*Server, error) {
	fixupMIMETypes(log)

	return &Server{
		mux:     http.NewServeMux(),
		log:     log,
		options: options,
	}, nil
}

func (s *Server) HostApp(app *App) {
	s.mux.Handle(app.Domain+"/", app.Handler)
}

func (s *Server) HostFallbackApp(app *App) {
	s.mux.Handle("/", app.Handler)
}

func (s *Server) serve(tls bool) error {
	if tls {
		return s.serveTLS()
	}

	return s.serveTCP()
}

func (s *Server) Start() error {
	top := http.NewServeMux()
	top.Handle("/",
		serverHeaderHandler(
			wrapHandlerWithLogging(s.mux, s.log),
		),
	)

	top.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusNoContent)
	})

	s.server = &http.Server{
		ReadHeaderTimeout: ReadHeaderTimeout,
		ReadTimeout:       ReadTimeout,
		WriteTimeout:      WriteTimeout,
		IdleTimeout:       IdleTimeout,
		Handler:           s.mux,
	}

	if err := s.serve(s.options.TLS); err != http.ErrServerClosed {
		return errors.WithMessage(err, "error creating/closing server")
	}

	return nil
}

func (s *Server) Stop() chan struct{} {
	s.log.Debug("stop called")

	idleConnsClosed := make(chan struct{})

	go func() {
		s.log.Debug("shutting down server")
		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		err := s.server.Shutdown(ctx)
		s.log.Debug("server shut down")
		if err != nil {
			// Error from closing listeners, or context timeout:
			s.log.Warn("HTTP server Shutdown", "error", err)
		}
		close(idleConnsClosed)
	}()

	return idleConnsClosed
}