#ifdef WITH_TESTS

#include "../../Tests.h"

#include "../../../sensors/radio/VAPGrouper.h"

/** test the RSSI storage. [we use only a single byte due to memory constraints, but allow 0.25 dB steps!] */
TEST(WiFiVAPGrouper, baseMAC) {

	VAPGrouper vg(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::AVERAGE);

	// first VAP group
	const MACAddress ap1B("aa:bb:cc:dd:ee:f0");		// base-mac (last digit zero)
	const MACAddress ap10("aa:bb:cc:dd:ee:f3");		// vap 1
	const MACAddress ap11("aa:bb:cc:dd:ee:f7");		// vap 2
	const MACAddress ap12("aa:bb:cc:dd:ee:ff");		// vap 3

	// second VAP group
	const MACAddress ap2B("ff:ee:dd:cc:bb:a0");		// base-mac (last digit zero)
	const MACAddress ap20("ff:ee:dd:cc:bb:a9");		// vap 1
	const MACAddress ap21("ff:ee:dd:cc:bb:a8");		// vap 2
	const MACAddress ap22("ff:ee:dd:cc:bb:ae");		// vap 3

	// all in first group must equal
	ASSERT_EQ( ap1B, vg.getBaseMAC(ap10) );
	ASSERT_EQ( vg.getBaseMAC(ap10), vg.getBaseMAC(ap11) );
	ASSERT_EQ( vg.getBaseMAC(ap11), vg.getBaseMAC(ap12) );

	// all in second group must equal
	ASSERT_EQ( ap2B, vg.getBaseMAC(ap20) );
	ASSERT_EQ( vg.getBaseMAC(ap20), vg.getBaseMAC(ap21) );
	ASSERT_EQ( vg.getBaseMAC(ap21), vg.getBaseMAC(ap22) );

	// first and second must be different
	ASSERT_NE( vg.getBaseMAC(ap10), vg.getBaseMAC(ap20) );

}

TEST(WiFiVAPGrouper, aggregation) {

	VAPGrouper vgAvg(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::AVERAGE, VAPGrouper::TimeAggregation::AVERAGE);
	VAPGrouper vgMedian(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::MEDIAN, VAPGrouper::TimeAggregation::MINIMUM);
	VAPGrouper vgMax(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::MAXIMUM, VAPGrouper::TimeAggregation::MAXIMUM);

	WiFiMeasurements scan;

	const AccessPoint vap10("aa:bb:cc:dd:ee:f3");
	const AccessPoint vap11("aa:bb:cc:dd:ee:f5");
	const AccessPoint vap12("aa:bb:cc:dd:ee:fe");

	const AccessPoint vap20("01:bb:cc:dd:11:a3");
	const AccessPoint vap21("01:bb:cc:dd:11:a5");
	const AccessPoint vap22("01:bb:cc:dd:11:ae");
	const AccessPoint vap23("01:bb:cc:dd:11:ae");

	scan.entries.push_back(WiFiMeasurement(vap10, -75, Timestamp::fromMS(11)));
	scan.entries.push_back(WiFiMeasurement(vap11, -70, Timestamp::fromMS(12)));
	scan.entries.push_back(WiFiMeasurement(vap12, -71, Timestamp::fromMS(13)));

	scan.entries.push_back(WiFiMeasurement(vap20, -69, Timestamp::fromMS(22)));
	scan.entries.push_back(WiFiMeasurement(vap21, -61, Timestamp::fromMS(25)));
	scan.entries.push_back(WiFiMeasurement(vap22, -62, Timestamp::fromMS(21)));
	scan.entries.push_back(WiFiMeasurement(vap23, -60, Timestamp::fromMS(20)));

	const WiFiMeasurements gAvg = vgAvg.group(scan);
	const WiFiMeasurements gMedian = vgMedian.group(scan);
	const WiFiMeasurements gMax = vgMax.group(scan);

	// correct number of grouped entries?
	ASSERT_EQ(2, gAvg.entries.size());
	ASSERT_EQ(2, gMedian.entries.size());
	ASSERT_EQ(2, gMax.entries.size());

	// correct average rssi / average timestamp?
	ASSERT_EQ(-72, gAvg.entries.back().getRSSI());
	ASSERT_EQ(-63, gAvg.entries.front().getRSSI());
	ASSERT_EQ(Timestamp::fromMS(12), gAvg.entries.back().getTimestamp());		// average ts
	ASSERT_EQ(Timestamp::fromMS(22), gAvg.entries.front().getTimestamp());		// average ts

	// correct median rssi / min timestamp?
	ASSERT_EQ(-71, gMedian.entries.back().getRSSI());
	ASSERT_EQ(-61.5, gMedian.entries.front().getRSSI());
	ASSERT_EQ(Timestamp::fromMS(11), gMedian.entries.back().getTimestamp());	// min ts
	ASSERT_EQ(Timestamp::fromMS(20), gMedian.entries.front().getTimestamp());	// min ts

	// correct max rssi / max timestamp?
	ASSERT_EQ(-70, gMax.entries.back().getRSSI());
	ASSERT_EQ(-60, gMax.entries.front().getRSSI());
	ASSERT_EQ(Timestamp::fromMS(13), gMax.entries.back().getTimestamp());	// max ts
	ASSERT_EQ(Timestamp::fromMS(25), gMax.entries.front().getTimestamp());	// max ts


}

TEST(WiFiVAPGrouper, aggregationTS) {

	VAPGrouper vgAvg(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::AVERAGE, VAPGrouper::TimeAggregation::AVERAGE);
	VAPGrouper vgMedian(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::MEDIAN, VAPGrouper::TimeAggregation::MINIMUM);
	VAPGrouper vgMax(VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO, VAPGrouper::Aggregation::MAXIMUM, VAPGrouper::TimeAggregation::MAXIMUM);

	WiFiMeasurements scan;

	const AccessPoint vap0("01:bb:cc:dd:11:a0");
	const AccessPoint vap1("01:bb:cc:dd:11:a1");
	const AccessPoint vap2("01:bb:cc:dd:11:a2");
	const AccessPoint vap3("01:bb:cc:dd:11:a3");
	const AccessPoint vap4("01:bb:cc:dd:11:a4");
	const AccessPoint vap5("01:bb:cc:dd:11:a5");
	const AccessPoint vap6("01:bb:cc:dd:11:a6");
	const AccessPoint vap7("01:bb:cc:dd:11:a7");
	const AccessPoint vap8("01:bb:cc:dd:11:a8");

	Timestamp base = Timestamp::fromUnixTime();

	scan.entries.push_back(WiFiMeasurement(vap0, -1, base+Timestamp::fromMS(1)));
	scan.entries.push_back(WiFiMeasurement(vap1, -2, base+Timestamp::fromMS(2)));
	scan.entries.push_back(WiFiMeasurement(vap2, -3, base+Timestamp::fromMS(3)));
	scan.entries.push_back(WiFiMeasurement(vap3, -4, base+Timestamp::fromMS(4)));
	scan.entries.push_back(WiFiMeasurement(vap4, -5, base+Timestamp::fromMS(5)));
	scan.entries.push_back(WiFiMeasurement(vap5, -6, base+Timestamp::fromMS(6)));
	scan.entries.push_back(WiFiMeasurement(vap6, -7, base+Timestamp::fromMS(7)));
	scan.entries.push_back(WiFiMeasurement(vap7, -8, base+Timestamp::fromMS(8)));
	scan.entries.push_back(WiFiMeasurement(vap8, -9, base+Timestamp::fromMS(9)));

	const WiFiMeasurements gAvg = vgAvg.group(scan);
	const WiFiMeasurements gMedian = vgMedian.group(scan);
	const WiFiMeasurements gMax = vgMax.group(scan);

	// correct average rssi / average timestamp?
	ASSERT_EQ(-5, gAvg.entries.back().getRSSI());
	ASSERT_EQ(base+Timestamp::fromMS(5), gAvg.entries.front().getTimestamp());

	// correct median rssi / min timestamp?
	ASSERT_EQ(-5, gMedian.entries.back().getRSSI());
	ASSERT_EQ(base+Timestamp::fromMS(1), gMedian.entries.back().getTimestamp());	// min ts

	// correct max rssi / max timestamp?
	ASSERT_EQ(-1, gMax.entries.back().getRSSI());
	ASSERT_EQ(base+Timestamp::fromMS(9), gMax.entries.back().getTimestamp());	// max ts

}

#endif