use async_trait::async_trait;
use zenoh_flow_nodes::prelude::*;
// MySink is where you implement your business' logic.
//
// `Input` is a structure provided by Zenoh-Flow through which you receive data from upstream nodes.
// The way to pass an `Input` is through its Constructor --- see below.
//
// That structure is also where a state can be saved. For concurrency reasons, the state must
// implement `Send` and `Sync` (`Arc` and `Mutex` structures can be helpful, in particular their
// `async_std` variant).
//
// The `export_sink` macro is required to properly expose the symbol and information about the
// version of the Rust compiler and Zenoh-Flow, to Zenoh-Flow.
//
// It allows Zenoh-Flow to detect, at runtime, a version mismatch between the Zenoh-Flow daemon and
// the shared library (be it on the version of the Rust compiler or of Zenoh-Flow itself).
#[export_sink]
struct MySink {
    input: Input<String>,
}
#[async_trait]
impl Node for MySink {
    async fn iteration(&self) -> Result<()> {
        // Add your business logic here.
        let data_to_process = self.input.recv().await?;
        println!("This is what was received: {:?}", data_to_process);
    }
}
#[async_trait]
impl Sink for MySink {
    async fn new(
        // The `context` provides information about the Zenoh-Flow daemon on which the generated
        // node MySink will be executed.
        context: Context,
        // The `configuration`(1) is a re-export of `serde_json::Value`(2). It behaves as a
        // dictionary and allows accessing configuration variables defined in the descriptor.
        configuration: Option<Configuration>,
        // The `Inputs` are encapsulated `flume::Receivers` created by Zenoh-Flow. It is a HashMap
        // whose keys match what was defined in the descriptor file.
        mut inputs: Inputs,
    ) -> Result<Self> {
        let input = inputs
                .take("input")
                .expect("No input named 'input' found")
                // The method `typed` allows automatically deserialising data if it comes from a
                // node located on another process. It will call the provided closure.
                .typed(|bytes| todo!());
        Ok(MySink { input })
    }
}