#include <iostream>
#include <cassert>
#include <cstring>
#include "Vector.h"

using namespace std;

//Указатель, который используется для хранения адреса памяти под массив.
int* buffer;

//Текущее колличество элементво в массиве.
unsigned array_size;

//Максимальное количество элементов в массиве.
unsigned capacity;
int newSize = 0;

//Инициализация массива.
//Выполняется один раз перед тем, как будет использоваться массив.
void init_array() {
    capacity = 0;
    buffer = new int[capacity];
}

//Освобождение ресурсов массива.
//Выполняется один раз перед тем, как массив прекратит использоваться.
void destroy_array() {
    delete[] buffer;
    buffer = nullptr;
    capacity = 0;
    array_size = 0;
}


int* mem() {
    newBuffer = new int[capacity * 2 + 2];
    memcpy(newBuffer, buffer, sizeof(buffer)*capacity);
    newSize = capacity * 2 + 2;
    return newBuffer;
}
//Добавление нового элемента в массив.
void add_element(const int& element) {
    //int* newBuffer;
    if (capacity == newSize) {
        newBuffer = mem();
    }
    newBuffer[capacity] = element;
    //delete[] buffer;
    buffer = newBuffer;
    capacity = capacity + 1;
}

//Удаление элемента из массива.
//Функция возвращает true, если элемент был удален корректно, иначе - false.
bool delete_element(const int& element)
{
    bool found = false;
    for (unsigned i = 0; i < capacity; i++)
    {
        if (buffer[i] == element) {
            found = true;
            int* newBuffer = new int[capacity - 1];
            memcpy(newBuffer, buffer, sizeof(int)*i);
            memcpy(newBuffer + i, buffer + (i + 1), sizeof(int)*(capacity - i));
            delete[] buffer;
            buffer = newBuffer;
            capacity = capacity - 1;
        }
    }
    return found;
}

//Удаление элемента по индексу из массива.
//Функция возвращает true, если элемент был удален корректно, иначе - false.
bool delete_element_by_index(const unsigned& index)
{
    bool found = false;
    for (unsigned i = 0; i < capacity; i++)
    {
        if (i == index) {
            found = true;
            int* newBuffer = new int[capacity - 1];
            memcpy(newBuffer, buffer, sizeof(int)*i);
            memcpy(newBuffer + i, buffer + (i + 1), sizeof(int)*(capacity - i));
            delete[] buffer;
            buffer = newBuffer;
            capacity = capacity - 1;
        }
    }
    return found;
}

//Поиск элемента в массиве.
//Функция возвращает true, если элемент был найден в массиве, иначе - false.
bool find_element(const int& element) {

    for (unsigned i = 0; i < capacity; i++) {
        if (buffer[i] == element) {
            return true;
        }
    }
    return false;
}

//Получить значение элемента по его индексу.
//Если индекс некорректный (меньше 0, или слишком большой) - нужно кинуть исключение
// (я показываю в примере ниже, как это делать).
const int& get_element(const unsigned& index) {
    if (index >= capacity) {
        throw std::runtime_error("index is invalid");
    }
    else {
        return buffer[index];
    }
}

//Получить текущее количество элементов в массиве.
unsigned get_array_size() {
    array_size = capacity;
    return array_size;
}

//Следующие тесты должны выполняться (программа должна успешно запускаться).
//Менять тесты нельзя.
//Менять мои заглушки на функции нельзя.

void check_preconditions() {
    assert(array_size == 0);
    assert(capacity == 0);
    assert(buffer == nullptr);
}

void can_init_and_destroy_new_array_test() {
    init_array();
    destroy_array();
    check_preconditions();
}

void can_add_elements_to_array_test() {
    init_array();

    for (int i = 0; i < 2000; ++i) {
        add_element(i);
    }

    for (int i = 0; i < 2000; ++i) {
        int current_element = get_element(i);
        assert(current_element == i);
    }

    destroy_array();
    check_preconditions();
}

void cannot_delete_not_existed_element_test() {
    init_array();

    for (int i = 0; i < 2000; ++i) {
        add_element(i);
    }

    assert(delete_element(3000) == false);

    for (int i = 0; i < 2000; ++i) {
        int current_element = get_element(i);
        assert(current_element == i);
    }

    destroy_array();
    check_preconditions();
}

void cannot_delete_not_existed_element_test2() {
    init_array();

    for (int i = 0; i < 2000; ++i) {
        add_element(i);
    }

    assert(delete_element_by_index(3000) == false);

    for (int i = 0; i < 2000; ++i) {
        int current_element = get_element(i);
        assert(current_element == i);
    }

    destroy_array();
    check_preconditions();
}

void can_delete_existed_element_test() {
    init_array();

    for (int i = 0; i < 5; ++i) {
        add_element(i + 2);
    }

    int size_before_removing_element = get_array_size();

    assert(delete_element(3) == true);

    int size_after_removing_element = get_array_size();

    assert(size_after_removing_element + 1 == size_before_removing_element);
    assert(size_after_removing_element == 4);

    assert(get_element(0) == 2);
    assert(get_element(1) == 4);
    assert(get_element(2) == 5);
    assert(get_element(3) == 6);

    destroy_array();
    check_preconditions();
}

void can_delete_existed_element_test2() {
    init_array();

    for (int i = 0; i < 5; ++i) {
        add_element(i + 2);
    }

    int size_before_removing_element = get_array_size();

    assert(delete_element_by_index(3) == true);

    int size_after_removing_element = get_array_size();

    assert(size_after_removing_element + 1 == size_before_removing_element);
    assert(size_after_removing_element == 4);

    assert(get_element(0) == 2);
    assert(get_element(1) == 3);
    assert(get_element(2) == 4);
    assert(get_element(3) == 6);

    assert(find_element(2) == true);
    assert(find_element(3) == true);
    assert(find_element(4) == true);
    assert(find_element(5) == false);
    assert(find_element(6) == true);

    destroy_array();
    check_preconditions();
}

void exception_occurred_when_getiing_element_with_invalid_index_test() {
    init_array();

    for (int i = 0; i < 5; ++i) {
        add_element(i + 2);
    }

    assert(get_element(0) == 2);

    bool has_exception = false;

    try {
        get_element(5);
    }
    catch (...)
    {
        has_exception = true;
    }

    assert(has_exception == true);

    destroy_array();
    check_preconditions();
}

void exception_occurred_when_getiing_element_with_invalid_index_test2() {
    init_array();

    for (int i = 0; i < 5; ++i) {
        add_element(i + 2);
    }

    assert(get_element(0) == 2);

    bool has_exception = false;

    try {
        get_element(-1);
    }
    catch (...)
    {
        has_exception = true;
    }

    assert(has_exception == true);

    destroy_array();
    check_preconditions();
}

void capacity_has_to_decrease_while_elements_were_deleted_test() {
    init_array();

    for (int i = 0; i < 2000; ++i) {
        add_element(i);
    }

    for (int i = 0; i < 2000; ++i) {
        delete_element_by_index(0);
    }

    assert(get_array_size() == 0);
    assert(capacity < 100);

    destroy_array();
    check_preconditions();
}

int main()
{
    /*can_init_and_destroy_new_array_test();*/
    can_add_elements_to_array_test();
    /*cannot_delete_not_existed_element_test();
    cannot_delete_not_existed_element_test2();
    can_delete_existed_element_test();
    can_delete_existed_element_test2();
    exception_occurred_when_getiing_element_with_invalid_index_test();
    exception_occurred_when_getiing_element_with_invalid_index_test2();
    capacity_has_to_decrease_while_elements_were_deleted_test();
    can_init_and_destroy_new_array_test();*/

    system("PAUSE");
    return 0;
}

void* add_element() {
    int *newBuffer;
}