#include <kpn/kpn.hpp>
#include <iostream>
#include <chrono>
#include <thread>

// A minimal linear pipeline: producer → double → print
//
//  [produce] --int--> [double_it] --int--> [print_it]

// --8<-- [start:basic_node_fns]
static int  produce()        { return 42; }
static int  double_it(int x) { return x * 2; }
static void print_it(int x)  { std::cout << "result: " << x << '\n'; }
// --8<-- [end:basic_node_fns]

int main() {
    using namespace kpn;

    // --8<-- [start:index_only_nodes]
    auto src  = make_node<produce>(5);
    auto dbl  = make_node<double_it>(5);
    auto sink = make_node<print_it>(5);
    // --8<-- [end:index_only_nodes]

    // Wire channels
    auto& dbl_in  = dbl.input_channel<0>();
    auto& sink_in = sink.input_channel<0>();
    src.set_output_channel<0>(&dbl_in);
    dbl.set_output_channel<0>(&sink_in);

    // --8<-- [start:network_build]
    Network net;
    net.add("src",  src)
       .add("dbl",  dbl)
       .add("sink", sink)
       .connect("src",  src.output<0>(),  "dbl",  dbl.input<0>())
       .connect("dbl",  dbl.output<0>(),  "sink", sink.input<0>())
       .build();

    net.start();
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    net.stop();
    // --8<-- [end:network_build]
}