#ifdef WITH_TESTS

#include "Plot.h"
#include "../Tests.h"
#include "../../grid/Grid.h"
#include "../../grid/GridPoint.h"
#include "../../grid/GridNode.h"

TEST(Grid, addTwice) {

	Grid<GP> grid(20);
	ASSERT_EQ(0, grid.add(GP(0,0,0)));
	ASSERT_EQ(1, grid.add(GP(20,20,20)));

	// already present -> error
	ASSERT_THROW(grid.add(GP(0,0,0)), std::exception);
	ASSERT_THROW(grid.add(GP(20,20,20)), std::exception);

	ASSERT_EQ(2, grid.add(GP(20,20,40)));

	// already present -> error
	ASSERT_THROW(grid.add(GP(20,20,40)), std::exception);

}

TEST(Grid, add) {

	Grid<GP> grid(20);
	ASSERT_EQ(0, grid.add(GP()));

	// not aligned? -> error
	ASSERT_THROW(grid.add(GP(10,10,10)), std::exception);
	ASSERT_THROW(grid.add(GP(10,20,20)), std::exception);
	ASSERT_THROW(grid.add(GP(20,10,20)), std::exception);
	//ASSERT_THROW(grid.add(GP(20,20,11)), std::exception);		// unaligned z is OK

	// aligned -> OK
	ASSERT_EQ(1, grid.add(GP(20,20,20)));

	// access
	ASSERT_EQ(GP(20,20,20), grid[1]);

}

TEST(Grid, BBox) {

	Grid<GP> grid(20);
	int idx = grid.add(GP(40,40,40));
	ASSERT_EQ(30, grid.getBBox(idx).getMin().x);
	ASSERT_EQ(50, grid.getBBox(idx).getMax().x);
	ASSERT_EQ(30, grid.getBBox(idx).getMin().y);
	ASSERT_EQ(50, grid.getBBox(idx).getMax().y);

}


TEST(Grid, connectBiDir) {

	Grid<GP> grid(1);

	int idx1 = grid.add(GP( 0, 0, 0));
	int idx2 = grid.add(GP( 0, 1, 0));
	int idx3 = grid.add(GP( 0,-1, 0));
	int idx4 = grid.add(GP( 1, 0, 0));
	int idx5 = grid.add(GP(-1, 0, 0));

	grid.connectBiDir(idx1, idx2);
	grid.connectBiDir(idx1, idx3);
	grid.connectBiDir(idx1, idx4);
	grid.connectBiDir(idx1, idx5);

	ASSERT_EQ(4, grid.getNumNeighbors(idx1));
	ASSERT_EQ(1, grid.getNumNeighbors(idx2));
	ASSERT_EQ(1, grid.getNumNeighbors(idx3));
	ASSERT_EQ(1, grid.getNumNeighbors(idx4));
	ASSERT_EQ(1, grid.getNumNeighbors(idx5));

	ASSERT_EQ(grid[idx2], grid.getNeighbor(idx1, 0));
	ASSERT_EQ(grid[idx3], grid.getNeighbor(idx1, 1));
	ASSERT_EQ(grid[idx4], grid.getNeighbor(idx1, 2));
	ASSERT_EQ(grid[idx5], grid.getNeighbor(idx1, 3));

}

TEST(Grid, disconnectBiDir) {

	Grid<GP> grid(1);

	int idx1 = grid.add(GP( 0, 0, 0));
	int idx2 = grid.add(GP( 0, 1, 0));
	int idx3 = grid.add(GP( 0,-1, 0));
	int idx4 = grid.add(GP( 1, 0, 0));
	int idx5 = grid.add(GP(-1, 0, 0));

	grid.connectBiDir(idx1, idx2);
	grid.connectBiDir(idx1, idx3);
	grid.connectBiDir(idx1, idx4);
	grid.connectBiDir(idx1, idx5);

	// remove 1 <-> 4
	grid.disconnectBiDir(idx1, idx4);
	ASSERT_EQ(3, grid.getNumNeighbors(idx1));
	ASSERT_EQ(0, grid.getNumNeighbors(idx4));
	ASSERT_EQ(grid[idx2], grid.getNeighbor(idx1, 0));
	ASSERT_EQ(grid[idx3], grid.getNeighbor(idx1, 1));
	ASSERT_EQ(grid[idx5], grid.getNeighbor(idx1, 2));

	// remove 1 <-> 5
	grid.disconnectBiDir(idx1, idx5);
	ASSERT_EQ(2, grid.getNumNeighbors(idx1));
	ASSERT_EQ(0, grid.getNumNeighbors(idx5));
	ASSERT_EQ(grid[idx2], grid.getNeighbor(idx1, 0));
	ASSERT_EQ(grid[idx3], grid.getNeighbor(idx1, 1));

	// remove 1 <-> 2
	grid.disconnectBiDir(idx1, idx2);
	ASSERT_EQ(1, grid.getNumNeighbors(idx1));
	ASSERT_EQ(0, grid.getNumNeighbors(idx2));
	ASSERT_EQ(grid[idx3], grid.getNeighbor(idx1, 0));

	// remove 1 <-> 2
	grid.disconnectBiDir(idx1, idx3);
	ASSERT_EQ(0, grid.getNumNeighbors(idx1));
	ASSERT_EQ(0, grid.getNumNeighbors(idx3));

}

TEST(Grid, uid) {

	Grid<GP> grid(20);

	GP gp1(+20, +40, +60);
	GP gp2(-20, -40, -60);

	const uint64_t uid1 = grid.getUID(gp1);
	const uint64_t uid2 = grid.getUID(gp2);

	// must be different
	ASSERT_NE(uid1, uid2);

	const uint64_t center = 1 << 19;

	const int mask = (1 << 20) - 1;	// 20-bit mask
	ASSERT_EQ(center+60/20*5, (uid1) >> 40 & mask);	// z		(z UID has a higher resolution: * 5
	ASSERT_EQ(center+40/20, (uid1) >> 20 & mask);	// y
	ASSERT_EQ(center+20/20, (uid1) >> 0 & mask);	// x

	ASSERT_EQ(center-60/20*5, (uid2) >> 40 & mask);	// z		(z UID has a higher resolution: * 5
	ASSERT_EQ(center-40/20, (uid2) >> 20 & mask);	// y
	ASSERT_EQ(center-20/20, (uid2) >> 0 & mask);	// x

}

TEST(Grid, unconnect) {

	Grid<GP> grid(1);

	int idx1 = grid.add(GP(0,0,0));
	int idx2 = grid.add(GP(1,0,0));
	int idx3 = grid.add(GP(1,1,0));

	grid.connectBiDir(idx1,idx2);
	grid.connectBiDir(idx2,idx3);
	grid.connectBiDir(idx3,idx1);

	ASSERT_EQ(2, grid.getNumNeighbors(idx1));
	ASSERT_EQ(2, grid.getNumNeighbors(idx2));
	ASSERT_EQ(2, grid.getNumNeighbors(idx3));

	grid.disconnectUniDir(idx1, idx2);
	ASSERT_EQ(1, grid.getNumNeighbors(idx1));		ASSERT_EQ(idx3, grid.getNeighbor(idx1,0).getIdx());
	ASSERT_EQ(2, grid.getNumNeighbors(idx2));
	grid.disconnectUniDir(idx2,idx1);
	ASSERT_EQ(1, grid.getNumNeighbors(idx1));		ASSERT_EQ(idx3, grid.getNeighbor(idx1,0).getIdx());
	ASSERT_EQ(1, grid.getNumNeighbors(idx2));		ASSERT_EQ(idx3, grid.getNeighbor(idx2,0).getIdx());

	grid.disconnectUniDir(idx1, idx3);
	ASSERT_EQ(0, grid.getNumNeighbors(idx1));
	ASSERT_EQ(2, grid.getNumNeighbors(idx3));
	grid.disconnectUniDir(idx3, idx1);
	ASSERT_EQ(0, grid.getNumNeighbors(idx1));
	ASSERT_EQ(1, grid.getNumNeighbors(idx3));		ASSERT_EQ(idx2, grid.getNeighbor(idx3,0).getIdx());

	grid.disconnectUniDir(idx2, idx3);
	ASSERT_EQ(0, grid.getNumNeighbors(idx2));
	ASSERT_EQ(1, grid.getNumNeighbors(idx3));
	grid.disconnectUniDir(idx3, idx2);
	ASSERT_EQ(0, grid.getNumNeighbors(idx2));
	ASSERT_EQ(0, grid.getNumNeighbors(idx3));

}

TEST(Grid, remove) {

	Grid<GP> grid(1);

	GP gp1( 0, 0, 0);
	GP gp2( 0, 1, 0);
	GP gp3( 0,-1, 0);
	GP gp4( 1, 0, 0);
	GP gp5(-1, 0, 0);

	int idx1 = grid.add(gp1);
	int idx2 = grid.add(gp2);
	int idx3 = grid.add(gp3);
	int idx4 = grid.add(gp4);
	int idx5 = grid.add(gp5);

	grid.connectBiDir(idx1, idx2);
	grid.connectBiDir(idx1, idx3);
	grid.connectBiDir(idx1, idx4);
	grid.connectBiDir(idx1, idx5);

	grid.remove(idx1);
	grid.cleanup();

	ASSERT_EQ(4, grid.getNumNodes());
	ASSERT_EQ(gp2, grid[0]);
	ASSERT_EQ(gp3, grid[1]);
	ASSERT_EQ(gp4, grid[2]);
	ASSERT_EQ(gp5, grid[3]);

	ASSERT_EQ(0, grid.getNumNeighbors(grid[0]));
	ASSERT_EQ(0, grid.getNumNeighbors(grid[1]));
	ASSERT_EQ(0, grid.getNumNeighbors(grid[2]));
	ASSERT_EQ(0, grid.getNumNeighbors(grid[3]));

}

TEST(Grid, neighborIter) {

	Grid<GP> grid(1);

	int idx1 = grid.add(GP( 0, 0, 0));
	int idx2 = grid.add(GP( 0, 1, 0));
	int idx3 = grid.add(GP( 0,-1, 0));
	int idx4 = grid.add(GP( 1, 0, 0));
	int idx5 = grid.add(GP(-1, 0, 0));

	grid.connectBiDir(idx1, idx2);
	grid.connectBiDir(idx1, idx3);
	grid.connectBiDir(idx1, idx4);
	grid.connectBiDir(idx1, idx5);

	int i = 0;
	for (GP& node : grid.neighbors(idx1)) { (void) node; ++i; }
	ASSERT_EQ(4, i);

}

TEST(Grid, bbox) {

	Grid<GP> grid(1);

	grid.add(GP( 0, 0, 0));
	grid.add(GP( 0, 1, 0));
	grid.add(GP( 0,-1, 0));
	grid.add(GP( 1, 0, 0));
	grid.add(GP(-1, 0, 0));

	BBox3 bb = grid.getBBox();

	ASSERT_EQ(bb.getMin().x, -1);
	ASSERT_EQ(bb.getMin().y, -1);
	ASSERT_EQ(bb.getMin().z,  0);

	ASSERT_EQ(bb.getMax().x, +1);
	ASSERT_EQ(bb.getMax().y, +1);
	ASSERT_EQ(bb.getMax().z,  0);


}

TEST(Grid, nearest) {

	Grid<GP> grid(20);

	GP c1(20,20,20);
	GP c2(40,40,40);

	grid.add(c1);
	grid.add(c2);

	ASSERT_EQ(c1, grid.getNodeFor(GP(15,20,20)));
	ASSERT_EQ(c1, grid.getNodeFor(GP(20,15,20)));
	//ASSERT_EQ(c1, grid.getNodeFor(GP(20,20,15)));		// Z has a higher resolution!

	ASSERT_EQ(c1, grid.getNodeFor(GP(25,20,20)));
	ASSERT_EQ(c1, grid.getNodeFor(GP(20,25,20)));
	//ASSERT_EQ(c1, grid.getNodeFor(GP(20,20,25)));		// Z has a higher resolution!

	ASSERT_EQ(c2, grid.getNodeFor(GP(35,40,40)));
	ASSERT_EQ(c2, grid.getNodeFor(GP(40,35,40)));
	//ASSERT_EQ(c2, grid.getNodeFor(GP(40,40,35)));		// Z has a higher resolution!

	ASSERT_EQ(c2, grid.getNodeFor(GP(45,40,40)));
	ASSERT_EQ(c2, grid.getNodeFor(GP(40,45,40)));
	//ASSERT_EQ(c2, grid.getNodeFor(GP(40,40,45)));		// Z has a higher resolution!

}

#endif