use crate::abi::envoy_dynamic_module_type_metrics_result;

use crate::buffer::{EnvoyBuffer, EnvoyMutBuffer};

use crate::utility::HeaderPairSlice;

use crate::{

  abi,

  bytes_to_module_buffer,

  str_to_module_buffer,

  ClusterHostCount,

  EnvoyCounterId,

  EnvoyCounterVecId,

  EnvoyGaugeId,

  EnvoyGaugeVecId,

  EnvoyHistogramId,

  EnvoyHistogramVecId,

  NewHttpFilterConfigFunction,

  NewHttpFilterPerRouteConfigFunction,

  NEW_HTTP_FILTER_CONFIG_FUNCTION,

  NEW_HTTP_FILTER_PER_ROUTE_CONFIG_FUNCTION,

};

use mockall::*;

use std::any::Any;

/// The trait that represents the configuration for an Envoy Http filter configuration.

/// This has one to one mapping with the [`EnvoyHttpFilterConfig`] object.

///

/// The object is created when the corresponding Envoy Http filter config is created, and it is

/// dropped when the corresponding Envoy Http filter config is destroyed. Therefore, the

/// implementation is recommended to implement the [`Drop`] trait to handle the necessary cleanup.

///

/// Implementations must also be `Sync` since they are accessed from worker threads.

pub trait HttpFilterConfig<EHF: EnvoyHttpFilter>: Sync {

  /// This is called from a worker thread when a HTTP filter chain is created for a new stream.

  fn new_http_filter(&self, _envoy: &mut EHF) -> Box<dyn HttpFilter<EHF>> {

    panic!("not implemented");

  }

  /// This is called when the new event is scheduled via the

  /// [`EnvoyHttpFilterConfigScheduler::commit`] for this [`HttpFilterConfig`].

  ///

  /// * `event_id` is the ID of the event that was scheduled with

  ///   [`EnvoyHttpFilterConfigScheduler::commit`] to distinguish multiple scheduled events.

  fn on_scheduled(&self, _event_id: u64) {}

  /// This is called when an HTTP callout initiated via

  /// [`EnvoyHttpFilterConfig::send_http_callout`] completes.

  ///

  /// * `envoy_config` can be used to interact with the underlying Envoy filter config object.

  /// * `callout_id` is the opaque handle returned from

  ///   [`EnvoyHttpFilterConfig::send_http_callout`].

  /// * `result` indicates the result of the callout.

  /// * `response_headers` is a list of key-value pairs of the response headers.

  /// * `response_body` is the response body chunks.

  fn on_http_callout_done(

    &self,

    _envoy_config: &mut EnvoyHttpFilterConfigImpl,

    _callout_id: u64,

    _result: abi::envoy_dynamic_module_type_http_callout_result,

    _response_headers: Option<&[(EnvoyBuffer, EnvoyBuffer)]>,

    _response_body: Option<&[EnvoyBuffer]>,

  ) {

  }

  /// This is called when response headers are received from an HTTP stream started via

  /// [`EnvoyHttpFilterConfig::start_http_stream`].

  ///

  /// * `envoy_config` can be used to interact with the underlying Envoy filter config object.

  /// * `stream_handle` is the opaque handle to the HTTP stream.

  /// * `response_headers` is a list of key-value pairs of the response headers.

  /// * `end_stream` indicates whether this is the final frame of the response.

  fn on_http_stream_headers(

    &self,

    _envoy_config: &mut EnvoyHttpFilterConfigImpl,

    _stream_handle: u64,

    _response_headers: &[(EnvoyBuffer, EnvoyBuffer)],

    _end_stream: bool,

  ) {

  }

  /// This is called when response data is received from an HTTP stream started via

  /// [`EnvoyHttpFilterConfig::start_http_stream`].

  ///

  /// * `envoy_config` can be used to interact with the underlying Envoy filter config object.

  /// * `stream_handle` is the opaque handle to the HTTP stream.

  /// * `response_data` is the response body data chunks.

  /// * `end_stream` indicates whether this is the final frame of the response.

  fn on_http_stream_data(

    &self,

    _envoy_config: &mut EnvoyHttpFilterConfigImpl,

    _stream_handle: u64,

    _response_data: &[EnvoyBuffer],

    _end_stream: bool,

  ) {

  }

  /// This is called when response trailers are received from an HTTP stream started via

  /// [`EnvoyHttpFilterConfig::start_http_stream`].

  ///

  /// * `envoy_config` can be used to interact with the underlying Envoy filter config object.

  /// * `stream_handle` is the opaque handle to the HTTP stream.

  /// * `response_trailers` is a list of key-value pairs of the response trailers.

  fn on_http_stream_trailers(

    &self,

    _envoy_config: &mut EnvoyHttpFilterConfigImpl,

    _stream_handle: u64,

    _response_trailers: &[(EnvoyBuffer, EnvoyBuffer)],

  ) {

  }

  /// This is called when an HTTP stream started via [`EnvoyHttpFilterConfig::start_http_stream`]

  /// completes successfully.

  ///

  /// * `envoy_config` can be used to interact with the underlying Envoy filter config object.

  /// * `stream_handle` is the opaque handle to the HTTP stream (no longer valid after this call).

  fn on_http_stream_complete(

    &self,

    _envoy_config: &mut EnvoyHttpFilterConfigImpl,

    _stream_handle: u64,

  ) {

  }

  /// This is called when an HTTP stream started via [`EnvoyHttpFilterConfig::start_http_stream`]

  /// is reset (failed or cancelled).

  ///

  /// * `envoy_config` can be used to interact with the underlying Envoy filter config object.

  /// * `stream_handle` is the opaque handle to the HTTP stream (no longer valid after this call).

  /// * `reset_reason` indicates why the stream was reset.

  fn on_http_stream_reset(

    &self,

    _envoy_config: &mut EnvoyHttpFilterConfigImpl,

    _stream_handle: u64,

    _reset_reason: abi::envoy_dynamic_module_type_http_stream_reset_reason,

  ) {

  }

}

/// The trait that corresponds to an Envoy Http filter for each stream

/// created via the [`HttpFilterConfig::new_http_filter`] method.

///

/// All the event hooks are called on the same thread as the one that the [`HttpFilter`] is created

/// via the [`HttpFilterConfig::new_http_filter`] method. In other words, the [`HttpFilter`] object

/// is thread-local.

pub trait HttpFilter<EHF: EnvoyHttpFilter> {

  /// This is called when the request headers are received.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// The `end_of_stream` indicates whether the request is the last message in the stream.

  ///

  /// This must return [`abi::envoy_dynamic_module_type_on_http_filter_request_headers_status`] to

  /// indicate the status of the request headers processing.

  fn on_request_headers(

    &mut self,

    _envoy_filter: &mut EHF,

    _end_of_stream: bool,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_request_headers_status {

    abi::envoy_dynamic_module_type_on_http_filter_request_headers_status::Continue

  }

  /// This is called when the request body is received.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// The `end_of_stream` indicates whether the request is the last message in the stream.

  ///

  /// This must return [`abi::envoy_dynamic_module_type_on_http_filter_request_body_status`] to

  /// indicate the status of the request body processing.

  fn on_request_body(

    &mut self,

    _envoy_filter: &mut EHF,

    _end_of_stream: bool,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_request_body_status {

    abi::envoy_dynamic_module_type_on_http_filter_request_body_status::Continue

  }

  /// This is called when the request trailers are received.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  ///

  /// This must return [`abi::envoy_dynamic_module_type_on_http_filter_request_trailers_status`] to

  /// indicate the status of the request trailers processing.

  fn on_request_trailers(

    &mut self,

    _envoy_filter: &mut EHF,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_request_trailers_status {

    abi::envoy_dynamic_module_type_on_http_filter_request_trailers_status::Continue

  }

  /// This is called when the response headers are received.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// The `end_of_stream` indicates whether the request is the last message in the stream.

  ///

  /// This must return [`abi::envoy_dynamic_module_type_on_http_filter_response_headers_status`] to

  /// indicate the status of the response headers processing.

  fn on_response_headers(

    &mut self,

    _envoy_filter: &mut EHF,

    _end_of_stream: bool,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_response_headers_status {

    abi::envoy_dynamic_module_type_on_http_filter_response_headers_status::Continue

  }

  /// This is called when the response body is received.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// The `end_of_stream` indicates whether the request is the last message in the stream.

  ///

  /// This must return [`abi::envoy_dynamic_module_type_on_http_filter_response_body_status`] to

  /// indicate the status of the response body processing.

  fn on_response_body(

    &mut self,

    _envoy_filter: &mut EHF,

    _end_of_stream: bool,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_response_body_status {

    abi::envoy_dynamic_module_type_on_http_filter_response_body_status::Continue

  }

  /// This is called when the response trailers are received.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// The `end_of_stream` indicates whether the request is the last message in the stream.

  ///

  /// This must return [`abi::envoy_dynamic_module_type_on_http_filter_response_trailers_status`] to

  /// indicate the status of the response trailers processing.

  fn on_response_trailers(

    &mut self,

    _envoy_filter: &mut EHF,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_response_trailers_status {

    abi::envoy_dynamic_module_type_on_http_filter_response_trailers_status::Continue

  }

  /// This is called when the stream is complete.

  /// The `envoy_filter` can be used to interact with the underlying Envoy filter object.

  ///

  /// This is called before this [`HttpFilter`] object is dropped and access logs are flushed.

  fn on_stream_complete(&mut self, _envoy_filter: &mut EHF) {}

  /// This is called when the HTTP callout is done.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `callout_id` is the ID of the callout that was done.

  /// * `result` indicates the result of the callout.

  /// * `response_headers` is a list of key-value pairs of the response headers. This is optional.

  /// * `response_body` is the response body. This is optional.

  fn on_http_callout_done(

    &mut self,

    _envoy_filter: &mut EHF,

    _callout_id: u64,

    _result: abi::envoy_dynamic_module_type_http_callout_result,

    _response_headers: Option<&[(EnvoyBuffer, EnvoyBuffer)]>,

    _response_body: Option<&[EnvoyBuffer]>,

  ) {

  }

  /// This is called when response headers are received from an HTTP stream callout.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `stream_handle` is the opaque handle to the HTTP stream.

  /// * `response_headers` is a list of key-value pairs of the response headers.

  /// * `end_stream` indicates whether this is the final frame of the response.

  fn on_http_stream_headers(

    &mut self,

    _envoy_filter: &mut EHF,

    _stream_handle: u64,

    _response_headers: &[(EnvoyBuffer, EnvoyBuffer)],

    _end_stream: bool,

  ) {

  }

  /// This is called when response data is received from an HTTP stream callout.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `stream_handle` is the opaque handle to the HTTP stream.

  /// * `response_data` is the response body data chunks.

  /// * `end_stream` indicates whether this is the final frame of the response.

  fn on_http_stream_data(

    &mut self,

    _envoy_filter: &mut EHF,

    _stream_handle: u64,

    _response_data: &[EnvoyBuffer],

    _end_stream: bool,

  ) {

  }

  /// This is called when response trailers are received from an HTTP stream callout.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `stream_handle` is the opaque handle to the HTTP stream.

  /// * `response_trailers` is a list of key-value pairs of the response trailers.

  fn on_http_stream_trailers(

    &mut self,

    _envoy_filter: &mut EHF,

    _stream_handle: u64,

    _response_trailers: &[(EnvoyBuffer, EnvoyBuffer)],

  ) {

  }

  /// This is called when an HTTP stream callout completes successfully.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `stream_handle` is the opaque handle to the HTTP stream (no longer valid after this call).

  fn on_http_stream_complete(&mut self, _envoy_filter: &mut EHF, _stream_handle: u64) {}

  /// This is called when an HTTP stream callout is reset (failed or cancelled).

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `stream_handle` is the opaque handle to the HTTP stream (no longer valid after this call).

  /// * `reset_reason` indicates why the stream was reset.

  fn on_http_stream_reset(

    &mut self,

    _envoy_filter: &mut EHF,

    _stream_handle: u64,

    _reset_reason: abi::envoy_dynamic_module_type_http_stream_reset_reason,

  ) {

  }

  /// This is called when the new event is scheduled via the [`EnvoyHttpFilterScheduler::commit`]

  /// for this [`HttpFilter`].

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `event_id` is the ID of the event that was scheduled with

  ///   [`EnvoyHttpFilterScheduler::commit`] to distinguish multiple scheduled events.

  ///

  /// See [`EnvoyHttpFilter::new_scheduler`] for more details on how to use this.

  fn on_scheduled(&mut self, _envoy_filter: &mut EHF, _event_id: u64) {}

  /// This is called when the downstream buffer size goes above the high watermark for a

  /// terminal filter.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  fn on_downstream_above_write_buffer_high_watermark(&mut self, _envoy_filter: &mut EHF) {}

  /// This is called when the downstream buffer size goes below the low watermark for a

  /// terminal filter.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  fn on_downstream_below_write_buffer_low_watermark(&mut self, _envoy_filter: &mut EHF) {}

  /// This is called when a local reply (error response) is being sent to the downstream.

  ///

  /// * `envoy_filter` can be used to interact with the underlying Envoy filter object.

  /// * `response_code` is the HTTP status code of the local reply.

  /// * `body` is the body content of the local reply.

  /// * `details` is the response code details string.

  ///

  /// Returns the action to take after the local reply hook completes:

  /// - Continue: Send the local reply as normal.

  /// - ContinueAndResetStream: Reset the stream instead of sending the local reply.

  fn on_local_reply(

    &mut self,

    _envoy_filter: &mut EHF,

    _response_code: u32,

    _details: EnvoyBuffer,

    _reset_imminent: bool,

  ) -> abi::envoy_dynamic_module_type_on_http_filter_local_reply_status {

    abi::envoy_dynamic_module_type_on_http_filter_local_reply_status::Continue

  }

}

/// An opaque object that represents the underlying Envoy Http filter config. This has one to one

/// mapping with the Envoy Http filter config object as well as [`HttpFilterConfig`] object.

pub trait EnvoyHttpFilterConfig {

  /// Define a new counter scoped to this filter config with the given name.

  fn define_counter(

    &mut self,

    name: &str,

  ) -> Result<EnvoyCounterId, envoy_dynamic_module_type_metrics_result>;

  // Define a new counter vec scoped to this filter config with the given name.

  fn define_counter_vec(

    &mut self,

    name: &str,

    labels: &[&str],

  ) -> Result<EnvoyCounterVecId, envoy_dynamic_module_type_metrics_result>;

  /// Define a new gauge scoped to this filter config with the given name.

  fn define_gauge(

    &mut self,

    name: &str,

  ) -> Result<EnvoyGaugeId, envoy_dynamic_module_type_metrics_result>;

  /// Define a new gauge vec scoped to this filter config with the given name.

  fn define_gauge_vec(

    &mut self,

    name: &str,

    labels: &[&str],

  ) -> Result<EnvoyGaugeVecId, envoy_dynamic_module_type_metrics_result>;

  /// Define a new histogram scoped to this filter config with the given name.

  fn define_histogram(

    &mut self,

    name: &str,

  ) -> Result<EnvoyHistogramId, envoy_dynamic_module_type_metrics_result>;

  /// Define a new histogram vec scoped to this filter config with the given name.

  fn define_histogram_vec(

    &mut self,

    name: &str,

    labels: &[&str],

  ) -> Result<EnvoyHistogramVecId, envoy_dynamic_module_type_metrics_result>;

  /// Create a new implementation of the [`EnvoyHttpFilterConfigScheduler`] trait.

  ///

  /// This can be used to schedule an event to the main thread where the filter config is running.

  fn new_scheduler(&self) -> Box<dyn EnvoyHttpFilterConfigScheduler>;

  /// Perform an HTTP callout from the config context. The result will be delivered to

  /// [`HttpFilterConfig::on_http_callout_done`].

  fn send_http_callout<'a>(

    &mut self,

    cluster_name: &'a str,

    headers: &'a [(&'a str, &'a [u8])],

    body: Option<&'a [u8]>,

    timeout_milliseconds: u64,

  ) -> (abi::envoy_dynamic_module_type_http_callout_init_result, u64);

  /// Start an HTTP stream from the config context. Events will be delivered to

  /// [`HttpFilterConfig::on_http_stream_headers`], etc.

  fn start_http_stream<'a>(

    &mut self,

    cluster_name: &'a str,

    headers: &'a [(&'a str, &'a [u8])],

    body: Option<&'a [u8]>,

    end_stream: bool,

    timeout_milliseconds: u64,

  ) -> (abi::envoy_dynamic_module_type_http_callout_init_result, u64);

  /// Send data on an HTTP stream started via [`EnvoyHttpFilterConfig::start_http_stream`].

  ///

  /// # Safety

  ///

  /// * `stream_handle` must be a valid handle returned from

  ///   [`EnvoyHttpFilterConfig::start_http_stream`].

  unsafe fn send_http_stream_data(

    &mut self,

    stream_handle: u64,

    data: &[u8],

    end_stream: bool,

  ) -> bool;

  /// Send trailers on an HTTP stream started via [`EnvoyHttpFilterConfig::start_http_stream`].

  ///

  /// # Safety

  ///

  /// * `stream_handle` must be a valid handle returned from

  ///   [`EnvoyHttpFilterConfig::start_http_stream`].

  unsafe fn send_http_stream_trailers<'a>(

    &mut self,

    stream_handle: u64,

    trailers: &'a [(&'a str, &'a [u8])],

  ) -> bool;

  /// Reset an HTTP stream started via [`EnvoyHttpFilterConfig::start_http_stream`].

  ///

  /// # Safety

  ///

  /// * `stream_handle` must be a valid handle returned from

  ///   [`EnvoyHttpFilterConfig::start_http_stream`].

  unsafe fn reset_http_stream(&mut self, stream_handle: u64);

}

pub struct EnvoyHttpFilterConfigImpl {

  pub(crate) raw_ptr: abi::envoy_dynamic_module_type_http_filter_config_envoy_ptr,

}

impl EnvoyHttpFilterConfig for EnvoyHttpFilterConfigImpl {

  fn define_counter(

    &mut self,

    name: &str,

  ) -> Result<EnvoyCounterId, envoy_dynamic_module_type_metrics_result> {

    let mut id: usize = 0;

    Result::from(unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_define_counter(

        self.raw_ptr,

        str_to_module_buffer(name),

        std::ptr::null_mut(),

        0,

        &mut id,

      )

    })?;

    Ok(EnvoyCounterId(id))

  }

  fn define_counter_vec(

    &mut self,

    name: &str,

    labels: &[&str],

  ) -> Result<EnvoyCounterVecId, envoy_dynamic_module_type_metrics_result> {

    let labels_ptr = labels.as_ptr();

    let labels_size = labels.len();

    let mut id: usize = 0;

    Result::from(unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_define_counter(

        self.raw_ptr,

        str_to_module_buffer(name),

        labels_ptr as *const _ as *mut _,

        labels_size,

        &mut id,

      )

    })?;

    Ok(EnvoyCounterVecId(id))

  }

  fn define_gauge(

    &mut self,

    name: &str,

  ) -> Result<EnvoyGaugeId, envoy_dynamic_module_type_metrics_result> {

    let mut id: usize = 0;

    Result::from(unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_define_gauge(

        self.raw_ptr,

        str_to_module_buffer(name),

        std::ptr::null_mut(),

        0,

        &mut id,

      )

    })?;

    Ok(EnvoyGaugeId(id))

  }

  fn define_gauge_vec(

    &mut self,

    name: &str,

    labels: &[&str],

  ) -> Result<EnvoyGaugeVecId, envoy_dynamic_module_type_metrics_result> {

    let labels_ptr = labels.as_ptr();

    let labels_size = labels.len();

    let mut id: usize = 0;

    Result::from(unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_define_gauge(

        self.raw_ptr,

        str_to_module_buffer(name),

        labels_ptr as *const _ as *mut _,

        labels_size,

        &mut id,

      )

    })?;

    Ok(EnvoyGaugeVecId(id))

  }

  fn define_histogram(

    &mut self,

    name: &str,

  ) -> Result<EnvoyHistogramId, envoy_dynamic_module_type_metrics_result> {

    let mut id: usize = 0;

    Result::from(unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_define_histogram(

        self.raw_ptr,

        str_to_module_buffer(name),

        std::ptr::null_mut(),

        0,

        &mut id,

      )

    })?;

    Ok(EnvoyHistogramId(id))

  }

  fn define_histogram_vec(

    &mut self,

    name: &str,

    labels: &[&str],

  ) -> Result<EnvoyHistogramVecId, envoy_dynamic_module_type_metrics_result> {

    let labels_ptr = labels.as_ptr();

    let labels_size = labels.len();

    let mut id: usize = 0;

    Result::from(unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_define_histogram(

        self.raw_ptr,

        str_to_module_buffer(name),

        labels_ptr as *const _ as *mut _,

        labels_size,

        &mut id,

      )

    })?;

    Ok(EnvoyHistogramVecId(id))

  }

  fn new_scheduler(&self) -> Box<dyn EnvoyHttpFilterConfigScheduler> {

    unsafe {

      let scheduler_ptr =

        abi::envoy_dynamic_module_callback_http_filter_config_scheduler_new(self.raw_ptr);

      Box::new(EnvoyHttpFilterConfigSchedulerImpl {

        raw_ptr: scheduler_ptr,

      })

    }

  }

  fn send_http_callout<'a>(

    &mut self,

    cluster_name: &'a str,

    headers: &'a [(&'a str, &'a [u8])],

    body: Option<&'a [u8]>,

    timeout_milliseconds: u64,

  ) -> (abi::envoy_dynamic_module_type_http_callout_init_result, u64) {

    let body_ptr = body.map(|s| s.as_ptr()).unwrap_or(std::ptr::null());

    let body_length = body.map(|s| s.len()).unwrap_or(0);

    let HeaderPairSlice(headers_ptr, headers_len) = headers.into();

    let mut callout_id: u64 = 0;

    let result = unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_http_callout(

        self.raw_ptr,

        &mut callout_id as *mut _ as *mut _,

        str_to_module_buffer(cluster_name),

        headers_ptr as *const _ as *mut _,

        headers_len,

        abi::envoy_dynamic_module_type_module_buffer {

          ptr: body_ptr as *mut _,

          length: body_length,

        },

        timeout_milliseconds,

      )

    };

    (result, callout_id)

  }

  fn start_http_stream<'a>(

    &mut self,

    cluster_name: &'a str,

    headers: &'a [(&'a str, &'a [u8])],

    body: Option<&'a [u8]>,

    end_stream: bool,

    timeout_milliseconds: u64,

  ) -> (abi::envoy_dynamic_module_type_http_callout_init_result, u64) {

    let body_ptr = body.map(|s| s.as_ptr()).unwrap_or(std::ptr::null());

    let body_length = body.map(|s| s.len()).unwrap_or(0);

    let HeaderPairSlice(headers_ptr, headers_len) = headers.into();

    let mut stream_id: u64 = 0;

    let result = unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_start_http_stream(

        self.raw_ptr,

        &mut stream_id as *mut _ as *mut _,

        str_to_module_buffer(cluster_name),

        headers_ptr as *const _ as *mut _,

        headers_len,

        abi::envoy_dynamic_module_type_module_buffer {

          ptr: body_ptr as *mut _,

          length: body_length,

        },

        end_stream,

        timeout_milliseconds,

      )

    };

    (result, stream_id)

  }

  unsafe fn send_http_stream_data(

    &mut self,

    stream_handle: u64,

    data: &[u8],

    end_stream: bool,

  ) -> bool {

    unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_stream_send_data(

        self.raw_ptr,

        stream_handle,

        bytes_to_module_buffer(data),

        end_stream,

      )

    }

  }

  unsafe fn send_http_stream_trailers<'a>(

    &mut self,

    stream_handle: u64,

    trailers: &'a [(&'a str, &'a [u8])],

  ) -> bool {

    let HeaderPairSlice(trailers_ptr, trailers_len) = trailers.into();

    unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_stream_send_trailers(

        self.raw_ptr,

        stream_handle,

        trailers_ptr as *const _ as *mut _,

        trailers_len,

      )

    }

  }

  unsafe fn reset_http_stream(&mut self, stream_handle: u64) {

    unsafe {

      abi::envoy_dynamic_module_callback_http_filter_config_reset_http_stream(

        self.raw_ptr,

        stream_handle,

      );

    }

  }

}

/// An opaque object that represents the underlying Envoy Http filter. This has one to one

/// mapping with the Envoy Http filter object as well as [`HttpFilter`] object per HTTP stream.

///

/// The Envoy filter object is inherently not thread-safe, and it is always recommended to

/// access it from the same thread as the one that [`HttpFilter`] event hooks are called.

#[automock]

#[allow(clippy::needless_lifetimes)] // Explicit lifetime specifiers are needed for mockall.

pub trait EnvoyHttpFilter {

  /// Get the value of the request header with the given key.

  /// If the header is not found, this returns `None`.

  ///

  /// To handle multiple values for the same key, use

  /// [`EnvoyHttpFilter::get_request_header_values`] variant.

  fn get_request_header_value<'a>(&'a self, key: &str) -> Option<EnvoyBuffer<'a>>;

  /// Get the values of the request header with the given key.

  ///

  /// If the header is not found, this returns an empty vector.

  fn get_request_header_values<'a>(&'a self, key: &str) -> Vec<EnvoyBuffer<'a>>;

  /// Get all request headers.

  ///

  /// Returns a list of key-value pairs of the request headers.

  /// If there are no headers or headers are not available, this returns an empty list.

  fn get_request_headers<'a>(&'a self) -> Vec<(EnvoyBuffer<'a>, EnvoyBuffer<'a>)>;

  /// Set the request header with the given key and value.

  ///

  /// This will overwrite the existing value if the header is already present.

  /// In case of multiple values for the same key, this will remove all the existing values and

  /// set the new value.

  ///

  /// Returns true if the header is set successfully.

  fn set_request_header(&mut self, key: &str, value: &[u8]) -> bool;

  /// Add a new request header with the given key and value.

  ///

  /// This will add a new header even if the header with the same key already exists.

  ///

  /// Returns true if the header is added successfully.

  fn add_request_header(&mut self, key: &str, value: &[u8]) -> bool;

  /// Remove the request header with the given key.

  ///

  /// Returns true if the header is removed successfully.

  fn remove_request_header(&mut self, key: &str) -> bool;

  /// Get the value of the request trailer with the given key.

  /// If the trailer is not found, this returns `None`.

  ///

  /// To handle multiple values for the same key, use

  /// [`EnvoyHttpFilter::get_request_trailer_values`] variant.

  fn get_request_trailer_value<'a>(&'a self, key: &str) -> Option<EnvoyBuffer<'a>>;

  /// Get the values of the request trailer with the given key.

  ///

  /// If the trailer is not found, this returns an empty vector.

  fn get_request_trailer_values<'a>(&'a self, key: &str) -> Vec<EnvoyBuffer<'a>>;

  /// Get all request trailers.

  ///

  /// Returns a list of key-value pairs of the request trailers.

  /// If there are no trailers or trailers are not available, this returns an empty list.

  fn get_request_trailers<'a>(&'a self) -> Vec<(EnvoyBuffer<'a>, EnvoyBuffer<'a>)>;

  /// Set the request trailer with the given key and value.

  ///

  /// This will overwrite the existing value if the trailer is already present.

  /// In case of multiple values for the same key, this will remove all the existing values and

  /// set the new value.

  ///

  /// Returns true if the trailer is set successfully.

  fn set_request_trailer(&mut self, key: &str, value: &[u8]) -> bool;

  /// Add a new request trailer with the given key and value.

  ///

  /// This will add a new trailer even if the trailer with the same key already exists.

  ///

  /// Returns true if the trailer is added successfully.

  fn add_request_trailer(&mut self, key: &str, value: &[u8]) -> bool;

  /// Remove the request trailer with the given key.

  ///

  /// Returns true if the trailer is removed successfully.

  fn remove_request_trailer(&mut self, key: &str) -> bool;

  /// Get the value of the response header with the given key.

  /// If the header is not found, this returns `None`.

  ///

  /// To handle multiple values for the same key, use

  /// [`EnvoyHttpFilter::get_response_header_values`] variant.

  fn get_response_header_value<'a>(&'a self, key: &str) -> Option<EnvoyBuffer<'a>>;

  /// Get the values of the response header with the given key.

  ///

  /// If the header is not found, this returns an empty vector.

  fn get_response_header_values<'a>(&'a self, key: &str) -> Vec<EnvoyBuffer<'a>>;

  /// Get all response headers.

  ///

  /// Returns a list of key-value pairs of the response headers.

  /// If there are no headers or headers are not available, this returns an empty list.

  fn get_response_headers<'a>(&'a self) -> Vec<(EnvoyBuffer<'a>, EnvoyBuffer<'a>)>;

  /// Set the response header with the given key and value.

  ///

  /// This will overwrite the existing value if the header is already present.

  /// In case of multiple values for the same key, this will remove all the existing values and

  /// set the new value.

  ///

  /// Returns true if the header is set successfully.

  fn set_response_header(&mut self, key: &str, value: &[u8]) -> bool;

  /// Add a new response header with the given key and value.

  ///

  /// This will add a new header even if the header with the same key already exists.

  ///

  /// Returns true if the header is added successfully.

  fn add_response_header(&mut self, key: &str, value: &[u8]) -> bool;

  /// Remove the response header with the given key.

  ///

  /// Returns true if the header is removed successfully.

  fn remove_response_header(&mut self, key: &str) -> bool;

  /// Get the value of the response trailer with the given key.

  /// If the trailer is not found, this returns `None`.

  ///

  /// To handle multiple values for the same key, use

  /// [`EnvoyHttpFilter::get_response_trailer_values`] variant.

  fn get_response_trailer_value<'a>(&'a self, key: &str) -> Option<EnvoyBuffer<'a>>;

  /// Get the values of the response trailer with the given key.

  ///

  /// If the trailer is not found, this returns an empty vector.

  fn get_response_trailer_values<'a>(&'a self, key: &str) -> Vec<EnvoyBuffer<'a>>;

  /// Get all response trailers.

  ///

  /// Returns a list of key-value pairs of the response trailers.

  /// If there are no trailers or trailers are not available, this returns an empty list.

  fn get_response_trailers<'a>(&'a self) -> Vec<(EnvoyBuffer<'a>, EnvoyBuffer<'a>)>;

  /// Set the response trailer with the given key and value.

  ///

  /// This will overwrite the existing value if the trailer is already present.

  /// In case of multiple values for the same key, this will remove all the existing values and

  /// set the new value.

  ///

  /// Returns true if the operation is successful.

  fn set_response_trailer(&mut self, key: &str, value: &[u8]) -> bool;

  /// Add a new response trailer with the given key and value.

  ///

  /// This will add a new trailer even if the trailer with the same key already exists.

  ///

  /// Returns true if the trailer is added successfully.

  fn add_response_trailer(&mut self, key: &str, value: &[u8]) -> bool;

  /// Remove the response trailer with the given key.

  ///

  /// Returns true if the trailer is removed successfully.

  fn remove_response_trailer(&mut self, key: &str) -> bool;

  /// Send a response to the downstream with the given status code, headers, and body.

  ///

  /// The headers are passed as a list of key-value pairs.

  fn send_response<'a>(

    &mut self,

    status_code: u32,

    headers: &'a [(&'a str, &'a [u8])],

    body: Option<&'a [u8]>,

    details: Option<&'a str>,

  );

  /// Send response headers to the downstream, optionally indicating end of stream.

  /// Necessary pseudo headers such as :status should be present.

  ///

  /// The headers are passed as a list of key-value pairs.

  fn send_response_headers<'a>(&mut self, headers: &'a [(&'a str, &'a [u8])], end_stream: bool);

  /// Send response body data to the downstream, optionally indicating end of stream.

  fn send_response_data<'a>(&mut self, body: &'a [u8], end_stream: bool);

  /// Send response trailers to the downstream. This implicitly ends the stream.

  ///

  /// The trailers are passed as a list of key-value pairs.

  fn send_response_trailers<'a>(&mut self, trailers: &'a [(&'a str, &'a [u8])]);

  /// add a custom flag to indicate a noteworthy event of this stream. Mutliple flags could be added

  /// and will be concatenated with comma. It should not contain any empty or space characters (' ',

  /// '\t', '\f', '\v', '\n', '\r'). to the HTTP stream. The flag can later be used in logging or

  /// metrics. Ideally, it should be a very short string that represents a single event, like the

  /// the Envoy response flag.

  fn add_custom_flag(&mut self, flag: &str);

  /// Get the number-typed metadata value with the given key.

  /// Use the `source` parameter to specify which metadata to use.

  /// If the metadata is not found or is the wrong type, this returns `None`.

  fn get_metadata_number(

    &self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

  ) -> Option<f64>;

  /// Set the number-typed dynamic metadata value with the given key.

  /// If the namespace is not found, this will create a new namespace.

  fn set_dynamic_metadata_number(&mut self, namespace: &str, key: &str, value: f64);

  /// Get the string-typed metadata value with the given key.

  /// Use the `source` parameter to specify which metadata to use.

  /// If the metadata is not found or is the wrong type, this returns `None`.

  fn get_metadata_string<'a>(

    &'a self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

  ) -> Option<EnvoyBuffer<'a>>;

  /// Set the string-typed dynamic metadata value with the given key.

  /// If the namespace is not found, this will create a new namespace.

  ///

  /// Returns true if the operation is successful.

  fn set_dynamic_metadata_string(&mut self, namespace: &str, key: &str, value: &str);

  /// Get the bool-typed metadata value with the given key.

  /// Use the `source` parameter to specify which metadata to use.

  /// If the metadata is not found or is the wrong type, this returns `None`.

  fn get_metadata_bool(

    &self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

  ) -> Option<bool>;

  /// Set the bool-typed dynamic metadata value with the given key.

  /// If the namespace is not found, this will create a new namespace.

  fn set_dynamic_metadata_bool(&mut self, namespace: &str, key: &str, value: bool);

  /// Get all keys in the given metadata namespace.

  /// Use the `source` parameter to specify which metadata to use.

  /// Returns a vector of `EnvoyBuffer` representing the key names,

  /// or `None` if the namespace is not found.

  fn get_metadata_keys<'a>(

    &'a self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

  ) -> Option<Vec<EnvoyBuffer<'a>>>;

  /// Get all namespace names in the metadata.

  /// Use the `source` parameter to specify which metadata to use.

  /// Returns a vector of `EnvoyBuffer` representing the namespace names,

  /// or `None` if no namespaces exist.

  fn get_metadata_namespaces<'a>(

    &'a self,

    source: abi::envoy_dynamic_module_type_metadata_source,

  ) -> Option<Vec<EnvoyBuffer<'a>>>;

  /// Append a number value to the dynamic metadata list stored under the given namespace and key.

  /// If the key does not exist, a new list is created. If the key exists but is not a list,

  /// or if the metadata is not accessible, this returns false.

  fn add_dynamic_metadata_list_number(&mut self, namespace: &str, key: &str, value: f64) -> bool;

  /// Append a string value to the dynamic metadata list stored under the given namespace and key.

  /// If the key does not exist, a new list is created. If the key exists but is not a list,

  /// or if the metadata is not accessible, this returns false.

  fn add_dynamic_metadata_list_string(&mut self, namespace: &str, key: &str, value: &str) -> bool;

  /// Append a bool value to the dynamic metadata list stored under the given namespace and key.

  /// If the key does not exist, a new list is created. If the key exists but is not a list,

  /// or if the metadata is not accessible, this returns false.

  fn add_dynamic_metadata_list_bool(&mut self, namespace: &str, key: &str, value: bool) -> bool;

  /// Get the number of elements in the metadata list stored under the given namespace and key.

  /// Use the `source` parameter to specify which metadata to use.

  /// Returns `None` if the metadata is not accessible, the namespace or key does not exist,

  /// or the value is not a list.

  fn get_metadata_list_size(

    &self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

  ) -> Option<usize>;

  /// Get the number value at the given index in the metadata list stored under the given namespace

  /// and key. Use the `source` parameter to specify which metadata to use.

  /// Returns `None` if the metadata is not accessible, the namespace or key does not exist,

  /// the value is not a list, the index is out of range, or the element is not a number.

  fn get_metadata_list_number(

    &self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

    index: usize,

  ) -> Option<f64>;

  /// Get the string value at the given index in the metadata list stored under the given namespace

  /// and key. Use the `source` parameter to specify which metadata to use.

  /// Returns `None` if the metadata is not accessible, the namespace or key does not exist,

  /// the value is not a list, the index is out of range, or the element is not a string.

  ///

  /// The returned buffer's lifetime is tied to the current event hook.

  fn get_metadata_list_string<'a>(

    &'a self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

    index: usize,

  ) -> Option<EnvoyBuffer<'a>>;

  /// Get the bool value at the given index in the metadata list stored under the given namespace

  /// and key. Use the `source` parameter to specify which metadata to use.

  /// Returns `None` if the metadata is not accessible, the namespace or key does not exist,

  /// the value is not a list, the index is out of range, or the element is not a bool.

  fn get_metadata_list_bool(

    &self,

    source: abi::envoy_dynamic_module_type_metadata_source,

    namespace: &str,

    key: &str,

    index: usize,

  ) -> Option<bool>;

  /// Get the bytes-typed filter state value with the given key.

  /// If the filter state is not found or is the wrong type, this returns `None`.

  fn get_filter_state_bytes<'a>(&'a self, key: &[u8]) -> Option<EnvoyBuffer<'a>>;

  /// Set the bytes-typed filter state value with the given key.

  /// If the filter state is not found, this will create a new filter state.

  ///

  /// Returns true if the operation is successful.

  fn set_filter_state_bytes(&mut self, key: &[u8], value: &[u8]) -> bool;

  /// Set a typed filter state value with the given key. The value is deserialized by a

  /// registered `StreamInfo::FilterState::ObjectFactory` on the Envoy side. This is useful for

  /// setting filter state objects that other Envoy filters expect to read as specific C++ types

  /// (e.g., `PerConnectionCluster` used by TCP Proxy).

  ///

  /// Returns true if the operation is successful. This can fail if no ObjectFactory is registered

  /// for the key, if deserialization fails, or if the key already exists and is read-only.

  fn set_filter_state_typed(&mut self, key: &[u8], value: &[u8]) -> bool;

  /// Get the serialized value of a typed filter state object with the given key. The object must

  /// support `serializeAsString()` on the Envoy side.

  ///

  /// Returns None if the key does not exist, the object does not support serialization, or the

  /// filter state is not accessible.

  fn get_filter_state_typed<'a>(&'a self, key: &[u8]) -> Option<EnvoyBuffer<'a>>;

  /// Get the received request body (the request body pieces received in the latest event).

  /// This should only be used in the [`HttpFilter::on_request_body`] callback.

  ///

  /// The body is represented as a list of [`EnvoyBuffer`].

  /// Memory contents pointed by each [`EnvoyBuffer`] is mutable and can be modified in place.

  /// However, the vector itself is a "copied view". For example, adding or removing

  /// [`EnvoyBuffer`] from the vector has no effect on the underlying Envoy buffer. To write beyond

  /// the end of the buffer, use [`EnvoyHttpFilter::append_received_request_body`]. To remove data

  /// from the buffer, use [`EnvoyHttpFilter::drain_received_request_body`].

  ///

  /// To write completely new data, use [`EnvoyHttpFilter::drain_received_request_body`] for the

  /// size of the buffer, and then use [`EnvoyHttpFilter::append_received_request_body`] to write

  /// the new data.

  ///

  /// ```

  /// use envoy_proxy_dynamic_modules_rust_sdk::*;

  ///

  /// // This is the test setup.

  /// let mut envoy_filter = MockEnvoyHttpFilter::default();

  /// // Mutable static storage is used for the test to simulate the response body operation.

  /// static mut BUFFER: [u8; 10] = *b"helloworld";

  /// envoy_filter

  ///   .expect_get_received_request_body()

  ///   .returning(|| Some(vec![unsafe { EnvoyMutBuffer::new(&raw mut BUFFER) }]));

  /// envoy_filter

  ///   .expect_drain_received_request_body()

  ///   .return_const(true);

  ///

  ///

  /// // Calculate the size of the new received request body in bytes.

  /// let buffers = envoy_filter.get_received_request_body().unwrap();

  /// let mut size = 0;

  /// for buffer in &buffers {

  ///   size += buffer.as_slice().len();

  /// }

  /// assert_eq!(size, 10);

  ///

  /// // drain the new received request body.

  /// assert!(envoy_filter.drain_received_request_body(10));

  ///

  /// // Now start writing new data from the beginning of the request body.

  /// ```

  ///

  /// This returns None if the request body is not available.

  fn get_received_request_body<'a>(&'a mut self) -> Option<Vec<EnvoyMutBuffer<'a>>>;

  /// Similar to [`EnvoyHttpFilter::get_received_request_body`], but returns the buffered request

  /// body (the request body pieces buffered so far in the filter chain).

  fn get_buffered_request_body<'a>(&'a mut self) -> Option<Vec<EnvoyMutBuffer<'a>>>;

  /// Get the size of the received request body in bytes.

  /// This should only be used in the [`HttpFilter::on_request_body`] callback.

  ///

  /// Returns None if the request body is not available.

  fn get_received_request_body_size(&mut self) -> usize;

  /// Similar to [`EnvoyHttpFilter::get_received_request_body_size`], but returns the size of the

  /// buffered request body in bytes.

  fn get_buffered_request_body_size(&mut self) -> usize;

  /// Drain the given number of bytes from the front of the received request body.

  /// This should only be used in the [`HttpFilter::on_request_body`] callback.

  ///

  /// Returns false if the request body is not available.

  ///

  /// Note that after changing the request body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn drain_received_request_body(&mut self, number_of_bytes: usize) -> bool;

  /// Similar to [`EnvoyHttpFilter::drain_received_request_body`], but drains from the buffered

  /// request body.

  ///

  /// This method should only be used by the final data-processing filter in the chain.

  /// In other words, a filter may safely modify the buffered body only if no later filters

  /// in the chain have accessed it yet.

  ///

  /// Returns false if the request body is not available.

  /// Note that after changing the request body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn drain_buffered_request_body(&mut self, number_of_bytes: usize) -> bool;

  /// Append the given data to the end of the received request body.

  /// This should only be used in the [`HttpFilter::on_request_body`] callback.

  ///

  /// Returns false if the request body is not available.

  ///

  /// Note that after changing the request body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn append_received_request_body(&mut self, data: &[u8]) -> bool;

  /// Similar to [`EnvoyHttpFilter::append_received_request_body`], but appends to the buffered

  /// request body.

  ///

  /// This method should only be used by the final data-processing filter in the chain.

  /// In other words, a filter may safely modify the buffered body only if no later filters

  /// in the chain have accessed it yet.

  ///

  /// Returns false if the request body is not available.

  /// Note that after changing the request body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn append_buffered_request_body(&mut self, data: &[u8]) -> bool;

  /// Get the received response body (the response body pieces received in the latest event).

  /// This should only be used in the [`HttpFilter::on_response_body`] callback.

  ///

  /// The body is represented as a list of

  /// [`EnvoyBuffer`]. Memory contents pointed by each [`EnvoyBuffer`] is mutable and can be

  /// modified in place. However, the buffer itself is immutable. For example, adding or removing

  /// [`EnvoyBuffer`] from the vector has no effect on the underlying Envoy buffer. To write the

  /// contents by changing its length, use [`EnvoyHttpFilter::drain_received_response_body`] or

  /// [`EnvoyHttpFilter::append_received_response_body`].

  ///

  /// To write completely new data, use [`EnvoyHttpFilter::drain_received_response_body`] for the

  /// size of the buffer, and then use [`EnvoyHttpFilter::append_received_response_body`] to write

  /// the new data.

  ///

  /// ```

  /// use envoy_proxy_dynamic_modules_rust_sdk::*;

  ///

  /// // This is the test setup.

  /// let mut envoy_filter = MockEnvoyHttpFilter::default();

  /// // Mutable static storage is used for the test to simulate the response body operation.

  /// static mut BUFFER: [u8; 10] = *b"helloworld";

  /// envoy_filter

  ///   .expect_get_received_response_body()

  ///   .returning(|| Some(vec![unsafe { EnvoyMutBuffer::new(&raw mut BUFFER) }]));

  /// envoy_filter

  ///   .expect_drain_received_response_body()

  ///   .return_const(true);

  ///

  ///

  /// // Calculate the size of the received response body in bytes.

  /// let buffers = envoy_filter.get_received_response_body().unwrap();

  /// let mut size = 0;

  /// for buffer in &buffers {

  ///   size += buffer.as_slice().len();

  /// }

  /// assert_eq!(size, 10);

  ///

  /// // drain the received response body.

  /// assert!(envoy_filter.drain_received_response_body(10));

  ///

  /// // Now start writing new data from the beginning of the request body.

  /// ```

  ///

  /// Returns None if the response body is not available.

  fn get_received_response_body<'a>(&'a mut self) -> Option<Vec<EnvoyMutBuffer<'a>>>;

  /// Similar to [`EnvoyHttpFilter::get_received_response_body`], but returns the buffered response

  /// body (the response body pieces buffered so far in the filter chain).

  fn get_buffered_response_body<'a>(&'a mut self) -> Option<Vec<EnvoyMutBuffer<'a>>>;

  /// Get the size of the received response body in bytes.

  /// This should only be used in the [`HttpFilter::on_response_body`] callback.

  ///

  /// Returns zero if the response body is not available or empty.

  fn get_received_response_body_size(&mut self) -> usize;

  /// Similar to [`EnvoyHttpFilter::get_received_response_body_size`], but returns the size of the

  /// buffered response body in bytes.

  ///

  /// Returns zero if the response body is not available or empty.

  fn get_buffered_response_body_size(&mut self) -> usize;

  /// Drain the given number of bytes from the front of the received response body.

  /// This should only be used in the [`HttpFilter::on_response_body`] callback.

  ///

  /// Returns false if the response body is not available.

  ///

  /// Note that after changing the response body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn drain_received_response_body(&mut self, number_of_bytes: usize) -> bool;

  /// Similar to [`EnvoyHttpFilter::drain_received_response_body`], but drains from the buffered

  /// response body.

  ///

  /// This method should only be used by the final data-processing filter in the chain.

  /// In other words, a filter may safely modify the buffered body only if no later filters

  /// in the chain have accessed it yet.

  ///

  /// Returns false if the response body is not available.

  /// Note that after changing the response body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn drain_buffered_response_body(&mut self, number_of_bytes: usize) -> bool;

  /// Append the given data to the end of the received response body.

  /// This should only be used in the [`HttpFilter::on_response_body`] callback.

  ///

  /// Returns false if the response body is not available.

  ///

  /// Note that after changing the response body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn append_received_response_body(&mut self, data: &[u8]) -> bool;

  /// Similar to [`EnvoyHttpFilter::append_received_response_body`], but appends to the buffered

  /// response body.

  ///

  /// This method should only be used by the final data-processing filter in the chain.

  /// In other words, a filter may safely modify the buffered body only if no later filters

  /// in the chain have accessed it yet.

  ///

  /// Returns false if the response body is not available.

  /// Note that after changing the response body, it is caller's responsibility to modify the

  /// content-length header if necessary.

  fn append_buffered_response_body(&mut self, data: &[u8]) -> bool;

  /// Returns true if the latest received request body is the previously buffered request body.

  ///

  /// This is true when a previous filter in the chain stopped and buffered the request body,

  /// then resumed, and this filter is now receiving that buffered body.

  ///

  /// NOTE: This is only meaningful inside [`HttpFilter::on_request_body`].

  fn received_buffered_request_body(&mut self) -> bool;

  /// Returns true if the latest received response body is the previously buffered response body.

  ///

  /// This is true when a previous filter in the chain stopped and buffered the response body,

  /// then resumed, and this filter is now receiving that buffered body.

  ///

  /// NOTE: This is only meaningful inside [`HttpFilter::on_response_body`].

  fn received_buffered_response_body(&mut self) -> bool;

  /// Clear the route cache calculated during a previous phase of the filter chain.

  ///

  /// This is useful when the filter wants to force a re-evaluation of the route selection after

  /// modifying the request headers, etc that affect the routing decision.

  fn clear_route_cache(&mut self);

  /// Get the value of the attribute with the given ID as a string.

  ///

  /// If the attribute is not found, not supported or is the wrong type, this returns `None`.

  fn get_attribute_string<'a>(

    &'a self,

    attribute_id: abi::envoy_dynamic_module_type_attribute_id,

  ) -> Option<EnvoyBuffer<'a>>;

  /// Get the value of the attribute with the given ID as an integer.

  ///

  /// If the attribute is not found, not supported or is the wrong type, this returns `None`.

  fn get_attribute_int(

    &self,

    attribute_id: abi::envoy_dynamic_module_type_attribute_id,

  ) -> Option<i64>;

  /// Get the value of the attribute with the given ID as a boolean.

  ///

  /// If the attribute is not found, not supported or is the wrong type, this returns `None`.

  fn get_attribute_bool(

    &self,

    attribute_id: abi::envoy_dynamic_module_type_attribute_id,

  ) -> Option<bool>;

  /// Send an HTTP callout to the given cluster with the given headers and body.

  /// Multiple callouts can be made from the same filter. Different callouts can be

  /// distinguished by the returned callout id.

  ///

  /// Headers must contain the `:method`, ":path", and `host` headers.

  ///

  /// This returns the status and callout id of the callout. The id is used to

  /// distinguish different callouts made from the same filter and is generated by Envoy.

  /// The meaning of the status is:

  ///

  ///   * Success: The callout was sent successfully.

  ///   * MissingRequiredHeaders: One of the required headers is missing: `:method`, `:path`, or

  ///     `host`.

  ///   * ClusterNotFound: The cluster with the given name was not found.

  ///   * DuplicateCalloutId: The callout ID is already in use.

  ///   * CouldNotCreateRequest: The request could not be created. This happens when, for example,

  ///     there's no healthy upstream host in the cluster.

  ///

  /// The callout result will be delivered to the [`HttpFilter::on_http_callout_done`] method.

  fn send_http_callout<'a>(

    &mut self,

    _cluster_name: &'a str,

    _headers: &'a [(&'a str, &'a [u8])],

    _body: Option<&'a [u8]>,

    _timeout_milliseconds: u64,

  ) -> (

    abi::envoy_dynamic_module_type_http_callout_init_result,

    u64, // callout handle

  );

  /// Start a streamable HTTP callout to the given cluster with the given headers and optional

  /// body. Multiple concurrent streams can be created from the same filter.

  ///

  /// Headers must contain the `:method`, `:path`, and `host` headers.

  ///

  /// This returns a tuple of (status, stream_handle):

  ///   * Success + valid stream_handle: The stream was started successfully.

  ///   * MissingRequiredHeaders + null: One of the required headers is missing.

  ///   * ClusterNotFound + null: The cluster with the given name was not found.

  ///   * CannotCreateRequest + null: The stream could not be created (e.g., no healthy upstream).

  ///

  /// After starting the stream, use the returned stream_handle to send data/trailers or reset.

  /// Stream events will be delivered to the [`HttpFilter::on_http_stream_*`] methods.

  ///

  /// When the HTTP stream ends (either successfully or via reset), no further callbacks will

  /// be invoked for that stream.

  fn start_http_stream<'a>(

    &mut self,

    _cluster_name: &'a str,

    _headers: &'a [(&'a str, &'a [u8])],