#include <iostream>
#include <cassert>

using namespace std;

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

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

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

//Инициализация массива.
//Выполняется один раз перед тем, как будет использоваться массив.
void init_array() {
    buffer = new int[100] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
}

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

//Добавление нового элемента в массив.
void add_element(const int& element) {
    *buffer = element;
}

//Удаление элемента из массива.
//Функция возвращает true, если элемент был удален корректно, иначе - false.
bool delete_element(const int& element)
{
    for (int i = 0; i < capacity; i++)
    {
        if (buffer[i] == element) // check for equality
        {
            for (int j = j; j + 1 < capacity; j++)  //shift over elements in new array
            {
                buffer[j] = buffer[j + 1];
            }
            capacity--;        // this will modify the original
            return true;
        }
    }
    return false;
}



//Удаление элемента по индексу из массива.
//Функция возвращает true, если элемент был удален корректно, иначе - false.
bool delete_element_by_index(const unsigned& index)
{

    for (int i = 0; i < capacity; i++)
    {
        if (buffer[i] == buffer[index]) // check for equality
        {
            for (int j = j; j + 1 < capacity; j++)  //shift over elements in new array
            {
                buffer[j] = buffer[j + 1];
            }
            capacity--;        // this will modify the original
            return true;
        }
    }
    return false;
}

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

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

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

//Получить текущее количество элементов в массиве.
unsigned get_array_size() {
    array_size = sizeof(buffer);
    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;
}