#ifndef _DISPATCHER_H_
#define _DISPATCHER_H_
#include <list>
#include <QString>
#include <iostream>
#include <map>


//****************************************************************************************************/
//                        EventDispatcher && EventIdentDispatcher                                  //
/***************************************************************************************************/
//      This handy class(es) act as very simple signals/events.
//      Its OOP-only, so dont even try to add static functions
//      or C-like methods!
//
//      :: Return Types ::
//
//      at the moment only callbacks for void methods with a parameter
//      count of one ( whos type is the primary template parameter)
//
//      :: callback signature ::
//
//      typedef void (T::*callback)(U); // with <U, T> as template
//
//      :: Usage Example ::
//
//      *creating a Dispatcher
//
//   -- EventDispatcher<Type A>* nameYourDispatcher = new EventDispatcher<Type A>; // simple Dispatcher
//   -- EventIdentDispatcher<Type A>* nameYourIdentDispatcher = new EventIdentDispatcher<Type A>; // ident dispatcher
//
//      *difference between simple and ident
//
//      a simple dispatcher features only one type of signal, so you can only call all
//      attached listeners at once or none at all
//
//      an ident dispatcher uses an ident string to hold and fire more than one event type at once
//      but is limited to the one defined parameter type for its methods
//
//      *subscribung to a dispatcher
//
//   -- nameYourDispatcher->addListener(<pointer-to-object-of-Type-myClass>, &myClass::myMethod); // simple Dispatcher
//   -- nameYourIdentDispatcher->addListener(<string-as-ident>, <pointer-to-object-of-Type-myClass>, &myClass::myMethod); // ident dispatcher//
//
//      you can add the same method/instance to different dispatchers oder differnt ident-distinguished dispatchers in a identdispatcher.
//      you can also add the same method/instance to the same dispatchers all over again, which is not recommended
//
//
//      *firing a dispatcher
//
//   -- nameYourDispatcher->fire(Type_A Object); // simple Dispatcher
//   -- nameYourIdentDispatcher->fire(<string-as-ident>, Type_A Object); // ident dispatcher//
//
//      All respective attached callbacks are called in the order they were added
//
//
//      *unsubscribing
//
//   -- nameYourDispatcher->removeListener(<pointer-to-object-of-Type-myClass>, &myClass::myMethod); // simple Dispatcher
//   -- nameYourIdentDispatcher->removeListener(<string-as-ident>, <pointer-to-object-of-Type-myClass>, &myClass::myMethod); // ident dispatcher//
//
//      just the reverse of addListener. currently no removeAll() available
//
//
//
/***************************************************************************************************/
class CallbackHandle
{
};

template<class U>
class CallbackBase : public CallbackHandle
{
public:
    virtual void fire(U u) {};

private:
};

template<class T, class U>
class Callback : public CallbackBase<U>
{
public:

    virtual void fire(U u)
    {
        if (cbVU)
            (callee->*cbVU)(u);
    };

    typedef void (T::*callbackVU)(U);

    Callback(T* who, callbackVU cb)
    {
        cbVU = cb;
        callee = who;
    };

    T* getCallee()
    {
        return callee;
    };
    callbackVU getCBVU()
    {
        return cbVU;
    };

private:
    callbackVU cbVU;
    T* callee;

};

template<class U>
class EventDispatcher
{
public:
    template<class T> void addListener(T *who, void (T :: *func)(U))
    {
        Callback<T, U> *tmp = new Callback<T, U>(who, func);
        _listener.push_back(dynamic_cast<CallbackBase<U>*>(tmp));
    };
    void fire(U u)
    {
        for (typename std::list<CallbackBase<U>*>::iterator it = _listener.begin(); it != _listener.end(); it++)
        {
            if (*it)
            {
                (*it)->fire(u);
            }
        }
    };

    template<class T> void removeListener(T* who, void (T :: *func)(U))
    {
        if (_listener.size())
        {
            for (typename std::list<CallbackBase<U>*>::iterator it = _listener.begin(); it != _listener.end(); it++)
            {
                CallbackBase<U>* pro = (*it);
                Callback<T, U> *probe = dynamic_cast<Callback<T,U>*>(pro);
                if (probe)
                {
                    if (probe->getCallee() == who && probe->getCBVU() == func )
                    {
                        delete (probe);
                        _listener.remove((*it));
                        return;
                    }
                }
            }
        }
    };

private:

    std::list<CallbackBase<U>*> _listener;
};

template<class U>
class EventIdentDispatcher
{
public:
    template<class T> void addListener(QString ident, T* who, void (T :: *func)(U))
    {
        Callback<T, U>* tmp = new Callback<T, U>(who, func);
        _listener.push_back(std::pair<QString, CallbackBase<U>*>(ident, dynamic_cast<CallbackBase<U>*>(tmp)));
    };

    void fire(QString ident, U u)
    {
        for ( typename std::list<std::pair<QString, CallbackBase<U>* > >::iterator it = _listener.begin(); it != _listener.end(); it++)
        {
            if ((*it).first.compare(ident) == 0 || QString("*").compare((*it).first) == 0)
            {
                if ((*it).second)
                {
                    (*it).second->fire(u);
                }
            }
        }
    };
    template<class T> void removeListener(QString ident, T* who, void (T :: *func)(U))
    {
        if (_listener.size())
        {
            for (std::list<std::pair <QString, CallbackHandle*> >::iterator it = _listener.begin(); it != _listener.end(); it++)
            {
                if ((*it).first.compare(ident) == 0)
                {
                    CallbackBase<U>* pro = (*it).second;
                    Callback<T, U> *probe = dynamic_cast<Callback<T,U>*>(pro);
                    if (probe)
                    {
                        if (probe->getCallee() == who && probe->getVoidCB == func)
                        {
                            delete (*it).second;
                            _listener.remove((*it));
                            return;
                        }
                    }
                }
            }
        }
    };
private:
    std::list<std::pair<QString, CallbackBase<U>* > > _listener;
};

#endif