#include <gtest/gtest.h>
#include <XCEngine/Core/Containers/HashMap.h>
#include <XCEngine/Core/Containers/String.h>

using namespace XCEngine::Containers;

namespace {

TEST(Containers_HashMap, DefaultConstructor) {
    HashMap<int, int> map;
    EXPECT_EQ(map.Size(), 0u);
    EXPECT_TRUE(map.Empty());
}

TEST(Containers_HashMap, Insert) {
    HashMap<int, String> map;
    map.Insert(1, String("one"));
    EXPECT_EQ(map.Size(), 1u);
}

TEST(Containers_HashMap, InsertDuplicate) {
    HashMap<int, int> map;
    map.Insert(1, 10);
    map.Insert(1, 20);
    EXPECT_EQ(map.Size(), 1u);
    
    auto* val = map.Find(1);
    EXPECT_EQ(*val, 20);
}

TEST(Containers_HashMap, Find) {
    HashMap<int, int> map;
    map.Insert(1, 100);
    map.Insert(2, 200);
    
    auto* val = map.Find(1);
    ASSERT_NE(val, nullptr);
    EXPECT_EQ(*val, 100);
    
    val = map.Find(2);
    ASSERT_NE(val, nullptr);
    EXPECT_EQ(*val, 200);
    
    val = map.Find(3);
    EXPECT_EQ(val, nullptr);
}

TEST(Containers_HashMap, Find_NotFound) {
    HashMap<int, int> map;
    map.Insert(1, 100);
    EXPECT_EQ(map.Find(999), nullptr);
}

TEST(Containers_HashMap, OperatorBracket) {
    HashMap<int, int> map;
    map[1] = 100;
    map[2] = 200;
    
    EXPECT_EQ(map[1], 100);
    EXPECT_EQ(map[2], 200);
}

TEST(Containers_HashMap, OperatorBracket_NewKey) {
    HashMap<int, int> map;
    map[1] = 100;
    EXPECT_EQ(map.Size(), 1u);
    EXPECT_EQ(map[1], 100);
}

TEST(Containers_HashMap, Contains) {
    HashMap<int, int> map;
    map.Insert(1, 100);
    map.Insert(2, 200);
    
    EXPECT_TRUE(map.Contains(1));
    EXPECT_TRUE(map.Contains(2));
    EXPECT_FALSE(map.Contains(3));
}

TEST(Containers_HashMap, Erase) {
    HashMap<int, int> map;
    map.Insert(1, 100);
    map.Insert(2, 200);
    EXPECT_EQ(map.Size(), 2u);
    
    bool erased = map.Erase(1);
    EXPECT_TRUE(erased);
    EXPECT_EQ(map.Size(), 1u);
    EXPECT_FALSE(map.Contains(1));
    EXPECT_TRUE(map.Contains(2));
}

TEST(Containers_HashMap, Erase_NotFound) {
    HashMap<int, int> map;
    map.Insert(1, 100);
    
    bool erased = map.Erase(999);
    EXPECT_FALSE(erased);
    EXPECT_EQ(map.Size(), 1u);
}

TEST(Containers_HashMap, Clear) {
    HashMap<int, int> map;
    map.Insert(1, 100);
    map.Insert(2, 200);
    map.Insert(3, 300);
    
    map.Clear();
    EXPECT_EQ(map.Size(), 0u);
    EXPECT_TRUE(map.Empty());
}

TEST(Containers_HashMap, MultipleInsertions) {
    HashMap<int, int> map;
    for (int i = 0; i < 100; ++i) {
        map.Insert(i, i * 10);
    }
    EXPECT_EQ(map.Size(), 100u);
    
    for (int i = 0; i < 100; ++i) {
        auto* val = map.Find(i);
        ASSERT_NE(val, nullptr);
        EXPECT_EQ(*val, i * 10);
    }
}

TEST(Containers_HashMap, StringKey) {
    HashMap<String, int> map;
    map.Insert(String("apple"), 1);
    map.Insert(String("banana"), 2);
    map.Insert(String("cherry"), 3);
    
    EXPECT_EQ(map.Size(), 3u);
    EXPECT_EQ(map[String("apple")], 1);
    EXPECT_EQ(map[String("banana")], 2);
    EXPECT_EQ(map[String("cherry")], 3);
}

} // namespace