service-vclaim/internal/routes/v1/routes.go

package v1

import (
	"api-service/internal/config"
	"api-service/internal/database"
	authHandlers "api-service/internal/handlers/auth"
	healthcheckHandlers "api-service/internal/handlers/healthcheck"
	pesertaHandlers "api-service/internal/handlers/peserta"
	retribusiHandlers "api-service/internal/handlers/retribusi"
	"api-service/internal/middleware"
	services "api-service/internal/services/auth"
	"api-service/pkg/logger"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	swaggerFiles "github.com/swaggo/files"
	ginSwagger "github.com/swaggo/gin-swagger"
)

func RegisterRoutes(cfg *config.Config) *gin.Engine {
	router := gin.New()

	// Initialize auth middleware configuration
	middleware.InitializeAuth(cfg)

	// Add global middleware
	router.Use(middleware.CORSConfig())
	router.Use(middleware.ErrorHandler())
	router.Use(logger.RequestLoggerMiddleware(logger.Default()))
	router.Use(gin.Recovery())

	// Initialize services with error handling
	authService := services.NewAuthService(cfg)
	if authService == nil {
		logger.Fatal("Failed to initialize auth service")
	}

	// Initialize database service
	dbService := database.New(cfg)

	// =============================================================================
	// HEALTH CHECK & SYSTEM ROUTES
	// =============================================================================

	healthCheckHandler := healthcheckHandlers.NewHealthCheckHandler(dbService)
	sistem := router.Group("/api/sistem")
	{
		sistem.GET("/health", healthCheckHandler.CheckHealth)
		sistem.GET("/databases", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"databases": dbService.ListDBs(),
				"health":    dbService.Health(),
				"timestamp": time.Now().Unix(),
			})
		})
		sistem.GET("/info", func(c *gin.Context) {
			c.JSON(200, gin.H{
				"service":          "API Service v1.0.0",
				"websocket_active": true,
				"databases":        dbService.ListDBs(),
				"timestamp":        time.Now().Unix(),
			})
		})
	}

	// =============================================================================
	// SWAGGER DOCUMENTATION
	// =============================================================================

	router.GET("/swagger/*any", ginSwagger.WrapHandler(
		swaggerFiles.Handler,
		ginSwagger.DefaultModelsExpandDepth(-1),
		ginSwagger.DeepLinking(true),
	))

	// =============================================================================
	// WEBSOCKET TEST CLIENT
	// =============================================================================

	// router.GET("/websocket-test", func(c *gin.Context) {
	// 	c.Header("Content-Type", "text/html")
	// 	c.String(http.StatusOK, getWebSocketTestHTML())
	// })

	// =============================================================================
	// API v1 GROUP
	// =============================================================================

	v1 := router.Group("/api/v1")

	// =============================================================================
	// PUBLIC ROUTES (No Authentication Required)
	// =============================================================================

	// Authentication routes
	authHandler := authHandlers.NewAuthHandler(authService)
	tokenHandler := authHandlers.NewTokenHandler(authService)

	// Basic auth routes
	v1.POST("/auth/login", authHandler.Login)
	v1.POST("/auth/register", authHandler.Register)
	v1.POST("/auth/refresh", authHandler.RefreshToken)

	// Token generation routes
	v1.POST("/token/generate", tokenHandler.GenerateToken)
	v1.POST("/token/generate-direct", tokenHandler.GenerateTokenDirect)

	// =============================================================================
	// PUBLISHED ROUTES
	// =============================================================================

	// Participant eligibility information (peserta) routes
	pesertaHandler := pesertaHandlers.NewPesertaHandler(pesertaHandlers.PesertaHandlerConfig{
		Config:    cfg,
		Logger:    *logger.Default(),
		Validator: validator.New(),
	})
	pesertaGroup := v1.Group("/Peserta")
	pesertaGroup.GET("/nokartu/:nokartu", pesertaHandler.GetBynokartu)
	pesertaGroup.GET("/nik/:nik", pesertaHandler.GetBynik)

	// Retribusi endpoints with WebSocket notifications
	retribusiHandler := retribusiHandlers.NewRetribusiHandler()
	retribusiGroup := v1.Group("/retribusi")
	{
		retribusiGroup.GET("", retribusiHandler.GetRetribusi)
		retribusiGroup.GET("/dynamic", retribusiHandler.GetRetribusiDynamic)
		retribusiGroup.GET("/search", retribusiHandler.SearchRetribusiAdvanced)
		retribusiGroup.GET("/id/:id", retribusiHandler.GetRetribusiByID)

		// POST/PUT/DELETE with automatic WebSocket notifications
		retribusiGroup.POST("", func(c *gin.Context) {
			retribusiHandler.CreateRetribusi(c)
		})

		retribusiGroup.PUT("/id/:id", func(c *gin.Context) {
			retribusiHandler.UpdateRetribusi(c)
		})

		retribusiGroup.DELETE("/id/:id", func(c *gin.Context) {
			retribusiHandler.DeleteRetribusi(c)
		})
	}

	// =============================================================================
	// PROTECTED ROUTES (Authentication Required)
	// =============================================================================

	protected := v1.Group("/")
	protected.Use(middleware.ConfigurableAuthMiddleware(cfg))
	// Protected retribusi endpoints (Authentication Required)
	protectedRetribusiGroup := protected.Group("/retribusi")
	{
		protectedRetribusiGroup.GET("", retribusiHandler.GetRetribusi)
		protectedRetribusiGroup.GET("/dynamic", retribusiHandler.GetRetribusiDynamic)
		protectedRetribusiGroup.GET("/search", retribusiHandler.SearchRetribusiAdvanced)
		protectedRetribusiGroup.GET("/id/:id", retribusiHandler.GetRetribusiByID)
		protectedRetribusiGroup.POST("", func(c *gin.Context) {
			retribusiHandler.CreateRetribusi(c)
		})

		protectedRetribusiGroup.PUT("/id/:id", func(c *gin.Context) {
			retribusiHandler.UpdateRetribusi(c)
		})

		protectedRetribusiGroup.DELETE("/id/:id", func(c *gin.Context) {
			retribusiHandler.DeleteRetribusi(c)
		})
	}
	return router
}