#ifndef WIRECELLTBB_FANOUTCAT
#define WIRECELLTBB_FANOUTCAT

#include "WireCellIface/IFanoutNode.h"
#include "WireCellUtil/TupleHelpers.h"
#include "WireCellUtil/Testing.h"
#include "WireCellTbb/NodeWrapper.h"

#include <iostream>

namespace WireCellTbb {


    // Body for a TBB split node.
    template<typename std::size_t N>    
    class FanoutBody {
	WireCell::IFanoutNodeBase::pointer m_wcnode;
    public:
	typedef typename WireCell::IFanoutNodeBase::any_vector any_vector;
	typedef typename WireCell::type_repeater<N, boost::any>::type TupleType;
	// typedef typename WireCell::tuple_helper<TupleType> helper_type;

	FanoutBody(WireCell::INode::pointer wcnode) {
	    m_wcnode = std::dynamic_pointer_cast<WireCell::IFanoutNodeBase>(wcnode);
	    Assert(m_wcnode);
        // helper_type ih;
	}

	TupleType operator() (boost::any in) const {
	    // helper_type ih;
	    any_vector ret;
        // bool ok = (*m_wcnode)(in, ret);
        (*m_wcnode)(in, ret); // fixme: don't ignore return code
	    // return ih.from_any(vectorToTuple<N>(ret));
	    return WireCell::vectorToTuple<N>(ret);
	}
	
    };

    template<std::size_t N>
    sender_port_vector build_fanouter(tbb::flow::graph& graph, WireCell::INode::pointer wcnode,
				      tbb::flow::graph_node*& spliter, tbb::flow::graph_node*& caller)
    {
	typedef typename WireCell::type_repeater<N, boost::any>::type TupleType;

	// this node is fully TBB and splits N sender ports into a tuple
	typedef tbb::flow::split_node< TupleType > tbb_split_node_type;
	tbb_split_node_type* sp = new tbb_split_node_type(graph);
	spliter = sp;

	// this node takes user WC body and runs it after converting input verctor to tuple
	typedef tbb::flow::function_node<boost::any,TupleType> spliting_node;
	spliting_node* fn = new spliting_node(graph, wcnode->concurrency(), FanoutBody<N>(wcnode));
	caller = fn;

	tbb::flow::make_edge(*fn,*sp);

	//FanoutNodeInputPorts<TupleType,N> ports;
	//return ports(*sp);
	return sender_ports(*sp);
    }
    
    // Wrap the TBB (compound) node
    class FanoutWrapper : public NodeWrapper {
	tbb::flow::graph_node *m_spliter, *m_caller;
	sender_port_vector m_sender_ports;

    public:

	FanoutWrapper(tbb::flow::graph& graph, WireCell::INode::pointer wcnode)
	    : m_spliter(0), m_caller(0)
	{
	    int nout = wcnode->output_types().size();
	    // an exhaustive switch to convert from run-time to compile-time types and enumerations.
	    Assert (nout > 0 && nout <= 6); // fixme: exception instead?
	    if (1 == nout) m_sender_ports = build_fanouter<1>(graph, wcnode, m_spliter, m_caller);
	    if (2 == nout) m_sender_ports = build_fanouter<2>(graph, wcnode, m_spliter, m_caller);
	    if (3 == nout) m_sender_ports = build_fanouter<3>(graph, wcnode, m_spliter, m_caller);
	    if (4 == nout) m_sender_ports = build_fanouter<4>(graph, wcnode, m_spliter, m_caller);
	    if (5 == nout) m_sender_ports = build_fanouter<5>(graph, wcnode, m_spliter, m_caller);
	    if (6 == nout) m_sender_ports = build_fanouter<6>(graph, wcnode, m_spliter, m_caller);
	}
	
	virtual sender_port_vector sender_ports() {
	    return m_sender_ports;
	}

	virtual receiver_port_vector  receiver_ports() {
	    auto ptr = dynamic_cast< receiver_type* >(m_caller);
	    return receiver_port_vector{ptr};
	}

    };


}

#endif
