#include <gtest/gtest.h>
#include <XCEngine/Core/Containers/Array.h>

using namespace XCEngine::Containers;

namespace {

TEST(Containers_Array, DefaultConstructor) {
    Array<int> arr;
    EXPECT_EQ(arr.Size(), 0u);
    EXPECT_EQ(arr.Capacity(), 0u);
    EXPECT_TRUE(arr.Empty());
}

TEST(Containers_Array, CapacityConstructor) {
    Array<int> arr(10);
    EXPECT_EQ(arr.Size(), 0u);
    EXPECT_GE(arr.Capacity(), 10u);
}

TEST(Containers_Array, CountValueConstructor) {
    Array<int> arr(5, 42);
    EXPECT_EQ(arr.Size(), 5u);
    for (size_t i = 0; i < 5; ++i) {
        EXPECT_EQ(arr[i], 42);
    }
}

TEST(Containers_Array, InitializerListConstructor) {
    Array<int> arr = {1, 2, 3, 4, 5};
    EXPECT_EQ(arr.Size(), 5u);
    EXPECT_EQ(arr[0], 1);
    EXPECT_EQ(arr[4], 5);
}

TEST(Containers_Array, CopyConstructor) {
    Array<int> arr1 = {1, 2, 3};
    Array<int> arr2(arr1);
    EXPECT_EQ(arr2.Size(), 3u);
    EXPECT_EQ(arr2[0], 1);
    EXPECT_EQ(arr2[2], 3);
}

TEST(Containers_Array, MoveConstructor) {
    Array<int> arr1 = {1, 2, 3};
    Array<int> arr2(std::move(arr1));
    EXPECT_EQ(arr2.Size(), 3u);
    EXPECT_EQ(arr2[0], 1);
}

TEST(Containers_Array, CopyAssignment) {
    Array<int> arr1 = {1, 2, 3};
    Array<int> arr2;
    arr2 = arr1;
    EXPECT_EQ(arr2.Size(), 3u);
    EXPECT_EQ(arr2[0], 1);
}

TEST(Containers_Array, MoveAssignment) {
    Array<int> arr1 = {1, 2, 3};
    Array<int> arr2;
    arr2 = std::move(arr1);
    EXPECT_EQ(arr2.Size(), 3u);
    EXPECT_EQ(arr2[0], 1);
}

TEST(Containers_Array, OperatorSquareBrackets) {
    Array<int> arr = {10, 20, 30};
    EXPECT_EQ(arr[0], 10);
    EXPECT_EQ(arr[1], 20);
    EXPECT_EQ(arr[2], 30);
    
    arr[1] = 25;
    EXPECT_EQ(arr[1], 25);
}

TEST(Containers_Array, PushBack) {
    Array<int> arr;
    arr.PushBack(1);
    arr.PushBack(2);
    arr.PushBack(3);
    EXPECT_EQ(arr.Size(), 3u);
    EXPECT_EQ(arr[2], 3);
}

TEST(Containers_Array, EmplaceBack) {
    Array<int> arr;
    arr.EmplaceBack(1);
    arr.EmplaceBack(2);
    arr.EmplaceBack(3);
    EXPECT_EQ(arr.Size(), 3u);
}

TEST(Containers_Array, PopBack) {
    Array<int> arr = {1, 2, 3};
    arr.PopBack();
    EXPECT_EQ(arr.Size(), 2u);
    EXPECT_EQ(arr[1], 2);
}

TEST(Containers_Array, Clear) {
    Array<int> arr = {1, 2, 3};
    arr.Clear();
    EXPECT_EQ(arr.Size(), 0u);
    EXPECT_TRUE(arr.Empty());
}

TEST(Containers_Array, Reserve) {
    Array<int> arr;
    arr.Reserve(100);
    EXPECT_GE(arr.Capacity(), 100u);
}

TEST(Containers_Array, Resize) {
    Array<int> arr;
    arr.Resize(5);
    EXPECT_EQ(arr.Size(), 5u);
    EXPECT_EQ(arr[0], 0);
    EXPECT_EQ(arr[4], 0);
    
    arr.Resize(8, 42);
    EXPECT_EQ(arr.Size(), 8u);
    EXPECT_EQ(arr[0], 0);
    EXPECT_EQ(arr[5], 42);
    EXPECT_EQ(arr[7], 42);
}

TEST(Containers_Array, Front) {
    Array<int> arr = {10, 20, 30};
    EXPECT_EQ(arr.Front(), 10);
}

TEST(Containers_Array, Back) {
    Array<int> arr = {10, 20, 30};
    EXPECT_EQ(arr.Back(), 30);
}

TEST(Containers_Array, Data) {
    Array<int> arr = {10, 20, 30};
    EXPECT_EQ(arr.Data()[0], 10);
    EXPECT_EQ(arr.Data()[1], 20);
}

TEST(Containers_Array, Iterator) {
    Array<int> arr = {1, 2, 3, 4, 5};
    int sum = 0;
    for (auto it = arr.begin(); it != arr.end(); ++it) {
        sum += *it;
    }
    EXPECT_EQ(sum, 15);
}

TEST(Containers_Array, RangeBasedFor) {
    Array<int> arr = {1, 2, 3, 4, 5};
    int sum = 0;
    for (int v : arr) {
        sum += v;
    }
    EXPECT_EQ(sum, 15);
}

} // namespace