#ifndef BjxF7IwCJEpR8eQGIzMk04pwFg
#define BjxF7IwCJEpR8eQGIzMk04pwFg

#include <algorithm>
#include <boost/tuple/tuple.hpp>
#include <boost/mpl/set.hpp>
#include <boost/mpl/contains.hpp>

#include "context.hpp"
#include "event.hpp"
#include "evolve.hpp"
#include "index.hpp"
#include "index_global.hpp"
#include "index_spike.hpp"
#include "index_spike_arrival.hpp"
#include "filter.hpp"
#include "multi_queue.hpp"
#include "pla_apply.hpp"
#include "pla_evolve.hpp"
#include "pla_generate.hpp"
#include "pla_initbycopy.hpp"
#include "pla_sync.hpp"
#include "time.hpp"
#include "topology.hpp"
#include "type_set.hpp"

#include "model.hpp"

namespace SimReplayImpl {

using namespace boost;
using namespace boost::mpl;

// TODO: remove (is redundant code)
template <typename Quant> struct CalcDPtr { 
  typedef Ptr<Quant> type; 
};
template <> struct CalcDPtr<SpikeArrival> {
  typedef boost::tuple<Ptr<SpikeArrival>, Ptr<Synapse>> type;
};

/// factory defining which discrete quants we have to consider

template<typename ReplayQuant>
struct MultiQueueFactory;

template<>
struct MultiQueueFactory<Global> {
  typedef list<GlobalMsg> dependencies;
  typedef MultiQueue<Time, FilterPayload, dependencies, FilterContainer> type;
  typedef IdList<Ptr<Global>::ptr_t> id_list_t;
  static type instance(id_list_t &, const Time time) {
    return type(time);
  }
};

template<>
struct MultiQueueFactory<Neuron> {
  typedef list<GlobalMsg, Spike, RandomSpike, SpikeArrival> dependencies;
  typedef MultiQueue<Time, FilterPayload, dependencies, FilterContainer> type;
  typedef IdList<Ptr<Neuron>::ptr_t> id_list_t;
  static type instance(id_list_t ids, const Time time) {
    return type(Filter<GlobalMsg>   (time),
		Filter<Spike>       (ids, time),
		Filter<RandomSpike> (ids, time),
		Filter<SpikeArrival>(ids, time));
  }
};

template<>
struct MultiQueueFactory<Synapse> : MultiQueueFactory<Neuron> {
  typedef IdList<Ptr<Synapse>::ptr_t> id_list_t;
  static type instance(id_list_t ids_synapse, Time time) {
    MultiQueueFactory<Neuron>::id_list_t ids_neuron;
    for (auto syn : ids_synapse)
      ids_neuron.insert(Ptr<Synapse>(syn).extractNeuron()());
    return MultiQueueFactory<Neuron>::instance(ids_neuron, time);
  }
};

/// template brainfuck to prevent instancing unnecessary handleEvents<>()

template<typename ReplayQuant, typename Quant>
struct MaybeHandleEvent {
  template<typename Q> struct HandleEvent {
    template<typename Sim> void operator() (Sim &sim) {
      sim.template handleEvent<Q>();
    }
  };

  struct IgnoreEvent {
    template<typename Sim> void operator() (Sim &sim) {}
  };

  typedef typename contains<
    typename MultiQueueFactory<ReplayQuant>::dependencies,
    Quant>::type isRelevant;
  typedef typename if_<isRelevant,
		       HandleEvent<Quant>,
		       IgnoreEvent
		       >::type impl;
};


/// extract neurons from arbitrary id list
template<typename Quant> struct ExtractNeuronIDs;

template<>
struct ExtractNeuronIDs<Global> {
  IdList<Ptr<Neuron>::ptr_t> operator() (IdList<Ptr<Global>::ptr_t> &) {
    return IdList<Ptr<Neuron>::ptr_t>();
  }
};

template<>
struct ExtractNeuronIDs<Neuron> {
  IdList<Ptr<Neuron>::ptr_t> operator() (IdList<Ptr<Neuron>::ptr_t> &src) {
    return src;
  }
};

template<>
struct ExtractNeuronIDs<Synapse> {
  IdList<Ptr<Neuron>::ptr_t> operator() (IdList<Ptr<Synapse>::ptr_t> &src) {
    IdList<Ptr<Neuron>::ptr_t> res;
    for (auto id : src)
      res.insert(Ptr<Synapse>(id).extractNeuron()());
    return res;
  }
};

/// the precious replay

template<typename PropList, typename ReplayQuant,
	 template<class, class> class EventHandler = MaybeHandleEvent>
struct SimReplay {
  typedef PropertyComposition<PropList> PropComp;
  typedef Checkpoint<Void, 1> Cp;
  typedef IdList<typename Ptr<ReplayQuant>::ptr_t> id_list_t;
  typedef IdList<typename Ptr<Neuron>::ptr_t> neuron_list_t;

  SimReplay(id_list_t ids, Time start)
    // we need the previous checkpoint interval
    : ct(Cp::interval() * (std::max((const uint32_t) 1, Cp::binTime(start)) - 1)),
      ids(ids),
      neurons(ExtractNeuronIDs<ReplayQuant>()(ids)),
      queues(std::move(MultiQueueFactory<ReplayQuant>::instance(ids, ct)))
  {
    // init values of our quant
    pc.cast(PLA_InitByCopy{ct});

    // forward precisely to the request time
    run(start, -1);
  }

  template<typename Prop>
  typename Prop::type get(Ptr<ReplayQuant> id, Time t) {
    // TODO (maybe): allow to read all calculated values, not just
    // those of the ReplayQuant (e.g. the synapses properties of a
    // simulated neuron)
    assert(t >= ct);
    assert(ids.count(id()));
    run(t, -1);
    typedef ContinuousContext<ReplayQuant> Ctx;
    PLA_Get<Prop, Ctx> pla_get(t, Ctx(id));
    return pc.call(pla_get);
  }

  bool run(const Time until, uint64_t maxEvents) {
    assert(until != Time::never());
    while (queues.min() <= until && maxEvents) {
      ct = queues.min();
      switch (queues.minType()) {
#define HT(T) case RuntimeID<T>::value: typename EventHandler<ReplayQuant, T>::impl()(*this); break;
	HT(SpikeArrival);
	HT(Spike);
	HT(RandomSpike);
	HT(GlobalMsg);
#undef HT
      default: assert(false);
      }
      --maxEvents;
    }
    return maxEvents;
  }
    
  template<typename Quant>
  inline bool handleEvent() {
    typedef typename QuantDestinationQuant<Quant>::type DstQuant;
    typename CalcDPtr<Quant>::type src(queues.get<Quant>().minPayload().src);
    Ptr<DstQuant>                  dst(queues.get<Quant>().minPayload().dst);

    // deliever the event and check if to create new events
    DelieverContext<Quant, DstQuant> delieverContext{src, dst};
    PLA_Apply<Quant, DstQuant, PropComp> apply(ct, delieverContext);
    pc.call(apply);
    
    // create events
    if (apply.generateAny()) {
      // determine how much we have to simulate:
      if (is_same<ReplayQuant, Global>::value) {
	// - global replay don't needs any childs
	pc.cast(PLA_Evolve<Global>{ContinuousContext<Global>{Ptr<Global>{}}, ct});
      }else{
	if (is_same<DstQuant, Global>::value) {
	  // - neuron/synapse replay needs global and selected neurons
	  for (auto id : neurons)
	    Evolve<Neuron>()(pc, ct, Ptr<Neuron>{id});
	  pc.cast(PLA_Evolve<Global>{ContinuousContext<Global>{Ptr<Global>{}}, ct});
	}else{
	  // - neuron/synapse evolve happens as usual
	  Evolve<DstQuant>()(pc, ct, dst);
	}
      }
    }
    // commit data calculated during apply
    //   this is necessary because childs are only eventually evolved,
    //   but require the pre-event values of the instance we are
    //   committing to now
    apply.commit(pc);

    // call the continuous property related post-event triggers to
    // update state
#define HGE(Q) \
    if (apply.template generate<Q>()) \
      handleEventGeneration<DstQuant, Q, Quant>(ct, dst, apply);

    HGE(GlobalMsg);
    HGE(Spike);
    HGE(RandomSpike);
    HGE(SpikeArrival);
#undef HGE

    queues.template removeMin<Quant>(ct);

    return apply.template generate<Spike>();
  }

  template<typename ContQuant, typename EventQuant, typename SrcEvQuant>
  inline void handleEventGeneration(Time ct, Ptr<ContQuant> src, 
				    PLA_Apply<SrcEvQuant, ContQuant, PropComp> &)
  {
    Void nix;
    pc.cast(PLA_Generate<ContQuant, EventQuant, Void, Void>
	    (ct, EmitContext<ContQuant, EventQuant>(src, Ptr<EventQuant>(-1)),
	     nix, nix));
  }

  Time currentTime() {
    return ct;
  }

  /// ephermal state
  Time ct;
  id_list_t ids;
  neuron_list_t neurons;
  typename MultiQueueFactory<ReplayQuant>::type queues;
  PropComp pc;  

  /// persistant data storage (holds every mmap'ed data structure)
  //Topology topology;
};

} // Namespace ReplayImpl

using SimReplayImpl::SimReplay;

#endif // BjxF7IwCJEpR8eQGIzMk04pwFg