// Copyright (C) 2018 Jonathan Müller <jonathanmueller.dev@gmail.com>
// This file is subject to the license terms in the LICENSE file
// found in the top-level directory of this distribution.

#include <foonathan/array/array.hpp>

#include <catch.hpp>

#include <foonathan/array/block_storage_embedded.hpp>
#include <foonathan/array/block_storage_sbo.hpp>

#include "equal_checker.hpp"
#include "leak_checker.hpp"

using namespace foonathan::array;

namespace
{
struct test_type : leak_tracked
{
    std::uint16_t id;

    test_type(int i) : id(static_cast<std::uint16_t>(i)) {}
};

template <class BlockStorage>
using test_array = array<test_type, BlockStorage>;

template <class Array>
void verify_array_impl(const Array& array, std::initializer_list<int> ids)
{
    REQUIRE(array.empty() == (array.size() == 0u));
    REQUIRE(array.size() == size_type(ids.end() - ids.begin()));
    REQUIRE(array.capacity() >= array.size());
    REQUIRE(array.capacity() <= array.max_size());

    auto view = array_view<const test_type>(array);
    REQUIRE(view.size() == array.size());
    REQUIRE(view.data() == iterator_to_pointer(array.begin()));
    REQUIRE(view.data_end() == iterator_to_pointer(array.end()));
    REQUIRE(view.data() == iterator_to_pointer(array.cbegin()));
    REQUIRE(view.data_end() == iterator_to_pointer(array.cend()));
    check_equal(
        view.begin(), view.end(), ids.begin(), ids.end(),
        [](const test_type& test, int i) { return test.id == i; },
        [&](const test_type& test) { FAIL_CHECK(std::hex << test.id); });

    for (size_type i = 0u; i != array.size(); ++i)
        REQUIRE(array[i].id == ids.begin()[i]);

    if (!array.empty())
    {
        REQUIRE(array.front().id == *ids.begin());
        REQUIRE(array.back().id == *std::prev(ids.end()));
    }
}

template <class Array>
void verify_array(const Array& array, std::initializer_list<int> ids)
{
    verify_array_impl(array, ids);

    // copy constructor
    Array copy(array);
    verify_array_impl(copy, ids);
    REQUIRE(copy.capacity() <= array.capacity());

    // shrink to fit
    auto old_cap = copy.capacity();
    copy.shrink_to_fit();
    verify_array_impl(copy, ids);
    REQUIRE(copy.capacity() <= old_cap);

    // reserve
    copy.reserve(copy.size() + 4u);
    REQUIRE(copy.capacity() >= copy.size() + 4u);
    verify_array_impl(copy, ids);

    // copy assignment
    copy.push_back(0xFFFF);
    copy = array;
    verify_array_impl(copy, ids);

    // range assignment
    copy.push_back(0xFFFF);
    copy.assign_range(array.begin(), array.end());
    verify_array_impl(copy, ids);

    // block assignment
    copy.push_back(0xFFFF);
    copy.assign(array);
    verify_array_impl(copy, ids);
}

template <class Array>
void array_test_impl()
{
    SECTION("default ctor")
    {
        Array array;
        verify_array(array, {});

        // emplace_back/push_back
        array.emplace_back(0xF0F0);
        verify_array(array, {0xF0F0});

        array.push_back(test_type(0xF1F1));
        verify_array(array, {0xF0F0, 0xF1F1});

        test_type test(0xF2F2);
        array.push_back(test);
        verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2});

        SECTION("emplace/insert")
        {
            array.emplace(array.begin(), 0xF3F3);
            verify_array(array, {0xF3F3, 0xF0F0, 0xF1F1, 0xF2F2});

            array.insert(std::next(array.begin()), 0xF4F4);
            verify_array(array, {0xF3F3, 0xF4F4, 0xF0F0, 0xF1F1, 0xF2F2});

            test.id = 0xF5F5;
            array.insert(std::prev(array.end()), test);
            verify_array(array, {0xF3F3, 0xF4F4, 0xF0F0, 0xF1F1, 0xF5F5, 0xF2F2});
        }
        SECTION("append")
        {
            test_type tests[] = {{0xF3F3}, {0xF4F4}, {0xF5F5}};
            array.append(tests);
            verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5});

            array.append_range(std::begin(tests), std::end(tests));
            verify_array(array,
                         {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3, 0xF4F4, 0xF5F5});

            SECTION("pop_back/erase")
            {
                array.pop_back();
                verify_array(array,
                             {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3, 0xF4F4});

                array.erase(array.begin());
                verify_array(array, {0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3, 0xF4F4});

                array.erase(array.begin() + 3);
                verify_array(array, {0xF1F1, 0xF2F2, 0xF3F3, 0xF5F5, 0xF3F3, 0xF4F4});
            }
            SECTION("erase range")
            {
                array.erase_range(std::prev(array.end(), 3), array.end());
                verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5});

                array.erase_range(std::next(array.begin()), std::prev(array.end()));
                verify_array(array, {0xF0F0, 0xF5F5});

                array.erase_range(array.begin(), array.begin());
                verify_array(array, {0xF0F0, 0xF5F5});
            }
            SECTION("move constructor")
            {
                using is_embedded = embedded_storage<typename Array::block_storage>;

                auto  data = iterator_to_pointer(array.begin());
                Array other(std::move(array));
                verify_array(other, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3, 0xF4F4,
                                     0xF5F5});
                verify_array(array, {});
                if (!is_embedded{})
                    REQUIRE(iterator_to_pointer(other.begin()) == data);

                SECTION("copy assignment")
                {
                    array = other;
                    verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3,
                                         0xF4F4, 0xF5F5});
                    verify_array(other, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3,
                                         0xF4F4, 0xF5F5});
                }
                SECTION("move assignment")
                {
                    array = std::move(other);
                    verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3,
                                         0xF4F4, 0xF5F5});
                    verify_array(other, {});
                    if (!is_embedded{})
                        REQUIRE(iterator_to_pointer(array.begin()) == data);
                }
                SECTION("input_view assignment")
                {
                    array = input_view<test_type, typename Array::block_storage>(std::move(other));
                    verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3,
                                         0xF4F4, 0xF5F5});
                    verify_array(other, {});
                    if (!is_embedded{})
                        REQUIRE(iterator_to_pointer(array.begin()) == data);
                }
                SECTION("swap")
                {
                    swap(array, other);
                    verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3, 0xF4F4, 0xF5F5, 0xF3F3,
                                         0xF4F4, 0xF5F5});
                    verify_array(other, {});
                    if (!is_embedded{})
                        REQUIRE(iterator_to_pointer(array.begin()) == data);
                }
            }
        }
        SECTION("multi insert")
        {
            test_type tests[] = {{0xF3F3}, {0xF4F4}, {0xF5F5}};
            array.insert(std::next(array.begin()), tests);
            verify_array(array, {0xF0F0, 0xF3F3, 0xF4F4, 0xF5F5, 0xF1F1, 0xF2F2});

            array.insert_range(std::prev(array.end()), std::begin(tests), std::end(tests));
            verify_array(array,
                         {0xF0F0, 0xF3F3, 0xF4F4, 0xF5F5, 0xF1F1, 0xF3F3, 0xF4F4, 0xF5F5, 0xF2F2});
        }
        SECTION("clear")
        {
            auto old_cap = array.capacity();
            array.clear();
            REQUIRE(old_cap == array.capacity());
            verify_array(array, {});
        }
    }
    SECTION("input_view ctor")
    {
        Array array{{test_type(0xF0F0), test_type(0xF1F1), test_type(0xF2F2), test_type(0xF3F3)}};
        verify_array(array, {0xF0F0, 0xF1F1, 0xF2F2, 0xF3F3});
    }
}
} // namespace

TEST_CASE("array block_storage_new", "[container]")
{
    array_test_impl<test_array<block_storage_new<default_growth>>>();
}

TEST_CASE("array block_storage_embedded", "[container]")
{
    array_test_impl<test_array<block_storage_embedded<15 * sizeof(test_type)>>>();
}

TEST_CASE("array block_storage_sbo", "[container]")
{
    array_test_impl<test_array<block_storage_sbo<5 * sizeof(test_type), block_storage_default>>>();
}