#pragma once

#ifdef BMCWEB_ENABLE_GRPC
#include "absl/log/log.h"
#include "bmcweb_authorizer_singleton.h"
#endif

#include <memory>
#include <string>
#include <string_view>
#include <system_error>  // NOLINT
#include <unordered_set>

#include "boost/asio/io_context.hpp"  // NOLINT
#include "boost/asio/ip/address.hpp"  // NOLINT
#include "boost/beast/http/message.hpp"  // NOLINT
#include "boost/beast/http/string_body.hpp"  // NOLINT
#include "boost/beast/websocket.hpp"  // NOLINT
#include "boost/url/url.hpp"  // NOLINT
#include "common.hpp"  // NOLINT(misc-include-cleaner)
#include "sessions.hpp"

namespace crow {

struct Request {
  boost::beast::http::request<boost::beast::http::string_body> req;

 private:
  boost::urls::url urlBase;  // NOLINT

 public:
  bool isSecure{false};  // NOLINT

  boost::asio::io_context* ioService{};  // NOLINT
  boost::asio::ip::address ipAddress;  // NOLINT

  std::shared_ptr<persistent_data::UserSession> session;

  bool isSubscriptionRequest = false;  // NOLINT

  // Dynamic fine grained authorization
  bool fromGrpc = false;  // NOLINT
  bool with_trust_bundle = false;
  bool peer_authenticated = false;
  std::unordered_set<std::string> peer_privileges;

  std::string userRole;  // NOLINT
  Request(boost::beast::http::request<boost::beast::http::string_body> reqIn,
          std::error_code& ec);

  Request(std::string_view bodyIn, std::error_code& ec);

  Request() = default;
  Request(const Request& other) = default;
  Request(Request&& other) = default;

  Request& operator=(const Request&) = delete;
  Request& operator=(const Request&&) = delete;
  ~Request() = default;

  boost::beast::http::verb method() const { return req.method(); }

  boost::beast::http::request<boost::beast::http::string_body> request() const {
    return req;
  }

  std::string_view getHeaderValue(std::string_view key) const {
    return req[key];
  }

  std::string_view getHeaderValue(boost::beast::http::field key) const {
    return req[key];
  }

  std::string_view methodString() const { return req.method_string(); }

  std::string_view target() const { return req.target(); }

  boost::urls::url& mutableUrl() { return urlBase; }

  boost::urls::url_view url() const { return {urlBase}; }

  const boost::beast::http::fields& fields() const { return req.base(); }

  const std::string& body() const { return req.body(); }

  bool target(std::string_view target) {
    req.target(target);
    return setUrlInfo();
  }

  void set_method(boost::beast::http::verb method) { req.method(method); }

  unsigned version() const { return req.version(); }

  bool isUpgrade() const { return boost::beast::websocket::is_upgrade(req); }

  bool keepAlive() const { return req.keep_alive(); }

 private:
  bool setUrlInfo();
};

}  // namespace crow