package httpserver

import (
	"context"
	"crypto/tls"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/pelletier/go-toml"
	"github.com/phuslu/log"
	"go.sebtobie.de/httpserver/auth"
	"go.sebtobie.de/httpserver/menus"
)

// Config that is used to map the toml config to the settings that are used.
type Config struct {
	Addr      string
	TLSconfig *tls.Config
	Certfile  string
	Keyfile   string
}

// MarshalObject adds the information over the object to the *log.Entry
func (c *Config) MarshalObject(e *log.Entry) {
	e.Str("Address", c.Addr).Bool("TLS", c.TLSconfig != nil).Strs("Cert", []string{c.Certfile, c.Keyfile})
}

var _ log.ObjectMarshaler = &Config{}

// Server is an wrapper for the *http.Server and *gin.Engine
type Server struct {
	http            *http.Server
	conf            *Config
	mrouter         map[string]*gin.Engine
	config          *toml.Tree
	sites           []Site
	menu            []menus.Menu
	NotFoundHandler http.Handler
}

func init() {
	gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
		log.Trace().Msgf("%-4s(%02d): %-20s %s", httpMethod, nuHandlers, absolutePath, handlerName)
	}
}

// StartServer starts the server as configured and sends the errormessage to the log.
func (s *Server) StartServer() {
	log.Info().Msg("Starting server")
	var err error
	if s.conf.Certfile != "" && s.conf.Keyfile != "" {
		err = s.http.ListenAndServeTLS(s.conf.Certfile, s.conf.Keyfile)

	} else {
		err = s.http.ListenAndServe()
	}
	if err != http.ErrServerClosed {
		log.Error().Err(err).Msg("Server unexpected exited")
	}
}

// DomainRouter redirects the requests to the routers of the domains
func (s *Server) DomainRouter(w http.ResponseWriter, r *http.Request) {
	var domain string
	if r.URL.Host != "" {
		domain = r.URL.Host
	} else if r.Host != "" {
		domain = r.Host
	} else if r.Header.Get("X-Original-Host") != "" {
		domain = r.Header.Get("X-Original-Host")
	}
	r.Host = domain
	r.URL.Host = domain
	for header, value := range map[string][]string(r.Header) {
		log.Trace().Strs(header, value).Msg("Headers")
	}
	if router, found := s.mrouter[domain]; found {
		router.NoMethod(gin.WrapH(s.NotFoundHandler))
		router.NoRoute(gin.WrapH(s.NotFoundHandler))
		router.ServeHTTP(w, r)
		return
	}
	var entrys []string
	for d := range s.mrouter {
		entrys = append(entrys, d)
	}
	log.Trace().Strs("reqistred domains", entrys).Msg("domain not found")
	s.NotFoundHandler.ServeHTTP(w, r)
}

// CreateServer creates an server that can be run in a coroutine.
func CreateServer(config *toml.Tree) *Server {
	log.Info().Msg("Redirect logging output to phuslu/log")
	gin.DefaultErrorWriter = log.DefaultLogger.Std(log.ErrorLevel, log.Context{}, "GIN", 0).Writer()
	gin.DefaultWriter = log.DefaultLogger.Std(log.DebugLevel, log.Context{}, "GIN", 0).Writer()
	log.Info().Msg("Creating HTTP-Server")
	var server = &Server{
		conf: &Config{
			Addr: "127.0.0.1:8080",
		},
		mrouter: map[string]*gin.Engine{},
	}
	if err := config.Unmarshal(server.conf); err != nil {
		log.Error().Msg("Problem mapping config to Configstruct")
	}
	log.Debug().EmbedObject(server.conf).Msg("Config")
	server.http = &http.Server{
		Addr:      server.conf.Addr,
		ErrorLog:  log.DefaultLogger.Std(log.ErrorLevel, log.Context{}, "", 0),
		Handler:   http.HandlerFunc(server.DomainRouter),
		TLSConfig: server.conf.TLSconfig,
	}
	server.NotFoundHandler = http.NotFoundHandler()
	server.menu = []menus.Menu{}
	return server
}

// Use installs the middleware into the router.
// The Middleware must be able to detect multiple calls byy itself. Deduplication is not performed.
func (s *Server) Use(m ...gin.HandlerFunc) {
	for _, router := range s.mrouter {
		router.Use(m...)
	}
}

// Stop Shuts the Server down
func (s *Server) Stop(ctx context.Context) {
	log.Info().Err(s.http.Shutdown(ctx)).Msg("Server Shut down.")
	for _, site := range s.sites {
		site.Teardown()
	}
}

// Site is an Interface to abstract the modularized group of pages.
// The Middleware must be able to detect multiple calls byy itself. Deduplication is not performed.
type Site interface {
	Init(*gin.RouterGroup)
	Teardown()
}

func (s *Server) menus() []menus.Menu {
	return s.menu
}

// RegisterSite adds an site to the engine as its own grouo
func (s *Server) RegisterSite(domain, path string, site Site) {
	var router *gin.Engine
	var found bool
	if router, found = s.mrouter[domain]; !found {
		var authhf auth.AuthenticationHandler
		router = gin.New()
		mw := []gin.HandlerFunc{
			func(c *gin.Context) {
				c.Set(Menus, s.menus)
				c.Set(Domain, domain)
			},
		}
		if authhf, found = site.(auth.AuthenticationHandler); !found {
			authhf = &auth.AnonAccountHandler{}
		}
		mw = append(mw, func(c *gin.Context) { authhf.Account(c) })
		router.Use(mw...)
		s.mrouter[domain] = router
	}
	site.Init(router.Group(path))
	s.sites = append(s.sites, site)
	if ms, ok := site.(menus.MenuSite); ok {
		menus := ms.Menu(domain)
		log.Debug().Msgf("%d menus are added", len(menus))
		s.menu = append(s.menu, menus...)
	}
	return
}