use crate::message::backend::BackendMessage;
use crate::reader::oneway::OneWayProtoReader;
use async_trait::async_trait;

#[async_trait]
pub trait BackendProtoReader: OneWayProtoReader<BackendMessage> {}

#[async_trait]
impl<R> BackendProtoReader for R where R: OneWayProtoReader<BackendMessage> {}

#[cfg(test)]
mod tests {
    use crate::message::backend::{
        AuthenticationOkData, BackendKeyDataData, BackendMessage, CommandCompleteData,
    };
    use crate::reader::oneway::OneWayProtoReader;
    use crate::reader::protoreader::ProtoReader;
    use std::io::Cursor;
    use tokio::io::{AsyncBufReadExt, BufReader};

    #[tokio::test]
    async fn test_message_sequence() {
        let data = [
            b'R', 0, 0, 0, 8, 0, 0, 0, 123, b'K', 0, 0, 0, 12, 0, 0, 0, 111, 0, 0, 0, 222, b'C', 0,
            0, 0, 8, b'A', b'B', b'C', 0,
        ];

        let reader = BufReader::new(Cursor::new(&data));
        let mut reader = ProtoReader::new(reader, 1024);

        let msg = reader.read_proto().await;
        assert!(matches!(
            msg,
            Ok(BackendMessage::AuthenticationOk(AuthenticationOkData {
                status: 123
            }))
        ));

        let msg = reader.read_proto().await;
        assert!(matches!(
            msg,
            Ok(BackendMessage::BackendKeyData(BackendKeyDataData {
                process: 111,
                secret: 222
            }))
        ));

        let msg = reader.read_proto().await;
        assert!(match msg {
            Ok(BackendMessage::CommandComplete(CommandCompleteData { tag })) =>
                tag.as_str() == "ABC",
            _ => false,
        });

        let rest = reader.inner.fill_buf().await.unwrap();
        assert!(rest.is_empty());
    }
}