#include "tests/BitArrayTests.h"

#include "data/BitArray.h"
#include "test/Test.h"

using String = Core::ArrayString<128>;

template<typename T>
static String build(const T& t) {
    String s;
    CORE_TEST_FALSE(s.append(t));
    return s;
}

static void testSetRead() {
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(4, 3));
    bits.set(0, 1).set(1, 2).set(2, 3).set(3, 4);
    CORE_TEST_EQUAL(1, bits.get(0));
    CORE_TEST_EQUAL(2, bits.get(1));
    CORE_TEST_EQUAL(3, bits.get(2));
    CORE_TEST_EQUAL(4, bits.get(3));
}

static void testOutOfBoundsSetRead() {
    Core::BitArray bits;
    bits.set(0, 1).set(1, 2).set(2, 3).set(3, 4);
    CORE_TEST_EQUAL(0, bits.get(0));
    CORE_TEST_EQUAL(0, bits.get(1));
    CORE_TEST_EQUAL(0, bits.get(2));
    CORE_TEST_EQUAL(0, bits.get(3));
}

static void testBigSetRead() {
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(100, 13));
    for(int i = 0; i < bits.getLength(); i++) {
        bits.set(i, i);
    }
    for(int i = 0; i < bits.getLength(); i++) {
        CORE_TEST_EQUAL(i, bits.get(i));
    }
}

static void testRandomSetReadResize() {
    const int length = 100;
    int data[length];
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(100, 13));
    int seed = 534;
    for(int k = 0; k < 20; k++) {
        for(int i = 0; i < bits.getLength(); i++) {
            seed = seed * 636455 + 53453;
            bits.set(i, seed & (0x1FFF));
            data[i] = seed & (0x1FFF);
        }
    }
    for(int i = 0; i < bits.getLength(); i++) {
        CORE_TEST_EQUAL(data[i], bits.get(i));
    }
    CORE_TEST_FALSE(bits.resize(bits.getLength(), bits.getBits() + 1));
    CORE_TEST_EQUAL(14, bits.getBits());
    CORE_TEST_EQUAL(100, bits.getLength());
    for(int i = 0; i < bits.getLength(); i++) {
        CORE_TEST_EQUAL(data[i], bits.get(i));
    }
}

static void testReadOnly() {
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(4, 3));
    bits.set(0, 1).set(1, 2).set(2, 3).set(3, 4);
    Core::BitArray copy;
    CORE_TEST_FALSE(copy.copyFrom(bits));
    const Core::BitArray bits2 = Core::move(copy);
    CORE_TEST_EQUAL(1, bits2.get(0));
    CORE_TEST_EQUAL(2, bits2.get(1));
    CORE_TEST_EQUAL(3, bits2.get(2));
    CORE_TEST_EQUAL(4, bits2.get(3));
}

static void testSelect() {
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(90, 1));
    bits.fill(0);
    bits.set(0, 1).set(5, 1).set(20, 1).set(31, 1);
    bits.set(32, 1).set(33, 1).set(60, 1);
    CORE_TEST_EQUAL(-1, bits.select(-1));
    CORE_TEST_EQUAL(-1, bits.select(0));
    CORE_TEST_EQUAL(0, bits.select(1));
    CORE_TEST_EQUAL(5, bits.select(2));
    CORE_TEST_EQUAL(20, bits.select(3));
    CORE_TEST_EQUAL(31, bits.select(4));
    CORE_TEST_EQUAL(32, bits.select(5));
    CORE_TEST_EQUAL(33, bits.select(6));
    CORE_TEST_EQUAL(60, bits.select(7));
    CORE_TEST_EQUAL(-1, bits.select(8));
}

static void testToString1() {
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(4, 3));
    bits.set(0, 1).set(1, 2).set(2, 3).set(3, 4);
    CORE_TEST_EQUAL(build("[1, 2, 3, 4]"), build(bits));
}

static void testToString2() {
    Core::BitArray bits;
    CORE_TEST_FALSE(bits.resize(1, 3));
    bits.set(0, 1);
    CORE_TEST_EQUAL(build("[1]"), build(bits));
}

static void testToString3() {
    Core::BitArray bits;
    CORE_TEST_EQUAL(build("[]"), build(bits));
}

void Core::BitArrayTests::test() {
    testSetRead();
    testOutOfBoundsSetRead();
    testBigSetRead();
    testRandomSetReadResize();
    testReadOnly();
    testSelect();
    testToString1();
    testToString2();
    testToString3();
}