//! Sending and receiving slices of bytes.
//!
//! ## Example usage from a std crate
//!
//! See the `decode_*` and `encode_*` functions for simple uses with
//! various input and output types.
//!
//! The `Sender` struct writes encoded payloads to an
//! inner `std::io::Write` instance, and the `Receiver` struct reads
//! and decodes payloads from an inner `std::io::Read` instance.
//!
//! ```rust
//! # use framed::*;
//! # use framed::bytes::*;
//! # use std::io::Cursor;
//! #
//! let mut config = Config::default();
//!
//! let payload = [1, 2, 3];
//!
//! let mut encoded = vec![];
//! {
//!     let mut sender = config.clone().to_sender(&mut encoded);
//!     sender.send(&payload).expect("send ok");
//! }
//!
//! // `encoded` now contains the encoded frame.
//!
//! let mut receiver = config.clone().to_receiver(Cursor::new(encoded));
//! let decoded = receiver.recv().expect("recv ok");
//!
//! assert_eq!(payload, *decoded);
//! ```
//!
//! ## Example usage from a `no_std` crate
//!
//! The `encode_to_slice` and `decode_from_slice` functions offer an
//! API for `no_std` crates that do not have a heap allocator
//! available and cannot use `std::io::Read` or `std::io::Write`.
//!
//! ```rust
//! # use framed::*;
//! # use framed::bytes::*;
//! #
//! let mut codec = Config::default().to_codec();
//!
//! // In a no_std crate without dynamic memory allocation we would typically
//! // know the maximum payload length, which we can use for payload buffers.
//! const MAX_PAYLOAD_LEN: usize = 10;
//!
//! // The maximum payload length implies a maximum encoded frame length,
//! // which we can use for frame buffers.
//! //
//! // Using a calculated frame buffer length like this requires
//! // const fn, which is currently unstable and only available on nightly rust.
//! // Enable cargo feature flag "use_nightly" to use it.
//! const MAX_FRAME_LEN: usize = max_encoded_len(MAX_PAYLOAD_LEN);
//!
//! let payload: [u8; 3] = [1, 2, 3];
//! assert!(payload.len() <= MAX_PAYLOAD_LEN);
//!
//! let mut encoded_buf = [0u8; MAX_FRAME_LEN];
//! let encoded_len = codec.encode_to_slice(&payload, &mut encoded_buf)
//!                        .expect("encode ok");
//! let encoded = &encoded_buf[0..encoded_len];
//!
//! // `encoded` now contains the encoded frame.
//!
//! let mut decoded_buf = [0u8; MAX_PAYLOAD_LEN];
//! let decoded_len = codec.decode_to_slice(&encoded, &mut decoded_buf)
//!                        .expect("decode ok");
//! let decoded = &decoded_buf[0..decoded_len];
//!
//! assert_eq!(payload, *decoded);
//! ```
//!

// ## use statements
use ::{Payload, Encoded, FRAME_END_SYMBOL};
#[cfg(feature = "use_std")]
use ::{BoxPayload, BoxEncoded};
use ::checksum::MAX_CHECKSUM_LEN;
use ::error::{Error, Result};
use ::typed;
use cobs;
use serde::Serialize;
use serde::de::DeserializeOwned;

#[cfg(feature = "use_std")]
use ref_slice::ref_slice_mut;

#[cfg(feature = "use_std")]
use std::io::{self, Read, Write};

pub use ::checksum::Checksum;

/// Contains methods for encoding and decoding byte slices with a
/// specific configuration.
///
/// Construct an instance from a `Config` instance with the
/// `Config::to_codec` method.
pub struct Codec {
    config: Config
}

/// Configurable options for encoding and decoding byte slices using a
/// builder pattern.
///
/// Construct an instance with `Config::default()`.
#[derive(Clone, Debug, Default)]
pub struct Config {
    checksum: Checksum,
}

impl Config {
    /// Construct a `Codec` instance with this configuration.
    pub fn to_codec(&mut self) -> Codec {
        Codec {
            config: self.clone(),
        }
    }

    #[cfg(feature = "use_std")]
    /// Construct a `Receiver` instance with this configuration.
    pub fn to_receiver<R: Read>(&mut self, r: R) -> Receiver<R> {
        Receiver::<R> {
            codec: self.to_codec(),
            r,
        }
    }

    #[cfg(feature = "use_std")]
    /// Construct a `Sender` instance with this configuration.
    pub fn to_sender<W: Write>(&mut self, w: W) -> Sender<W> {
        Sender::<W> {
            codec: self.to_codec(),
            w,
        }
    }

    /// Construct a `framed::typed::Config` instance to encode and decode a
    /// serializable type `T` with this byte encoding configuration.
    pub fn typed<T: DeserializeOwned + Serialize>(&mut self) -> typed::Config<T> {
        typed::Config::<T>::new(self)
    }

    /// Get the current checksum configuration.
    #[must_use] pub fn checksum(&self) -> &Checksum {
        &self.checksum
    }

    /// Set the checksum configuration.
    pub fn set_checksum(&mut self, checksum: Checksum) -> &mut Self {
        self.checksum = checksum;
        self
    }
}

const MAX_FRAMING_LEN: usize = MAX_CHECKSUM_LEN + 1;

impl Codec {
    fn checksum(&self) -> &Checksum {
        &self.config.checksum
    }

    fn min_frame_len(&self) -> usize {
        self.checksum().len()
        + 1 // sentinel length
    }

    /// Encode the supplied payload data as a frame at the beginning of
    /// the supplied buffer `dest`. Available from `no_std` crates.
    ///
    /// Returns the number of bytes it has written to the buffer.
    ///
    /// # Panics
    ///
    /// This function will panic if `dest` is not large enough for the encoded frame.
    /// Ensure `dest.len() >= max_encoded_len(p.len())`.
    pub fn encode_to_slice(&mut self, p: &Payload, dest: &mut Encoded)
    -> Result<usize> {
        // Panic if encoded frame won't fit in `dest` because this is a
        // programmer error.
        assert!(max_encoded_len(p.len()) <= dest.len());

        #[cfg(feature = "trace")] {
            println!("framed::encode: Payload = {:?}", p);
        }

        let checksum_type = self.checksum();
        let checksum_value = checksum_type.calculate(p);

        let cobs_len = {
            let mut cobs_enc = cobs::CobsEncoder::new(dest);
            cobs_enc.push(p)
                    .map_err(|()| Error::CobsEncodeFailed)?;
            if checksum_value.len() > 0 {
                cobs_enc.push(&checksum_value)
                        .map_err(|()| Error::CobsEncodeFailed)?;
            }
            let cobs_len = cobs_enc.finalize()
                                   .map_err(|()| Error::CobsEncodeFailed)?;
            // make sure sentinel is not in output buffer
            for x in &mut dest[..cobs_len] {
                *x ^= FRAME_END_SYMBOL;
            }
            cobs_len
        };
        dest[cobs_len] = FRAME_END_SYMBOL;

        // len is cobs_len + len(FRAME_END_SYMBOL)
        let len = cobs_len + 1;
        #[cfg(feature = "trace")] {
            println!("framed::encode: Frame = {:?}", &dest[0..len]);
        }
        Ok(len)
    }

    /// Encode the supplied payload data as a frame and return it on the heap.
    #[cfg(feature = "use_std")]
    pub fn encode_to_box(&mut self, p: &Payload) -> Result<BoxEncoded> {
        let mut buf = vec![0; max_encoded_len(p.len())];
        let len = self.encode_to_slice(p, &mut buf)?;
        buf.truncate(len);
        Ok(BoxEncoded::from(buf))
    }

    /// Encode the supplied payload data as a frame and write it to the
    /// supplied `Write`.
    ///
    /// This function will not call `flush` on the writer; the caller must do
    /// so if this is required.
    ///
    /// Returns the length of the frame it has written.
    #[cfg(feature = "use_std")]
    pub fn encode_to_writer<W: Write>(&mut self, p: &Payload, w: &mut W)
    -> Result<usize> {
        let b = self.encode_to_box(p)?;
        w.write_all(&b.0)?;
        Ok(b.len())
    }

    /// Decode the supplied encoded frame, placing the payload at the
    /// beginning of the supplied buffer `dest`. Available from `no_std` crates.
    ///
    /// When reading from a stream, the caller can continue reading data
    /// and buffering it until a `FRAME_END_SYMBOL` is read, then pass the
    /// whole buffer including `FRAME_END_SYMBOL` to this function for
    /// decoding.
    ///
    /// If there is more than 1 `FRAME_END_SYMBOL` within `e`, the result
    /// is undefined. Make sure you only pass 1 frame at a time.
    ///
    /// Returns the length of the payload it has decoded.
    ///
    /// # Errors
    ///
    /// Returns `Err(Error::EofDuringFrame`) if `e` contains >= 1 bytes of
    /// a frame, but not a complete frame. A complete frame should have
    /// `FRAME_END_SYMBOL` as the last byte.
    ///
    /// Returns `Err(Error::EofBeforeFrame`) if `e.len()` is 0.
    ///
    /// # Panics
    ///
    /// This function will panic if `dest` is not large enough for the decoded frame.
    /// Ensure `dest.len() >= e.len()`.
    pub fn decode_to_slice(&mut self, e: &Encoded, dest: &mut [u8])
    -> Result<usize> {
        #[cfg(feature = "trace")] {
            println!("framed::decode: Encoded = {:?}", e);
        }

        if e.is_empty() {
            return Err(Error::EofBeforeFrame);
        }

        if e.len() < self.min_frame_len() {
            return Err(Error::EofDuringFrame);
        }

        if e[e.len()-1] != FRAME_END_SYMBOL {
            return Err(Error::EofDuringFrame)
        }

        assert!(dest.len() >= max_decoded_len(e.len()));
        assert_eq!(e[e.len() - 1], FRAME_END_SYMBOL);

        let cobs_payload = &e[0..e.len() - 1];
        let cobs_decoded_len =
            if cobs_payload.is_empty() {
                0
            } else {
                cobs::decode_with_sentinel(cobs_payload, dest, FRAME_END_SYMBOL)
                    .map_err(|()| Error::CobsDecodeFailed)?
            };
        let cobs_decoded = &dest[0..cobs_decoded_len];
        if cobs_decoded_len < self.checksum().len() {
            return Err(Error::EofDuringFrame);
        }
        let payload = &cobs_decoded[0..cobs_decoded_len - self.checksum().len()];

        #[cfg(feature = "trace")] {
            println!("framed::decode: cobs_decoded = {:?}",
                     cobs_decoded);
            println!("framed::decode: payload = {:?}",
                     payload);
        }

        let checksum = self.checksum();
        let calc_checksum = checksum.calculate(payload);
        let recv_checksum = &cobs_decoded[payload.len() .. payload.len() + checksum.len()];

        #[cfg(feature = "trace")] {
            println!("framed::decode: calc_checksum = {:?}\n\
                      framed::decode: recv_checksum = {:?}",
                     calc_checksum, recv_checksum);
        }

        if &*calc_checksum != recv_checksum {
            return Err(Error::ChecksumError);
        }

        Ok(payload.len())
    }

    /// Decode the supplied encoded frame, returning the payload on the heap.
    #[cfg(feature = "use_std")]
    pub fn decode_to_box(&mut self, e: &Encoded) -> Result<BoxPayload> {
        if e.is_empty() {
            return Err(Error::EofBeforeFrame);
        }
        let mut buf = vec![0; max_decoded_len(e.len())];
        let len = self.decode_to_slice(e, &mut buf)?;
        buf.truncate(len);
        Ok(BoxPayload::from(buf))
    }

    /// Reads bytes from the supplied `Read` until it has a complete
    /// encoded frame, then decodes the frame, returning the payload on the heap.
    #[cfg(feature = "use_std")]
    pub fn decode_from_reader<R: Read>(&mut self, r: &mut dyn Read)
    -> Result<BoxPayload> {
        // Read until FRAME_END_SYMBOL
        let mut next_frame = Vec::new();
        let mut b = 0u8;
        loop {
            let res = r.read(ref_slice_mut(&mut b));
            #[cfg(feature = "trace")] {
                println!("framed: Read result = {:?}", res);
            }
            match res {
                // In the 2 EOF cases defer to decode_to_box to return the
                // correct error (EofBeforeFrame or EofDuringFrame).
                Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof =>
                    return self.decode_to_box(&next_frame),
                Ok(0) =>
                    return self.decode_to_box(&next_frame),

                Err(e) => return Err(Error::from(e)),
                Ok(1) => (),
                Ok(_) => unreachable!(),
            };

            #[cfg(feature = "trace")] {
                println!("framed: Read byte = {}", b);
            }
            next_frame.push(b);
            if b == FRAME_END_SYMBOL {
                break;
            }
        }
        assert_eq!(next_frame[next_frame.len()-1], FRAME_END_SYMBOL);

        self.decode_to_box(&next_frame)
    }
} // End of impl Codec.

const_fn! {
    /// Returns an upper bound for the decoded length of the payload
    /// within a frame with the encoded length supplied.
    ///
    /// Useful for calculating an appropriate buffer length.
    pub fn max_decoded_len(code_len: usize) -> usize {
        // This is an over-estimate of the required decoded buffer, but
        // wasting MAX_HEADER_LEN + MAX_FOOTER_LEN bytes should be acceptable and
        // we can calculate this trivially in a const fn.
        code_len
    }
}

const_fn! {
    /// Returns an upper bound for the encoded length of a frame with
    /// the payload length supplied.
    ///
    /// Useful for calculating an appropriate buffer length.
    pub fn max_encoded_len(payload_len: usize) -> usize {
        MAX_FRAMING_LEN
            + cobs_max_encoded_len(payload_len)
    }
}

const_fn! {
    /// Copied from `cobs` crate and modified to make a `const` version.
    ///
    /// Source: https://github.com/awelkie/cobs.rs/blob/f8ff1ad2aa7cd069a924d75170d3def3fa6df10b/src/lib.rs#L183-L188
    ///
    /// TODO: Submit a PR to `cobs` to make `cobs::max_encoding_length` a `const fn`.
    ///       Issue for this: https://github.com/fluffysquirrels/framed-rs/issues/19
    fn cobs_max_encoded_len(payload_len: usize) -> usize {
        payload_len
            + (payload_len / 254)

            // This `+ 1` was
            // `+ if payload_len % 254 > 0 { 1 } else { 0 }` in cobs.rs,
            // but that won't compile in a const fn. `1` is less than both the
            // values in the if and else branches, so use that instead, with the
            // acceptable cost of allocating 1 byte more than required some of the
            // time.
            + 1
    }
}

/// Sends encoded frames over an inner `std::io::Write` instance.
///
/// Construct an instance using the method `Config::to_sender`
#[cfg(feature = "use_std")]
pub struct Sender<W: Write> {
    codec: Codec,
    w: W,
}

#[cfg(feature = "use_std")]
impl<W: Write> Sender<W> {
    /// Consume this `Sender` and return the inner `std::io::Write`.
    pub fn into_inner(self) -> W {
        self.w
    }

    /// Flush all buffered data. Includes calling `flush` on the inner
    /// writer.
    pub fn flush(&mut self) -> Result<()> {
        Ok(self.w.flush()?)
    }

    /// Queue the supplied payload for transmission.
    ///
    /// This `Sender` may buffer the data indefinitely, as may the
    /// inner writer. To ensure all buffered data has been
    /// transmitted call [`flush`](#method.flush).
    ///
    /// See also: [`send`](#method.send)
    pub fn queue(&mut self, p: &Payload) -> Result<usize> {
        self.codec.encode_to_writer(p, &mut self.w)
    }

    /// Encode the supplied payload as a frame, write it to the
    /// inner writer, then flush.
    ///
    /// Ensures the data has been transmitted before returning to the
    /// caller.
    ///
    /// See also: [`queue`](#method.queue)
    pub fn send(&mut self, p: &Payload) -> Result<usize> {
        let len = self.queue(p)?;
        self.flush()?;
        Ok(len)
    }
}

/// Receives encoded frames from an inner `std::io::Read` instance.
///
/// Construct an instance using the method `Config::to_receiver`
#[cfg(feature = "use_std")]
pub struct Receiver<R: Read> {
    codec: Codec,
    r: R,
}

#[cfg(feature = "use_std")]
impl<R: Read> Receiver<R> {
    /// Consume this `Receiver` and return the inner `io::Read`.
    pub fn into_inner(self) -> R {
        self.r
    }

    /// Receive an encoded frame from the inner `io::Read`, decode it
    /// and return the payload.
    pub fn recv(&mut self) -> Result<BoxPayload> {
        self.codec.decode_from_reader::<R>(&mut self.r)
    }
}

#[cfg(test)]
mod tests {
    #[cfg(feature = "use_std")]
    use std::io::Cursor;
    use super::*;

    #[test]
    fn max_encoded_len_ok() {
        assert_eq!(max_encoded_len(0)  , 4);
        assert_eq!(max_encoded_len(1)  , 5);
        assert_eq!(max_encoded_len(2)  , 6);
        assert_eq!(max_encoded_len(254), 259);
        assert_eq!(max_encoded_len(255), 260);
    }

    #[test]
    fn max_decoded_len_ok() {
        assert_eq!(max_decoded_len(0)  , 0);
        assert_eq!(max_decoded_len(1)  , 1);
        assert_eq!(max_decoded_len(2)  , 2);
        assert_eq!(max_decoded_len(3)  , 3);
        assert_eq!(max_decoded_len(255), 255);
    }

    fn codec() -> Codec {
        Config::default().to_codec()
    }

    // A test payload.
    const PAYLOAD: [u8; PAYLOAD_LEN] = [0, 1, 2, 3];
    const PAYLOAD_LEN: usize = 4;

    const ENCODED_LEN: usize = 9;

    /// Returns an encoded frame with payload PAYLOAD.
    fn encoded_payload(buf: &mut [u8; ENCODED_LEN]) -> &[u8] {
        let len = codec().encode_to_slice(&PAYLOAD, buf).unwrap();
        &buf[0..len]
    }

    fn assert_payload_eq(encoded: &Encoded, payload: &Payload) {
        #[cfg(feature = "use_std")] {
            println!("assert_payload_eq \n\
                      -  encoded = {encoded:?}\n\
                      -  payload = {payload:?}");
        }
        let mut decoded_buf = [0; 100];
        let len = codec().decode_to_slice(encoded, &mut decoded_buf).unwrap();
        let decoded = &decoded_buf[0..len];
        assert_eq!(decoded, payload);
    }

    #[test]
    #[should_panic]
    fn encode_to_slice_dest_too_small() {
        let mut encoded_buf = [0u8; PAYLOAD_LEN];
        let _ = codec().encode_to_slice(&PAYLOAD, &mut encoded_buf);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn encode_to_slice_ok_dynamic_dest() {
        let mut encoded_buf = vec![0u8; max_encoded_len(PAYLOAD.len())];
        let len = codec().encode_to_slice(&PAYLOAD, &mut encoded_buf).unwrap();
        let encoded = &encoded_buf[0..len];

        assert_payload_eq(encoded, &PAYLOAD);
    }

    // use_nightly required for statically allocated buffer
    #[test]
    #[cfg(feature = "use_nightly")]
    fn encode_to_slice_ok_static_dest() {
        let mut encoded_buf = [0u8; max_encoded_len(PAYLOAD_LEN)];
        let len = codec().encode_to_slice(&PAYLOAD, &mut encoded_buf).unwrap();
        let encoded = &encoded_buf[0..len];

        assert_payload_eq(encoded, &PAYLOAD);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn encode_to_writer_ok() {
        let mut encoded = vec![];
        codec().encode_to_writer(&PAYLOAD, &mut encoded).unwrap();
        assert_payload_eq(&encoded, &PAYLOAD);
    }

    #[test]
    #[should_panic]
    fn decode_to_slice_dest_too_small() {
        let mut buf = [0; ENCODED_LEN];
        let encoded = encoded_payload(&mut buf);
        let mut decoded_buf = [0u8; PAYLOAD_LEN - 1];
        let _ = codec().decode_to_slice(encoded, &mut decoded_buf);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_slice_ok_dynamic_dest() {
        let encoded = codec().encode_to_box(&PAYLOAD).unwrap();
        let mut decoded_buf = vec![0u8; max_decoded_len(encoded.len())];
        let len = codec().decode_to_slice(&encoded, &mut decoded_buf).unwrap();
        let decoded = &decoded_buf[0..len];

        assert_eq!(&PAYLOAD, decoded);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_slice_no_end_symbol() {
        let encoded = vec![FRAME_END_SYMBOL + 1; max_encoded_len(0)];
        let mut decoded_buf = [];
        let res = codec().decode_to_slice(&encoded, &mut decoded_buf);

        match res {
            Err(Error::EofDuringFrame) => (),
            _ => panic!("Bad output: {:?}", res),
        }
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_slice_encoded_too_short() {
        let mut c = codec();
        let encoded = vec![FRAME_END_SYMBOL; c.min_frame_len() - 1];
        let mut decoded_buf = [];
        let res = c.decode_to_slice(&encoded, &mut decoded_buf);

        match res {
            Err(Error::EofDuringFrame) => (),
            _ => panic!("Bad output: {:?}", res),
        }
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_slice_encoded_empty() {
        let encoded = vec![];
        let mut decoded_buf = [];
        let res = codec().decode_to_slice(&encoded, &mut decoded_buf);

        match res {
            Err(Error::EofBeforeFrame) => (),
            _ => panic!("Bad output: {:?}", res),
        }
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_slice_bad_checksum() {
        let mut c = codec();
        let encoded = c.encode_to_box(&PAYLOAD).unwrap();
        let mut encoded = Vec::from(&*encoded);
        let checksum_offset = encoded.len() - c.checksum().len() - 1;

        {
            let checksum =
                &mut encoded[checksum_offset..
                             (checksum_offset + c.config.checksum.len())];
            checksum[0] = checksum[0].wrapping_add(1);
            checksum[1] = checksum[1].wrapping_add(2);
        }

        let mut decoded_buf = vec![0u8; max_decoded_len(encoded.len())];
        let res = codec().decode_to_slice(&encoded, &mut decoded_buf);

        match res {
            Err(Error::ChecksumError) => (),
            _ => panic!("Bad output: {:?}", res),
        }
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_slice_missing_bytes() {
        let encoded = codec().encode_to_box(&PAYLOAD).unwrap();
        let encoded = &encoded[1..encoded.len()];

        let mut decoded_buf = vec![0u8; max_decoded_len(encoded.len())];
        let res = codec().decode_to_slice(encoded, &mut decoded_buf);

        match res {
            Err(Error::ChecksumError) => (),
            _ => panic!("Bad output: {:?}", res),
        }
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_box_ok() {
        let encoded = codec().encode_to_box(&PAYLOAD).unwrap();
        let decoded = codec().decode_to_box(&encoded).unwrap();

        assert_eq!(&PAYLOAD, &*decoded);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_to_box_extra_byte_in_front() {
        let encoded = codec().encode_to_box(&PAYLOAD).unwrap();
        let encoded_with_extra_in_front = [&[3], &*encoded].concat();
        let decoded = codec().decode_to_box(&encoded_with_extra_in_front);
        assert!(decoded.is_err());
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn decode_from_reader_ok() {
        let mut c = codec();
        let encoded = c.encode_to_box(&PAYLOAD).unwrap();
        let mut reader = Cursor::new(&*encoded);
        let decoded = c.decode_from_reader::<Cursor<&[u8]>>(&mut reader).unwrap();
        assert_eq!(&*decoded, &PAYLOAD);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn roundtrip_default_config() {
        roundtrip_case(&mut Config::default()
                                   .to_codec(),
                       &PAYLOAD);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn roundtrip_no_checksum() {
        roundtrip_case(&mut Config::default()
                               .set_checksum(Checksum::None)
                               .to_codec(),
                       &PAYLOAD);
    }

    #[test]
    #[cfg(feature = "use_std")]
    fn roundtrip_empty_payload() {
        roundtrip_case(&mut Config::default()
                                   .to_codec(),
                       &[]);
    }

    #[cfg(feature = "use_std")]
    fn roundtrip_case(c: &mut Codec, payload: &Payload) {
        let encoded = c.encode_to_box(payload);
        println!("encoded: {encoded:?}");
        let encoded = encoded.unwrap();
        let decoded = c.decode_to_box(&encoded);
        println!("decoded: {decoded:?}");
        let decoded = decoded.unwrap();
        assert_eq!(&*decoded, payload);
    }
}

#[cfg(all(test, feature = "use_std"))]
mod rw_tests {
    use channel::Channel;
    use error::Error;
    use std::io::{Read, Write};
    use super::*;

    #[test]
    fn one_frame() {
        let (mut tx, mut rx) = pair();
        let p = [0x00, 0x01, 0x02];
        tx.send(&p).unwrap();
        let recvd = rx.recv().unwrap();
        assert_eq!(*recvd, p);
    }

    #[test]
    fn two_frames_sequentially() {
        let (mut tx, mut rx) = pair();
        {
            let sent = [0x00, 0x01, 0x02];
            tx.send(&sent).unwrap();
            let recvd = rx.recv().unwrap();
            assert_eq!(*recvd, sent);
        }

        {
            let sent = [0x10, 0x11, 0x12];
            tx.send(&sent).unwrap();
            let recvd = rx.recv().unwrap();
            assert_eq!(*recvd, sent);
        }
    }

    #[test]
    fn two_frames_at_once() {
        let (mut tx, mut rx) = pair();
        let s1 = [0x00, 0x01, 0x02];
        let s2 = [0x10, 0x11, 0x12];

        tx.send(&s1).unwrap();
        tx.send(&s2).unwrap();

        let r1 = rx.recv().unwrap();
        let r2 = rx.recv().unwrap();
        println!("r1: {r1:?}\n\
                  r2: {r2:?}");

        assert_eq!(*r1, s1);
        assert_eq!(*r2, s2);
    }

    #[test]
    fn empty_input() {
        let (mut _tx, mut rx) = pair();
        match rx.recv() {
            Err(Error::EofBeforeFrame) => (),
            e => panic!("Bad value: {:?}", e)
        }
    }

    #[test]
    fn partial_input() {
        let chan = Channel::new();
        let mut rx = config().to_receiver(chan.reader());
        let mut tx_raw = chan.writer();
        tx_raw.write(&[0x01]).unwrap();
        match rx.recv() {
            Err(Error::EofDuringFrame) => (),
            e => panic!("Bad value: {:?}", e)
        }
    }

    fn config() -> Config {
        Config::default()
    }

    fn pair() -> (Sender<Box<dyn Write>>, Receiver<Box<dyn Read>>) {
        let chan = Channel::new();
        let c = config();
        let tx = c.clone().to_sender(Box::new(chan.writer()) as Box<dyn Write>);
        let rx = c.clone().to_receiver(Box::new(chan.reader()) as Box<dyn Read>);
        (tx, rx)
    }
}