use std::marker::PhantomData;

use prost::Message;

use crate::error::Error;

use super::{Buf, ConnectCodec, ConnectDecoder, ConnectEncoder, EncodeBuf, MessageCodec};

pub struct ProtoConnectCodec<T, U> {
    _phantom: PhantomData<fn(T) -> U>,
}

impl<T, U> ProtoConnectCodec<T, U> {
    pub fn new() -> Self {
        Self {
            _phantom: PhantomData,
        }
    }
}

impl<T, U> Default for ProtoConnectCodec<T, U> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Message, U: Message + Default> ConnectCodec for ProtoConnectCodec<T, U> {
    type Encode = T;
    type Decode = U;
    type Encoder = ProtoConnectEncoder<T>;
    type Decoder = ProtoConnectDecoder<U>;

    fn message_codec(&self) -> MessageCodec {
        MessageCodec::Proto
    }

    fn encoder(&mut self) -> Self::Encoder {
        ProtoConnectEncoder {
            _phantom: PhantomData,
        }
    }

    fn decoder(&mut self) -> Self::Decoder {
        ProtoConnectDecoder {
            _phantom: PhantomData,
        }
    }
}

pub struct ProtoConnectEncoder<T> {
    _phantom: PhantomData<fn(T)>,
}

impl<T: Message> ConnectEncoder<T> for ProtoConnectEncoder<T> {
    fn encode(&mut self, message: T, buf: &mut EncodeBuf) -> Result<(), Error> {
        message.encode(buf.as_buf_mut())?;
        Ok(())
    }

    fn size_hint(&mut self, message: &T) -> usize {
        message.encoded_len()
    }
}

pub struct ProtoConnectDecoder<T> {
    _phantom: PhantomData<fn() -> T>,
}

impl<T: Message + Default> ConnectDecoder<T> for ProtoConnectDecoder<T> {
    fn decode(&mut self, buf: impl Buf) -> Result<T, Error> {
        Ok(T::decode(buf)?)
    }
}