#ifndef CHAIN_1_STRUCT_H
#define CHAIN_1_STRUCT_H

#include <vector>
#include <iostream>
#include <assert.h>

namespace handler_chain
{
    template <class NODE, class ADAPTER>
    struct NodeBase 
    {
    private:
        typedef  void (*FP1)(void* , void*);
    public:    
		typedef  typename ADAPTER::RET_TYPE RET_TYPE;
		typedef  typename ADAPTER::VALUE_TYPE VALUE_TYPE;
        NodeBase() : p_(0), fn_(0) 
        {}
        template <class T>
        void setNext(T& x)
        {
            p_ = &x;
            fn_ = &functions<T>::processImpl;
        }
        void operator()(VALUE_TYPE* v)
        {
			if( ADAPTER()(NODE(), v ) )
				return;
			if (p_==0 || fn_== 0)
			{
				std::cout << "No Result Found\n";
				return;
			}
			fn_(p_, v);
        }
    private:
        template <class TT>
        struct functions
        {
            static void processImpl( void* a , void* v)
            {
				(*static_cast<TT*>(a))(static_cast<VALUE_TYPE*>(v));
            }
        };
        void* p_;
        FP1 fn_;
    };
	
	template <typename V, typename R>
	struct Adapter
	{
		typedef R RET_TYPE;
		typedef V VALUE_TYPE;
		template <class H>
		RET_TYPE operator()( const  H& h, VALUE_TYPE* v) const 
		{
			return h.handleEvent(v);
		}
	};
	
    struct Connection 
    {
		template <class V>
		bool handleEvent(V*  v ) const 
        {
            std::cout << "Connection\n" ;
			return *v <  1 ? true : false;
        }
	};
    struct Lsp 
    {
		template <class V>
		bool handleEvent(V* v ) const
        {
            std::cout << "Lsp\n" ;
			return *v <  3 ? true : false;
        }
	};
	struct Path 
    {
		template <class V>
		bool handleEvent( V* v ) const
        {
            std::cout << "Path\n" ;
			return *v <  5 ? true : false;
        }
	};

	class INode
    {
    private:
        typedef  void (*FP1)(void* , void*);
    public:   
        template <class T>
        INode(T& x)
        : p_(&x),
        fn_(&functions<T>::processImpl)
        {}
		template <class V>
        void operator()(V* v)
        {
             fn_(p_, v);
        }
    private:
        template <class TT>
        struct functions
        {
            static void processImpl( void* a, void* v)
            {
                  (*static_cast<TT*>(a)) (static_cast<typename TT::VALUE_TYPE*>(v) );
            }
        };
        void* p_;
        FP1 fn_;
    };
	
	template <class Head>
	INode* createChain( Head& head)
	{
		return new INode(head);
	}

    void test()
    {
		std::cout << "TESTING HANDLER_CHAIN1\n" ;
        
		typedef Adapter<int, bool> ADAPTER;
		NodeBase<Connection, ADAPTER> connection;
		NodeBase<Lsp, ADAPTER> lsp;
		NodeBase<Path, ADAPTER> path;
		
		connection.setNext(lsp);
		lsp.setNext(path);
        
		int k = 1;
		connection(&k);

		std::auto_ptr<INode> i(createChain(connection));
		k = 10;
		(*i)(&k);
    }

}
#endif