package server

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

	"alin.ovh/x/log"
	"github.com/osdevisnot/sorvor/pkg/livereload"

	"github.com/Southclaws/fault"
	"github.com/Southclaws/fault/fmsg"
)

type Options struct {
	Redirect        bool          `conf:"default:true"`
	ListenAddress   string        `conf:"default:::"`
	Port            int           `conf:"default:8080,short:p"`
	ShutdownTimeout time.Duration `conf:"default:10s"`

	Development     bool                   `conf:"-"`
	LiveReload      *livereload.LiveReload `conf:"-"`
	Domains         []string               `conf:"-"`
	WildcardDomains []string               `conf:"-"`
	Listener        net.Listener           `conf:"-"`
}

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

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

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

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) {
	return &Server{
		mux:     http.NewServeMux(),
		log:     log,
		options: options,
	}, nil
}

func (s *Server) HostApp(app *App) error {
	if app.Domain == "" {
		return fault.New("app needs a domain")
	}
	s.options.Domains = append(s.options.Domains, app.Domain)
	s.mux.Handle(app.Domain+"/", app.Handler)

	return nil
}

func (s *Server) HostFallbackApp(app *App) {
	if len(app.Domains) > 0 {
		s.options.Domains = append(s.options.Domains, app.Domains...)
	}
	if app.WildcardDomain != "" {
		s.options.WildcardDomains = append(s.options.WildcardDomains, app.WildcardDomain)
	}
	s.mux.Handle("/", app.Handler)
}

func (s *Server) Start() error {
	var lh http.Handler
	if s.options.Development {
		lh = wrapHandlerWithLogging(s.mux, s.log)
	} else {
		lh = s.mux
	}

	top := http.NewServeMux()
	top.Handle("/",
		serverHeaderHandler(
			lh,
		),
	)

	if s.options.LiveReload != nil {
		top.Handle("/_/reload", s.options.LiveReload)
		s.options.LiveReload.Start()
	}

	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:           top,
	}

	if s.options.Listener == nil {
		var err error
		s.options.Listener, err = s.tcpListener()
		if err != nil {
			return fault.Wrap(err, fmsg.With("error creating listener"))
		}
	}

	if err := s.server.Serve(s.options.Listener); !errors.Is(err, http.ErrServerClosed) {
		return fault.Wrap(err, fmsg.With("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(), s.options.ShutdownTimeout)
		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
}