#ifndef LAYER_INC_CPP

#define LAYER_INC_CPP

#include <cmath></cmath>

#include <cstdio></cstdio>

#include <cstdlib></cstdlib>

#include <cstring></cstring>

#include <cassert></cassert>

#include <atomic></atomic>

#include <vector></vector>

#include <string></string>

#include <algorithm></algorithm>

#include "layout.inc.cpp"

typedef double WeightReal;

typedef double NeuronReal;

typedef double AccumReal;

typedef int WeightInt;

typedef int AccumInt;

#define RANDOM_MAX 0x7fffffff

inline unsigned int randomNext(unsigned int prev)

  { return (1103515245*prev + 12345) & RANDOM_MAX; }

struct Accum {

  union { AccumReal v; AccumInt i; };

};

struct Neuron {

  NeuronReal v, d;

  Accum a;

};

struct Weight {

  union { WeightReal w; WeightInt i; };

};

struct Iter {

  typedef Accum AccumType;

  typedef NeuronReal* DataType;

  typedef AccumType DataAccumType;

  static inline void init(Neuron&, AccumType&) { }

  static inline void iter(Neuron&, Weight&, AccumType&) { }

  static inline void done(Neuron&, AccumType&) { }

  static inline void iter2(Neuron&, Neuron&, Weight&) { }

  static inline void iter3(Neuron&) { }

  static inline void iter4(Neuron&, DataType, DataAccumType&) { }

};

class Barrier {

private:

  std::atomic<unsigned int=""> &counter;</unsigned>

  unsigned int next;

public:

  const unsigned int tid;

  const unsigned int threads;

  Barrier(const Barrier&) = delete;

  inline Barrier(std::atomic<unsigned int=""> &counter, unsigned int tid, unsigned int threads):</unsigned>

    counter(counter), next(), tid(tid), threads(threads) { assert(tid < threads); }

  inline void wait() { next += threads; ++counter; while(counter < next); }

  inline void subwait() { while(counter < next + tid); }

};

struct Stat {

  int neurons;

  int activeNeurons;

  int weights;

  int links;

  size_t memsize;

  Stat(): neurons(), activeNeurons(), weights(), links(), memsize() { }

  Stat& operator+= (const Stat &b) {

    neurons += b.neurons;

    activeNeurons += b.activeNeurons;

    weights += b.weights;

    links   += b.links;

    memsize += b.memsize;

    return *this;

  }

  void print(const char *prefix = nullptr) const {

    if (prefix && *prefix) printf("%s: ", prefix);

    printf("neurons: %d / %d, links %d / %d, memSize: %llu\n", activeNeurons, neurons, weights, links, (unsigned long long)memsize);

  }

};

class Layer {

public:

  Layer *prev, *next;

  Layout layout;

  Neuron *neurons;

  int neuronsCount;

  Weight *weights;

  int weightsCount;

  bool ownWeights;

  const char *filename;

  Stat stat;

  Layout::List mtLayouts;

  Layout::List mtPrevLayouts;

  Layer(Layer *prev, const Layout &layout, int weightsCount = 0, Weight *weights = nullptr):

    prev(prev ? &prev->back() : nullptr),

    next(),

    layout(layout),

    neurons(),

    neuronsCount(layout.getCount()),

    weights(weights),

    weightsCount(weightsCount),

    ownWeights(!weights && weightsCount),

    filename()

  {

    assert(layout);

    assert(neuronsCount > 0);

    assert(weightsCount >= 0);

    assert(!prev == !weightsCount);

    if (this->prev) this->prev->next = this;

    if (neuronsCount) {

      neurons = new Neuron[neuronsCount];

      memset(neurons, 0, sizeof(*neurons)*neuronsCount);

    }

    if (ownWeights) {

      this->weights = new Weight[weightsCount];

      memset(this->weights, 0, sizeof(*this->weights)*weightsCount);

    }

    stat.neurons = neuronsCount;

    stat.activeNeurons = layout.getActiveCount();

    stat.weights = weightsCount;

    stat.links = weightsCount;

    stat.memsize = neuronsCount*sizeof(*neurons);

    if (ownWeights) stat.memsize += weightsCount*sizeof(*weights);

  }

  virtual ~Layer() {

    if (next) delete next;

    if (neurons) delete[] neurons;

    if (ownWeights) delete[] weights;

  }

  inline Layer& front()

    { Layer *l = this; while(l->prev) l = l->prev; return *l; }

  inline Layer& back()

    { Layer *l = this; while(l->next) l = l->next; return *l; }

  inline Stat sumStat() const

    { Stat s; for(const Layer *l = this; l; l = l->next) s += l->stat; return s; }

  bool save() const {

    if (filename && weightsCount) {

      FILE *f = fopen(filename, "wb");

      if (!f)

        return printf("cannot open file for write: %s\n", filename), false;

      if (!fwrite(weights, sizeof(*weights)*weightsCount, 1, f))

        return fclose(f), printf("cannot write to file: %s\n", filename), false;

      fclose(f);

    }

    return !next || next->save();

  }

  bool load() {

    if (filename && weightsCount) {

      FILE *f = fopen(filename, "rb");

      if (!f)

        return printf("cannot open file for read: %s\n", filename), false;

      if (!fread(weights, sizeof(*weights)*weightsCount, 1, f))

        return fclose(f), printf("cannot read from file: %s\n", filename), false;

      fclose(f);

    }

    return !next || next->load();

  }

  void clearAccum() {

    Accum a = {};

    for(Neuron *in = neurons, *e = in + neuronsCount; in < e; ++in)

      in->a = a;

  }

  void fillWeights(WeightReal wmin, WeightReal wmax) {

    WeightReal k = (wmax - wmin)/RAND_MAX;

    for(Weight *iw = weights, *e = iw + weightsCount; iw < e; ++iw)

      iw->w = rand()*k + wmin;

  }

  virtual void split(int threadsCount) {

    layout.split(mtLayouts, threadsCount);

    if (prev) prev->layout.split(mtPrevLayouts, threadsCount);

  }

  virtual void pass(Barrier &barrier) { }

  virtual void backpassWeights(Barrier &barrier) { }

  virtual void backpassDeltas(Barrier &barrier) { }

  virtual void testPass() { }

  virtual void testBackpass() { }

  virtual void clGetThreadsData(std::vector<unsigned char=""> &data) { }</unsigned>

  virtual void clGetPassProgram(std::string &text) { }

  virtual void clGetBackpassWeightsProgram(std::string &text) { }

  virtual void clGetBackpassDeltasProgram(std::string &text) { }

};

#endif