use super::Layer;

use std::fmt;

/// Two middlewares chained together.

#[derive(Clone)]

pub struct Stack<Inner, Outer> {

    inner: Inner,

    outer: Outer,

}

impl<Inner, Outer> Stack<Inner, Outer> {

    /// Create a new `Stack`.

    pub const fn new(inner: Inner, outer: Outer) -> Self {

        Stack { inner, outer }

    }

}

impl<S, Inner, Outer> Layer<S> for Stack<Inner, Outer>

where

    Inner: Layer<S>,

    Outer: Layer<Inner::Service>,

{

    type Service = Outer::Service;

    fn layer(&self, service: S) -> Self::Service {

        let inner = self.inner.layer(service);

        self.outer.layer(inner)

    }

}

impl<Inner, Outer> fmt::Debug for Stack<Inner, Outer>

where

    Inner: fmt::Debug,

    Outer: fmt::Debug,

{

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        // The generated output of nested `Stack`s is very noisy and makes

        // it harder to understand what is in a `ServiceBuilder`.

        //

        // Instead, this output is designed assuming that a `Stack` is

        // usually quite nested, and inside a `ServiceBuilder`. Therefore,

        // this skips using `f.debug_struct()`, since each one would force

        // a new layer of indentation.

        //

        // - In compact mode, a nested stack ends up just looking like a flat

        //   list of layers.

        //

        // - In pretty mode, while a newline is inserted between each layer,

        //   the `DebugStruct` used in the `ServiceBuilder` will inject padding

        //   to that each line is at the same indentation level.

        //

        // Also, the order of [outer, inner] is important, since it reflects

        // the order that the layers were added to the stack.

        if f.alternate() {

            // pretty

            write!(f, "{:#?},\n{:#?}", self.outer, self.inner)

        } else {

            write!(f, "{:?}, {:?}", self.outer, self.inner)

        }

    }

}