package httpserver

import (
	"context"
	"gitee.com/scottq/go-framework/src/v1/log"
	"github.com/julienschmidt/httprouter"
	"net/http"
	"strings"
)

const HealthUrl = "/health"

type HttpServer struct {
	name      string
	listenAdd string
	routers   []*Router
	rHandler  *httprouter.Router
	server    *http.Server

	config *ServerConfig

	log.InvokeLog
}

func NewHttpServer(name string, addr string, ops ...ServerOps) (*HttpServer, error) {
	server := &HttpServer{
		name:      name,
		listenAdd: addr,
		routers:   []*Router{},
		config:    &ServerConfig{},
		rHandler:  httprouter.New(),
	}

	for i, _ := range ops {
		ops[i](server)
	}

	//register health router
	server.DefaultRouteHealth()

	return server, nil
}

func (s *HttpServer) Router() *httprouter.Router {
	return s.rHandler
}

func (s *HttpServer) RouteFiles(path string, f http.FileSystem) *HttpServer {
	s.rHandler.ServeFiles(path+"/*filepath", f)
	return s
}

func (s *HttpServer) RouteHandler(method, path string, f http.Handler, middleware []Middleware) *HttpServer {
	s.addRouteHandler(method, path, f, middleware)
	return s
}

func (s *HttpServer) RoutePost(path string, f HttpRouteFunc, middleware []Middleware) *HttpServer {
	s.addRoute("post", path, f, middleware)
	return s
}
func (s *HttpServer) RouteGet(path string, f HttpRouteFunc, middleware []Middleware) *HttpServer {
	s.addRoute("get", path, f, middleware)
	return s
}
func (s *HttpServer) RouteOptions(path string, f HttpRouteFunc, middleware []Middleware) *HttpServer {
	s.addRoute("options", path, f, middleware)
	return s
}
func (s *HttpServer) RouteDelete(path string, f HttpRouteFunc, middleware []Middleware) *HttpServer {
	s.addRoute("delete", path, f, middleware)
	return s
}
func (s *HttpServer) RoutePut(path string, f HttpRouteFunc, middleware []Middleware) *HttpServer {
	s.addRoute("put", path, f, middleware)
	return s
}

func (s *HttpServer) DefaultRouteHealth() *HttpServer {

	healthF := func(ctx *Ctx) {
		ctx.Write([]byte("ok"))
	}

	s.addRoute("get", HealthUrl, healthF, nil)
	s.addRoute("post", HealthUrl, healthF, nil)
	return s
}

func (s *HttpServer) addRoute(method, path string, f HttpRouteFunc, middleware []Middleware) *HttpServer {
	s.routers = append(s.routers, &Router{
		Path:         path,
		Method:       strings.ToLower(method),
		RouteHandler: f,
		Middleware:   middleware,
	})
	return s
}
func (s *HttpServer) addRouteHandler(method, path string, f http.Handler, middleware []Middleware) *HttpServer {
	s.routers = append(s.routers, &Router{
		Path:        path,
		Method:      strings.ToLower(method),
		HttpHandler: f,
		Middleware:  middleware,
	})
	return s
}

func (s *HttpServer) initRouter() error {

	routers := map[string]*Router{}

	for _, x := range s.routers {
		routers[x.hash()] = x
	}

	for _, x := range routers {
		x.invokeRegister(s.rHandler, s.config)
	}
	return nil
}

func (s *HttpServer) Name() string {
	return s.name
}

func (s *HttpServer) Run() error {

	err := s.initRouter()
	if err != nil {
		return err
	}
	s.Info("[%s]http running at %s", s.name, s.listenAdd)

	srv := &http.Server{
		Addr:    s.listenAdd,
		Handler: s.rHandler,
	}
	s.server = srv

	return srv.ListenAndServe()
}

func (s *HttpServer) Stop() error {
	if s.server == nil {
		return nil
	}
	s.Info("http stop %s", s.listenAdd)

	err := s.server.Shutdown(context.Background())
	s.server = nil
	return err
}