//! Deep chain comparison: dagx vs dagrs
//!
//! Long sequential chain: 100 tasks in sequence

use criterion::Criterion;

pub fn bench_deep_chain(c: &mut Criterion) {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let mut group = c.benchmark_group("comparisons/deep_chain_100_tasks");

    // dagx implementation
    group.bench_function("dagx", |b| {
        b.iter(|| {
            rt.block_on(async {
                use dagx::DagRunner;
                use dagx_test::task_fn;

                let mut dag = DagRunner::new();

                let first = dag.add_task(task_fn::<(), _, _>(|_: ()| 0));
                let mut prev = dag
                    .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
                    .depends_on(&first);

                for i in 2..100 {
                    prev = dag
                        .add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
                        .depends_on(&prev);
                }

                let mut output = dag
                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                    .await
                    .unwrap();
                output.get(prev)
            })
        });
    });

    // dagrs implementation
    group.bench_function("dagrs", |b| {
        b.iter(|| {
            use async_trait::async_trait;
            use dagrs::*;
            use std::sync::Arc;

            struct Initial;
            #[async_trait]
            impl Action for Initial {
                async fn run(
                    &self,
                    _: &mut InChannels,
                    out: &mut OutChannels,
                    _: Arc<EnvVar>,
                ) -> Output {
                    out.broadcast(Content::new(0i32)).await;
                    Output::Out(Some(Content::new(0i32)))
                }
            }

            struct Increment(i32);
            #[async_trait]
            impl Action for Increment {
                async fn run(
                    &self,
                    input: &mut InChannels,
                    out: &mut OutChannels,
                    _: Arc<EnvVar>,
                ) -> Output {
                    let vals: Vec<i32> = input
                        .map(|c| *c.unwrap().into_inner::<i32>().unwrap())
                        .await;
                    let result = vals[0] + self.0;
                    out.broadcast(Content::new(result)).await;
                    Output::Out(Some(Content::new(result)))
                }
            }

            let mut table = NodeTable::new();
            let mut nodes = vec![];
            let mut node_ids = vec![];

            let initial = DefaultNode::with_action("task_0".to_string(), Initial, &mut table);
            node_ids.push(initial.id());
            nodes.push(initial);

            for i in 1..100 {
                let node =
                    DefaultNode::with_action(format!("task_{}", i), Increment(i), &mut table);
                node_ids.push(node.id());
                nodes.push(node);
            }

            let mut graph = Graph::new();
            for node in nodes {
                graph.add_node(node);
            }

            for i in 1..100 {
                graph.add_edge(node_ids[i - 1], vec![node_ids[i]]);
            }

            graph.set_env(EnvVar::new(table));
            graph.start().unwrap();
        });
    });

    group.finish();
}