use postcard::de_flavors::Flavor;
use postcard::Error;

pub struct ReadSingleError;

pub trait ReadSingle {
    fn read_single(&mut self) -> Result<u8, ReadSingleError>;
}

pub struct Seq<'de, R> {
    src: R,
    buf: &'de mut [u8]
}

impl<'de, R> Seq<'de, R> {
    fn new(src: R, buf: &'de mut [u8]) -> Self {
        Self {
            src,
            buf
        }
    }

    fn try_take_n_internal<'a>(&'a mut self, ct: usize) -> postcard::Result<&'de [u8]> where R: ReadSingle + 'de, 'a: 'de {
        for i in 0..ct {
            self.buf[i] = self.pop()?
        }

        let (used, unused)  = self.buf.split_at_mut(ct);
        self.buf = unused;

        Ok(used)
    }
}

impl<'de, R> Flavor<'de> for Seq<'de, R> where R: ReadSingle + 'de {
    type Remainder = &'de [u8];
    type Source = &'de [u8];

    fn pop(&mut self) -> postcard::Result<u8> {
        self.src.read_single().map_err(|_| Error::DeserializeUnexpectedEnd)
    }

    fn try_take_n(&mut self, ct: usize) -> postcard::Result<&'de [u8]> {
        self.try_take_n_internal(ct)
    }

    fn finalize(self) -> postcard::Result<Self::Remainder> {
        todo!()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{to_stdvec_magic, InfoMem, de::Magic};

    use postcard::Deserializer;
    use serde::Deserialize;

    impl<'de> ReadSingle for &'de [u8] {
        fn read_single(&mut self) -> Result<u8, ReadSingleError> {
            let byte = *self.get(0).ok_or(ReadSingleError)?;
            *self = &self[1..];

            Ok(byte)
        }
    }

    #[test]
    fn test_seq_deser() {
        let mut im: InfoMem = InfoMem::default();
        im.user = Some(b"test data");

        let mut buf = [0; 127];
        let ser = to_stdvec_magic(&im).unwrap();

        let seq = Seq::new(&*ser, &mut buf);
        let magic = Magic::try_new(seq).unwrap();
        let mut de_magic = Deserializer::from_flavor(magic);
        let im_de = InfoMem::<&[u8]>::deserialize(&mut de_magic).unwrap();

        assert_eq!(im, im_de);
    }
}