// Copyright Epic Games, Inc. All Rights Reserved.

#include "zenstore/cidstore.h"

#include <zencore/compress.h>
#include <zencore/filesystem.h>
#include <zencore/fmtutils.h>
#include <zencore/logging.h>
#include <zencore/string.h>
#include <zenstore/scrubcontext.h>

#include "cas.h"

#include <filesystem>

namespace zen {

struct CidStore::Impl
{
	Impl(CasStore& InCasStore) : m_CasStore(InCasStore) {}

	CasStore& m_CasStore;

	void Initialize(const CidStoreConfiguration& Config) { m_CasStore.Initialize(Config); }

	CidStore::InsertResult AddChunk(const CompressedBuffer& ChunkData)
	{
		const IoHash DecompressedId = IoHash::FromBLAKE3(ChunkData.GetRawHash());
		IoBuffer	 Payload		= ChunkData.GetCompressed().Flatten().AsIoBuffer();

		Payload.SetContentType(ZenContentType::kCompressedBinary);

		CasStore::InsertResult Result = m_CasStore.InsertChunk(Payload, DecompressedId);

		return {.New = Result.New};
	}

	IoBuffer FindChunkByCid(const IoHash& DecompressedId) { return m_CasStore.FindChunk(DecompressedId); }

	bool ContainsChunk(const IoHash& DecompressedId) { return m_CasStore.ContainsChunk(DecompressedId); }

	void FilterChunks(HashKeySet& InOutChunks)
	{
		InOutChunks.RemoveHashesIf([&](const IoHash& Hash) { return ContainsChunk(Hash); });
	}

	void Flush() { m_CasStore.Flush(); }

	void Scrub(ScrubContext& Ctx)
	{
		if (Ctx.ScrubTimestamp() == m_LastScrubTime)
		{
			return;
		}

		m_LastScrubTime = Ctx.ScrubTimestamp();

		m_CasStore.Scrub(Ctx);
	}

	uint64_t m_LastScrubTime = 0;
};

//////////////////////////////////////////////////////////////////////////

CidStore::CidStore(GcManager& Gc) : m_CasStore(CreateCasStore(Gc)), m_Impl(std::make_unique<Impl>(*m_CasStore))
{
}

CidStore::~CidStore()
{
}

void
CidStore::Initialize(const CidStoreConfiguration& Config)
{
	m_Impl->Initialize(Config);
}

CidStore::InsertResult
CidStore::AddChunk(const CompressedBuffer& ChunkData)
{
	return m_Impl->AddChunk(ChunkData);
}

IoBuffer
CidStore::FindChunkByCid(const IoHash& DecompressedId)
{
	return m_Impl->FindChunkByCid(DecompressedId);
}

bool
CidStore::ContainsChunk(const IoHash& DecompressedId)
{
	return m_Impl->ContainsChunk(DecompressedId);
}

void
CidStore::FilterChunks(HashKeySet& InOutChunks)
{
	return m_Impl->FilterChunks(InOutChunks);
}

void
CidStore::Flush()
{
	m_Impl->Flush();
}

void
CidStore::Scrub(ScrubContext& Ctx)
{
	m_Impl->Scrub(Ctx);
}

CidStoreSize
CidStore::TotalSize() const
{
	return m_Impl->m_CasStore.TotalSize();
}

}  // namespace zen