use super::reader::{Reader, is_eof_error};
use super::value::{NestedValue, Domain};

pub use super::reader::{Error, Result, DecodePlaceholderMap};

pub struct Decoder<'a, R: Reader, N: NestedValue<Dom>, Dom: Domain> {
    pub read: R,
    placeholders: Option<&'a DecodePlaceholderMap<N, Dom>>,
    read_annotations: bool,
}

impl<'a, R: Reader, N: NestedValue<D>, D: Domain> Decoder<'a, R, N, D> {
    pub fn new(read: R, placeholders: Option<&'a DecodePlaceholderMap<N, D>>) ->
        Self
    {
        Decoder {
            read,
            placeholders,
            read_annotations: true,
        }
    }

    pub fn set_read_annotations(&mut self, read_annotations: bool) {
        self.read_annotations = read_annotations
    }

    pub fn next_or_err(&mut self) -> Result<N> {
        self.read.next(self.placeholders, self.read_annotations)
    }
}

impl<'a, R: Reader, N: NestedValue<D>, D: Domain> std::iter::Iterator for Decoder<'a, R, N, D> {
    type Item = Result<N>;
    fn next(&mut self) -> Option<Self::Item> {
        match self.next_or_err() {
            Err(e) if is_eof_error(&e) => None,
            other => Some(other)
        }
    }
}