use std::fmt;

use rmp_serde;
use serde::Deserialize;
use serde::de::{Deserializer, Visitor};

// a sample struct that expects an array with one i8 at the end
// to simulate error recovery
struct ContinueTillI8(i8);

impl<'de> Deserialize<'de> for ContinueTillI8 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct ContinueTillI8Visitor;

        impl<'de> Visitor<'de> for ContinueTillI8Visitor {
            type Value = ContinueTillI8;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("array that has one i8 at the end")
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where
                    A: serde::de::SeqAccess<'de>, {
                loop {
                    match seq.next_element() {
                        Ok(Some(i)) => {
                            return Ok(ContinueTillI8(i));
                        }
                        Err(e) => {
                            println!("discraded element with err: {:?}", e);
                        }
                        Ok(None) => {
                            return Err(serde::de::Error::custom("No i8 found"));
                        }
                    }
                }
            }
        }

        deserializer.deserialize_any(ContinueTillI8Visitor)
    }
}

fn main(){
    let data = ("hi", 8);
    let raw_data = rmp_serde::to_vec(&data).unwrap();

    let value: ContinueTillI8 = rmp_serde::from_slice(&raw_data[..]).unwrap();

    println!("{:?}", value.0); // should print 8
}