infrastructure

var HandlerModule = fx.Options(

	AnnotateHandler(func(core CoreParams) (h.Handler, error) {
		handler := handler.NewStaticHandler(core.Logger, core.Config)
		if handler == nil {
			return nil, errors.New("failed to create static handler")
		}
		core.Logger.Debug("registered handler",
			logging.StringField("handler_name", "StaticHandler"),
			logging.StringField("handler_type", fmt.Sprintf("%T", handler)),
			logging.StringField("operation", "handler_registration"),
		)
		return handler, nil
	}),

	AnnotateHandler(func(core CoreParams, middlewareManager *appmiddleware.Manager) (h.Handler, error) {
		handler := webhandler.NewHomeHandler(core.Logger, core.Renderer)
		if handler == nil {
			return nil, fmt.Errorf("failed to create home handler: renderer=%T", core.Renderer)
		}
		core.Logger.Debug("registered handler",
			logging.StringField("handler_name", "HomeHandler"),
			logging.StringField("handler_type", fmt.Sprintf("%T", handler)),
			logging.StringField("operation", "handler_registration"),
		)
		return handler, nil
	}),
	AnnotateHandler(func(core CoreParams, middlewareManager *appmiddleware.Manager) (h.Handler, error) {
		handler := wh_auth.NewWebLoginHandler(core.Logger, core.Renderer)
		if handler == nil {
			return nil, fmt.Errorf("failed to create web login handler: renderer=%T", core.Renderer)
		}
		core.Logger.Debug("registered handler",
			logging.StringField("handler_name", "WebLoginHandler"),
			logging.StringField("handler_type", fmt.Sprintf("%T", handler)),
			logging.StringField("operation", "handler_registration"),
		)
		return handler, nil
	}),
	AnnotateHandler(
		func(
			core CoreParams,
			services ServiceParams,
			middlewareManager *appmiddleware.Manager,
		) (h.Handler, error) {
			handler, err := handler.NewWebHandler(
				core.Logger,
				core.Renderer,
				handler.WithMiddlewareManager(middlewareManager),
				handler.WithConfig(core.Config),
			)
			if err != nil {
				return nil, fmt.Errorf("failed to create web handler: %w", err)
			}
			core.Logger.Debug(
				"registered handler",
				logging.StringField("handler_name", "WebHandler"),
				logging.StringField("handler_type", fmt.Sprintf("%T", handler)),
				logging.StringField("operation", "handler_registration"),
			)
			return handler, nil
		},
	),

	AnnotateHandler(func(core CoreParams, services ServiceParams) (h.Handler, error) {
		handler := handler.NewAuthHandler(core.Logger, handler.WithUserService(services.UserService))
		if handler == nil {
			return nil, fmt.Errorf("failed to create auth handler: user_service=%T", services.UserService)
		}
		core.Logger.Debug("registered handler",
			logging.StringField("handler_name", "AuthHandler"),
			logging.StringField("handler_type", fmt.Sprintf("%T", handler)),
			logging.StringField("operation", "handler_registration"),
		)
		return handler, nil
	}),

	AnnotateHandler(func(core CoreParams, services ServiceParams) (h.Handler, error) {
		authMiddleware := appmiddleware.NewCookieAuthMiddleware(services.UserService, core.Logger)
		baseHandler := handlers.NewBaseHandler(
			authMiddleware,
			services.FormService,
			core.Logger,
		)
		handler, err := handlers.NewHandler(services.UserService, services.FormService, core.Logger)
		if err != nil {
			return nil, fmt.Errorf("failed to create dashboard handler: %w", err)
		}

		handler.DashboardHandler.Base = baseHandler
		handler.FormHandler.Base = baseHandler
		handler.SubmissionHandler.Base = baseHandler
		handler.SchemaHandler.Base = baseHandler

		core.Logger.Debug("registered handler",
			logging.StringField("handler_name", "DashboardHandler"),
			logging.StringField("handler_type", fmt.Sprintf("%T", handler)),
			logging.StringField("operation", "handler_registration"),
		)
		return handler, nil
	}),
)

var InfrastructureModule = fx.Options(
	fx.Provide(
		func(logger logging.Logger) (*config.Config, error) {
			logger.Info("InfrastructureModule: Starting configuration loading...")
			cfg, cfgErr := config.New(logger)
			if cfgErr != nil {
				logger.Error("InfrastructureModule: Error loading configuration",
					logging.Error(cfgErr))
				return nil, fmt.Errorf("failed to load configuration: %w", cfgErr)
			}

			logger.Info("InfrastructureModule: Configuration loaded, starting validation...")
			if validationErr := validateConfig(cfg, logger); validationErr != nil {
				logger.Error("InfrastructureModule: Validation failed",
					logging.Error(validationErr))
				return nil, validationErr
			}

			logger.Info("InfrastructureModule: Configuration validated successfully")
			return cfg, nil
		},
		database.NewDB,
	),
)

var RootModule = fx.Options(
	InfrastructureModule,
	StoreModule,
	ServerModule,
	HandlerModule,
)

var ServerModule = fx.Options(
	fx.Provide(server.New),
)

var StoreModule = fx.Options(
	fx.Provide(NewStores),
)