#ifndef SEGMENT_TEST_INC_CPP

#define SEGMENT_TEST_INC_CPP

#include "test.inc.cpp"

#include "segment.inc.cpp"

class SegmentTest: public Test {

public:

  static bool testSegment(const char *name, Segment &segment, Layout l, int x, int y, int z, NeuronReal trainRatio) {

    Stage st(name);

    class H: public ThreadControl {

    public:

      Segment &segment;

      int x, y, z;

      Quality testQ;

      NeuronReal ratio;

      std::vector<quality> qualities;</quality>

      H(Segment &segment, int x, int y, int z, NeuronReal ratio): segment(segment), x(x), y(y), z(z), ratio(ratio) { }

      void prepareData()

        { memcpy(segment.weights, weights.data(), segment.weightsCount*sizeof(Weight)); }

      void threadFunc(Barrier &barrier) override

        { qualities[barrier.tid] = segment.pass(barrier, x, y, z, ratio); }

      bool test(const char *name, int threadsCount) {

        Stage st(name);

        assert(threadsCount > 0);

        qualities.clear();

        qualities.resize(threadsCount);

        prepareData();

        segment.split(threadsCount);

        runThreads(threadsCount);

        Quality q;

        for(int i = 0; i < threadsCount; ++i) q += qualities[i];

        if ( fabs(q.train - testQ.train) > 1e-10 

          || fabs(q.human - testQ.human) > 1e-10 )

        {

            printf("qualities differs, was %g (%g), expected %g (%g)\n",

              q.human, q.train, testQ.human, testQ.train );

            ++errors;

        }

        for(int i = 0; i < segment.weightsCount; ++i) {

          WeightReal a = segment.weights[i].w;

          WeightReal b = weights[i + segment.weightsCount].w;

          if (fabs(a - b) > 1e-10) {

            printf("weights differs at %d, was %g, expected %g\n", i, a, b);

            segment.layout.printYXZ("layout");

            ++errors; break;

          }

        }

        return st;

      }

    } h(segment, x, y, z, trainRatio);

    assert(segment.weightsCount > 0);

    int valuesCount = l.getCount();

    init(0, 0, segment.weightsCount*3, valuesCount);

    for(int i = 0; i < valuesCount; ++i)

      values[i] = rand()/(NeuronReal)RAND_MAX;

    for(int i = 0; i < segment.weightsCount; ++i)

      weights[i].w = (WeightReal)(2.0*rand()/RAND_MAX - 1);

    segment.layout = l;

    segment.f_values = values.data();

    segment.weights = &weights[segment.weightsCount];

    segment.check(x, y, z);

    h.prepareData();

    h.testQ = segment.testPass(x, y, z, trainRatio);

    segment.weights += segment.weightsCount;

    h.test("single-thread", 1);

    h.test("single-thread-repeat", 1);

    h.test("2-threads", 2);

    h.test("7-threads", 7);

    h.test("7-threads-repeat", 7);

    h.test("8-threads", 8);

    return st;

  }

  static bool testSegment(const char *name, Segment &segment) {

    Layout l = segment.layout;

    int x = l.x0 + rand()%(l.getW() - segment.sx + 1);

    int y = l.y0 + rand()%(l.getH() - segment.sy + 1);

    int z = l.z0 + rand()%(l.getD() - segment.sz + 1);

    return testSegment(name, segment, l, x, y, z, 0.1);

  }

};

#endif