use crate::response::Response;
#[cfg(feature = "cookie")]
use cookie::{Cookie, CookieJar};
use hyper::{body::Bytes, StatusCode};
use serde::Deserialize;
use std::{
    borrow::{Borrow, BorrowMut},
    ops::{Deref, DerefMut},
};

macro_rules! status_responder {
    ( $( $x:ty ),+ ) => {
        $(
            impl Responder for $x {
                #[inline]
                fn response(self, builder: Response) -> Response {
                    builder.status(self as u16)
                }
            }
        )+
    }
}

macro_rules! body_responder {
    ( $( $x:ty ),+ ) => {
        $(
            impl Responder for $x {
                #[inline]
                fn response(self, mut builder: Response) -> Response {
                    *builder.inner.body_mut() = self.into();
                    builder
                }
            }
        )+
    }
}

macro_rules! plain_body_responder {
    ( $( $x:ty ),+ ) => {
        $(
            impl Responder for $x {
                #[inline]
                fn response(self, builder: Response) -> Response {
                    builder.with("text/plain; charset=utf-8", self)
                }
            }
        )+
    }
}

macro_rules! tuple_responder {

    ( $($idx:tt -> $T:ident),+ ) => {

        impl<$($T:Responder),+> Responder for ($($T),+) {
            #[inline]
            fn response(self, builder: Response) -> Response {
                $(let builder = self.$idx.response(builder);)+
                builder
            }
        }
    }
}

status_responder!(u16, i16, u32, i32, u64, i64, usize, isize);
plain_body_responder!(String, &'static str);
body_responder!(Vec<u8>, &'static [u8], hyper::body::Bytes);
tuple_responder!(0->A, 1->B);
tuple_responder!(0->A, 1->B, 2->C);
tuple_responder!(0->A, 1->B, 2->C, 3->D);
tuple_responder!(0->A, 1->B, 2->C, 3->D, 4->E);
tuple_responder!(0->A, 1->B, 2->C, 3->D, 4->E, 5->F);

pub trait Responder {
    fn response(self, builder: Response) -> Response;
}

impl<T> Responder for Vec<T>
where
    T: Responder,
{
    #[inline]
    fn response(self, mut builder: Response) -> Response {
        for responder in self {
            builder = responder.response(builder);
        }
        builder
    }
}

impl<T> Responder for &'static [T]
where
    T: Responder + Clone,
{
    #[inline]
    fn response(self, mut builder: Response) -> Response {
        for responder in self {
            builder = responder.clone().response(builder);
        }
        builder
    }
}

impl Responder for StatusCode {
    #[inline]
    fn response(self, builder: Response) -> Response {
        builder.status(self)
    }
}

impl Responder for () {
    #[inline]
    fn response(self, builder: Response) -> Response {
        builder.status(200)
    }
}

impl<T: Responder> Responder for Option<T> {
    #[inline]
    fn response(self, builder: Response) -> Response {
        if let Some(r) = self {
            r.response(builder).status_if_not_set(200)
        } else {
            builder.status_if_not_set(404)
        }
    }
}

impl<T: Responder, E: Responder> Responder for Result<T, E> {
    #[inline]
    fn response(self, builder: Response) -> Response {
        match self {
            Ok(r) => r.response(builder).status_if_not_set(200),
            Err(r) => r.response(builder).status_if_not_set(500),
        }
    }
}

impl Responder for hyper::Error {
    #[inline]
    fn response(self, builder: Response) -> Response {
        builder.status(500)
    }
}

impl Responder for Response {
    #[inline]
    fn response(self, _builder: Response) -> Response {
        self
    }
}

impl<T: serde::Serialize> Responder for Json<T> {
    #[inline]
    fn response(self, builder: Response) -> Response {
        builder.json(&self.0)
    }
}

impl<T: serde::Serialize> Responder for Form<T> {
    #[inline]
    fn response(self, builder: Response) -> Response {
        builder.form(&self.0)
    }
}

impl<T: Into<Bytes>> Responder for Html<T> {
    fn response(self, builder: Response) -> Response {
        builder.html(self.0)
    }
}

#[cfg(feature = "cookie")]
impl Responder for Cookie<'static> {
    #[inline]
    fn response(self, builder: Response) -> Response {
        builder.cookie(self)
    }
}

#[cfg(feature = "cookie")]
impl Responder for CookieJar {
    #[inline]
    fn response(self, mut builder: Response) -> Response {
        for c in self.iter() {
            builder.inner.headers_mut().append(
                hyper::http::header::SET_COOKIE,
                hyper::http::HeaderValue::from_str(c.to_string().as_str()).expect("Invalid Cookie"),
            );
        }
        builder
    }
}

#[derive(Deserialize)]
pub struct Json<T>(pub T);

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> AsRef<T> for Json<T> {
    fn as_ref(&self) -> &T {
        &self.0
    }
}

impl<T> AsMut<T> for Json<T> {
    fn as_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

impl<T> Borrow<T> for Json<T> {
    fn borrow(&self) -> &T {
        &self.0
    }
}

impl<T> BorrowMut<T> for Json<T> {
    fn borrow_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

#[derive(Deserialize)]
pub struct Form<T>(pub T);

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> AsRef<T> for Form<T> {
    fn as_ref(&self) -> &T {
        &self.0
    }
}

impl<T> AsMut<T> for Form<T> {
    fn as_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

impl<T> Borrow<T> for Form<T> {
    fn borrow(&self) -> &T {
        &self.0
    }
}

impl<T> BorrowMut<T> for Form<T> {
    fn borrow_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

pub struct Html<T>(pub T);

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

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

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

impl<T> AsRef<T> for Html<T> {
    fn as_ref(&self) -> &T {
        &self.0
    }
}

impl<T> AsMut<T> for Html<T> {
    fn as_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

impl<T> Borrow<T> for Html<T> {
    fn borrow(&self) -> &T {
        &self.0
    }
}

impl<T> BorrowMut<T> for Html<T> {
    fn borrow_mut(&mut self) -> &mut T {
        &mut self.0
    }
}