/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2025 Chelsio Communications, Inc.
 * Written by: John Baldwin <jhb@FreeBSD.org>
 */

#ifndef __LIBUTILPP_HH__
#define __LIBUTILPP_HH__

#include <sys/nv.h>
#include <libutil.h>
#include <netdb.h>
#include <unistd.h>

#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <memory>

namespace freebsd {
        /*
         * FILE_up is a std::unique_ptr<> for FILE objects which uses
         * fclose() to destroy the wrapped pointer.
         */
        struct fclose_deleter {
                void operator() (std::FILE *fp) const
                {
                        std::fclose(fp);
                }
        };

        using FILE_up = std::unique_ptr<std::FILE, fclose_deleter>;

        /*
         * addrinfo_up is a std::unique_ptr<> which uses
         * freeaddrinfo() to destroy the wrapped pointer.  It is
         * intended to wrap arrays allocated by getaddrinfo().
         */
        struct freeaddrinfo_deleter {
                void operator() (struct addrinfo *ai) const
                {
                        freeaddrinfo(ai);
                }
        };

        using addrinfo_up = std::unique_ptr<addrinfo, freeaddrinfo_deleter>;

        /*
         * This class is intended to function similar to unique_ptr<>,
         * but it contains a file descriptor rather than a pointer to
         * an object.  On destruction the descriptor is closed via
         * close(2).
         *
         * Similar to unique_ptr<>, release() returns ownership of the
         * file descriptor to the caller.  reset() closes the current
         * file descriptor and takes ownership of a new one.  A move
         * constructor permits ownership to be transferred via
         * std::move().  An integer file descriptor can be assigned
         * directly which is equivalent to calling reset().
         *
         * An explicit bool conversion operator permits testing this
         * class in logical expressions.  It returns true if it
         * contains a valid descriptor.
         *
         * An implicit int conversion operator returns the underlying
         * file descriptor allowing objects of this type to be passed
         * directly to APIs such as connect(), listen(), etc.
         */
        class fd_up {
        public:
                fd_up() : fd(-1) {}
                fd_up(int _fd) : fd(_fd) {}
                fd_up(fd_up &&other) : fd(other.release()) {}
                fd_up(fd_up const &) = delete;

                ~fd_up() { reset(); }

                int get() const { return (fd); }

                int release()
                {
                        int oldfd = fd;

                        fd = -1;
                        return (oldfd);
                }

                void reset(int newfd = -1)
                {
                        if (fd >= 0)
                                close(fd);
                        fd = newfd;
                }

                fd_up &operator=(fd_up &&other) noexcept
                {
                        if (this == &other)
                                return *this;

                        reset(other.release());
                        return *this;
                }

                fd_up &operator=(fd_up const &) = delete;

                fd_up &operator=(int newfd)
                {
                        reset(newfd);
                        return *this;
                }

                explicit operator bool() const { return fd >= 0; }
                operator int() const { return fd; }
        private:
                int     fd;
        };

        /*
         * malloc_up<T> is a std::unique_ptr<> which uses free() to
         * destroy the wrapped pointer.  This can be used to wrap
         * pointers allocated implicitly by malloc() such as those
         * returned by strdup().
         */
        template <class T>
        struct free_deleter {
                void operator() (T *p) const
                {
                        std::free(p);
                }
        };

        template <class T>
        using malloc_up = std::unique_ptr<T, free_deleter<T>>;

        /*
         * nvlist_up is a std::unique_ptr<> for nvlist_t objects which
         * uses nvlist_destroy() to destroy the wrapped pointer.
         */
        struct nvlist_deleter {
                void operator() (nvlist_t *nvl) const
                {
                        nvlist_destroy(nvl);
                }
        };

        using nvlist_up = std::unique_ptr<nvlist_t, nvlist_deleter>;

        /*
         * A wrapper class for the pidfile_* API.  The destructor
         * calls pidfile_remove() when an object is destroyed.  This
         * class is similar to std::unique_ptr<> in that it retains
         * exclusive ownership of the pidfh object.
         *
         * In addition to release() and reset methods(), write(),
         * close(), and fileno() methods are provided as wrappers for
         * pidfile_*.
         */
        class pidfile {
        public:
                pidfile() = default;
                pidfile(struct pidfh *_pfh) : pfh(_pfh) {}
                pidfile(pidfile &&other) : pfh(other.release()) {}
                pidfile(pidfile const &) = delete;

                ~pidfile() { reset(); }

                struct pidfh *release()
                {
                        struct pidfh *oldpfh = pfh;

                        pfh = nullptr;
                        return (oldpfh);
                }

                void reset(struct pidfh *newpfh = nullptr)
                {
                        if (pfh != nullptr)
                                pidfile_remove(pfh);
                        pfh = newpfh;
                }

                int write()
                {
                        return (pidfile_write(pfh));
                }

                int close()
                {
                        int rv = pidfile_close(pfh);
                        if (rv == 0)
                                pfh = nullptr;
                        return (rv);
                }

                int fileno()
                {
                        return (pidfile_fileno(pfh));
                }

                pidfile &operator=(pidfile &&other) noexcept
                {
                        if (this == &other)
                                return *this;
                        reset(other.release());
                        return *this;
                }

                pidfile &operator=(pidfile const &) = delete;

                pidfile &operator=(struct pidfh *newpfh)
                {
                        reset(newpfh);
                        return *this;
                }

                explicit operator bool() const { return pfh != nullptr; }
        private:
                struct pidfh *pfh = nullptr;
        };

        /*
         * Returns a std::string containing the same output as
         * sprintf().  Throws std::bad_alloc if an error occurs.
         */
        std::string stringf(const char *fmt, ...) __printflike(1, 2);
        std::string stringf(const char *fmt, std::va_list ap);
}

#endif /* !__LIBUTILPP_HH__ */