package server

import (
	"time"

	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
)

type ServiceHandler interface {
	SetupRoutes(r *gin.Engine)
	Close() error
}

type Server struct {
	router   *gin.Engine
	logger   *logrus.Logger
	config   *Config
	handlers []ServiceHandler
}

func NewGinServer(logger *logrus.Logger, config *Config) (*Server, error) {
	if logger == nil {
		return nil, NewError("initialize", ErrInvalidConfig, "logger is required")
	}

	// Set Gin mode to release
	gin.SetMode(gin.ReleaseMode)

	// Initialize router
	router := gin.New()

	server := &Server{
		router: router,
		logger: logger,
		config: config,
	}

	// Add middleware in specific order
	router.Use(server.recoveryMiddleware())
	router.Use(server.requestIDMiddleware())
	router.Use(server.loggerMiddleware())
	router.Use(server.corsMiddleware())
	router.Use(server.errorHandlerMiddleware())

	return server, nil
}

func (s *Server) Router() *gin.Engine {
	return s.router
}

func (s *Server) Run() error {
	if err := s.router.Run(); err != nil {
		return NewError("run", ErrServerStartFailed, err.Error())
	}
	return nil
}

func (s *Server) Close() error {
	return nil
}

func (s *Server) AddHandler(h ServiceHandler) {
	s.handlers = append(s.handlers, h)
}

func (s *Server) SetupRoutes() {
	if len(s.handlers) == 0 {
		s.logger.Warn("no handlers registered")
		return
	}

	for _, h := range s.handlers {
		if h == nil {
			s.logger.Error("nil handler found")
			continue
		}
		h.SetupRoutes(s.router)
	}
}

// AddHealthCheck adds a basic health check endpoint
func (s *Server) AddHealthCheck() {
	s.router.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"status": "ok",
			"time":   time.Now().UTC(),
		})
	})
}