use std::io::{Read, Write, Error};
use super::{
    decoder::{self, Decoder, DecodePlaceholderMap},
    encoder::{Encoder, EncodePlaceholderMap},
    invert_map,
    reader::{BinaryReader, is_eof_error},
    value::IOValue,
};

pub struct Codec {
    pub decode_placeholders: Option<DecodePlaceholderMap>,
    pub encode_placeholders: Option<EncodePlaceholderMap>,
}

impl Codec {
    pub fn new(decode_placeholders: DecodePlaceholderMap) -> Self {
        let encode_placeholders = Some(invert_map(&decode_placeholders));
        Codec { decode_placeholders: Some(decode_placeholders), encode_placeholders }
    }

    pub fn without_placeholders() -> Self {
        Codec { decode_placeholders: None, encode_placeholders: None }
    }

    pub fn decoder<'a, 'r, R: Read>(&'a self, read: &'r mut R) -> Decoder<'a, BinaryReader<'r, R>> {
        Decoder::new(BinaryReader::new(read), self.decode_placeholders.as_ref())
    }

    pub fn encoder<'a, 'w, W: Write>(&'a self, write: &'w mut W) -> Encoder<'w, 'a, W> {
        Encoder::new(write, self.encode_placeholders.as_ref())
    }

    pub fn decode_all<'r, R: Read>(&self, read: &'r mut R) -> decoder::Result<Vec<IOValue>> {
        let mut r = BinaryReader::new(read);
        let vs: Vec<IOValue> = Decoder::new(&mut r, self.decode_placeholders.as_ref())
            .collect::<decoder::Result<Vec<IOValue>>>()?;
        match r.peek() {
            Err(e) if is_eof_error(&e) => Ok(vs),
            Err(e) => Err(e),
            Ok(_) => Err(Error::new(std::io::ErrorKind::Other, "trailing bytes")),
        }
    }

    pub fn encode_bytes(&self, v: &IOValue) -> std::io::Result<Vec<u8>> {
        let mut buf: Vec<u8> = Vec::new();
        self.encoder(&mut buf).write(v)?;
        Ok(buf)
    }
}