#ifdef WITH_TESTS

#include <cmath>
#include "../Tests.h"
#include "../../math/FixedFrequencyInterpolator.h"
#include <fstream>
#include <random>

/*
TEST(FixedFrequencyInterpolator, testOLD) {

	FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(10));

	std::ofstream out("/tmp/test.dat");

	std::vector<float> data;
	auto callback = [&] (const Timestamp ts, const float val) {
		out << ts.ms() << " " << val << "\n";
		data.push_back(val);
	};

	float x = 10;

	// output should be a straight line
	ffi.add(Timestamp::fromMS(55), x*55, callback);
	ffi.add(Timestamp::fromMS(93), x*93, callback);
	ffi.add(Timestamp::fromMS(102), x*102, callback);
	ffi.add(Timestamp::fromMS(134), x*134, callback);
	ffi.add(Timestamp::fromMS(212), x*212, callback);
	ffi.add(Timestamp::fromMS(214), x*214, callback);
	ffi.add(Timestamp::fromMS(216), x*216, callback);
	ffi.add(Timestamp::fromMS(219), x*219, callback);
	ffi.add(Timestamp::fromMS(220), x*220, callback);
	ffi.add(Timestamp::fromMS(240), x*240, callback);

	out.close();

	const float d = 0.001;
	ASSERT_NEAR(data[0], x*60, d);
	ASSERT_NEAR(data[1], x*70, d);
	ASSERT_NEAR(data[2], x*80, d);
	ASSERT_NEAR(data[3], x*90, d);
	ASSERT_NEAR(data[4], x*100, d);
	ASSERT_NEAR(data[5], x*110, d);
	ASSERT_NEAR(data[6], x*120, d);
	ASSERT_NEAR(data[7], x*130, d);
	ASSERT_NEAR(data[8], x*140, d);
	ASSERT_NEAR(data[9], x*150, d);
	ASSERT_NEAR(data[10], x*160, d);
	ASSERT_NEAR(data[11], x*170, d);
	ASSERT_NEAR(data[12], x*180, d);
	ASSERT_NEAR(data[13], x*190, d);
	ASSERT_NEAR(data[14], x*200, d);
	ASSERT_NEAR(data[15], x*210, d);
	ASSERT_NEAR(data[16], x*220, d);
	ASSERT_NEAR(data[17], x*230, d);
	ASSERT_NEAR(data[18], x*240, d);

}
*/

TEST(FixedFrequencyInterpolator, testNEW) {

	FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(9));

	// randomly draw points along a line using random intervals
	Timestamp pos;
	std::minstd_rand gen;
	std::uniform_int_distribution<int> dist(2, 65);
	auto func = [] (const Timestamp ts) {
		return 0.5 * ts.ms() + 12;
	};

	// compare the randomly drawn points against interpolated fixed-frequency interpolated versions
	auto cb = [&] (const Timestamp ts, const float val) {
		ASSERT_NEAR(val, func(ts), 0.001);	// interpolated vs original position on line
	};

	// run
	for (int i = 0; i < 200; ++i) {
		const float y = func(pos);
		ffi.add(pos, y, cb);
		pos += Timestamp::fromMS(dist(gen));
	}



}

TEST(FixedFrequencyInterpolator, testUpsample) {

	FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(10));
	int cnt = 0;

	auto cb = [&] (const Timestamp ts, const float f) {
		if (cnt ==  0) {ASSERT_EQ(ts.ms(),  0); ASSERT_NEAR(  0, f, 0.001);}
		if (cnt ==  1) {ASSERT_EQ(ts.ms(), 10); ASSERT_NEAR( 10, f, 0.001);}
		if (cnt == 10) {ASSERT_EQ(ts.ms(),100); ASSERT_NEAR(100, f, 0.001);}
		++cnt;
	};

	// add two entries. one at t=0 one at t=100. must be up-sampled into 11 entries (t=0, t=10, t=100)
	ffi.add(Timestamp::fromMS(0), 0, cb);
	ffi.add(Timestamp::fromMS(101), 101, cb);
	ASSERT_EQ(11, cnt);

}

TEST(FixedFrequencyInterpolator, testDownsample) {

	FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(50));
	int cnt = 0;

	auto cb = [&] (const Timestamp ts, const float f) {
		if (cnt == 0) {ASSERT_EQ(ts.ms(),   0); ASSERT_NEAR(  0, f, 0.001);}
		if (cnt == 1) {ASSERT_EQ(ts.ms(),  50); ASSERT_NEAR( 50, f, 0.001);}
		if (cnt == 2) {ASSERT_EQ(ts.ms(), 100); ASSERT_NEAR(100, f, 0.001);}
		++cnt;
	};

	// add 100+ entries in 1 ms steps. must be downsampled to 3 entries (t=0, t=50, t=100)
	for (int i = 0; i <= 101; ++i) {
		ffi.add(Timestamp::fromMS(i), i, cb);
	}
	ASSERT_EQ(3, cnt);

}


#endif