use serde_derive::{Deserialize, Serialize};

#[derive(Deserialize, Debug)]
pub struct RequestA {
	pub a: String,
}

#[derive(Deserialize, Debug)]
pub struct RequestB {
	pub b: String,
}

#[derive(Deserialize, Debug)]
#[serde(deny_unknown_fields)]
pub struct RequestType<T> {
	pub id: u64,
	pub params: T,
}

#[derive(Deserialize, Debug)]
#[serde(tag = "method", rename_all = "lowercase")]
pub enum Request {
    RequestA(RequestType<RequestA>),
    RequestB(RequestType<RequestB>),
}

#[derive(Serialize, Debug)]
pub struct ResponseA {
	pub a: String,
}

#[derive(Serialize, Debug)]
pub struct ResponseB {
	pub b: String,
}

#[derive(Serialize, Debug)]
pub struct ResponseType {
    pub id: u64,
    pub result: Response,
}

#[derive(Serialize, Debug)]
pub enum Response {
	ResponseA(ResponseA),
	ResponseB(ResponseB),
}

fn main() {
    let request_str = r#"
        {
            "id": 0,
            "method": "requesta",
            "params": {
                "a": "foo"
            }
        }"#;
    let request: Request = serde_json::from_str(&request_str).unwrap();

    let result = match request {
        Request::RequestA(_request) => Response::ResponseA(ResponseA { a: "bar".to_string() }),
        Request::RequestB(_request) => Response::ResponseB(ResponseB { b: "baz".to_string() }),
    };

    let response_id = 0; // request.id

    let response = ResponseType {
        id: response_id,
        result,
    };

    let response_str = serde_json::to_string(&response).unwrap();

    println!("{}", response_str);

}