salvo-oapi 0.92.0

use std::fmt::{self, Debug, Display, Formatter};
use std::ops::{Deref, DerefMut};

use salvo_core::Depot;
use salvo_core::extract::{Extractible, Metadata};
use salvo_core::http::{ParseError, Request};
use serde::{Deserialize, Deserializer};

use crate::endpoint::EndpointArgRegister;
use crate::{Components, Operation, Parameter, ParameterIn, ToSchema};

/// Represents the parameters passed by header.
pub struct HeaderParam<T, const REQUIRED: bool = true>(Option<T>);
impl<T> HeaderParam<T, true> {
    /// Consumes self and returns the value of the parameter.
    pub fn into_inner(self) -> T {
        self.0
            .expect("`HeaderParam<T, true>` into_inner get `None`")
    }
}
impl<T> HeaderParam<T, false> {
    /// Consumes self and returns the value of the parameter.
    pub fn into_inner(self) -> Option<T> {
        self.0
    }
}

impl<T> Deref for HeaderParam<T, true> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.0
            .as_ref()
            .expect("`HeaderParam<T, true>` defref get `None`")
    }
}
impl<T> Deref for HeaderParam<T, false> {
    type Target = Option<T>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for HeaderParam<T, true> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.0
            .as_mut()
            .expect("`HeaderParam<T, true>` defref_mut get `None`")
    }
}
impl<T> DerefMut for HeaderParam<T, false> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<'de, T, const R: bool> Deserialize<'de> for HeaderParam<T, R>
where
    T: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        T::deserialize(deserializer).map(|value| Self(Some(value)))
    }
}
// impl<'de, T> Deserialize<'de> for HeaderParam<T, false>
// where
//     T: Deserialize<'de>,
// {
//     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
//     where
//         D: Deserializer<'de>,
//     {
//         T::deserialize(deserializer).map(|value| Self(Some(value)))
//     }
// }

impl<T, const R: bool> fmt::Debug for HeaderParam<T, R>
where
    T: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}
impl<T: Display> Display for HeaderParam<T, true> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0
            .as_ref()
            .expect("HeaderParam value should not be None")
            .fmt(f)
    }
}

impl<'ex, T> Extractible<'ex> for HeaderParam<T, true>
where
    T: Deserialize<'ex>,
{
    fn metadata() -> &'static Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    #[allow(refining_impl_trait)]
    async fn extract(_req: &'ex mut Request, _depot: &'ex mut Depot) -> Result<Self, ParseError> {
        unimplemented!("header parameter can not be extracted from request")
    }
    #[allow(refining_impl_trait)]
    async fn extract_with_arg(
        req: &'ex mut Request,
        _depot: &'ex mut Depot,
        arg: &str,
    ) -> Result<Self, ParseError> {
        let value = req.header(arg).ok_or_else(|| {
            ParseError::other(format!(
                "header parameter {arg} not found or convert to type failed"
            ))
        })?;
        Ok(Self(value))
    }
}

impl<'ex, T> Extractible<'ex> for HeaderParam<T, false>
where
    T: Deserialize<'ex>,
{
    fn metadata() -> &'static Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    #[allow(refining_impl_trait)]
    async fn extract(_req: &'ex mut Request, _depot: &'ex mut Depot) -> Result<Self, ParseError> {
        unimplemented!("header parameter can not be extracted from request")
    }
    #[allow(refining_impl_trait)]
    async fn extract_with_arg(
        req: &'ex mut Request,
        _depot: &'ex mut Depot,
        arg: &str,
    ) -> Result<Self, ParseError> {
        Ok(Self(req.header(arg)))
    }
}

impl<T, const R: bool> EndpointArgRegister for HeaderParam<T, R>
where
    T: ToSchema,
{
    fn register(components: &mut Components, operation: &mut Operation, arg: &str) {
        let parameter = Parameter::new(arg)
            .parameter_in(ParameterIn::Header)
            .description(format!("Get parameter `{arg}` from request headers."))
            .schema(T::to_schema(components))
            .required(R);
        operation.parameters.insert(parameter);
    }
}

#[cfg(test)]
mod tests {
    use assert_json_diff::assert_json_eq;
    use http::header::HeaderValue;
    use salvo_core::test::TestClient;
    use serde_json::json;

    use super::*;

    #[test]
    fn test_required_header_param_into_inner() {
        let param = HeaderParam::<String, true>(Some("param".to_owned()));
        assert_eq!("param".to_owned(), param.into_inner());
    }

    #[test]
    fn test_required_header_param_deref() {
        let param = HeaderParam::<String, true>(Some("param".to_owned()));
        assert_eq!(&"param".to_owned(), param.deref())
    }

    #[test]
    fn test_required_header_param_deref_mut() {
        let mut param = HeaderParam::<String, true>(Some("param".to_owned()));
        assert_eq!(&mut "param".to_owned(), param.deref_mut())
    }

    #[test]
    fn test_header_param_into_inner() {
        let param = HeaderParam::<String, false>(Some("param".to_owned()));
        assert_eq!(Some("param".to_owned()), param.into_inner());
    }

    #[test]
    fn test_header_param_deref() {
        let param = HeaderParam::<String, false>(Some("param".to_owned()));
        assert_eq!(&Some("param".to_owned()), param.deref())
    }

    #[test]
    fn test_header_param_deref_mut() {
        let mut param = HeaderParam::<String, false>(Some("param".to_owned()));
        assert_eq!(&mut Some("param".to_owned()), param.deref_mut())
    }

    #[test]
    fn test_header_param_deserialize() {
        let param = serde_json::from_str::<HeaderParam<String, true>>(r#""param""#).unwrap();
        assert_eq!(param.0.unwrap(), "param");
    }

    #[test]
    fn test_header_param_debug() {
        let param = HeaderParam::<String, true>(Some("param".to_owned()));
        assert_eq!(format!("{param:?}"), r#"Some("param")"#);
    }

    #[test]
    fn test_header_param_display() {
        let param = HeaderParam::<String, true>(Some("param".to_owned()));
        assert_eq!(format!("{param}"), "param");
    }

    #[test]
    fn test_required_header_param_metadata() {
        let metadata = HeaderParam::<String, true>::metadata();
        assert_eq!("", metadata.name);
    }

    #[tokio::test]
    #[should_panic]
    async fn test_required_header_prarm_extract() {
        let mut req = Request::new();
        let mut depot = Depot::new();
        let _ = HeaderParam::<String, true>::extract(&mut req, &mut depot).await;
    }

    #[tokio::test]
    async fn test_required_header_prarm_extract_with_value() {
        let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
        req.headers_mut()
            .append("param", HeaderValue::from_static("param"));
        let schema = req.uri().scheme().cloned().unwrap();
        let mut req = Request::from_hyper(req, schema);
        let mut depot = Depot::new();
        let result =
            HeaderParam::<String, true>::extract_with_arg(&mut req, &mut depot, "param").await;
        assert_eq!(result.unwrap().0.unwrap(), "param");
    }

    #[tokio::test]
    #[should_panic]
    async fn test_required_header_prarm_extract_with_value_panic() {
        let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
        let schema = req.uri().scheme().cloned().unwrap();
        let mut req = Request::from_hyper(req, schema);
        let mut depot = Depot::new();
        let result =
            HeaderParam::<String, true>::extract_with_arg(&mut req, &mut depot, "param").await;
        assert_eq!(result.unwrap().0.unwrap(), "param");
    }

    #[test]
    fn test_header_param_metadata() {
        let metadata = HeaderParam::<String, false>::metadata();
        assert_eq!("", metadata.name);
    }

    #[tokio::test]
    #[should_panic]
    async fn test_header_prarm_extract() {
        let mut req = Request::new();
        let mut depot = Depot::new();
        let _ = HeaderParam::<String, false>::extract(&mut req, &mut depot).await;
    }

    #[tokio::test]
    async fn test_header_prarm_extract_with_value() {
        let mut req = TestClient::get("http://127.0.0.1:5801").build_hyper();
        req.headers_mut()
            .append("param", HeaderValue::from_static("param"));
        let schema = req.uri().scheme().cloned().unwrap();
        let mut req = Request::from_hyper(req, schema);
        let mut depot = Depot::new();
        let result =
            HeaderParam::<String, false>::extract_with_arg(&mut req, &mut depot, "param").await;
        assert_eq!(result.unwrap().0.unwrap(), "param");
    }

    #[tokio::test]
    #[should_panic]
    async fn test_header_prarm_extract_with_value_panic() {
        let req = TestClient::get("http://127.0.0.1:5801").build_hyper();
        let schema = req.uri().scheme().cloned().unwrap();
        let mut req = Request::from_hyper(req, schema);
        let mut depot = Depot::new();
        let result =
            HeaderParam::<String, false>::extract_with_arg(&mut req, &mut depot, "param").await;
        assert_eq!(result.unwrap().0.unwrap(), "param");
    }

    #[test]
    fn test_header_param_register() {
        let mut components = Components::new();
        let mut operation = Operation::new();
        HeaderParam::<String, false>::register(&mut components, &mut operation, "arg");

        assert_json_eq!(
            operation,
            json!({
                "parameters": [
                    {
                        "name": "arg",
                        "in": "header",
                        "description": "Get parameter `arg` from request headers.",
                        "required": false,
                        "schema": {
                            "type": "string"
                        }
                    }
                ],
                "responses": {}
            })
        )
    }
}