#pragma once

#include <cstdint>

#include <string>

#include "envoy/common/exception.h"

#include "envoy/common/platform.h"

#include "envoy/grpc/status.h"

#include "envoy/http/filter.h"

#include "envoy/http/header_map.h"

#include "envoy/http/message.h"

#include "source/common/common/hash.h"

#include "source/common/grpc/status.h"

#include "source/common/protobuf/protobuf.h"

#include "absl/types/optional.h"

#include "google/rpc/status.pb.h"

namespace Envoy {

namespace Grpc {

class Exception : public EnvoyException {

public:

  Exception(const absl::optional<uint64_t>& grpc_status, const std::string& message)

  const absl::optional<uint64_t> grpc_status_;

};

class Common {

public:

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether content-type is gRPC.

   */

  static bool hasGrpcContentType(const Http::RequestOrResponseHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether Connect-Protocol-Version is present.

   */

  static bool hasConnectProtocolVersionHeader(const Http::RequestOrResponseHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether content-type is connect streaming.

   */

  static bool hasConnectStreamingContentType(const Http::RequestOrResponseHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether content-type is Protobuf.

   */

  static bool hasProtobufContentType(const Http::RequestOrResponseHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether the header is a gRPC request header.

   * Currently headers are considered gRPC request headers if they have the gRPC

   * content type, and have a path header.

   */

  static bool isGrpcRequestHeaders(const Http::RequestHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether the header is a Connect request header.

   * This is determined by checking for the connect protocol version header and a path header.

   */

  static bool isConnectRequestHeaders(const Http::RequestHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether the header is a Connect streaming request header.

   * This is determined by checking for the connect streaming content type and a path header.

   */

  static bool isConnectStreamingRequestHeaders(const Http::RequestHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether the header is a protobuf request header.

   * Currently headers are considered gRPC request headers if they have the protobuf

   * content type, and have a path header.

   */

  static bool isProtobufRequestHeaders(const Http::RequestHeaderMap& headers);

  /**

   * @param headers the headers to parse.

   * @param bool indicating whether the header is at end_stream.

   * @return bool indicating whether the header is a gRPC response header

   */

  static bool isGrpcResponseHeaders(const Http::ResponseHeaderMap& headers, bool end_stream);

  /**

   * @param headers the headers to parse.

   * @return bool indicating whether the header is a Connect streaming response header.

   */

  static bool isConnectStreamingResponseHeaders(const Http::ResponseHeaderMap& headers);

  /**

   * Returns the GrpcStatus code from a given set of trailers, if present.

   * @param trailers the trailers to parse.

   * @param allow_user_status whether allow user defined grpc status.

   *        if this value is false, custom grpc status is regarded as invalid status

   * @return absl::optional<Status::GrpcStatus> the parsed status code or InvalidCode if no valid

   * status is found.

   */

  static absl::optional<Status::GrpcStatus>

  getGrpcStatus(const Http::ResponseHeaderOrTrailerMap& trailers, bool allow_user_defined = false);

  /**

   * Returns the GrpcStatus code from the set of trailers, headers, and StreamInfo, if present.

   * @param trailers the trailers to parse for a status code

   * @param headers the headers to parse if no status code was found in the trailers

   * @param info the StreamInfo to check for HTTP response code if no code was found in the trailers

   * or headers

   * @return absl::optional<Status::GrpcStatus> the parsed status code or absl::nullopt if no status

   * is found

   */

  static absl::optional<Status::GrpcStatus> getGrpcStatus(const Http::ResponseTrailerMap& trailers,

                                                          const Http::ResponseHeaderMap& headers,

                                                          const StreamInfo::StreamInfo& info,

                                                          bool allow_user_defined = false);

  /**

   * Returns the grpc-message from a given set of trailers, if present.

   * @param trailers the trailers to parse.

   * @return std::string the gRPC status message or empty string if grpc-message is not present in

   *         trailers.

   */

  static std::string getGrpcMessage(const Http::ResponseHeaderOrTrailerMap& trailers);

  /**

   * Returns the decoded google.rpc.Status message from a given set of trailers, if present.

   * @param trailers the trailers to parse.

   * @return std::unique_ptr<google::rpc::Status> the gRPC status message or empty pointer if no

   *         grpc-status-details-bin trailer found or it was invalid.

   */

  static absl::optional<google::rpc::Status>

  getGrpcStatusDetailsBin(const Http::HeaderMap& trailers);

  /**

   * Parse gRPC header 'grpc-timeout' value to a duration in milliseconds.

   * @param request_headers the header map from which to extract the value of 'grpc-timeout' header.

   *        If this header is missing the timeout corresponds to infinity. The header is encoded in

   *        maximum of 8 decimal digits and a char for the unit.

   * @return absl::optional<std::chrono::milliseconds> the duration in milliseconds. absl::nullopt

   *         is returned if 'grpc-timeout' is missing or malformed.

   */

  static absl::optional<std::chrono::milliseconds>

  getGrpcTimeout(const Http::RequestHeaderMap& request_headers);

  /**

   * Encode 'timeout' into 'grpc-timeout' format in the grpc-timeout header.

   * @param timeout the duration in std::chrono::milliseconds.

   * @param headers the HeaderMap in which the grpc-timeout header will be set with the timeout in

   * 'grpc-timeout' format, up to 8 decimal digits and a letter indicating the unit.

   */

  static void toGrpcTimeout(const std::chrono::milliseconds& timeout,

                            Http::RequestHeaderMap& headers);

  /**

   * Serialize protobuf message with gRPC frame header.

   */

  static Buffer::InstancePtr serializeToGrpcFrame(const Protobuf::Message& message);

  /**

   * Serialize protobuf message. Without grpc header.

   */

  static Buffer::InstancePtr serializeMessage(const Protobuf::Message& message);

  /**

   * Prepare headers for protobuf service.

   */

  static Http::RequestMessagePtr

  prepareHeaders(absl::string_view upstream_cluster, absl::string_view service_full_name,

                 absl::string_view method_name,

                 const absl::optional<std::chrono::milliseconds>& timeout);

  /**

   * @return const std::string& type URL prefix.

   */

  static const std::string& typeUrlPrefix();

  /**

   * Prefix type URL to a qualified name.

   * @param qualified_name packagename.messagename.

   * @return qualified_name prefixed with typeUrlPrefix + "/".

   */

  static std::string typeUrl(absl::string_view qualified_name);

  /**

   * Prepend a gRPC frame header to a Buffer::Instance containing a single gRPC frame.

   * @param buffer containing the frame data which will be modified.

   */

  static void prependGrpcFrameHeader(Buffer::Instance& buffer);

  /**

   * Parse a Buffer::Instance into a Protobuf::Message.

   * @param buffer containing the data to be parsed.

   * @param proto the parsed proto.

   * @return bool true if the parse was successful.

   */

  static bool parseBufferInstance(Buffer::InstancePtr&& buffer, Protobuf::Message& proto);

  struct RequestNames {

    absl::string_view service_;

    absl::string_view method_;

  };

  /**

   * Resolve the gRPC service and method from the HTTP2 :path header.

   * @param path supplies the :path header.

   * @return if both gRPC serve and method have been resolved successfully returns

   *   a populated RequestNames, otherwise returns an empty optional.

   * @note The return value is only valid as long as `path` is still valid and unmodified.

   */

  static absl::optional<RequestNames> resolveServiceAndMethod(const Http::HeaderEntry* path);

private:

  static constexpr size_t MAX_GRPC_TIMEOUT_VALUE = 99999999;

};

} // namespace Grpc

} // namespace Envoy