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

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

const KEY: &str = "COUNTER";

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

fn main() {
    let node = Counter;
    let node = Arc::new(Mutex::new(node));

    let runner = Runner::new(node);

    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(Some(on_init));
}

impl Node for Counter {
    fn handle<'slf>(&'slf mut self, runner: &'slf Runner, req: Message) {
        let read_payload = mk_payload(&[("key", KEY.into())]);
        let read_body = Body::from_type("read").with_payload(read_payload);
        let typ = req.body.typ.as_str();
        //let frm = req.src.clone();
        //let msg_id = req.body.msg_id.to_owned();
        match typ {
            "add" => {
                let delta = req.body.payload.get("delta").unwrap().as_i64().unwrap();
                let cur = runner
                    .rpc("seq-kv", read_body)
                    .recv()
                    .unwrap()
                    .body
                    .payload
                    .get("value")
                    .cloned()
                    .unwrap()
                    .as_i64()
                    .unwrap();
                let cas_payload = mk_payload(&[
                    ("key", KEY.into()),
                    ("from", cur.into()),
                    ("to", (cur + delta).into()),
                ]);
                // ERRORS BE HERE
                runner
                    .rpc("seq-kv", Body::from_type("cas").with_payload(cas_payload))
                    .recv()
                    .unwrap();
                runner.reply(&req, Body::from_type("add_ok"));
            }
            "read" => {
                let payload = mk_payload(&[("key", KEY.into())]);
                let body = Body::from_type("read").with_payload(payload);
                let val = runner
                    .rpc("seq-kv", body)
                    .recv()
                    .unwrap()
                    .body
                    .payload
                    .get("value")
                    .cloned()
                    .unwrap();
                let body = Body::from_type("read_ok").with_payload(mk_payload(&[("value", val)]));
                runner.reply(&req, body);
            }
            _ => {
                eprintln!("unknown type: {req:?}");
            }
        }
    }
}