use std::future::Future;

use anyhow::ensure;
use bytes::Bytes;
use serde::{de::DeserializeOwned, Deserialize, Serialize};

use crate::codec::MessageCodec;

pub trait IntoBody {
    type Body;
    type Error;

    fn into_body(self, codec: &MessageCodec) -> Result<Self::Body, Self::Error>;
}

pub trait FromBody<T>: Sized {
    type Error;

    fn from_body(body: T, codec: &MessageCodec) -> impl Future<Output = Result<Self, Self::Error>>;
}

pub struct JsonBody<T>(pub T);

impl<'a, T: Serialize> IntoBody for JsonBody<&'a T> {
    type Body = String;
    type Error = anyhow::Error;

    fn into_body(self, codec: &MessageCodec) -> Result<Self::Body, Self::Error> {
        ensure!(
            codec == &MessageCodec::Json,
            "JsonBody doesn't support the {codec} codec"
        );
        let json = serde_json::to_string(&self.0)?;
        Ok(json)
    }
}

impl<'a, T: Deserialize<'a>> FromBody<&'a [u8]> for JsonBody<T> {
    type Error = anyhow::Error;

    async fn from_body(body: &'a [u8], codec: &MessageCodec) -> Result<Self, Self::Error> {
        ensure!(
            codec == &MessageCodec::Json,
            "JsonBody doesn't support the {codec} codec"
        );
        let msg: T = serde_json::from_slice(body)?;
        Ok(Self(msg))
    }
}

impl<T: DeserializeOwned> FromBody<Bytes> for JsonBody<T> {
    type Error = anyhow::Error;

    async fn from_body(body: Bytes, codec: &MessageCodec) -> Result<Self, Self::Error> {
        ensure!(
            codec == &MessageCodec::Json,
            "JsonBody doesn't support the {codec} codec"
        );
        let msg: T = serde_json::from_slice(&body).inspect_err(|err| {
            let bod = String::from_utf8_lossy(&body);
            eprintln!("decoding {} {bod:?}: {err:?}", std::any::type_name::<T>());
        })?;
        Ok(Self(msg))
    }
}

#[cfg(feature = "proto")]
mod message {
    pub struct MessageBody<T>(pub T);

    use anyhow::bail;

    use super::*;

    impl<'a, T: prost::Message + serde::Serialize> IntoBody for MessageBody<&'a T> {
        type Body = Vec<u8>;
        type Error = anyhow::Error;

        fn into_body(self, codec: &MessageCodec) -> Result<Self::Body, Self::Error> {
            Ok(match codec {
                MessageCodec::Json => serde_json::to_vec(&self.0)?,
                MessageCodec::Proto => self.0.encode_to_vec(),
                other => bail!("MessageBody doesn't support the {other} codec"),
            })
        }
    }

    impl<T: Default + prost::Message + DeserializeOwned, U: AsRef<[u8]>> FromBody<U>
        for MessageBody<T>
    {
        type Error = anyhow::Error;

        async fn from_body(body: U, codec: &MessageCodec) -> Result<Self, Self::Error> {
            Ok(Self(match codec {
                MessageCodec::Json => serde_json::from_slice(body.as_ref())?,
                MessageCodec::Proto => T::decode(body.as_ref())?,
                other => bail!("MessageBody doesn't support the {other} codec"),
            }))
        }
    }
}
#[cfg(feature = "proto")]
pub use message::MessageBody;