use crate::{
    error::Error,
    extract::{Extract, Metadata},
    request::Request,
};
use async_trait::async_trait;
use hyper::body::Bytes;
use serde::{de::DeserializeOwned, Deserialize, Deserializer};
use std::{
    fmt::{self, Formatter},
    ops::{Deref, DerefMut},
};

#[cfg(feature = "cookie")]
pub(crate) mod cookie {
    use super::*;
    /// Represents the parameters passed by Cookie.

    pub struct CookieParam<T, const REQUIRED: bool>(pub Option<T>);
    impl<T> CookieParam<T, true> {
        /// Consumes self and returns the value of the parameter.
        pub fn inner(self) -> T {
            self.0.unwrap()
        }
    }
    impl<T> CookieParam<T, false> {
        /// Consumes self and returns the value of the parameter.
        pub fn inner(self) -> Option<T> {
            self.0
        }
    }

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

        fn deref(&self) -> &Self::Target {
            self.0.as_ref().unwrap()
        }
    }
    impl<T> Deref for CookieParam<T, false> {
        type Target = Option<T>;

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

    impl<T> DerefMut for CookieParam<T, true> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            self.0.as_mut().unwrap()
        }
    }
    impl<T> DerefMut for CookieParam<T, false> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            &mut self.0
        }
    }

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

    impl<T, const R: bool> fmt::Debug for CookieParam<T, R>
    where
        T: fmt::Debug,
    {
        fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
            self.0.fmt(f)
        }
    }

    impl<T> fmt::Display for CookieParam<T, true>
    where
        T: fmt::Display,
    {
        fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
            self.0.as_ref().unwrap().fmt(f)
        }
    }

    #[async_trait]
    impl<'de, T> Extract<'de> for CookieParam<T, true>
    where
        T: Deserialize<'de> + Send,
    {
        fn metadata() -> &'de Metadata {
            static METADATA: Metadata = Metadata::new("");
            &METADATA
        }
        async fn extract(req: &'de mut Request) -> Result<Self, Error> {
            req.parse_cookies()
        }
        async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
            let value = req
                .cookies()
                .get(_arg)
                .and_then(|v| crate::serde_request::from_str_val(v.value()).ok())
                .ok_or_else(|| {
                    Error::Other(format!(
                        "cookie parameter {} not found or convert to type failed",
                        _arg
                    ))
                })?;
            Ok(Self(value))
        }
    }

    #[async_trait]
    impl<'de, T> Extract<'de> for CookieParam<T, false>
    where
        T: Deserialize<'de> + Send,
    {
        fn metadata() -> &'de Metadata {
            static METADATA: Metadata = Metadata::new("");
            &METADATA
        }
        async fn extract(req: &'de mut Request) -> Result<Self, Error> {
            req.parse_cookies()
        }
        async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
            let value = req
                .cookies()
                .get(_arg)
                .and_then(|v| crate::serde_request::from_str_val(v.value()).ok());
            Ok(Self(value))
        }
    }
}

/// Represents the parameters passed by header.
pub struct Header<T, const REQUIRED: bool>(pub Option<T>);
impl<T> Header<T, true> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> T {
        self.0.unwrap()
    }
}

impl<T> Header<T, false> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> Option<T> {
        self.0
    }
}

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

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

impl<T> Deref for Header<T, false> {
    type Target = Option<T>;

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

impl<T> DerefMut for Header<T, true> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.0.as_mut().unwrap()
    }
}

impl<T> DerefMut for Header<T, false> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

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

impl<T, const R: bool> fmt::Debug for Header<T, R>
where
    T: fmt::Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<T> fmt::Display for Header<T, true>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.as_ref().unwrap().fmt(f)
    }
}

#[async_trait]
impl<'de, T> Extract<'de> for Header<T, true>
where
    T: Deserialize<'de> + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_header()
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        let value = req.header(_arg).ok_or_else(|| {
            Error::Other(format!(
                "header parameter {} not found or convert to type failed",
                _arg
            ))
        })?;
        Ok(Self(value))
    }
}

#[async_trait]
impl<'de, T> Extract<'de> for Header<T, false>
where
    T: Deserialize<'de> + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_header()
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        Ok(Self(req.header(_arg)))
    }
}

/// Represents the parameters passed by the URI path.
pub struct Path<T>(pub T);
impl<T> Path<T> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> T {
        self.0
    }
}

impl<T> Deref for Path<T> {
    type Target = T;

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

impl<T> DerefMut for Path<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T> fmt::Debug for Path<T>
where
    T: fmt::Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<T> fmt::Display for Path<T>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<'de, T> Deserialize<'de> for Path<T>
where
    T: Deserialize<'de> + Send,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        T::deserialize(deserializer).map(|value| Path(value))
    }
}

#[async_trait]
impl<'de, T> Extract<'de> for Path<T>
where
    T: Deserialize<'de> + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_param()
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        let value = req.param(_arg).ok_or_else(|| {
            Error::Other(format!(
                "path parameter {} not found or convert to type failed",
                _arg
            ))
        })?;
        Ok(Self(value))
    }
}

/// Represents the parameters passed by the URI path.
pub struct Query<T, const REQUIRED: bool>(pub Option<T>);

impl<T> Query<T, true> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> T {
        self.0.unwrap()
    }
}
impl<T> Query<T, false> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> Option<T> {
        self.0
    }
}

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

    fn deref(&self) -> &Self::Target {
        self.0.as_ref().unwrap()
    }
}
impl<T> Deref for Query<T, false> {
    type Target = Option<T>;

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

impl<T> DerefMut for Query<T, true> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.0.as_mut().unwrap()
    }
}
impl<T> DerefMut for Query<T, false> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T, const R: bool> fmt::Debug for Query<T, R>
where
    T: fmt::Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<T> fmt::Display for Query<T, true>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.as_ref().unwrap().fmt(f)
    }
}

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

#[async_trait]
impl<'de, T> Extract<'de> for Query<T, true>
where
    T: Deserialize<'de> + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_query()
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        let value = req.query(_arg).ok_or_else(|| {
            Error::Other(format!(
                "query parameter {} not found or convert to type failed",
                _arg
            ))
        })?;
        Ok(Self(value))
    }
}
#[async_trait]
impl<'de, T> Extract<'de> for Query<T, false>
where
    T: Deserialize<'de> + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_query()
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        Ok(Self(req.query(_arg)))
    }
}

pub struct Json<T>(pub T);
impl<T> Json<T> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> T {
        self.0
    }
}

impl<T> Deref for Json<T> {
    type Target = T;

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

impl<T> DerefMut for Json<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T> fmt::Debug for Json<T>
where
    T: fmt::Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<T> fmt::Display for Json<T>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<'de, T> Deserialize<'de> for Json<T>
where
    T: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        T::deserialize(deserializer).map(Json)
    }
}

#[async_trait]
impl<'de, T> Extract<'de> for Json<T>
where
    T: DeserializeOwned + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_json().await
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        Self::extract(req).await
    }
}

pub struct Form<T>(pub T);
impl<T> Form<T> {
    /// Consumes self and returns the value of the parameter.
    pub fn inner(self) -> T {
        self.0
    }
}

impl<T> Deref for Form<T> {
    type Target = T;

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

impl<T> DerefMut for Form<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T> fmt::Debug for Form<T>
where
    T: fmt::Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<T> fmt::Display for Form<T>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<'de, T> Deserialize<'de> for Form<T>
where
    T: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        T::deserialize(deserializer).map(Form)
    }
}

#[async_trait]
impl<'de, T> Extract<'de> for Form<T>
where
    T: DeserializeOwned + Send,
{
    fn metadata() -> &'de Metadata {
        static METADATA: Metadata = Metadata::new("");
        &METADATA
    }
    async fn extract(req: &'de mut Request) -> Result<Self, Error> {
        req.parse_form().await
    }
    async fn extract_with_arg(req: &'de mut Request, _arg: &str) -> Result<Self, Error> {
        Self::extract(req).await
    }
}

#[allow(dead_code)]
pub enum Text<C: Into<Bytes>> {
    /// It will set `content-type` to `text/plain; charset=utf-8`.
    Plain(C),
    /// It will set `content-type` to `application/json; charset=utf-8`.
    Json(C),
    /// It will set `content-type` to `application/xml; charset=utf-8`.
    Xml(C),
    /// It will set `content-type` to `text/html; charset=utf-8`.
    Html(C),
    /// It will set `content-type` to `text/javascript; charset=utf-8`.
    Js(C),
    /// It will set `content-type` to `text/css; charset=utf-8`.
    Css(C),
    /// It will set `content-type` to `text/csv; charset=utf-8`.
    Csv(C),
    /// It will set `content-type` to `application/atom+xml; charset=utf-8`.
    Atom(C),
    /// It will set `content-type` to `application/rss+xml; charset=utf-8`.
    Rss(C),
    /// It will set `content-type` to `application/rdf+xml; charset=utf-8`.
    Rdf(C),
}