package server

import (
	"context"
	"fmt"
	"net"
	"net/http"
	"net/url"
	"os"
	"slices"
	"time"

	cfg "website/internal/config"
	"website/internal/log"
	"website/internal/website"

	"github.com/getsentry/sentry-go"
	sentryhttp "github.com/getsentry/sentry-go/http"
	"github.com/pkg/errors"
	"golang.org/x/net/http2"
	"golang.org/x/net/http2/h2c"
)

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

type Config struct {
	Production    bool   `conf:"default:false"`
	InDevServer   bool   `conf:"default:false"`
	Root          string `conf:"default:website"`
	ListenAddress string `conf:"default:localhost"`
	Port          string `conf:"default:3000,short:p"`
}

type Server struct {
	*http.Server
}

func applyDevModeOverrides(config *cfg.Config, listenAddress string) {
	config.CSP.ScriptSrc = slices.Insert(config.CSP.ScriptSrc, 0, "'unsafe-inline'")
	config.CSP.ConnectSrc = slices.Insert(config.CSP.ConnectSrc, 0, "'self'")
	config.BaseURL = cfg.URL{
		URL: &url.URL{
			Scheme: "http",
			Host:   listenAddress,
		},
	}
}

func serverHeaderHandler(wrappedHandler http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.ProtoMajor >= 2 && r.Header.Get("Host") != "" {
			// net/http does this for HTTP/1.1, but not h2c
			// TODO: check with HTTP/2.0 (i.e. with TLS)
			r.Host = r.Header.Get("Host")
			r.Header.Del("Host")
		}
		w.Header().Set("Server", serverHeader)
		wrappedHandler.ServeHTTP(w, r)
	})
}

func New(runtimeConfig *Config) (*Server, error) {
	var err error
	config, err := cfg.GetConfig()
	if err != nil {
		return nil, errors.WithMessage(err, "error parsing configuration file")
	}

	listenAddress := net.JoinHostPort(runtimeConfig.ListenAddress, runtimeConfig.Port)

	env := "development"
	if runtimeConfig.Production {
		env = "production"
	} else {
		applyDevModeOverrides(config, listenAddress)
	}
	err = sentry.Init(sentry.ClientOptions{
		EnableTracing:    true,
		TracesSampleRate: 1.0,
		Dsn:              os.Getenv("SENTRY_DSN"),
		Release:          CommitSHA,
		Environment:      env,
	})
	if err != nil {
		return nil, errors.WithMessage(err, "could not set up sentry")
	}
	defer sentry.Flush(2 * time.Second)
	sentryHandler := sentryhttp.New(sentryhttp.Options{
		Repanic: true,
	})

	top := http.NewServeMux()
	mux, err := website.NewMux(config, runtimeConfig.Root)
	if err != nil {
		return nil, errors.Wrap(err, "could not create website mux")
	}
	log.Debug("binding main handler to", "host", listenAddress)
	hostname := config.BaseURL.Hostname()

	top.Handle(hostname+"/", mux)

	top.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		newURL := config.BaseURL.JoinPath(r.URL.String())
		http.Redirect(w, r, newURL.String(), 301)
	})

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

	return &Server{
		&http.Server{
			Addr:              listenAddress,
			ReadHeaderTimeout: 1 * time.Minute,
			Handler: http.MaxBytesHandler(h2c.NewHandler(
				sentryHandler.Handle(
					serverHeaderHandler(
						wrapHandlerWithLogging(top),
					),
				),
				&http2.Server{
					IdleTimeout: 15 * time.Minute,
				},
			), 0),
		},
	}, nil
}

func (s *Server) Start() error {
	if err := s.ListenAndServe(); err != http.ErrServerClosed {
		return errors.Wrap(err, "error creating/closing server")
	}

	return nil
}

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

	idleConnsClosed := make(chan struct{})

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

	return idleConnsClosed
}