#ifndef Orz6Wl1nWMpziVYSyArLK0EzFpA
#define Orz6Wl1nWMpziVYSyArLK0EzFpA

#include "array.hpp"
#include "pointers.hpp"
#include "scalar.hpp"
#include "simlimits.hpp"
#include "time.hpp"

struct Topology {
  // ctor for reading topo
  Topology() 
  : delay("topology_delay"),
    target("topology_target"),
    isInitialized("topology_initialized")
  { assert(isInitialized()); }

  // ctor for writing topo
  Topology(Array<Time, maxNeurons * maxSynapsesPerNeuron> &aDelay,
	   Array<Ptr<Synapse>::ptr_t, maxNeurons * maxSynapsesPerNeuron> &aTarget)
  : delay("topology_delay"),
    target("topology_target"),
    isInitialized("topology_initialized") {
      assert(not isInitialized());

      isInitialized() = true;
      target() = aTarget;
      delay() = aDelay;
    }

  
  // tools
  Ptr<Synapse> synapse(Ptr<Neuron> neuron, uint16_t offset) {
    return Ptr<Synapse>(target().get(neuron() * maxSynapsesPerNeuron + offset));
  }

  Time time(Ptr<Neuron> neuron, uint16_t offset) {
    return delay().get(neuron() * maxSynapsesPerNeuron + offset);
  }

  // consts
  inline static Ptr<Synapse> nil() { return Ptr<Synapse>(-1); }

  // storage
  Scalar<Array<Time, maxNeurons * maxSynapsesPerNeuron>> delay;
  Scalar<Array<Ptr<Synapse>::ptr_t, maxNeurons * maxSynapsesPerNeuron>> target;
  Scalar<bool> isInitialized;
};

/// a helper to generate the offset between the baseTime of an event
/// and it's arrival time (in priority queue); is zero except for the
/// case of sending a spike from a neuron

// default case: zero offset
template<typename ContQuant, typename EventQuant>
struct TopologicalTimeOffset {
  inline Time operator() (Topology &topology, typename ContQuant::instance_ptr_t src) {
    return Time(0.0);
  }
};

// neuron emit spike case: lookup offset in topology
template<>
struct TopologicalTimeOffset<Neuron, Spike> {
  inline Time operator() (Topology &topology, Neuron::instance_ptr_t src) {
    return topology.time(src, 0);
  }
};

/// a helper to catch the case of a neuron with empty fanout

// default case: emit event
template<typename ContQuant, typename EventQuant>
struct TopologicalEventDiscard {
  inline bool operator() (Topology &topology, typename ContQuant::instance_ptr_t src) {
    return false;
  }
};

// neuron emit spike case: lookup offset in topology
template<>
struct TopologicalEventDiscard<Neuron, Spike> {
  inline bool operator() (Topology &topology, Neuron::instance_ptr_t src) {
    return (topology.synapse(src, 0)() == Topology::nil()());
  }
};

#endif // Orz6Wl1nWMpziVYSyArLK0EzFpA