#include "utilities/IndexSelection.h"
#include "unittest/TestSuite.h"
#include <limits.h>

static void testInit(void) {
	IndexSelection * selection = IndexSelection_create();
	TestCase_assertUIntEqual(selection->indexCount, 0);
	TestCase_assertPointerNULL(selection->indexes);
	TestCase_assertPointerNonNULL(selection->reverseLookup);
	TestCase_assertUIntEqual(selection->selectionDirtyValue, 0);
	TestCase_assertUIntEqual(selection->reverseLookupDirtyValue, 0);
	IndexSelection_dispose(selection);
}

static void testBasicOperations(void) {
	IndexSelection * selection = IndexSelection_create();
	unsigned int selectionIndex = UINT_MAX;
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 0, &selectionIndex));
	TestCase_assertBoolTrue(IndexSelection_selectIndex(selection, 0, true));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 0, &selectionIndex));
	TestCase_assertUIntEqual(selectionIndex, 0);
	TestCase_assertBoolFalse(IndexSelection_selectIndex(selection, 0, false));
	
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 1, &selectionIndex));
	TestCase_assertBoolTrue(IndexSelection_selectIndex(selection, 1, true));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 1, &selectionIndex));
	TestCase_assertUIntEqual(selectionIndex, 1);
	
	TestCase_assertBoolFalse(IndexSelection_deselectIndex(selection, 2));
	IndexSelection_selectIndex(selection, 2, true);
	TestCase_assertBoolTrue(IndexSelection_deselectIndex(selection, 2));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 2, NULL));
	
	TestCase_assertBoolFalse(IndexSelection_toggleIndex(selection, 0));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 0, NULL));
	
	TestCase_assertBoolTrue(IndexSelection_toggleIndex(selection, 2));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 2, NULL));
	
	IndexSelection_deselectItemAtIndex(selection, 0);
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 1, NULL));
	
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 3, NULL));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 4, NULL));
	TestCase_assertBoolTrue(IndexSelection_selectRange(selection, 3, 2, true));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 3, NULL));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 4, NULL));
	TestCase_assertBoolFalse(IndexSelection_selectRange(selection, 3, 2, false));
	
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 5, NULL));
	IndexSelection_toggleRange(selection, 4, 2);
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 4, NULL));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 5, NULL));
	
	TestCase_assertBoolTrue(IndexSelection_truncateSelectionToMaxIndexCount(selection, 5));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 2, &selectionIndex));
	TestCase_assertUIntEqual(selectionIndex, 0);
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(selection, 3, &selectionIndex));
	TestCase_assertUIntEqual(selectionIndex, 1);
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 6, &selectionIndex));
	
	TestCase_assertBoolTrue(IndexSelection_deselectAll(selection));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 2, NULL));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(selection, 4, NULL));
	TestCase_assertUIntEqual(selection->indexCount, 0);
	
	TestCase_assertBoolFalse(IndexSelection_deselectAll(selection));
	IndexSelection_dispose(selection);
}

static void testCopy(void) {
	IndexSelection * selection = IndexSelection_create();
	IndexSelection * copy = IndexSelection_copy(selection);
	IndexSelection_dispose(selection);
	
	TestCase_assertUIntEqual(copy->indexCount, 0);
	TestCase_assertPointerNULL(copy->indexes);
	TestCase_assertPointerNonNULL(copy->reverseLookup);
	TestCase_assertUIntEqual(copy->selectionDirtyValue, 0);
	TestCase_assertUIntEqual(copy->reverseLookupDirtyValue, 0);
	IndexSelection_dispose(copy);
	
	selection = IndexSelection_create();
	IndexSelection_selectIndex(selection, 1, true);
	IndexSelection_selectIndex(selection, 3, true);
	copy = IndexSelection_copy(selection);
	IndexSelection_dispose(selection);
	
	TestCase_assertUIntEqual(copy->indexCount, 2);
	TestCase_assertPointerNonNULL(copy->indexes);
	TestCase_assertUIntEqual(copy->indexes[0], 1);
	TestCase_assertUIntEqual(copy->indexes[1], 3);
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(copy, 0, NULL));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(copy, 1, NULL));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(copy, 2, NULL));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(copy, 3, NULL));
	TestCase_assertBoolFalse(IndexSelection_isIndexSelected(copy, 4, NULL));
	
	IndexSelection * copy2 = IndexSelection_create();
	IndexSelection_copySelectionFrom(copy2, copy);
	IndexSelection_dispose(copy);
	
	TestCase_assertUIntEqual(copy2->indexCount, 2);
	TestCase_assertPointerNonNULL(copy2->indexes);
	TestCase_assertUIntEqual(copy2->indexes[0], 1);
	TestCase_assertUIntEqual(copy2->indexes[1], 3);
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(copy2, 1, NULL));
	TestCase_assertBoolTrue(IndexSelection_isIndexSelected(copy2, 3, NULL));
	IndexSelection_dispose(copy2);
}

static void testAdjustIndexes(void) {
	IndexSelection * selection = IndexSelection_create();
	IndexSelection_selectIndex(selection, 0, true);
	IndexSelection_selectIndex(selection, 2, true);
	IndexSelection_selectIndex(selection, 5, true);
	IndexSelection_selectIndex(selection, 9, true);
	
	IndexSelection_adjustIndexes(selection, 3, 1);
	TestCase_assertUIntEqual(selection->indexCount, 4);
	TestCase_assertUIntEqual(selection->indexes[0], 0);
	TestCase_assertUIntEqual(selection->indexes[1], 2);
	TestCase_assertUIntEqual(selection->indexes[2], 6);
	TestCase_assertUIntEqual(selection->indexes[3], 10);
	
	IndexSelection_adjustIndexes(selection, 2, -7);
	TestCase_assertUIntEqual(selection->indexCount, 2);
	TestCase_assertUIntEqual(selection->indexes[0], 0);
	TestCase_assertUIntEqual(selection->indexes[1], 3);
	IndexSelection_dispose(selection);
}

static void testMinMaxSelectedIndex(void) {
	IndexSelection * selection = IndexSelection_create();
	unsigned int selectionIndex = UINT_MAX;
	unsigned int minIndex = IndexSelection_getMinSelectedIndex(selection, &selectionIndex);
	TestCase_assertUIntEqual(minIndex, UINT_MAX);
	unsigned int maxIndex = IndexSelection_getMaxSelectedIndex(selection, &selectionIndex);
	TestCase_assertUIntEqual(maxIndex, UINT_MAX);
	
	IndexSelection_selectIndex(selection, 5, true);
	minIndex = IndexSelection_getMinSelectedIndex(selection, &selectionIndex);
	TestCase_assertUIntEqual(minIndex, 5);
	TestCase_assertUIntEqual(selectionIndex, 0);
	selectionIndex = UINT_MAX;
	maxIndex = IndexSelection_getMaxSelectedIndex(selection, &selectionIndex);
	TestCase_assertUIntEqual(maxIndex, 5);
	TestCase_assertUIntEqual(selectionIndex, 0);
	
	IndexSelection_selectIndex(selection, 3, true);
	IndexSelection_selectIndex(selection, 8, true);
	IndexSelection_selectIndex(selection, 7, true);
	minIndex = IndexSelection_getMinSelectedIndex(selection, &selectionIndex);
	TestCase_assertUIntEqual(minIndex, 3);
	TestCase_assertUIntEqual(selectionIndex, 1);
	maxIndex = IndexSelection_getMaxSelectedIndex(selection, &selectionIndex);
	TestCase_assertUIntEqual(maxIndex, 8);
	TestCase_assertUIntEqual(selectionIndex, 2);
	
	IndexSelection_deselectItemAtIndex(selection, 2);
	IndexSelection_selectIndex(selection, 1, true);
	minIndex = IndexSelection_getMinSelectedIndex(selection, NULL);
	TestCase_assertUIntEqual(minIndex, 1);
	maxIndex = IndexSelection_getMaxSelectedIndex(selection, NULL);
	TestCase_assertUIntEqual(maxIndex, 7);
	IndexSelection_dispose(selection);
}

static void testRemoveDuplicates(void) {
	IndexSelection * selection = IndexSelection_create();
	unsigned int result = IndexSelection_removeDuplicates(selection);
	TestCase_assertUIntEqual(result, 0);
	
	IndexSelection_selectIndex(selection, 0, true);
	IndexSelection_selectIndex(selection, 1, true);
	result = IndexSelection_removeDuplicates(selection);
	TestCase_assertUIntEqual(result, 0);
	TestCase_assertUIntEqual(selection->indexCount, 2);
	
	IndexSelection_selectIndex(selection, 0, true);
	result = IndexSelection_removeDuplicates(selection);
	TestCase_assertUIntEqual(result, 1);
	TestCase_assertUIntEqual(selection->indexCount, 2);
	TestCase_assertUIntEqual(selection->indexes[0], 0);
	TestCase_assertUIntEqual(selection->indexes[1], 1);
	
	IndexSelection_selectIndex(selection, 3, true);
	IndexSelection_selectIndex(selection, 4, true);
	IndexSelection_selectIndex(selection, 3, true);
	IndexSelection_selectIndex(selection, 1, true);
	result = IndexSelection_removeDuplicates(selection);
	TestCase_assertUIntEqual(result, 2);
	TestCase_assertUIntEqual(selection->indexCount, 4);
	TestCase_assertUIntEqual(selection->indexes[0], 0);
	TestCase_assertUIntEqual(selection->indexes[1], 1);
	TestCase_assertUIntEqual(selection->indexes[2], 3);
	TestCase_assertUIntEqual(selection->indexes[3], 4);
	IndexSelection_dispose(selection);
}

TEST_SUITE(IndexSelectionTest,
           testInit,
           testBasicOperations,
           testCopy,
           testAdjustIndexes,
           testMinMaxSelectedIndex,
           testRemoveDuplicates)