use std::ops::{Deref, DerefMut};

use peanuts::{Reader, Writer};
use tokio::io::{AsyncRead, AsyncWrite, ReadHalf, WriteHalf};

use crate::Error;

use super::{JabberReader, JabberStream, JabberWriter};

pub struct BoundJabberStream<S>(JabberStream<S>);

impl<S> Deref for BoundJabberStream<S>
where
    S: AsyncWrite + AsyncRead + Unpin + Send,
{
    type Target = JabberStream<S>;

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

impl<S> DerefMut for BoundJabberStream<S>
where
    S: AsyncWrite + AsyncRead + Unpin + Send,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<S> BoundJabberStream<S> {
    pub fn split(self) -> (BoundJabberReader<S>, BoundJabberWriter<S>) {
        let (reader, writer) = self.0.split();
        (BoundJabberReader(reader), BoundJabberWriter(writer))
    }
}

pub struct BoundJabberReader<S>(JabberReader<S>);

impl<S> BoundJabberReader<S> {
    pub fn unsplit(self, writer: BoundJabberWriter<S>) -> BoundJabberStream<S> {
        BoundJabberStream(self.0.unsplit(writer.0))
    }
}

impl<S> std::ops::Deref for BoundJabberReader<S> {
    type Target = JabberReader<S>;

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

impl<S> std::ops::DerefMut for BoundJabberReader<S> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

pub struct BoundJabberWriter<S>(JabberWriter<S>);

impl<S> BoundJabberWriter<S> {
    pub fn unsplit(self, reader: BoundJabberReader<S>) -> BoundJabberStream<S> {
        BoundJabberStream(self.0.unsplit(reader.0))
    }
}

impl<S> std::ops::Deref for BoundJabberWriter<S> {
    type Target = JabberWriter<S>;

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

impl<S> std::ops::DerefMut for BoundJabberWriter<S> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<S> JabberStream<S>
where
    S: AsyncWrite + AsyncRead + Unpin + Send,
{
    pub fn to_bound_jabber(self) -> BoundJabberStream<S> {
        BoundJabberStream(self)
    }
}