use std::marker::PhantomData;

use bytes::Buf;
use serde::{de::DeserializeOwned, Serialize};

use crate::error::Error;

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

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

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

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

impl<T: Serialize, U: DeserializeOwned> ConnectCodec for JsonConnectCodec<T, U> {
    type Encode = T;
    type Decode = U;
    type Encoder = JsonConnectEncoder<T>;
    type Decoder = JsonConnectDecoder<U>;

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

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

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

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

impl<T: Serialize> ConnectEncoder<T> for JsonConnectEncoder<T> {
    fn encode(&mut self, message: T, buf: &mut EncodeBuf) -> Result<(), Error> {
        serde_json::to_writer(&mut buf.writer(), &message)?;
        Ok(())
    }
}

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

impl<T: DeserializeOwned> ConnectDecoder<T> for JsonConnectDecoder<T> {
    fn decode(&mut self, buf: impl Buf) -> Result<T, Error> {
        Ok(serde_json::from_reader(buf.reader())?)
    }
}