use serde_json::Value;

use crate::{check_err, mk_payload, Body, RpcResult, Runner};

#[derive(Debug, Default, Clone)]
pub struct Kv {
    pub service: &'static str,
}

impl Kv {
    pub fn seq() -> Self {
        Kv { service: "seq-kv" }
    }

    pub fn lin() -> Self {
        Kv { service: "lin-kv" }
    }

    pub fn lww() -> Self {
        Kv { service: "lww-kv" }
    }

    pub fn read(&self, runner: &Runner, key: &str) -> RpcResult {
        let payload = mk_payload(&[("key", key.into())]);
        let body = Body::from_type("read").with_payload(payload);
        let rx = runner.rpc(self.service, body);
        let msg = rx.recv().unwrap();
        check_err(&msg)?;
        Ok(Some(msg.body.payload.get("value").unwrap().to_owned()))
    }

    pub fn write(&self, runner: &Runner, key: &str, val: Value) -> RpcResult {
        let payload = mk_payload(&[("key", key.into()), ("value", val)]);
        let body = Body::from_type("write").with_payload(payload);
        let msg = runner.rpc(self.service, body).recv().unwrap();
        check_err(&msg)?;
        Ok(None)
    }

    pub fn cas(
        &self,
        runner: &Runner,
        key: &str,
        from: Value,
        to: Value,
        create: bool,
    ) -> RpcResult {
        let payload = mk_payload(&[
            ("key", key.into()),
            ("from", from),
            ("to", to),
            ("create_if_not_exists", create.into()),
        ]);
        let body = Body::from_type("cas").with_payload(payload);
        let msg = runner.rpc(self.service, body).recv().unwrap();
        check_err(&msg)?;
        Ok(None)
    }
}