#include <cassert>
#include "../source/bitarray.hpp"


void bitarrayGoodAlloc_Constructors_test()
{
    bool caught = false;
    try
    {
        bitarray bad_vec(-1);
    }
    catch (...) {
        caught = true;
    }

    bitarray v(100, true);
    assert(v.size() == 100);

    bitarray v1(v);
    assert(v1.size() == 100);

    for (int i = 0; i < v.size(); i++)
        assert(v1[i] == v[i]);

    bitarray v_created_by_rvalue = std::move(bitarray{});
    assert(v_created_by_rvalue.size() == 0);
}


void bitarrayGoodAlloc_Assignments_test() {
    bitarray v(0, false);
    assert(v.size() == 0);

    bitarray other(13, true);
    assert(other.size() == 13);
    v = other;
    assert(v.size() == other.size());

    for (int i = 0; i < other.size(); i++)
        assert(v[i] == other[i]);

    bitarray v1;
    assert(v1.size() == 0);
    v1 = v = other;
    assert(v1.size() == other.size());

    for (int i = 0; i < other.size(); i++)
        assert(v1[i] == other[i]);

    v1 = std::move(bitarray{ 41, false });
    assert(v1.size() == 41);

    for (int i = 0; i < v1.size(); i++)
        assert(v1[i] == false);
}

void bitarrayGoodAlloc_PushBack_test() {
    bitarray v;
    int n = 100;

    std::vector<bool> varr(n, false);

    for (unsigned int i = 0; i < varr.size() - 1; i += 3)
        varr[i] = true;

    for (int i = 0; i < n; i++)
        v.push_back(varr[i]);

    assert(v.size() == n);

    for (int i = 0; i < n; i++)
        assert(v[i] == varr[i]);

    // operator[] for const object:
    const bitarray v_const = v;

    for (int i = 0; i < v_const.size(); i++)
        assert(v_const[i] == v[i]);
}

void bitarrayGoodAlloc_BadRanges_test() {

    bitarray v;
    bool caught1 = false;
    try
    {
        v[-1];
    }
    catch (...) {
        caught1 = true;
    }

    v.push_back(true);
    bool caught2 = false;
    try
    {
        v.at(2);
    }
    catch (...) {
        caught2 = true;
    }

    const bitarray v1(2, true);
    bool caught3 = false;
    try
    {
        v1[-1];
    }
    catch (...) {
        caught3 = true;
    }

    bool caught4 = false;
    try
    {
        v1.at(3);
    }
    catch (...) {
        caught4 = true;
    }
}

void bitarrayGoodAlloc_Resize_test() {

    bitarray v;
    v.resize(123);

    assert(v.size() == 123);

    v.resize(140);
    assert(v.size() == 140);

    std::vector<bool> values(140);
    values.resize(0);

    for (int i = 0; i < v.size(); i++) {
        if (i % 2)
            values.push_back(v[i] = true);
        else
            values.push_back(v[i] = false);
    }

    v.resize(10);
    assert(v.size() == 10);

    for (int i = 0; i < v.size(); i++)
        assert(v[i] == values[i]);

    bool caught = false;
    try
    {
        v.resize(-1);
    }
    catch (...) {
        caught = true;
    }

    v.resize(0);
    assert(v.size() == 0);
}

void bitarrayGoodAlloc_iterators_test() {

    bitarray v(100, true);
    assert(v.size() == 100);

    for (auto elem : v)
        assert(elem == true);

    *(v.at(41)) = false;

    assert(v[41] == false);
    assert(*v.at(41) == false);

    assert(*v.begin() == 1);

    auto it = v.at(41);

    auto save_it = it++;
    assert(*save_it == false);
    assert(*it == true);

    auto save_it1 = it--;
    assert(*save_it1 == true);
    assert(*it == false);

    it -= 41;
    assert((it == v.begin()) == true);

    it += 41;
    assert((it == save_it) == true);

    assert(((v.begin() + v.size()) == v.end()) == true);
    assert(((v.end() - v.size()) == v.begin()) == true);
}

void bitarrayGoodAlloc_const_iterators_test() {

    bitarray v1(100, true);
    assert(v1.size() == 100);

    for (auto elem : v1)
        assert(elem == true);

    *(v1.at(41)) = false;

    const bitarray v = v1;

    assert(v[41] == false);
    assert(*v.at(41) == false);

    assert(*v.begin() == 1);

    auto it = v.at(41);

    auto save_it = it++;
    assert(*save_it == false);
    assert(*it == true);

    auto save_it1 = it--;
    assert(*save_it1 == true);
    assert(*it == false);

    assert((save_it1 != it) == true);

    it -= 41;
    assert((it == v.begin()) == true);

    it += 41;
    assert((it == save_it) == true);

    assert(((v.begin() + v.size()) == v.end()) == true);
    assert(((v.end() - v.size()) == v.begin()) == true);
}

void bitarrayGoodAlloc_find_test() {
    bitarray elems(100, true);

    for (int i = 0; i < elems.size(); i += 3)
        elems[i] = false;

    assert(bitarray::find_bit(0, 64, 0x6db6db6db6db6db6, false) == 0);

    assert(elems.find(0, elems.size(), false) == 0);
    assert(elems.find(3, elems.size(), false) == 3);
    assert(elems.find(99, elems.size(), true) == -1);
    assert(elems.find(0, 3, false) == 0);
    assert(elems.find(0, 3, true) == 1);

    bool caught = false;
    try {
        elems.find(-1, 3, false);
    }
    catch (...) {
        caught = true;
    }
}

// BAD ALLOC TESTS
bool BAD_NEW = false;
void* operator new(size_t size) {
    if (BAD_NEW)
        throw std::bad_alloc();

    void* ptr = malloc(size);

    if (!ptr)
        throw std::bad_alloc();

    return ptr;
}

void bitarrayBadAlloc_constructors_test() {

    BAD_NEW = true;
    bool caught1 = false;
    try {
        bitarray v_bad_constructor(12, true);
    }
    catch (...) {
        caught1 = true;
    }
    BAD_NEW = false;

    // CREATING BITARRAY WITH NORMAL new TO TEST OTHER CONSTRUCTORS AND OTHER
    bitarray v(121, true);
    assert(v.size() == 121);
    for (auto elem : v)
        assert(elem == true);
    //

    BAD_NEW = true;
    bool caught2 = false;
    try {
        bitarray v_bad_copyctor = v;
    }
    catch (...) {
        caught2 = true;
    }
    BAD_NEW = false;

    bitarray v_assign(11, true);
    assert(v_assign.size() == 11);
    for (auto elem : v_assign)
        assert(elem == true);

    BAD_NEW = true;
    bool caught3 = false;
    try {
        v_assign = v;
    }
    catch (...) {
        caught3 = true;
    }
    BAD_NEW = false;

    assert(v_assign.size() == 11);
    for (auto elem : v_assign)
        assert(elem == true);

    BAD_NEW = true;
    bool caught4 = false;
    try {
        v_assign.resize(100000);
    }
    catch (...) {
        caught4 = true;
    }
    BAD_NEW = false;

    assert(v_assign.size() == 11);
    for (auto elem : v_assign)
        assert(elem == true);
}

int main(int argc, char** argv) {
    bitarrayBadAlloc_constructors_test();
    bitarrayGoodAlloc_Assignments_test();
    bitarrayGoodAlloc_BadRanges_test();
    bitarrayGoodAlloc_Constructors_test();
    bitarrayGoodAlloc_const_iterators_test();
    bitarrayGoodAlloc_find_test();
    bitarrayGoodAlloc_iterators_test();
    bitarrayGoodAlloc_PushBack_test();
    bitarrayGoodAlloc_Resize_test();
    return 0;
}