package server

import (
	"net"
	"net/http"
	"strings"
	"sync"

	"com.navi.medici.janus/lib"
	"github.com/gorilla/mux"
	"github.com/pkg/errors"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	"github.com/rs/cors"
	"go.uber.org/zap"
)

type Server struct {
	HttpServer *http.Server
	Listener   net.Listener
	wg         sync.WaitGroup
	logger     *zap.Logger
}

var (
	networkTCP = "tcp"
)

func NewServer(port string, corsList string, workerPool *lib.WorkerPool, logger *zap.Logger) (*Server, error) {
	network := networkTCP

	listener, err := net.Listen(network, ":"+port)
	if err != nil {
		return nil, errors.Wrap(err, "failed to create listener")
	}

	router := mux.NewRouter()
	router.HandleFunc("/events/json", eventsHandlerJson(workerPool)).Methods("POST")
	router.HandleFunc("/health", healthHandler).Methods("GET")

	httpServer := &http.Server{
		Addr:    ":" + port,
		Handler: enableCors(router, corsList),
	}

	newServer := &Server{
		HttpServer: httpServer,
		Listener:   listener,
		logger:     logger,
	}

	return newServer, nil
}

func enableCors(handler http.Handler, corsList string) http.Handler {
	corsArray := strings.Split(corsList, ",")
	c := cors.New(cors.Options{
		AllowedOrigins:   corsArray,
		AllowCredentials: false,
		Debug:            false,
	})
	return c.Handler(handler)
}

func MetricServer(port string, logger *zap.Logger) (*Server, error) {
	network := networkTCP

	listener, err := net.Listen(network, ":"+port)
	if err != nil {
		return nil, errors.Wrap(err, "failed to create listener for metric server")
	}

	router := mux.NewRouter()
	router.Path("/metrics").Handler(promhttp.Handler())

	httpServer := &http.Server{
		Addr:    ":" + port,
		Handler: router,
	}

	mServer := &Server{
		HttpServer: httpServer,
		Listener:   listener,
		logger:     logger,
	}

	return mServer, nil
}

func (s *Server) StartServer() {
	s.wg.Add(1)
	go func() {
		defer s.wg.Done()
		s.logger.Info("Starting server", zap.String("address", s.HttpServer.Addr))
		if err := s.HttpServer.Serve(s.Listener); err != nil && err != http.ErrServerClosed {
			s.logger.Fatal("Server error", zap.Error(err))
		}
	}()
}

func (s *Server) StopServer() {
	s.logger.Info("Stopping server", zap.String("address", s.HttpServer.Addr))
	if err := s.HttpServer.Close(); err != nil {
		s.logger.Error("Error stopping server", zap.Error(err))
	}
	s.wg.Wait()
	s.logger.Info("Server stopped", zap.String("address", s.HttpServer.Addr))
}