gistfile1.txt

#![allow(dead_code)]
#![allow(unused_imports)]

use serde::de::{self, SeqAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{json, Map, Value};
use std::borrow::Cow;
use std::fmt;
use std::marker::PhantomData;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum Selector {
    #[serde(rename = "css selector")]
    CSS,
    XPath,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Locator {
    using: Selector,
    value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum WebDriverCommand {
    FindElement(Locator),
    GetTimeouts,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum Command {
    WebDriver(WebDriverCommand),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum WebDriverCommandName {
    #[serde(rename = "WebDriver:FindElement")]
    FindElement,
    #[serde(rename = "WebDriver:GetTimeouts")]
    GetTimeouts,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
enum CommandName {
    WebDriver(WebDriverCommandName),
}

type MessageId = i32;
type Payload = Value;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Request(MessageId, Command);

/*
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Request {
    id: MessageId,
    name: CommandName,
    params: Map<String, Value>,
}
*/

#[derive(Debug, Clone, PartialEq, Serialize)]
enum Message {
    Incoming(Request),
}

fn deserialize_params(name: &CommandName, params: Payload) -> Result<Command, serde::de::Error> {
    let command = Command::WebDriver(match name {
        CommandName::WebDriver(webdriver_command) => match webdriver_command {
            WebDriverCommandName::FindElement => WebDriverCommand::FindElement(
                serde_json::from_value::<Locator>(params).map_err(de::Error::invalid_type("asd")),
            ),
            WebDriverCommandName::GetTimeouts => WebDriverCommand::GetTimeouts,
        },
    });
    dbg!(&command);
    Ok(command)
}

impl<'de> Deserialize<'de> for Message {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Debug, Deserialize)]
        struct Mapping {
            direction: u8,
            id: MessageId,
            name: CommandName,
            params: Payload,
        };

        let Mapping {
            direction,
            id,
            name,
            params,
        } = Mapping::deserialize(deserializer)?;
        dbg!(&name);

        let msg = match direction {
            0 => {
                let command = deserialize_params(&name)?;
                dbg!(&command);
                Message::Incoming(Request(id, command))
            }

            1 => panic!("outoging"),
            _ => panic!(),
        };

        Ok(msg)
    }
}

fn main() {
    let locator = Locator {
        using: Selector::CSS,
        value: "body".into(),
    };
    let find_element = WebDriverCommand::FindElement(locator);
    let command = Command::WebDriver(find_element);
    let request = Request(42, command);
    let msg = Message::Incoming(request);

    dbg!(&msg);

    let actual: Message = serde_json::from_value(
        json!([0,42,"WebDriver:FindElement",{"using":"css selector","value":"body"}]),
    )
    .unwrap();
    assert_eq!(msg, actual);
}