package org.xbib.datastructures.trie.radix.adaptive;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

public abstract class InnerNodeUnitTest {
	protected static class Pair implements Comparable<Pair> {
		final byte partialKey;
		final Node child;

		Pair(byte partialKey, Node child) {
			this.partialKey = partialKey;
			this.child = child;
		}

		@Override
		public int compareTo(Pair o) {
			return compare(partialKey, o.partialKey);
		}
	}

	public static int compare(byte a, byte b) {
		return toInt(a) - toInt(b);
	}
	public static int toInt(byte value) {
		return value & 0xFF;
	}

	protected InnerNode node;
	protected Pair[] existingData;

	InnerNodeUnitTest(int nodeSize) {
		InnerNode node = new Node4();
		existingData = new Pair[nodeSize + 1];
		for (int j = 0, i = -nodeSize / 2; j < nodeSize + 1; i++, j++) {
			if (node.isFull()) {
				node = node.grow();
			}
			Pair p = new Pair((byte) i, Mockito.spy(Node.class));
			existingData[j] = p;
			node.addChild(p.partialKey, p.child);
		}
		this.node = node;
	}

	@BeforeEach
	public void setup() {
		int i = 0;
		for (; i < existingData.length; i++) {
			if (existingData[i].partialKey < 0) {
				break;
			}
		}
		assertTrue(i < existingData.length, "sample key set should contain at least"
				+ " one negative integer to test for unsigned lexicographic ordering");
	}

	// lexicographic sorted order: 0, 1, -2, -1
	// -2, -1, 0, 1
	byte[] existingKeys() {
		byte[] keys = new byte[existingData.length];
		for (int i = 0; i < keys.length; i++) {
			keys[i] = existingData[i].partialKey;
		}
		return keys;
	}

	void verifyUnsignedLexicographicOrder() {
		verifyUnsignedLexicographicOrder(node);
	}

	/*
			work only with interface methods
			we don't care about the implementation details
			for example how Node4 stores bytes as unsigned, etc.
			we just care about the right lexicographic ordering.
			of course this requires us to test with negative as well as
			positive data set and hence the check in test setup.
			we don't test child mappings, since that is tested in findChild already (if the same mappings
			are maintained).
			this really is making sure negative bytes come after positives.
			we don't really want to test that children storage is sorted,
			all we want is if the lexicographic order dependant methods (first, last, greater, lesser)
			are answered correctly.
			they might be answered correctly even without storing the children in sorted order,
			but we don't care as a generic test suite.
			we base our assertions on invariants.
		 */
	void verifyUnsignedLexicographicOrder(InnerNode node) {
		boolean negExist = false;
		byte prev = node.first().uplinkKey();
		if (prev < 0) {
			negExist = true;
		}
		for (int i = 1; i < node.size(); i++) {
			byte next = node.greater(prev).uplinkKey();
			assertTrue(compare(prev, next) < 0);
			prev = next;
			if (prev < 0) {
				negExist = true;
			}
		}
		assertTrue(negExist, "expected at least one negative byte to test lexicographic ordering");

		prev = node.last().uplinkKey();
		for (int i = node.size() - 2; i >= 0; i--) {
			byte next = node.lesser(prev).uplinkKey();
			assertTrue(compare(prev, next) > 0);
			prev = next;
		}
	}


	/*
		add partial keys
		all key, child mappings should exist
		size increase
		uplinks setup
		expect keys to be in the right unsigned lexicographic order
	 */
	@Test
	public void testAddAndFindChild() {
		List<Pair> pairs = new ArrayList<>(Arrays.asList(existingData));
		for (byte i = 0; !node.isFull(); i++) {
			if (node.findChild(i) != null) {
				continue;
			}
			Pair p = new Pair(i, Mockito.spy(Node.class));
			pairs.add(p);
			node.addChild(p.partialKey, p.child);
		}

		// size
		assertEquals(node.size(), pairs.size());

		for (Pair p : pairs) {
			// uplinks setup
			assertEquals(node, p.child.parent());
			assertEquals(p.partialKey, p.child.uplinkKey());
			// all added partial keys exist
			assertEquals(p.child, node.findChild(p.partialKey));
		}

		verifyUnsignedLexicographicOrder();
	}

	/*
		sort sample data and expect the smallest lexicographic byte
	 */
	@Test
	public void testFirst() {
		byte[] data = existingKeys();
		sort(data);
		assertEquals(node.first().uplinkKey(), data[0]);
	}

	/*
		sort sample data and expect the largest lexicographic byte
	 */
	@Test
	public void testLast() {
		byte[] data = existingKeys();
		sortDescending(data);
		assertEquals(node.last().uplinkKey(), data[0]);
	}

	/*
		nothing greater than greatest
		first is greater than smallest lexicographic unsigned i.e. 0 (0000 0000)
	 */
	@Test
	public void testGreater() {
		Node last = node.last();
		assertNull(node.greater(last.uplinkKey()));
		Arrays.sort(existingData);
		for (int i = 0; i < node.size() - 1; i++) {
			Node greater = node.greater(existingData[i].partialKey);
			assertEquals(existingData[i + 1].child, greater);
		}
	}

	/*
		nothing lesser than least
		last is lesser than largest lexicographic unsigned i.e. -1 (1111 1111)
	 */
	@Test
	public void testLesser() {
		Node first = node.first();
		assertNull(node.lesser(first.uplinkKey()));
		Arrays.sort(existingData);
		for (int i = 1; i < node.size(); i++) {
			Node lesser = node.lesser(existingData[i].partialKey);
			assertEquals(existingData[i - 1].child, lesser);
		}
	}

	/*
		remove child
		unsigned lexicopgrahic order maintained
		removes uplink
		reduces size
		child no longer exists (findChild)
	 */
	@Test
	public void testRemove() {
		// since we remove two in the test
		// we must not break constraint of a node that it must have
		// a number of minimum elements (check node size assert in first, last assert)
		byte minByte = Byte.MAX_VALUE, maxByte = Byte.MIN_VALUE;
		for(int i = 0; i < existingKeys().length; i++){
			if(existingData[i].partialKey > maxByte){
				maxByte = existingData[i].partialKey;
			}
			if(existingData[i].partialKey < minByte){
				minByte = existingData[i].partialKey;
			}
		}
		Pair p = new Pair((byte)(minByte-1), Mockito.spy(Node.class));
		node.addChild(p.partialKey, p.child);
		p = new Pair((byte)(maxByte+1), Mockito.spy(Node.class));
		if(!node.isFull()){ // need for Node4 since we add 3 elements in test setup already
			node.addChild(p.partialKey, p.child);
		}

		int initialSize = node.size();

		// remove at head
		Node head = node.first();
		node.removeChild(head.uplinkKey());
		assertNull(node.findChild(head.uplinkKey()));
		assertEquals(initialSize - 1, node.size());
		assertNull(head.parent());

		// remove at tail
		Node tail = node.last();
		node.removeChild(tail.uplinkKey());
		assertNull(node.findChild(tail.uplinkKey()));
		assertEquals(initialSize - 2, node.size());
		assertNull(tail.parent());

		verifyUnsignedLexicographicOrder();
	}

	/*
		after growing, new node:
		 contains same key, child mappings in same lexicographic order but with uplinks to new grown node
		 same prefix key, no of children, uplink key, parent
	 */
	@Test
	public void testGrow() {
		List<Pair> pairs = new ArrayList<>(Arrays.asList(existingData));
		byte i;
		Pair pair;
		// fill node to capacity
		for (i = 0; ; i++) {
			if (node.findChild(i) != null) {
				continue; // find at least one non existent child to force add
			}
			pair = new Pair(i, Mockito.spy(Node.class));
			if (node.isFull()) {
				break;
			}
			pairs.add(pair);
			node.addChild(pair.partialKey, pair.child);
		}

		// capacity reached
		assertTrue(node.isFull());

		// hence we need to grow
		InnerNode grown = node.grow();
		assertEquals(node.size(), grown.size());
		assertEqualHeader(node, grown);

		// add child on newly grown node
		grown.addChild(pair.partialKey, pair.child);
		pairs.add(pair);

		// verify same key, child mappings exist
		for (i = 0; i < pairs.size(); i++) {
			Pair p = pairs.get(i);
			// uplinks setup
			assertEquals(grown, p.child.parent());
			assertEquals(p.partialKey, p.child.uplinkKey());
			// all added partial keys exist
			assertEquals(p.child, grown.findChild(p.partialKey));
		}
		verifyUnsignedLexicographicOrder(grown);
	}

	/*
		after shrinking contains same key, child mappings
		lexicographic order maintained
		same parent as before, prefix len, prefix keys
	 */
	@Test
	public void testShrink() {
		List<Pair> pairs = new ArrayList<>(Arrays.asList(existingData));
		while (!node.shouldShrink()) {
			node.removeChild(pairs.remove(0).partialKey);
		}
		assertTrue(node.shouldShrink());
		InnerNode shrunk = node.shrink();

		assertEquals(shrunk.size(), node.size());
		assertEqualHeader(node, shrunk);

		// verify same key, child mappings exist
		for (Pair p : pairs) {
			// uplinks setup
			assertEquals(shrunk, p.child.parent());
			assertEquals(p.partialKey, p.child.uplinkKey());
			// all added partial keys exist
			assertEquals(p.child, shrunk.findChild(p.partialKey));
		}
		verifyUnsignedLexicographicOrder(shrunk);
	}

	void assertEqualHeader(Node a, Node b) {
		InnerNode aa = (InnerNode) a;
		InnerNode bb = (InnerNode) b;
		assertEquals(aa.prefixLen, bb.prefixLen);
		assertArrayEquals(getValidPrefixKey(aa), getValidPrefixKey(bb));
		assertEquals(aa.parent(), bb.parent());
		assertEquals(aa.uplinkKey(), bb.uplinkKey());
	}


	static byte[] getValidPrefixKey(InnerNode innerNode) {
		int limit = Math.min(InnerNode.PESSIMISTIC_PATH_COMPRESSION_LIMIT, innerNode.prefixLen);
		byte[] valid = new byte[limit];
		System.arraycopy(innerNode.prefixKeys, 0, valid, 0, limit);
		return valid;
	}

	/*
		replace the child associated with a key
		assert new child found
		same size
		lexicographic order maintained
		uplink setup for new child
		old child uplink stays:
			why? because in lazy leaf expansion case, we first link current leaf node with a
			new Node4() and later replace current down pointer to this leaf node with this new
			Node4() parent. If we remove old child's uplink, it could be the case that the old child
			has been linked with a new parent.
			Well we could make sure that explicitly in the branch, but it is fine
			to not do in replace as well.
	 */
	@Test
	public void testReplace() {
		Node first = node.first();
		Node newChild = Mockito.spy(Node.class);
		node.replace(first.uplinkKey(), newChild);
		assertEquals(newChild, node.findChild(first.uplinkKey()));
		assertEquals(existingData.length, node.size());
		assertEquals(newChild.uplinkKey(), first.uplinkKey());
		assertEquals(node, newChild.parent());
		assertEquals(first.uplinkKey(), first.uplinkKey());
		assertEquals(node, first.parent());
	}

	public static void sort(byte[] array) {
		sort(array, 0, array.length);
	}

	public static void sort(byte[] array, int fromIndex, int toIndex) {
		for (int i = fromIndex; i < toIndex; i++) {
			array[i] = flip(array[i]);
		}
		Arrays.sort(array, fromIndex, toIndex);
		for (int i = fromIndex; i < toIndex; i++) {
			array[i] = flip(array[i]);
		}
	}

	private static byte flip(byte b) {
		return (byte) (b ^ 0x80);
	}

	public static void sortDescending(byte[] array) {
		sortDescending(array, 0, array.length);
	}

	public static void sortDescending(byte[] array, int fromIndex, int toIndex) {
		for (int i = fromIndex; i < toIndex; i++) {
			array[i] ^= Byte.MAX_VALUE;
		}
		Arrays.sort(array, fromIndex, toIndex);
		for (int i = fromIndex; i < toIndex; i++) {
			array[i] ^= Byte.MAX_VALUE;
		}
	}
}
