#include "../Tests.hpp"
#include "core/List.hpp"
#include "core/Test.hpp"

template class Core::List<size_t>;
using IntList = Core::List<size_t>;

static void testAdd() {
    IntList list;
    list.add(5u);
    const IntList& cList = list;
    TEST(5, list[0]);
    TEST(5, list.getLast());
    TEST(5, cList[0]);
    TEST(5, cList.getLast());
    TEST(1, list.getLength());
}

static void testMultipleAdd() {
    IntList list;
    list.add(4u).add(3u).add(2u);
    TEST(4, list[0]);
    TEST(3, list[1]);
    TEST(2, list[2]);
    TEST(3, list.getLength());
}

static void testAddReplace() {
    IntList list;
    list.add(5u);
    list[0] = 3;
    TEST(3, list[0]);
}

static void testClear() {
    IntList list;
    list.add(5u).add(4u);
    list.clear();
    TEST(0, list.getLength());
}

static void testShrink() {
    IntList list;
    list.add(5u).add(4u).add(3u);
    TEST_TRUE(list.getCapacity() >= 3);
    list.shrink();
    TEST_TRUE(list.getLength() == 3);
    TEST_TRUE(list.getCapacity() == 3);
    TEST(5, list[0]);
    TEST(4, list[1]);
    TEST(3, list[2]);
}

static void testBigAdd(bool light) {
    size_t limit = light ? 10'000 : 100'000;
    IntList list;
    for(size_t i = 0; i < limit; i++) {
        list.add(i);
    }
    for(size_t i = 0; i < list.getLength(); i++) {
        TEST(i, list[i]);
    }
    TEST(limit, list.getLength());
}

static void testCopy() {
    IntList list;
    list.add(1u).add(2u).add(3u);

    IntList copy = list;
    TEST(list.getLength(), copy.getLength());
    size_t limit = Core::min(copy.getLength(), list.getLength());
    for(size_t i = 0; i < limit; i++) {
        TEST(list[i], copy[i]);
    }
}

static void testMove() {
    IntList list;
    list.add(1u).add(2u).add(3u);

    IntList move(Core::move(list));
    TEST(0, list.getLength());
    TEST(3, move.getLength());
    TEST(1, move[0]);
    TEST(2, move[1]);
    TEST(3, move[2]);
}

static void testMoveAssignment() {
    IntList list;
    list.add(1u).add(2u).add(3u);

    IntList move;
    move = Core::move(list);
    TEST(0, list.getLength());
    TEST(3, move.getLength());
    TEST(1, move[0]);
    TEST(2, move[1]);
    TEST(3, move[2]);
}

static void testToString1() {
    IntList list;
    list.add(1u).add(243u).add(423u);
    TEST_STRING("[1, 243, 423]", list);
}

static void testToString2() {
    IntList list;
    list.add(1u);
    TEST_STRING("[1]", list);
}

static void testToString3() {
    IntList list;
    TEST_STRING("[]", list);
}

static void testRemoveBySwap() {
    IntList list;
    list.add(4u).add(3u).add(2u);
    list.removeBySwap(0);
    TEST(2, list[0]);
    TEST(3, list[1]);
    TEST(2, list.getLength());
    list.removeBySwap(1);
    TEST(2, list[0]);
    TEST(1, list.getLength());
    list.removeBySwap(0);
    TEST(0, list.getLength());
}

static void testRemove() {
    IntList list;
    list.add(4u).add(3u).add(2u);
    list.remove(0);
    TEST(3, list[0]);
    TEST(2, list[1]);
    TEST(2, list.getLength());
    list.remove(1);
    TEST(3, list[0]);
    TEST(1, list.getLength());
    list.remove(0);
    TEST(0, list.getLength());
}

static void testRemoveLast() {
    IntList list;
    list.add(4u).add(3u).add(2u);
    list.removeLast();
    TEST(4, list[0]);
    TEST(3, list[1]);
    TEST(2, list.getLength());
    list.removeLast();
    TEST(4, list[0]);
    TEST(1, list.getLength());
    list.removeLast();
    TEST(0, list.getLength());
}

static void testResize() {
    IntList list;
    list.resize(5, 10);
    TEST(5, list.getLength());
    for(size_t i = 0; i < 5; i++) {
        TEST(10, list[i]);
    }
}

static void testDefaultResize() {
    IntList list;
    list.resize(5);
    TEST(5, list.getLength());
    for(size_t i = 0; i < 5; i++) {
        TEST(0, list[i]);
    }
}

static void testInvalidReserve() {
    IntList list;
    list.reserve(0);
}

static void testShrinkExact() {
    IntList list;
    list.resize(50);
    list.shrink();
}

static void testShrinkResize() {
    IntList list;
    list.resize(50);
    list.resize(20, 5);
    list.resize(10);
}

static void testCopyEmpty() {
    IntList list;
    IntList copy = list;
}

static int listInstances = 0;

struct ListTest final {
    int value;

    ListTest(int i) : value(i) {
        listInstances++;
    }

    ListTest(const ListTest& o) = delete;

    ListTest(ListTest&& o) noexcept : value(o.value) {
        listInstances++;
    }

    ~ListTest() {
        listInstances--;
    }

    ListTest& operator=(ListTest&& o) noexcept {
        value = o.value;
        return *this;
    }

    ListTest& operator=(const ListTest& o) = delete;
};

static void testInsert() {
    Core::List<ListTest> l;
    l.addAt(0, 1);
    TEST(1, l.getLength());
    TEST(1, l[0].value);
    TEST(1, listInstances);

    l.addAt(0, 2);
    TEST(2, l.getLength());
    TEST(2, l[0].value);
    TEST(1, l[1].value);
    TEST(2, listInstances);

    l.addAt(0, 3);
    TEST(3, l.getLength());
    TEST(3, l[0].value);
    TEST(2, l[1].value);
    TEST(1, l[2].value);
    TEST(3, listInstances);

    l.addAt(1, 4);
    TEST(4, l.getLength());
    TEST(3, l[0].value);
    TEST(4, l[1].value);
    TEST(2, l[2].value);
    TEST(1, l[3].value);
    TEST(4, listInstances);

    l.addAt(2, 5);
    TEST(5, l.getLength());
    TEST(3, l[0].value);
    TEST(4, l[1].value);
    TEST(5, l[2].value);
    TEST(2, l[3].value);
    TEST(1, l[4].value);
    TEST(5, listInstances);

    l.addAt(5, 4);
    TEST(6, l.getLength());
    TEST(3, l[0].value);
    TEST(4, l[1].value);
    TEST(5, l[2].value);
    TEST(2, l[3].value);
    TEST(1, l[4].value);
    TEST(4, l[5].value);
    TEST(6, listInstances);

    l.clear();
    TEST(0, listInstances);
}

void testList(bool light) {
    testAdd();
    testMultipleAdd();
    testAddReplace();
    testClear();
    testShrink();
    testBigAdd(light);
    testCopy();
    testMove();
    testMoveAssignment();
    testToString1();
    testToString2();
    testToString3();
    testRemoveBySwap();
    testRemove();
    testRemoveLast();
    testResize();
    testDefaultResize();
    testInvalidReserve();
    testShrinkExact();
    testShrinkResize();
    testCopyEmpty();
    testInsert();
}