#ifndef sOuC39DJVwHiStoyuZdritpuC5M
#define sOuC39DJVwHiStoyuZdritpuC5M

#include <assert.h>

#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/set.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/tuple/tuple.hpp>

#include "pointers.hpp"
#include "time.hpp"
#include "type_set.hpp"

/* methods common to all context's

   getptr<Quant>() -> return an instance id

 */

namespace ContextImpl {
  
  using namespace boost;
  using namespace boost::mpl;

  // common context (internal)
  template<typename... Quants>
  struct CCtx : public TypeSet<Ptr<Quants>...> {
    CCtx(Ptr<Quants>... ids) : TypeSet<Ptr<Quants>...>(std::move(ids)...) {}

    template<typename Quant>
    typename Quant::instance_ptr_t getptr() {
      return this->template get<Ptr<Quant>>();
    }
  };

  /// SingleContext: stores a single quant w/o any relation
  template<typename Quant>
  struct SingleContext : public CCtx<Quant> {
    SingleContext(Ptr<Quant> id) : CCtx<Quant>(id) {}
  };

  /// ContinuousContext: resembles the global <- neuron <- synapse hierarchy
  template<typename Quant>
  struct ContinuousContext;

  template<>
  struct ContinuousContext<Global> : CCtx<Global> {
    ContinuousContext()
      : CCtx<Global>(Ptr<Global>()) {}
    explicit ContinuousContext(Ptr<Global> p) 
      : CCtx<Global>(p) {}
  };
  
  template<>
  struct ContinuousContext<Neuron> : CCtx<Neuron, Global> {
    explicit ContinuousContext(Ptr<Neuron> p) 
      : CCtx<Neuron, Global>(p, Ptr<Global>()) {}
  };
  
  template<>
  struct ContinuousContext<Synapse> 
    : CCtx<Synapse, Neuron, Global> {
    explicit ContinuousContext(Ptr<Synapse> p) 
      : CCtx<Synapse, Neuron, Global>(p, p.extractNeuron(), Ptr<Global>()) {}
  };

  // common context with one discrete ptr (internal)
  template<typename DQ, typename CQ>
  struct DCtx {
    DCtx(Ptr<DQ> did, Ptr<CQ> cid) 
      : id(did), sub(cid) {}

    template<typename Quant>
    typename Quant::instance_ptr_t getptr() {
      if (boost::is_same<Quant, DQ>::value) {
	return FORCE_CONV(typename Quant::instance_ptr_t, id);
      }else{
	return sub.getptr<Quant>();
      }
    }

    friend std::ostream& operator<< (std::ostream &os, DCtx val) {
      return os << val.id << ":" << val.sub;
    }
    
    Ptr<DQ> id;
    ContinuousContext<CQ> sub;
  };

  
  /// DelieverContext: when a (discrete) event is delievered to a
  /// continuous quantity
  template<typename DQ, typename CQ>
  struct DelieverContext : DCtx<DQ, CQ> {
    DelieverContext(Ptr<DQ> did, Ptr<CQ> cid)
      : DCtx<DQ, CQ>(did, cid) {}
  };
	
  // HACK: allow Neuron to access Synapse on SpikeArrival; this only
  // works because SA is send with a zero delay, so synapse is already
  // evolved to current time
  template<>
  struct DelieverContext<SpikeArrival, Neuron> : DCtx<SpikeArrival, Synapse> {
    DelieverContext(boost::tuple<Ptr<SpikeArrival>, Ptr<Synapse>> t, Ptr<Neuron>)
      : DCtx<SpikeArrival, Synapse>(t.get<0>(), t.get<1>()) {}
  };

  /// EmitContent: CQ emits event of class DQ
  template<typename CQ, typename DQ>
  struct EmitContext : DCtx<DQ, CQ> {
    EmitContext(Ptr<CQ> cid, Ptr<DQ> did)
      : DCtx<DQ, CQ>(did, cid) {}
  };
}
	
using ContextImpl::SingleContext;
using ContextImpl::ContinuousContext;
using ContextImpl::DelieverContext;
using ContextImpl::EmitContext;
	
#endif // sOuC39DJVwHiStoyuZdritpuC5M