#ifndef THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_REDFISH_REQUEST_H_
#define THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_REDFISH_REQUEST_H_

#include <string>
#include <string_view>
#include <unordered_set>
#include <utility>

#include "absl/status/statusor.h"
#include "boost/beast/http/string_body.hpp"  //NOLINT
#include "boost/beast/http/verb.hpp"  //NOLINT`
#include "boost/url/url.hpp"  // NOLINT
#include "redfish_v1.pb.h"
#include "tlbmc/redfish/query_parameters.h"

namespace milotic_tlbmc {

constexpr std::string_view kTlbmcPrefix = "/tlbmc/";

class RedfishRequest {
 public:
  static RedfishRequest CreateUnitTestRequest() { return RedfishRequest(); }
  RedfishRequest(const redfish::v1::Request& request,
                 boost::beast::http::verb method);

  explicit RedfishRequest(
      boost::beast::http::request<boost::beast::http::string_body>&& request)
      : request_(std::move(request)) {}

  static absl::StatusOr<RedfishRequest> Create(
      boost::beast::http::request<boost::beast::http::string_body>&& request);

  RedfishRequest(RedfishRequest&& request) = default;
  RedfishRequest& operator=(RedfishRequest&& request) = default;
  RedfishRequest(const RedfishRequest& request) = delete;
  RedfishRequest& operator=(const RedfishRequest& request) = delete;

  std::string_view Target() const;
  void SetTarget(std::string_view target) { request_.target(target); }

  boost::beast::http::verb Method() const;
  std::string_view GetHeaderValue(std::string_view key) const;
  std::string_view Body() const;

  void SetFromGrpc(bool from_grpc) { from_grpc_ = from_grpc; }

  bool FromGrpc() const { return from_grpc_; }

  void SetWithTrustBundle(bool with_trust_bundle) {
    with_trust_bundle_ = with_trust_bundle;
  }

  bool WithTrustBundle() const { return with_trust_bundle_; }

  void SetPeerAuthenticated(bool peer_authenticated) {
    peer_authenticated_ = peer_authenticated;
  }

  bool PeerAuthenticated() const { return peer_authenticated_; }

  void SetPeerPrivileges(
      const std::unordered_set<std::string>& peer_privileges) {
    peer_privileges_ = peer_privileges;
  }

  const std::unordered_set<std::string>& PeerPrivileges() const {
    return peer_privileges_;
  }

  const QueryParameters& GetQueryParameters() const {
    return query_parameters_;
  }

  bool TlbmcOnly() const { return tlbmc_only_; }

  void SetTlbmcOnly(bool tlbmc_only) { tlbmc_only_ = tlbmc_only; }

 protected:
  RedfishRequest() = default;

  static std::string_view TrimTlbmcPrefix(std::string_view url);

  static bool HasTlbmcPrefix(std::string_view url);

  boost::beast::http::request<boost::beast::http::string_body> request_;
  bool from_grpc_ = false;
  bool with_trust_bundle_ = false;
  bool peer_authenticated_ = false;
  bool tlbmc_only_ = false;
  std::unordered_set<std::string> peer_privileges_;

  QueryParameters query_parameters_;
};

}  // namespace milotic_tlbmc

#endif  // THIRD_PARTY_MILOTIC_EXTERNAL_CC_TLBMC_REDFISH_REQUEST_H_