package transport

import (
	"cybertron/internal/transport/middleware"
	"cybertron/internal/transport/router"
	"cybertron/pkg/metrics"
	"fmt"
	"github.com/gin-contrib/cors"
	"os"
	"os/signal"
	"syscall"

	"cybertron/configs"
	"cybertron/internal/dependencies"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

type Server struct {
	gin          *gin.Engine
	dependencies *dependencies.Dependencies
}

func NewServer(dep *dependencies.Dependencies) *Server {
	return &Server{
		gin:          gin.New(),
		dependencies: dep,
	}
}

func (s *Server) router() {
	router.ReadinessRouter(s.gin)
	router.ProjectRouter(s.gin, s.dependencies)
	router.SourceMapRouter(s.gin, s.dependencies)
	router.ReleasesRouter(s.gin, s.dependencies)
	router.ExceptionRouter(s.gin, s.dependencies)
	router.SearchRouter(s.gin, s.dependencies)
	router.HoustonRouter(s.gin, s.dependencies)
}

func (s *Server) Start() {
	var AllowOrigins = []string{"*"}
	corsConfig := cors.DefaultConfig()
	corsConfig.AllowOrigins = AllowOrigins
	s.gin.Use(middleware.CORSMiddleware())
	s.gin.Use(middleware.MetricMiddleware())
	//s.gin.Use(middleware.PermissionMiddleware(s.dependencies.Service.AuthService))
	s.router()
	metrics.AdminHandler()

	port := configs.GetPort()
	s.dependencies.Logger.Info("Starting server", zap.Int("port", port))

	err := s.gin.Run(fmt.Sprintf(":%v", port))
	if err != nil {
		s.dependencies.Logger.Fatal("error while starting the server", zap.Error(err))
	}
}

func (s *Server) Close() {
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	s.dependencies.Logger.Info("Shutdown server ...")
}