type udpNilMonitor struct{}

func (u *udpNilMonitor) UDPServerApply(cfg *udpServer.Config) {
	cfg.CreateInactivityMonitor = nil
}

var _ udpServer.Option = (*udpNilMonitor)(nil)

func NewUDPNilMonitor() udpServer.Option {
	return &udpNilMonitor{}
}

func (s *Server) Start() error {
	errCh := make(chan error)
	s.Logger.Info(fmt.Sprintf("%s service started using http, exposed port %s", s.Name, s.Address))
	s.Logger.Info(fmt.Sprintf("%s service %s server listening at %s without TLS", s.Name, s.Protocol, s.Address))

	opts := []any{}
	opts = append(opts, options.WithMux(s.handler), NewUDPNilMonitor())
	go func() {
		errCh <- gocoap.ListenAndServeWithOptions("udp", s.Address, opts...)
	}()

	select {
	case <-s.Ctx.Done():
		return s.Stop()
	case err := <-errCh:
		return err
	}
}

	go func() {
		errCh <- gocoap.ListenAndServeWithOptions(
			"udp",
			s.Address,
			options.WithMux(s.handler),
			options.WithInactivityMonitor(16*time.Second, func(cc *udpClient.Conn) {
				s.Logger.Info(fmt.Sprintf("starting to close inactive client"))
				pm := pool.NewMessage(context.Background())

				s.Logger.Info(fmt.Sprintf("got context of inactive client"))
				pm.SetCode(codes.Content)
				s.Logger.Info(fmt.Sprintf("set message code for  inactive client"))

				token, err := cc.GetToken()

				pm.SetMessageID(cc.GetMessageID())
				if err != nil {
					s.Logger.Error(fmt.Sprintf("failed to get token of inactive client : %s", err))
				}
				s.Logger.Info(fmt.Sprintf("set message token for  inactive client"))

				if err := cc.Session().WriteMessage(pm); err != nil {
					s.Logger.Error(fmt.Sprintf("failed to send close message to inactive client with token %s : %s.", token, err))
				}
				s.Logger.Info(fmt.Sprintf("written message  inactive client"))
				if err := cc.Close(); err != nil {
					s.Logger.Error(fmt.Sprintf("failed to send close connection to inactive client with token %s : %s.", token, err))
				}
				s.Logger.Info(fmt.Sprintf("closed connection of inactive client %s : %s.", token, err))

			}),
		)
	}()