#ifndef lolpAJAYZev7fEXugmdiNlqUhWA
#define lolpAJAYZev7fEXugmdiNlqUhWA

#include <boost/tuple/tuple.hpp>

#include "pointers.hpp"
#include "index_global.hpp"
#include "index_spike.hpp"
#include "template_helpers.hpp"
#include "topology.hpp"

template<typename UnknownType>
struct Event {
  DO_NOT_INSTANCE(UnknownType);
};

template<>
struct Event<GlobalMsg> {
  typedef GlobalMsg quant_t;
  typedef Ptr<GlobalMsg> msg_ptr_t;
  typedef Ptr<Global>    ptr_t;

  // regular ctors
  Event(msg_ptr_t inst)                : inst(inst) {}
  Event(Time ignored1, ptr_t ignored2, msg_ptr_t inst) : inst(inst) {}

  // ctor for illegal event sources
  GEN_ANYCAST_CTOR_3(Event) : inst(0) { DO_NOT_CALL }

  inline ptr_t dst(Topology &ignored) { return ptr_t(); }
  inline msg_ptr_t instance() { return inst; }

  msg_ptr_t inst;
};

template<>
struct Event<RandomSpike> {
  typedef RandomSpike quant_t;
  typedef Ptr<RandomSpike> msg_ptr_t;
  typedef Ptr<Neuron> ptr_t;
  
  Event(Time, ptr_t neuron, msg_ptr_t inst) : neuron(neuron), inst(inst) {}
  GEN_ANYCAST_CTOR_3(Event) : neuron(0), inst(0) { DO_NOT_CALL }

  inline ptr_t dst(Topology &) { return neuron; }
  inline msg_ptr_t instance() { return inst; }

  ptr_t neuron;
  msg_ptr_t inst;
};

template<>
struct Event<Spike> {
  typedef Spike quant_t;
  typedef Ptr<Neuron> neuron_ptr_t;
  typedef Ptr<Spike>  spike_ptr_t;
  typedef uint16_t offset_t;

  // legal ctors
  Event(Time baseTime, neuron_ptr_t src, spike_ptr_t spike)
    : baseTime(baseTime), 
      src(src),
      offset(0),
      spike(spike)
  {}
  Event(Time baseTime, neuron_ptr_t src, spike_ptr_t spike, offset_t offset)
    : baseTime(baseTime), 
      src(src),
      offset(offset),
      spike(spike)
  {}

  // ctor for illegal event sources
  GEN_ANYCAST_CTOR_3(Event) : baseTime(0),src(0),offset(0),spike(0) { DO_NOT_CALL }
  //  Event(Time baseTime, neuron_ptr_t src, uint16_t offset)
  //    : baseTime(baseTime), src(src), offset(offset) {}

  inline Ptr<Synapse> dst(Topology &topology) {
    return topology.synapse(src, offset);
  }
  inline spike_ptr_t instance() { return spike; }

  Time baseTime; // time of outgoing spike; add topology.time(src,
		 // offset) to get spike arrival time
  neuron_ptr_t src;  
  offset_t offset; // HINT: offset in topolgy, _not_ a synapse offset!
  spike_ptr_t spike;
};

template<>
struct Event<SpikeArrival> {
  typedef SpikeArrival quant_t;

  Event(Ptr<Synapse> dst, Ptr<SpikeArrival> sa)
    :  sdst(dst), sa(sa) {}
  inline Ptr<Neuron> dst(Topology &ignored) { return dst(); }
  inline Ptr<Neuron> dst() { return sdst.extractNeuron(); }
  // HACK for DelieverContext ... what a shame
  inline boost::tuple<Ptr<SpikeArrival>, Ptr<Synapse>> instance() { 
    return boost::make_tuple(sa, sdst);
  }

  Ptr<Synapse> sdst;
  Ptr<SpikeArrival> sa;
};

#endif // lolpAJAYZev7fEXugmdiNlqUhWA