use std;
use std::iter::{Iterator, IntoIterator, FromIterator};

use {Result, ErrorKind, Read, BufRead};

/// An iterator over `u8` values of a reader.
///
/// This struct is generally created by calling `bytes()` on a buffered reader.
/// Please see the documentation of [`BufRead::bytes`] for more details.
///
/// [`BufRead::bytes`]: ./trait.BufRead.html#method.bytes
pub struct Bytes<R> {
    inner: R,
}

impl<R> Bytes<R> {
    pub fn new(inner: R) -> Bytes<R> { Bytes { inner: inner } }
}

impl<R: std::io::BufRead> Iterator for Bytes<R> {
    type Item = Result<u8>;

    fn next(&mut self) -> Option<Result<u8>> {
        let result = match self.inner.fill_buf() {
            Ok(buf) if buf.len() == 0 => None,
            Ok(buf) => Some(Ok(buf[0])),
            Err(e) => Some(Err(e)),
        };
        self.inner.consume(1);
        result
    }
}

/// An iterator over the contents of an instance of `BufRead` split on a
/// particular byte.
///
/// This struct is generally created by calling `split()` on a
/// `BufRead`. Please see the documentation of [`BufRead::split`] for more details.
///
/// [`BufRead::split`]: ./trait.BufRead.html#method.split
pub struct Split<B> {
    reader: B,
    delim: u8,
    buf: Vec<u8>,
}

impl<I> Split<I> {
    pub fn new(reader: I, delim: u8) -> Split<I> {
        Split { reader: reader, delim: delim, buf: Vec::new() }
    }
}

impl<B: BufRead> Iterator for Split<B> {
    type Item = Result<Vec<u8>>;

    fn next(&mut self) -> Option<Result<Vec<u8>>> {
        match BufRead::read_until(&mut self.reader, self.delim, &mut self.buf) {
            Ok(()) => {
                self.buf.pop();
            }
            Err(ref e) if e.kind() == ErrorKind::UnexpectedEof => {
                if self.buf.is_empty() {
                    return None;
                }
            }
            Err(e) => return Some(Err(e)),
        }
        let mut result = Vec::new();
        std::mem::swap(&mut self.buf, &mut result);
        Some(Ok(result))
    }
}

/// A reader adapter over an iterator of readers
///
/// This adapter is a generalization of `std::io::Chain`.
///
/// This struct is generally created by calling `collect::<Collect<_>>()` on an iterator of
/// readers. Please see the documentation of [`collect`] for more details.
///
/// [`collect`]: https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.collect
pub struct Collect<R> {
    vec: Vec<R>,
}

impl<R: Read> Read for Collect<R> {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        while !self.vec.is_empty() {
            match try!(self.vec[0].read(buf)) {
                0 => {
                    self.vec.remove(0);
                }
                n => return Ok(n),
            }
        }
        Ok(0)
    }
}

impl<R: Read> std::io::Read for Collect<R> {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> { Read::read(self, buf) }
}

impl<R: BufRead> BufRead for Collect<R> {
    fn fill_buf(&mut self) -> Result<&[u8]> {
        while !self.vec.is_empty() {
            if try!(self.vec[0].fill_buf()).len() == 0 {
                self.vec.remove(0);
            } else {
                return self.vec[0].fill_buf();
            }
        }
        Ok(&[])
    }

    fn consume(&mut self, amt: usize) {
        if !self.vec.is_empty() {
            self.vec[0].consume(amt)
        }
    }
}

impl<R: BufRead> std::io::BufRead for Collect<R> {
    fn fill_buf(&mut self) -> Result<&[u8]> { BufRead::fill_buf(self) }

    fn consume(&mut self, amt: usize) { BufRead::consume(self, amt) }
}

impl<R> FromIterator<R> for Collect<R> {
    fn from_iter<II: IntoIterator<Item = R>>(iter: II) -> Self {
        Collect { vec: iter.into_iter().collect() }
    }
}

#[cfg(test)]
mod tests {
    use std::io;
    use std::iter::Iterator;
    use {BufRead, Collect};

    #[test]
    fn split() {
        let buf = io::Cursor::new(&b"12"[..]);
        let mut s = buf.split(b'3');
        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
        assert!(s.next().is_none());

        let buf = io::Cursor::new(&b"1233"[..]);
        let mut s = buf.split(b'3');
        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
        assert_eq!(s.next().unwrap().unwrap(), vec![]);
        assert!(s.next().is_none());
    }

    fn cmp_bufread<Br1: io::BufRead, Br2: io::BufRead>(mut br1: Br1, mut br2: Br2, exp: &[u8]) {
        let mut cat = Vec::new();
        loop {
            let consume = {
                let buf1 = br1.fill_buf().unwrap();
                let buf2 = br2.fill_buf().unwrap();
                let minlen = if buf1.len() < buf2.len() { buf1.len() } else { buf2.len() };
                assert_eq!(buf1[..minlen], buf2[..minlen]);
                cat.extend_from_slice(&buf1[..minlen]);
                minlen
            };
            if consume == 0 {
                break;
            }
            br1.consume(consume);
            br2.consume(consume);
        }
        assert_eq!(br1.fill_buf().unwrap().len(), 0);
        assert_eq!(br2.fill_buf().unwrap().len(), 0);
        assert_eq!(&cat[..], &exp[..])
    }

    #[test]
    fn collect_bufread() {
        let testdata = b"ABCDEFGHIJKL";
        let mut chain1 = [&testdata[..3],
                          &testdata[3..6],
                          &testdata[6..9],
                          &testdata[9..]];
        let mut chain2 = [&testdata[..4], &testdata[4..8], &testdata[8..]];
        let chain1 = chain1.iter_mut().collect::<Collect<_>>();
        let chain2 = chain2.iter_mut().collect::<Collect<_>>();
        cmp_bufread(chain1, chain2, &testdata[..]);
    }
}