use message_flow::{msg_flow, message, registers, MsgDef};
use anyhow::Result;
use serde::{Serialize, Deserialize};

#[derive(MsgDef, Serialize, Deserialize, Debug)]
struct User {
    first_name: String,
}

#[msg_flow(pattern = "service_A")]
impl User {
    #[message(pattern = "1")]
    async fn greeting(&self) -> Result<String> {
        println!("IN SERVICE 1");
        Ok("OK HELLO FROM GREETING".into())
    }

    #[message(pattern = "2")]
    async fn greeting2(&self) -> Result<String> {
        println!("IN SERVICE 2");
        Ok("OK HELLO FROM GREETING 2".into())
    }

    #[message(pattern = "3")]
    async fn greeting3(&self) -> Result<String> {
        println!("IN SERVICE 3");
        Ok("OK HELLO FROM GREETING 3".into())
    }
}

#[derive(MsgDef, Serialize, Deserialize, Debug)]
struct User2 {
    first_name: String,
}

#[msg_flow(pattern = "service_B")]
impl User2 {
    #[message(pattern = "ss")]
    async fn greeting(&self) -> Result<String> {
        println!("IN SERVICE B: greeting");
        Ok("OK HELLO FROM SERVICE B".into())
    }

    #[message(pattern = "service_2")]
    async fn ok(&self) -> Result<String> {
        println!("SERVICE B IS READY");
        Ok("OK HELLO FROM SERVICE B - OK".into())
    }
}

#[tokio::test]
async fn main() {
    println!("BEFORE");

    let _result = message_flow::connection::connect_and_wait(
        "localhost:4222".into(),
        registers!(User, User2)
    )
    .await
    .unwrap();

    let usr = User {
        first_name: "HO".into(),
    };

    // You can send or respond to messages
}