use std::sync::{Arc, Mutex};

use nebkor_maelstrom::{mk_payload, mk_stdin, Body, Message, Node, Runner};

fn main() {
    let out = std::io::stdout();

    let node = Counter;
    let node = Arc::new(Mutex::new(node));

    let runner = Runner::new(node, out);

    let (i, _, rx) = mk_stdin();

    let on_init = |rnr: &Runner| {
        let payload = mk_payload(&[
            ("key", KEY.into()),
            ("from", 0i64.into()),
            ("to", 0i64.into()),
            ("create_if_not_exists", true.into()),
        ]);
        let body = Body::from_type("cas").with_payload(payload);
        rnr.send("seq-kv", body);
    };

    let on_init = Box::new(on_init);

    runner.run(rx, Some(on_init));
    i.join().unwrap();
}

const KEY: &str = "COUNTER";

#[derive(Clone, Default)]
struct Counter;

impl Node for Counter {
    fn handle<'slf>(&'slf mut self, runner: &'slf Runner, req: Message) {
        let typ = req.body.typ.as_str();
        let frm = req.src.clone();
        let msg_id = req.body.msg_id.to_owned();

        match typ {
            "add" => {
                runner.reply(&req, Body::from_type("add_ok"));
            }
            "read" => {
                let rn = runner.clone();
                let h = move |msg: Message| {
                    let src = frm.clone();
                    let value = msg.body.payload.get("value").unwrap().as_i64().unwrap();
                    let irt = msg_id;
                    let payload = mk_payload(&[("value", value.into())]);
                    let body = Body::from_type("read_ok")
                        .with_in_reply_to(irt)
                        .with_payload(payload);
                    rn.send(&src, body);
                };
                let payload = mk_payload(&[("key", KEY.into())]);
                let body = Body::from_type("read").with_payload(payload);
                runner.rpc("seq-kv", body, Box::new(h));
            }
            _ => {
                eprintln!("unknown type: {req:?}");
            }
        }
    }
}