kbf/include/kbf/http/server.h

#ifndef KBF_HTTP_SERVER_H
#define KBF_HTTP_SERVER_H

#include <string>
#include <vector>
#include <map>

#include <esp_http_server.h>

#include "kbf/http/common.h"

using std::string;
using std::vector;
using std::map;

namespace kbf::http {
    /** @brief HTTP Server */
    class Server {
    public:
        /** @brief Tag used for logging. */
        static constexpr const char *TAG = "kbf::http::Server";

        /**
         * @brief Destructor.
         *
         * Will call stop() if #running.
         */
        ~Server();

        /**
         * @brief Holds information about a route and it's handler.
         */
        struct Route {
        public:
            /** @brief HTTP method */
            http::Method method;

            /**
             * @brief URI
             *
             * @example "/"
             * @example "/foo"
             */
            const string uri;

            /**
             * @brief Request handler function.
             *
             * @param request Request sent by a client
             * @param data custom data passed to the request handler function
             * @return Response to be sent to the client
             */
            Response (*handler)(const Request &request, void *data);

            /**
             * @brief Custom data passed to the request handler function.
             */
            void *data = nullptr;

            /**
             * @brief Called after a response is sent successfully.
             *
             * @param response sent http::Response
             * @param data custom data (from Route::data)
             */
            void (*onResponseSent)(const Response &response, void *data) = nullptr;
        };

        /**
         * @brief Adds a Route handler.
         *
         * @note All routes must be added before calling start().
         *
         * @note Removing routes is not yet supported.
         *
         * @param route Route to add
         * @return *this (to enable builder-like syntax)
         */
        Server &route(Route route);

        /**
         * @brief Starts the HTTP server.
         *
         * @param port TCP port, default is 80
         * @return *this (to enable builder-like syntax)
         */
        Server &start(int port = 80);

        /**
         * @brief Starts the server in SSL (HTTPS) mode.
         *
         * @param cert_start start of the certificate
         * @param cert_end end of the certificate
         * @param key_start start of the private key
         * @param key_end end of the private key
         * @param port TCP port, default is 443
         * @return *this (to enable builder-like syntax)
         */
        Server &startSSL(const unsigned char *cert_start, const unsigned char *cert_end,
                         const unsigned char *key_start, const unsigned char *key_end,
                         int port = 443);

        /**
         * @brief Stops the HTTP server.
         */
        void stop();

        /**
         * @brief Returns whether the server is running.
         *
         * @return true if server is running; false otherwise
         */
        [[nodiscard]] bool isRunning() const { return running; }

    private:
        bool           running = false;
        httpd_handle_t handle  = nullptr;
        vector<Route>  routes;

        static esp_err_t handleHttpRequest(httpd_req_t *httpdRequest);

        void registerUriHandlers();
    };
}

#endif //KBF_HTTP_SERVER_H