//! mockstream module
use std::io;
use std::io::{Cursor, Read, Seek, SeekFrom, Write};

use futures::Poll;
use tokio_io::{AsyncRead, AsyncWrite};

/// a mockstream that reads and writes from the same buffer
/// see tests for example usage
#[derive(Debug)]
pub struct MockStream {
    buf: Cursor<Vec<u8>>,
    read_from: u64,
}

impl MockStream {
    /// creates an empty MockStream
    pub fn new() -> MockStream {
        MockStream {
            buf: Cursor::new(Vec::new()),
            read_from: 0,
        }
    }
}

impl From<Vec<u8>> for MockStream {
    fn from(buf: Vec<u8>) -> MockStream {
        MockStream {
            buf: Cursor::new(buf),
            read_from: 0,
        }
    }
}

impl Read for MockStream {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        self.buf.seek(SeekFrom::Start(self.read_from)).unwrap();
        let read = self.buf.read(buf).unwrap();
        self.read_from += read as u64;
        Ok(read)
    }
}

impl Write for MockStream {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.buf.seek(SeekFrom::End(0)).unwrap();
        self.buf.write(buf)
    }

    fn flush(&mut self) -> io::Result<()> {
        self.buf.flush()
    }
}

impl AsyncRead for MockStream {}

impl AsyncWrite for MockStream {
    fn shutdown(&mut self) -> Poll<(), io::Error> {
        self.buf.shutdown()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_write() {
        let mut mockstream = MockStream::new();
        let buf = [1, 2, 3, 4, 5];
        let write = mockstream.write(&buf).unwrap();
        mockstream.flush().unwrap();
        assert_eq!(write, 5);
    }

    #[test]
    fn test_read() {
        let mut mockstream = MockStream::from(vec![1, 2, 3, 4, 5]);
        let mut buf = [0; 5];
        let read = mockstream.read(&mut buf).unwrap();
        assert_eq!(buf.len(), 5);
        assert_eq!(read, 5);
    }
}