package delivery

import (
	"fmt"
	"users_management/m/config"
	"users_management/m/delivery/controller"
	"users_management/m/manager"
	"users_management/m/middleware"
	"users_management/m/utils/common"

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

type Server struct {
	ucManager manager.UsecaseManager
	engine    *gin.Engine
	host      string
	cfg       *config.Config
}

func NewServer() *Server {
	cfg, err := config.NewConfig()
	if err != nil {
		panic(err)
	}

	infraManager, err := manager.NewInfraManager(cfg)
	if err != nil {
		panic(err)
	}

	repoManager := manager.NewRepositoryManager(infraManager)
	ucManager := manager.NewUsecaseManager(repoManager, cfg)
	engine := gin.Default()

	engine.Use(middleware.CORSMiddleware())
	engine.Use(middleware.ConditionalActivityLoggingMiddleware(ucManager.NewActivityLogUsecase(), cfg))

	engine.Use(common.LoggingToFile())
	host := fmt.Sprintf(":%s", cfg.ApiPort)

	return &Server{
		ucManager: ucManager,
		engine:    engine,
		host:      host,
		cfg:       cfg,
	}
}

func (s *Server) setupController() {

	s.engine.Static("/uploads", "./uploads")

	rg := s.engine.Group("/api/v1")

	// Add bypass controller FIRST - before any auth middleware
	controller.NewBypassController(s.ucManager.NewUserUsecase(), rg).Route()

	// Add auth controller (public endpoints)
	controller.NewAuthController(s.ucManager.NewAuthUsecase(), rg).Route()

	publicRegistration := rg.Group("/user-registration")
	{
		publicRegistration.POST("/register", controller.NewUserRegistrationController(s.ucManager.NewUserUsecase(), rg).RegisterUser)
	}

	// Add user registration controller (public endpoints)
	// controller.NewUserRegistrationController(s.ucManager.NewUserUsecase(), rg).Route()

	// Now apply auth middleware to protected routes
	protected := rg.Use(middleware.ConditionalAuthMiddleware(s.ucManager.NewUserUsecase(), s.ucManager.NewAuthUsecase(), s.cfg)).(*gin.RouterGroup)
	{
		protectedRegistration := protected.Group("/user-registration")
		{
			protectedRegistration.GET("/pending", middleware.RequireAdminRole(), controller.NewUserRegistrationController(s.ucManager.NewUserUsecase(), protected).GetPendingUsers)
			protectedRegistration.PUT("/approve/:id", middleware.RequireAdminRole(), controller.NewUserRegistrationController(s.ucManager.NewUserUsecase(), protected).ApproveUser)
			protectedRegistration.PUT("/reject/:id", middleware.RequireAdminRole(), controller.NewUserRegistrationController(s.ucManager.NewUserUsecase(), protected).RejectUser)
		}
		controller.NewUserRoleManagementController(s.ucManager.NewUserUsecase(), protected).Route()
		controller.NewUsersController(s.ucManager.NewUserUsecase(), s.ucManager.NewAuthUsecase(), protected).Route()
		controller.NewCountAssetsController(s.ucManager.NewCountAssetsUsecase(), protected).Route()
		controller.NewDeviceController(s.ucManager.NewDeviceUsecase(), protected, s.cfg).Route()
		controller.NewBackboneController(s.ucManager.NewBackboneUsecase(), protected, s.cfg).Route()
		controller.NewFishboneController(s.ucManager.NewFishboneUsecase(), protected, s.cfg).Route()
		controller.NewTowerController(s.ucManager.NewTowerUsecase(), protected, s.cfg).Route()
		controller.NewDevicePortController(s.ucManager.NewDevicePortUsecase(), protected).Route()
		controller.NewActivityLogController(s.ucManager.NewActivityLogUsecase(), protected, s.cfg).Route()
		controller.NewCableConnectionController(s.ucManager.NewCableConnectionUsecase(), protected, s.cfg).Route()
		controller.NewDeviceInspectionController(s.ucManager.NewDeviceInspectionUsecase(), protected).Route()
		controller.NewNearestDeviceController(s.ucManager.NewNearestDeviceUsecase(), protected, s.cfg).Route()
		controller.NewDeviceDetailsController(s.ucManager.NewDeviceDetailsUsecase(), protected, s.cfg).Route()
		controller.NewOLTController(s.ucManager.NewOLTUsecase(), protected).Route()

	}

}

func (s *Server) Run() {
	s.setupController()
	if err := s.engine.Run(s.host); err != nil {
		panic(err)
	}
}