#![allow(non_snake_case)]
#[macro_use]
extern crate serde_derive;

extern crate serde;
extern crate serde_json;
use serde::ser::{Serialize, SerializeStruct, SerializeTupleVariant, Serializer};
use serde::{Deserialize, Deserializer};

#[derive(Serialize, Deserialize, Debug)]
struct Foo {
    word: String,
}
#[derive(Serialize, Deserialize, Debug)]
struct Bar {
    number: i64,
}

#[derive(Deserialize, Debug)]
#[serde(rename = "Payload", remote = "Self")]
enum ClientPayload {
    Foo(Foo), //notice these are "real" structs nested in a tuple variant
    Bar(Bar),
}
impl<'de> Deserialize<'de> for ClientPayload {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        struct Wrapper {
            //#[serde(rename = "type")]
            //_ignore: String,
            #[serde(flatten, with = "ClientPayload")]
            inner: ClientPayload,
        }
        Wrapper::deserialize(deserializer).map(|w| w.inner)
    }
}

impl Serialize for ClientPayload {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            ClientPayload::Foo(ref a) => {
                let mut tv = serializer.serialize_tuple_variant("ClientPayload", 0, "Foo", 1)?;
                tv.serialize_field(a);
                tv.end()
            }
            ClientPayload::Bar(ref a) => {
                let mut tv = serializer.serialize_tuple_variant("ClientPayload", 1, "Bar", 1)?;
                tv.serialize_field(a);
                tv.end()
            }
        }
    }
}
#[derive(Deserialize, Debug)]
struct ClientMessage {
    Msgtype: String, //ie a string that says "Foo" or "Bar" denoting the struct that the serializer will find
    Otherinfo: String,
    Payload: ClientPayload,
}
impl Serialize for ClientMessage {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("ClientMessage", 3)?;
        state.serialize_field("Msgtype", &self.Msgtype)?;
        state.serialize_field("Otherinfo", &self.Otherinfo)?;
        state.serialize_field("Payload", &self.Payload)?;
        state.end()
    }
}
fn main() {
    let testmsg = r#"{"Msgtype":"Foo","Otherinfo":"oooka","Payload":{"word":"fooing"}"#;
    let _testenum: ClientPayload = ClientPayload::Foo(Foo {
        word: "foo".to_owned(),
    });
    let teststruct = ClientMessage {
        Msgtype: "Foo".to_owned(),
        Otherinfo: "ooooooka".to_owned(),
        Payload: ClientPayload::Foo(Foo {
            word: "fooooo".to_owned(),
        }),
    };
    let _teststruct2 = ClientMessage {
        Msgtype: "Bar".to_owned(),
        Otherinfo: "ooooooka".to_owned(),
        Payload: ClientPayload::Bar(Bar { number: 34 }),
    };
    let serialized = serde_json::to_string(&teststruct);
    println!("hmmm {:?}", serialized.unwrap());
    let msg: ClientMessage = serde_json::from_str(&testmsg).unwrap();
    println!("Hello, world! {:?}", msg);
}