#include "../Tests.h"
#include "core/BitArray.h"

static void testSetRead() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 4, 3);
    coreBitArraySet(&bits, 0, 1);
    coreBitArraySet(&bits, 1, 2);
    coreBitArraySet(&bits, 2, 3);
    coreBitArraySet(&bits, 3, 4);
    CORE_TEST_U64(1, coreBitArrayGet(&bits, 0));
    CORE_TEST_U64(2, coreBitArrayGet(&bits, 1));
    CORE_TEST_U64(3, coreBitArrayGet(&bits, 2));
    CORE_TEST_U64(4, coreBitArrayGet(&bits, 3));
    coreDestroyBitArray(&bits);
}

static void testBigSetRead() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 100, 13);
    for(size_t i = 0; i < bits.length; i++) {
        coreBitArraySet(&bits, i, i);
    }
    for(size_t i = 0; i < bits.length; i++) {
        CORE_TEST_U64(i, coreBitArrayGet(&bits, i));
    }
    coreDestroyBitArray(&bits);
}

static void testRandomSetReadResize() {
    u64 data[100];
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 100, 13);
    u64 seed = 534;
    for(int k = 0; k < 20; k++) {
        for(u64 i = 0; i < bits.length; i++) {
            seed = seed * 636455 + 53453;
            coreBitArraySet(&bits, i, seed);
            data[i] = seed & 0x1FFF;
        }
    }
    for(size_t i = 0; i < bits.length; i++) {
        CORE_TEST_U64(data[i], coreBitArrayGet(&bits, i));
    }
    coreResizeBitArray(&bits, bits.length, bits.bits + 1u);
    CORE_TEST_U64(14, bits.bits);
    CORE_TEST_U64(100, bits.length);
    for(size_t i = 0; i < bits.length; i++) {
        CORE_TEST_U64(data[i], coreBitArrayGet(&bits, i));
    }
    coreDestroyBitArray(&bits);
}

static void testCopy() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 4, 3);
    coreBitArraySet(&bits, 0, 1);
    coreBitArraySet(&bits, 1, 2);
    coreBitArraySet(&bits, 2, 3);
    coreBitArraySet(&bits, 3, 4);
    CoreBitArray copy = CORE_BIT_ARRAY;
    coreCopyBitArray(&copy, &bits);
    coreCopyBitArray(&copy, &copy);
    CORE_TEST_U64(1, coreBitArrayGet(&copy, 0));
    CORE_TEST_U64(2, coreBitArrayGet(&copy, 1));
    CORE_TEST_U64(3, coreBitArrayGet(&copy, 2));
    CORE_TEST_U64(4, coreBitArrayGet(&copy, 3));
    coreDestroyBitArray(&copy);
    coreDestroyBitArray(&bits);
}

static void testSelect() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 90, 1);
    coreFillBitArray(&bits, 0);
    coreBitArraySet(&bits, 0, 1);
    coreBitArraySet(&bits, 5, 1);
    coreBitArraySet(&bits, 20, 1);
    coreBitArraySet(&bits, 31, 1);
    coreBitArraySet(&bits, 32, 1);
    coreBitArraySet(&bits, 33, 1);
    coreBitArraySet(&bits, 60, 1);
    CORE_TEST_I64(-1, coreBitArraySelect(&bits, 0));
    CORE_TEST_I64(0, coreBitArraySelect(&bits, 1));
    CORE_TEST_I64(5, coreBitArraySelect(&bits, 2));
    CORE_TEST_I64(20, coreBitArraySelect(&bits, 3));
    CORE_TEST_I64(31, coreBitArraySelect(&bits, 4));
    CORE_TEST_I64(32, coreBitArraySelect(&bits, 5));
    CORE_TEST_I64(33, coreBitArraySelect(&bits, 6));
    CORE_TEST_I64(60, coreBitArraySelect(&bits, 7));
    CORE_TEST_I64(-1, coreBitArraySelect(&bits, 8));
    coreDestroyBitArray(&bits);
}

static void testToString1() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 4, 3);
    coreBitArraySet(&bits, 0, 1);
    coreBitArraySet(&bits, 1, 2);
    coreBitArraySet(&bits, 2, 3);
    coreBitArraySet(&bits, 3, 4);
    char buffer[128];
    size_t n = coreToStringBitArray(&bits, buffer, sizeof(buffer));
    CORE_TEST_SIZE(12, n);
    CORE_TEST_STRING("[1, 2, 3, 4]", buffer);
    coreDestroyBitArray(&bits);
}

static void testToString2() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 1, 3);
    coreBitArraySet(&bits, 0, 1);
    char buffer[128];
    size_t n = coreToStringBitArray(&bits, buffer, sizeof(buffer));
    CORE_TEST_SIZE(3, n);
    CORE_TEST_STRING("[1]", buffer);
    coreDestroyBitArray(&bits);
}

static void testToString3() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    char buffer[128];
    size_t n = coreToStringBitArray(&bits, buffer, sizeof(buffer));
    CORE_TEST_SIZE(2, n);
    CORE_TEST_STRING("[]", buffer);
    coreDestroyBitArray(&bits);
}

static void testResizeExact() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    CORE_TEST_U64(0, coreBitArrayBytes(&bits));
    // the size in bytes matches the internal storage type
    size_t elements = sizeof(u64);
    coreResizeBitArray(&bits, elements, 8);
    for(size_t i = 0; i < elements; i++) {
        coreBitArraySet(&bits, i, i);
    }
    for(size_t i = 0; i < elements; i++) {
        CORE_TEST_U64(i, coreBitArrayGet(&bits, i));
    }
    CORE_TEST_U64(sizeof(u64), coreBitArrayBytes(&bits));
    coreDestroyBitArray(&bits);
}

static void testMove() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 8, 8);
    for(size_t i = 0; i < bits.length; i++) {
        coreBitArraySet(&bits, i, i);
    }
    CoreBitArray m = CORE_BIT_ARRAY;
    coreMoveBitArray(&m, &bits);
    coreMoveBitArray(&m, &m);
    CORE_TEST_U64(8, m.length);
    for(size_t i = 0; i < m.length; i++) {
        CORE_TEST_U64(i, coreBitArrayGet(&m, i));
    }
    coreDestroyBitArray(&m);
    coreDestroyBitArray(&bits);
}

static void testInvalidArgument() {
    CoreBitArray bits = CORE_BIT_ARRAY;
    coreResizeBitArray(&bits, 0, 5);
    CORE_TEST_SIZE(0, bits.length);
    CORE_TEST_SIZE(0, bits.bits);
    coreResizeBitArray(&bits, 5, 0);
    CORE_TEST_SIZE(0, bits.length);
    CORE_TEST_SIZE(0, bits.bits);
    coreResizeBitArray(&bits, 0, 0);
    CORE_TEST_SIZE(0, bits.length);
    CORE_TEST_SIZE(0, bits.bits);
    coreResizeBitArray(&bits, 1, 65);
    CORE_TEST_SIZE(1, bits.length);
    CORE_TEST_SIZE(64, bits.bits);
    coreResizeBitArray(&bits, 5, 68);
    CORE_TEST_SIZE(5, bits.length);
    CORE_TEST_SIZE(64, bits.bits);
    coreDestroyBitArray(&bits);
}

void coreTestBitArray() {
    testSetRead();
    testBigSetRead();
    testRandomSetReadResize();
    testCopy();
    testSelect();
    testToString1();
    testToString2();
    testToString3();
    testResizeExact();
    testMove();
    testInvalidArgument();
}