#ifndef SIGNAL_NETWORK_MULTICHAIN_HPP
#define SIGNAL_NETWORK_MULTICHAIN_HPP

#include <boost/dataflow/signals/component/filter_base.hpp>
#include <boost/dataflow/signals/component/detail/unfused_inherited.hpp>
#include <boost/dataflow/signals/connection/operators.hpp>

#include <boost/mpl/vector.hpp>
#include <boost/fusion/functional/adapter/fused.hpp>
#include <boost/fusion/adapted/mpl.hpp>
#include <boost/function_types/parameter_types.hpp>

#include <boost/fusion/view/iterator_range.hpp>
#include <boost/fusion/include/iterator_range.hpp>
#include <boost/fusion/algorithm/iteration/for_each.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/view/zip_view.hpp>
#include <boost/fusion/include/zip_view.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/include/end.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/include/begin.hpp>
#include <cassert>

namespace boost { namespace signals {


template<typename Signature, typename T>
class multichain;

namespace detail
{

    struct connect_pair{
	template< typename T >
	void operator()(T& t){
		connect(fusion::at_c<0>(t), fusion::at_c<1>(t));
	}
    };

    template<typename Signature, typename T>
    class multichain_impl : public filter_base<multichain<Signature, T>, typename mpl::begin<T>::type::signal_type, mpl::vector<> >
    {
    protected:
        typedef typename boost::function_types::parameter_types<Signature>::type parameter_types;
        typedef typename boost::fusion::result_of::as_vector<parameter_types >::type parameter_vector;
public:
        typedef typename T::signal_type signal_type;
        typedef typename T::signature_type signature_type;
        typedef T proxy_producer_for;
	

	typedef typename boost::fusion::vector< T > vec_T;

	typedef typename boost::fusion::result_of::begin<vec_T>::type first;
	typedef typename boost::fusion::result_of::end<vec_T>::type last;
	typedef typename boost::fusion::result_of::next<first>::type after_first;
	typedef typename boost::fusion::result_of::prior<last>::type before_last;

	typedef typename boost::fusion::iterator_range<first, before_last> producer_range;
	typedef typename boost::fusion::iterator_range<after_first, last> consumer_range;
	/// Pairs of Component which should be connected
	typedef typename boost::fusion::vector<producer_range&, consumer_range&> connection_pairs;



	
        multichain_impl()
        {
	    initialize();
        }
        ~multichain_impl()
        {
        }
        template <class Seq>
        struct result
        {
            typedef typename boost::function_traits<Signature>::result_type type;
        };
        /// Sending a signal to the chain will forward it to the first component in the chain.
        typename boost::function_traits<Signature>::result_type 
        operator()(const parameter_vector &vec_par)
        {
            return boost::fusion::fused<T &>(fusion::deref(fusion::begin(components)))(vec_par);
        }
        ///	The default signal coming out of the chain is the default signal of the last component in the chain.
/*        typename T::signal_type &default_signal() const
        {
            return components[size-1].default_signal();
        }*/
        typename last::signal_type &default_signal() const
        {
            return boost::dataflow::get_default_port<dataflow::args::left, dataflow::signals::connect_mechanism, dataflow::signals::tag >(fusion::deref(fusion::prior(fusion::end(components))));
        }
    private:
        void initialize()
        {
	first First(components);
	last Last(components);
	after_first After_First(components);
	before_last Before_Last(components);
	
	producer_range Producer_Range(First, Before_Last);
	consumer_range Consumer_Range(After_First, Last);

	assert( Producer_Range == fusion::pop_back( components ) );
	assert( Consumer_Range == fusion::pop_front( components ) );

	/// Connect the pairs of producers and consumer components.
	boost::fusion::for_each( boost::fusion::zip_view<connection_pairs>(
					connection_pairs( Producer_Range, 
							  Consumer_Range ) ),
				 connect_pair() );
	
			
        }
	vec_T components;
    };
}


/** \brief Connects a number of components of different types in a chain.
\param T Type of the component.
\param Signature Signature of the signal sent and received.

*/
template<typename Signature, typename T>
class multichain : public boost::fusion::unfused_inherited<detail::multichain_impl<Signature, T>,
typename boost::function_types::parameter_types<Signature>::type >
{
protected:
    typedef boost::fusion::unfused_inherited<detail::multichain_impl<Signature, T>,
        typename boost::function_types::parameter_types<Signature>::type > base_type;
public:
	multichain() : base_type() {}
};


} } // namespace boost::signals

#endif // SIGNAL_NETWORK_MULTICHAIN_HPP