Bigfoot/Bigfoot/Tests/Engine/BigFile/BigFile.cpp

/*********************************************************************
 * \file   BigFile.cpp
 *
 * \author Romain BOULLARD
 * \date   August 2026
 *********************************************************************/
#include <Engine/BigFile/BigFile.hpp>

#include <System/File/File.hpp>

#include <EngineTests/BigFileInfo_generated.hpp>

#include <AssetsForTesting/Asset/AssetA.hpp>
#include <AssetsForTesting/Asset/AssetB.hpp>
#include <AssetsForTesting/Asset/AssetC.hpp>

#include <EASTL/array.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <chrono>
#include <thread>

namespace Bigfoot
{
#ifdef BIGFOOT_TOOLMODE
class BigFileFixture: public ::testing::Test
{
  protected:
    void SetUp() override
    {
        m_bigFile.Clear();
    }

    /*
     * Packs an asset and saves it to the BigFile
     *
     * \param p_asset The asset to save
     * \return The UUID the asset was saved under
     */
    template<class ASSET>
    UUID SaveAsset(ASSET& p_asset)
    {
        const eastl::vector<std::byte> flatbuffer = p_asset.Pack();

        m_bigFile.SaveAssetFlatbuffer(p_asset.GetHeader().uuid, flatbuffer, p_asset.GetHardReferences(flatbuffer));

        return p_asset.GetHeader().uuid;
    }

    /*
     * Packs and saves several assets to the BigFile in a single SaveAssetFlatbuffers
     *
     * \param p_assets The assets to save
     */
    void SaveAssets(const eastl::vector<AssetBase*>& p_assets)
    {
        eastl::vector<UUID> uuids;
        eastl::vector<eastl::vector<std::byte>> flatbuffers;
        eastl::vector<eastl::vector<UUID>> hardReferences;

        uuids.reserve(p_assets.size());
        flatbuffers.reserve(p_assets.size());
        hardReferences.reserve(p_assets.size());

        for (AssetBase* const asset: p_assets)
        {
            eastl::vector<std::byte> flatbuffer = asset->Pack();
            hardReferences.push_back(asset->GetHardReferences(flatbuffer));
            uuids.push_back(asset->GetHeader().uuid);
            flatbuffers.push_back(std::move(flatbuffer));
        }

        m_bigFile.SaveAssetFlatbuffers(uuids, flatbuffers, hardReferences);
    }

    BigFile m_bigFile {File {BIGFILE_ENGINETESTS_LOCATION}};
};

/****************************************************************************************/

TEST_F(BigFileFixture, Clear_ShouldRemoveAllAssetsMetadataAndHardReferences)
{
    AssetA referencedAsset;
    referencedAsset.SetName("referenced");
    SaveAsset(referencedAsset);

    AssetB asset;
    asset.SetName("hello");
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAsset.GetHeader().uuid};
    SaveAsset(asset);

    ASSERT_TRUE(m_bigFile.Has(referencedAsset.GetHeader().uuid));
    ASSERT_TRUE(m_bigFile.Has(asset.GetHeader().uuid));
    ASSERT_FALSE(m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid).empty());

    m_bigFile.Clear();

    EXPECT_FALSE(m_bigFile.Has(referencedAsset.GetHeader().uuid));
    EXPECT_FALSE(m_bigFile.Has(asset.GetHeader().uuid));

    EXPECT_TRUE(m_bigFile.GetAssetFlatbuffer(referencedAsset.GetHeader().uuid).empty());
    EXPECT_TRUE(m_bigFile.GetAssetFlatbuffer(asset.GetHeader().uuid).empty());

    EXPECT_TRUE(m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid).empty());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetFlatbuffer_ShouldReturnEmptyForNonExistentUUID)
{
    const UUID uuid;

    EXPECT_TRUE(m_bigFile.GetAssetFlatbuffer(uuid).empty());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetFlatbuffer_ShouldGetTheAssetFlatbuffer)
{
    AssetA asset;
    asset.SetName("hello");
    asset.GetAsset().health = 42;
    asset.GetAsset().mana = 7;
    SaveAsset(asset);

    const eastl::vector<std::byte> savedFlatbuffer = m_bigFile.GetAssetFlatbuffer(asset.GetHeader().uuid);
    EXPECT_EQ(savedFlatbuffer, asset.Pack());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetFlatbuffers_ShouldReturnEmptyForUUIDsThatDoNotExist)
{
    AssetA assetA;
    assetA.SetName("hello");
    SaveAsset(assetA);

    AssetA assetB;
    assetB.SetName("world");
    SaveAsset(assetB);

    const eastl::array<UUID, 3> uuids {assetA.GetHeader().uuid, UUID {}, assetB.GetHeader().uuid};

    const eastl::vector<eastl::vector<std::byte>> flatbuffers = m_bigFile.GetAssetFlatbuffers(uuids);

    ASSERT_EQ(flatbuffers.size(), 3);
    EXPECT_EQ(flatbuffers[0], assetA.Pack());
    EXPECT_TRUE(flatbuffers[1].empty());
    EXPECT_EQ(flatbuffers[2], assetB.Pack());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetFlatbuffers_ShouldReturnEmptyForASingleUUIDThatDoesNotExist)
{
    const eastl::array<UUID, 1> uuids {UUID {}};

    const eastl::vector<eastl::vector<std::byte>> flatbuffers = m_bigFile.GetAssetFlatbuffers(uuids);

    ASSERT_EQ(flatbuffers.size(), 1);
    EXPECT_TRUE(flatbuffers[0].empty());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetFlatbuffers_ShouldDuplicateResultsForADuplicateUUID)
{
    AssetA assetA;
    assetA.SetName("hello");
    SaveAsset(assetA);

    const eastl::array<UUID, 2> uuids {assetA.GetHeader().uuid, assetA.GetHeader().uuid};

    const eastl::vector<eastl::vector<std::byte>> flatbuffers = m_bigFile.GetAssetFlatbuffers(uuids);

    ASSERT_EQ(flatbuffers.size(), 2);
    EXPECT_EQ(flatbuffers[0], assetA.Pack());
    EXPECT_EQ(flatbuffers[1], assetA.Pack());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetHardReference_ShouldReturnEmptyVectorForNonExistentUUID)
{
    const UUID uuid;

    const eastl::vector<UUID> hardReferences = m_bigFile.GetAssetHardReferences(uuid);

    EXPECT_TRUE(hardReferences.empty());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetHardReference_ShouldGetTheAssetHardReferences)
{
    AssetA referencedAssetX;
    referencedAssetX.SetName("referencedX");

    AssetA referencedAssetY;
    referencedAssetY.SetName("referencedY");

    AssetB asset;
    asset.SetName("hello");
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAssetX.GetHeader().uuid};
    asset.GetAsset().refs_a.push_back(SoftReference<AssetA> {referencedAssetY.GetHeader().uuid});
    SaveAsset(asset);

    const eastl::vector<UUID> hardReferences = m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid);

    EXPECT_THAT(hardReferences, ::testing::ElementsAre(referencedAssetX.GetHeader().uuid));
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetHardReferences_ShouldReturnEmptyVectorsForUUIDsThatDoNotExistOrHaveNoReferences)
{
    AssetA referencedAsset;
    referencedAsset.SetName("referenced");

    AssetA assetWithoutReferences;
    assetWithoutReferences.SetName("noRefs");
    SaveAsset(assetWithoutReferences);

    AssetB assetWithReferences;
    assetWithReferences.SetName("withRefs");
    assetWithReferences.GetAsset().ref_a = HardReference<AssetA> {referencedAsset.GetHeader().uuid};
    SaveAsset(assetWithReferences);

    const UUID missingUUID;
    const eastl::array<UUID, 3> uuids {assetWithoutReferences.GetHeader().uuid,
                                       missingUUID,
                                       assetWithReferences.GetHeader().uuid};

    const eastl::vector<eastl::vector<UUID>> hardReferences = m_bigFile.GetAssetsHardReferences(uuids);

    ASSERT_EQ(hardReferences.size(), 3);
    EXPECT_TRUE(hardReferences[0].empty());
    EXPECT_TRUE(hardReferences[1].empty());
    ASSERT_EQ(hardReferences[2].size(), 1);
    EXPECT_EQ(hardReferences[2][0], referencedAsset.GetHeader().uuid);
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetHardReferences_ShouldDuplicateResultsForADuplicateUUID)
{
    AssetA referencedAssetX;
    referencedAssetX.SetName("referencedX");

    AssetA referencedAssetY;
    referencedAssetY.SetName("referencedY");

    AssetB asset;
    asset.SetName("hello");
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAssetX.GetHeader().uuid};
    asset.GetAsset().refs_a.push_back(SoftReference<AssetA> {referencedAssetY.GetHeader().uuid});
    SaveAsset(asset);

    const eastl::array<UUID, 2> uuids {asset.GetHeader().uuid, asset.GetHeader().uuid};

    const eastl::vector<eastl::vector<UUID>> hardReferences = m_bigFile.GetAssetsHardReferences(uuids);

    ASSERT_EQ(hardReferences.size(), 2);
    for (const eastl::vector<UUID>& entry: hardReferences)
    {
        EXPECT_THAT(entry, ::testing::ElementsAre(referencedAssetX.GetHeader().uuid));
    }
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetTime_ShouldReturnNulloptForNonExistentUUID)
{
    const UUID uuid;

    EXPECT_FALSE(m_bigFile.GetAssetTime(uuid).has_value());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetTime_ShouldReturnCreationAndModificationTimeOnFirstSave)
{
    AssetA asset;
    asset.SetName("hello");

    const std::uint64_t beforeSave = Time::Now().GetEpoch();
    SaveAsset(asset);

    const eastl::optional<BigFile::AssetTime> assetTime = m_bigFile.GetAssetTime(asset.GetHeader().uuid);
    ASSERT_TRUE(assetTime.has_value());

    constexpr std::uint64_t TOLERANCE_MICROSECONDS = 1'000'000;
    const std::uint64_t creationEpoch = assetTime->m_creationTime.GetEpoch();
    const std::uint64_t delta = creationEpoch > beforeSave ? creationEpoch - beforeSave : beforeSave - creationEpoch;
    EXPECT_LE(delta, TOLERANCE_MICROSECONDS);
    EXPECT_EQ(assetTime->m_creationTime, assetTime->m_modificationTime);
}

/****************************************************************************************/

TEST_F(BigFileFixture, SaveAssetFlatbuffer_ShouldUpdateModificationTimeButNotCreationTimeOnSecondSave)
{
    AssetA asset;
    asset.SetName("hello");
    SaveAsset(asset);

    const eastl::optional<BigFile::AssetTime> firstAssetTime = m_bigFile.GetAssetTime(asset.GetHeader().uuid);
    ASSERT_TRUE(firstAssetTime.has_value());

    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    asset.GetAsset().health = 42;
    SaveAsset(asset);

    const eastl::optional<BigFile::AssetTime> secondAssetTime = m_bigFile.GetAssetTime(asset.GetHeader().uuid);
    ASSERT_TRUE(secondAssetTime.has_value());

    EXPECT_EQ(secondAssetTime->m_creationTime, firstAssetTime->m_creationTime);
    EXPECT_GT(secondAssetTime->m_modificationTime.GetEpoch(), firstAssetTime->m_modificationTime.GetEpoch());
}

/****************************************************************************************/

TEST_F(BigFileFixture, SaveAssetFlatbuffers_ShouldUpdateModificationTimeButNotCreationTimeOnSecondSave)
{
    AssetA asset;
    asset.SetName("hello");
    SaveAssets({&asset});

    const eastl::optional<BigFile::AssetTime> firstAssetTime = m_bigFile.GetAssetTime(asset.GetHeader().uuid);
    ASSERT_TRUE(firstAssetTime.has_value());

    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    asset.GetAsset().health = 42;
    SaveAssets({&asset});

    const eastl::optional<BigFile::AssetTime> secondAssetTime = m_bigFile.GetAssetTime(asset.GetHeader().uuid);
    ASSERT_TRUE(secondAssetTime.has_value());

    EXPECT_EQ(secondAssetTime->m_creationTime, firstAssetTime->m_creationTime);
    EXPECT_GT(secondAssetTime->m_modificationTime.GetEpoch(), firstAssetTime->m_modificationTime.GetEpoch());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetsTime_ShouldReturnNulloptForUUIDsThatDoNotExist)
{
    AssetA asset;
    asset.SetName("hello");
    SaveAsset(asset);

    const UUID missingUUID;
    const eastl::array<UUID, 2> uuids {asset.GetHeader().uuid, missingUUID};

    const eastl::vector<eastl::optional<BigFile::AssetTime>> times = m_bigFile.GetAssetsTime(uuids);

    ASSERT_EQ(times.size(), 2);
    EXPECT_TRUE(times[0].has_value());
    EXPECT_FALSE(times[1].has_value());
}

/****************************************************************************************/

TEST_F(BigFileFixture, GetAssetsTime_ShouldDuplicateResultsForADuplicateUUID)
{
    AssetA asset;
    asset.SetName("hello");
    SaveAsset(asset);

    const eastl::optional<BigFile::AssetTime> expected = m_bigFile.GetAssetTime(asset.GetHeader().uuid);
    ASSERT_TRUE(expected.has_value());

    const eastl::array<UUID, 2> uuids {asset.GetHeader().uuid, asset.GetHeader().uuid};

    const eastl::vector<eastl::optional<BigFile::AssetTime>> times = m_bigFile.GetAssetsTime(uuids);

    ASSERT_EQ(times.size(), 2);
    ASSERT_TRUE(times[0].has_value());
    ASSERT_TRUE(times[1].has_value());
    EXPECT_EQ(*times[0], *expected);
    EXPECT_EQ(*times[1], *expected);
}

/****************************************************************************************/

TEST_F(BigFileFixture, Clear_ShouldRemoveAssetTime)
{
    AssetA asset;
    asset.SetName("hello");
    SaveAsset(asset);

    ASSERT_TRUE(m_bigFile.GetAssetTime(asset.GetHeader().uuid).has_value());

    m_bigFile.Clear();

    EXPECT_FALSE(m_bigFile.GetAssetTime(asset.GetHeader().uuid).has_value());
}

/****************************************************************************************/

TEST_F(BigFileFixture, SaveAssetFlatbuffer_ShouldSaveTheAsset)
{
    AssetA referencedAsset;
    referencedAsset.SetName("referenced");

    AssetB asset;
    asset.SetName("hello");
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAsset.GetHeader().uuid};
    SaveAsset(asset);

    EXPECT_TRUE(m_bigFile.Has(asset.GetHeader().uuid));

    const eastl::vector<UUID> hardReferences = m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid);
    ASSERT_EQ(hardReferences.size(), 1);
    EXPECT_EQ(hardReferences[0], referencedAsset.GetHeader().uuid);
}

/****************************************************************************************/

TEST_F(BigFileFixture, SaveAssetFlatbuffer_ShouldUpdateTheDataWhenCalledTwice)
{
    AssetA referencedAssetX;
    referencedAssetX.SetName("referencedX");

    AssetA referencedAssetY;
    referencedAssetY.SetName("referencedY");

    AssetB asset;
    asset.GetAsset().count = 1;
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAssetX.GetHeader().uuid};
    SaveAsset(asset);

    const eastl::vector<std::byte> savedFlatbuffer1 = m_bigFile.GetAssetFlatbuffer(asset.GetHeader().uuid);
    ASSERT_FALSE(savedFlatbuffer1.empty());

    AssetB savedAsset1;
    savedAsset1.Unpack(savedFlatbuffer1);
    EXPECT_EQ(savedAsset1.GetAsset().count, 1);

    const eastl::vector<UUID> hardReferences1 = m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid);
    ASSERT_EQ(hardReferences1.size(), 1);
    EXPECT_EQ(hardReferences1[0], referencedAssetX.GetHeader().uuid);

    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    asset.GetAsset().count = 2;
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAssetY.GetHeader().uuid};
    SaveAsset(asset);

    const eastl::vector<std::byte> savedFlatbuffer2 = m_bigFile.GetAssetFlatbuffer(asset.GetHeader().uuid);
    ASSERT_FALSE(savedFlatbuffer2.empty());

    AssetB savedAsset2;
    savedAsset2.Unpack(savedFlatbuffer2);
    EXPECT_EQ(savedAsset2.GetAsset().count, 2);

    const eastl::vector<UUID> hardReferences2 = m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid);
    ASSERT_EQ(hardReferences2.size(), 1);
    EXPECT_EQ(hardReferences2[0], referencedAssetY.GetHeader().uuid);
    EXPECT_NE(hardReferences2[0], referencedAssetX.GetHeader().uuid);
}

/****************************************************************************************/

TEST_F(BigFileFixture, SaveAssetFlatbuffers_ShouldSaveTheAssets)
{
    AssetA referencedAssetA;
    referencedAssetA.SetName("referencedA");

    AssetA referencedAssetB;
    referencedAssetB.SetName("referencedB");

    AssetB assetA;
    assetA.SetName("hello");
    assetA.GetAsset().count = 42;
    assetA.GetAsset().ref_a = HardReference<AssetA> {referencedAssetA.GetHeader().uuid};

    AssetB assetB;
    assetB.SetName("world");
    assetB.GetAsset().count = 7;
    assetB.GetAsset().ref_a = HardReference<AssetA> {referencedAssetB.GetHeader().uuid};

    SaveAssets({&assetA, &assetB});

    EXPECT_TRUE(m_bigFile.Has(assetA.GetHeader().uuid));
    EXPECT_TRUE(m_bigFile.Has(assetB.GetHeader().uuid));

    const eastl::vector<UUID> hardReferencesA = m_bigFile.GetAssetHardReferences(assetA.GetHeader().uuid);
    ASSERT_EQ(hardReferencesA.size(), 1);
    EXPECT_EQ(hardReferencesA[0], referencedAssetA.GetHeader().uuid);

    const eastl::vector<UUID> hardReferencesB = m_bigFile.GetAssetHardReferences(assetB.GetHeader().uuid);
    ASSERT_EQ(hardReferencesB.size(), 1);
    EXPECT_EQ(hardReferencesB[0], referencedAssetB.GetHeader().uuid);
}

/****************************************************************************************/

TEST_F(BigFileFixture, SaveAssetFlatbuffers_ShouldUpdateTheDataWhenCalledTwice)
{
    AssetA referencedAssetX;
    referencedAssetX.SetName("referencedX");

    AssetA referencedAssetY;
    referencedAssetY.SetName("referencedY");

    AssetB asset;
    asset.GetAsset().count = 1;
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAssetX.GetHeader().uuid};
    SaveAssets({&asset});

    eastl::vector<std::byte> savedFlatbuffer1 = m_bigFile.GetAssetFlatbuffer(asset.GetHeader().uuid);
    ASSERT_FALSE(savedFlatbuffer1.empty());

    AssetB savedAsset1;
    savedAsset1.Unpack(savedFlatbuffer1);
    EXPECT_EQ(savedAsset1.GetAsset().count, 1);

    const eastl::vector<UUID> hardReferences1 = m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid);
    ASSERT_EQ(hardReferences1.size(), 1);
    EXPECT_EQ(hardReferences1[0], referencedAssetX.GetHeader().uuid);

    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    asset.GetAsset().count = 2;
    asset.GetAsset().ref_a = HardReference<AssetA> {referencedAssetY.GetHeader().uuid};
    SaveAssets({&asset});

    const eastl::vector<std::byte> savedFlatbuffer2 = m_bigFile.GetAssetFlatbuffer(asset.GetHeader().uuid);
    ASSERT_FALSE(savedFlatbuffer2.empty());

    AssetB savedAsset2;
    savedAsset2.Unpack(savedFlatbuffer2);
    EXPECT_EQ(savedAsset2.GetAsset().count, 2);

    const eastl::vector<UUID> hardReferences2 = m_bigFile.GetAssetHardReferences(asset.GetHeader().uuid);
    ASSERT_EQ(hardReferences2.size(), 1);
    EXPECT_EQ(hardReferences2[0], referencedAssetY.GetHeader().uuid);
}

/****************************************************************************************/

TEST_F(BigFileFixture, Has_ShouldReturnTrueIfTheAssetExists)
{
    AssetA asset;
    asset.SetName("hello");
    asset.GetAsset().health = 42;
    asset.GetAsset().mana = 7;
    SaveAsset(asset);

    EXPECT_TRUE(m_bigFile.Has(asset.GetHeader().uuid));
}

/****************************************************************************************/

TEST_F(BigFileFixture, Has_ShouldReturnFalseIfTheAssetDoesNotExist)
{
    EXPECT_FALSE(m_bigFile.Has(UUID {}));
}
#endif
}   // namespace Bigfoot