#[macro_use]
extern crate serde_derive;

extern crate serde;
extern crate serde_json;

use serde::{Deserialize, Deserializer};

fn main() {
    let s = r#" {"error":"a string"} "#;
    println!("{:?}", serde_json::from_str::<Response>(s).unwrap());

    let s = r#" {"error":{"message":"not found","code":1}} "#;
    println!("{:?}", serde_json::from_str::<Response>(s).unwrap());

    let s = r#" {"error":null} "#;
    println!("{:?}", serde_json::from_str::<Response>(s).unwrap());
}

#[derive(Deserialize, Debug)]
struct Response {
    #[serde(deserialize_with = "string_map_or_null")]
    error: Option<ResponseError>,
}

#[derive(Deserialize, Debug)]
struct ResponseError {
    code: i32,
    message: String,
}

fn string_map_or_null<'de, D>(deserializer: D) -> Result<Option<ResponseError>, D::Error>
where
    D: Deserializer<'de>,
{
    #[derive(Deserialize, Debug)]
    #[serde(untagged)]
    enum Helper {
        Message(String),
        CodeMessage {
            code: i32,
            message: String,
        },
        Null,
    }

    let helper = Helper::deserialize(deserializer)?;
    match helper {
        Helper::Message(s) => Ok(Some(ResponseError {
            code: -1,
            message: s,
        })),
        Helper::CodeMessage { code, message } => Ok(Some(ResponseError {
            code,
            message,
        })),
        Helper::Null => Ok(None),
    }
}