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

#include "upstreamcache.h"
#include "jupiter.h"
#include "zen.h"

#include <zencore/compactbinary.h>
#include <zencore/compactbinarybuilder.h>
#include <zencore/compactbinarypackage.h>
#include <zencore/compactbinaryvalidation.h>
#include <zencore/fmtutils.h>
#include <zencore/stream.h>
#include <zencore/timer.h>

#include <zenstore/cas.h>
#include <zenstore/cidstore.h>

#include "cache/structuredcachestore.h"
#include "diag/logging.h"

#include <fmt/format.h>

#include <algorithm>
#include <atomic>
#include <deque>
#include <thread>
#include <unordered_map>

namespace zen {

using namespace std::literals;

namespace detail {

	template<typename T>
	class BlockingQueue
	{
	public:
		BlockingQueue() = default;

		~BlockingQueue() { CompleteAdding(); }

		void Enqueue(T&& Item)
		{
			{
				std::lock_guard Lock(m_Lock);
				m_Queue.emplace_back(std::move(Item));
			}

			m_NewItemSignal.notify_one();
		}

		bool WaitAndDequeue(T& Item)
		{
			if (m_CompleteAdding.load())
			{
				return false;
			}

			std::unique_lock Lock(m_Lock);
			m_NewItemSignal.wait(Lock, [this]() { return !m_Queue.empty() || m_CompleteAdding.load(); });

			if (!m_Queue.empty())
			{
				Item = std::move(m_Queue.front());
				m_Queue.pop_front();

				return true;
			}

			return false;
		}

		void CompleteAdding()
		{
			if (!m_CompleteAdding.load())
			{
				m_CompleteAdding.store(true);
				m_NewItemSignal.notify_all();
			}
		}

		std::size_t Num() const
		{
			std::unique_lock Lock(m_Lock);
			return m_Queue.size();
		}

	private:
		mutable std::mutex		m_Lock;
		std::condition_variable m_NewItemSignal;
		std::deque<T>			m_Queue;
		std::atomic_bool		m_CompleteAdding{false};
	};

	class JupiterUpstreamEndpoint final : public UpstreamEndpoint
	{
	public:
		JupiterUpstreamEndpoint(const CloudCacheClientOptions& Options) : m_UseLegacyDdc(Options.UseLegacyDdc)
		{
			using namespace fmt::literals;
			m_DisplayName = "Jupier - '{}'"_format(Options.ServiceUrl);
			m_Client	  = new CloudCacheClient(Options);
		}

		virtual ~JupiterUpstreamEndpoint() = default;

		virtual bool IsHealthy() const override { return m_HealthOk.load(); }

		virtual UpstreamEndpointHealth CheckHealth() override
		{
			try
			{
				CloudCacheSession	   Session(m_Client);
				const CloudCacheResult Result = Session.Authenticate();

				m_HealthOk = Result.ErrorCode == 0;

				return {.Reason = std::move(Result.Reason), .Ok = Result.Success};
			}
			catch (std::exception& Err)
			{
				return {.Reason = Err.what(), .Ok = false};
			}
		}

		virtual std::string_view DisplayName() const override { return m_DisplayName; }

		virtual GetUpstreamCacheResult GetCacheRecord(UpstreamCacheKey CacheKey, ZenContentType Type) override
		{
			try
			{
				CloudCacheSession Session(m_Client);
				CloudCacheResult  Result;

				if (m_UseLegacyDdc && Type == ZenContentType::kBinary)
				{
					Result = Session.GetDerivedData(CacheKey.Bucket, CacheKey.Hash);
				}
				else
				{
					const ZenContentType AcceptType = Type == ZenContentType::kCbPackage ? ZenContentType::kCbObject : Type;
					Result							= Session.GetRef(CacheKey.Bucket, CacheKey.Hash, AcceptType);

					if (Result.Success && Type == ZenContentType::kCbPackage)
					{
						CbPackage Package;

						const CbValidateError ValidationResult = ValidateCompactBinary(Result.Response, CbValidateMode::All);
						if (Result.Success = ValidationResult == CbValidateError::None; Result.Success)
						{
							CbObject CacheRecord = LoadCompactBinaryObject(Result.Response);

							CacheRecord.IterateAttachments([&Session, &Result, &Package](CbFieldView AttachmentHash) {
								CloudCacheResult AttachmentResult = Session.GetCompressedBlob(AttachmentHash.AsHash());
								Result.ElapsedSeconds += AttachmentResult.ElapsedSeconds;
								Result.ErrorCode = AttachmentResult.ErrorCode;

								if (CompressedBuffer Chunk = CompressedBuffer::FromCompressed(SharedBuffer(AttachmentResult.Response)))
								{
									Package.AddAttachment(CbAttachment(Chunk));
								}
								else
								{
									Result.Success = false;
								}
							});

							Package.SetObject(CacheRecord);
						}

						if (Result.Success)
						{
							MemoryOutStream MemStream;
							BinaryWriter	Writer(MemStream);
							Package.Save(Writer);

							Result.Response = IoBuffer(IoBuffer::Clone, MemStream.Data(), MemStream.Size());
							Result.Bytes	= MemStream.Size();
						}
					}
				}

				m_HealthOk = Result.ErrorCode == 0;

				return {.Value			= Result.Response,
						.Bytes			= Result.Bytes,
						.ElapsedSeconds = Result.ElapsedSeconds,
						.Success		= Result.Success};
			}
			catch (std::exception& Err)
			{
				return {.Error{.StatusCode = UpstreamStatusCode::Error, .Reason = Err.what()}};
			}
		}

		virtual GetUpstreamCacheResult GetCachePayload(UpstreamPayloadKey PayloadKey) override
		{
			try
			{
				CloudCacheSession	   Session(m_Client);
				const CloudCacheResult Result = Session.GetCompressedBlob(PayloadKey.PayloadId);

				m_HealthOk = Result.ErrorCode == 0;

				return {.Value			= Result.Response,
						.Bytes			= Result.Bytes,
						.ElapsedSeconds = Result.ElapsedSeconds,
						.Success		= Result.Success};
			}
			catch (std::exception& Err)
			{
				return {.Error{.StatusCode = UpstreamStatusCode::Error, .Reason = Err.what()}};
			}
		}

		virtual PutUpstreamCacheResult PutCacheRecord(const UpstreamCacheRecord& CacheRecord,
													  IoBuffer					 RecordValue,
													  std::span<IoBuffer const>	 Payloads) override
		{
			ZEN_ASSERT(CacheRecord.PayloadIds.size() == Payloads.size());
			const uint32_t MaxAttempts = 3;

			try
			{
				CloudCacheSession Session(m_Client);

				if (CacheRecord.Type == ZenContentType::kBinary)
				{
					CloudCacheResult Result;
					for (int32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
					{
						if (m_UseLegacyDdc)
						{
							Result = Session.PutDerivedData(CacheRecord.CacheKey.Bucket, CacheRecord.CacheKey.Hash, RecordValue);
						}
						else
						{
							Result = Session.PutRef(CacheRecord.CacheKey.Bucket,
													CacheRecord.CacheKey.Hash,
													RecordValue,
													ZenContentType::kBinary);
						}
					}

					return {.Bytes = Result.Bytes, .ElapsedSeconds = Result.ElapsedSeconds, .Success = Result.Success};
				}
				else
				{
					int64_t TotalBytes			= 0ull;
					double	TotalElapsedSeconds = 0.0;

					for (size_t Idx = 0, Count = Payloads.size(); Idx < Count; Idx++)
					{
						CloudCacheResult Result;
						for (int32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
						{
							Result = Session.PutCompressedBlob(CacheRecord.PayloadIds[Idx], Payloads[Idx]);
						}

						TotalBytes += Result.Bytes;
						TotalElapsedSeconds += Result.ElapsedSeconds;

						if (!Result.Success)
						{
							return {.Reason			= "Failed to upload payload",
									.Bytes			= TotalBytes,
									.ElapsedSeconds = TotalElapsedSeconds,
									.Success		= false};
						}
					}

					CloudCacheResult Result;
					for (int32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
					{
						Result =
							Session.PutRef(CacheRecord.CacheKey.Bucket, CacheRecord.CacheKey.Hash, RecordValue, ZenContentType::kCbObject);
					}

					TotalBytes += Result.Bytes;
					TotalElapsedSeconds += Result.ElapsedSeconds;

					return {.Bytes = TotalBytes, .ElapsedSeconds = TotalElapsedSeconds, .Success = Result.Success};
				}
			}
			catch (std::exception& e)
			{
				return {.Reason = std::string(e.what()), .Success = false};
			}
		}

	private:
		bool					 m_UseLegacyDdc;
		std::string				 m_DisplayName;
		RefPtr<CloudCacheClient> m_Client;
		std::atomic_bool		 m_HealthOk{false};
	};

	class ZenUpstreamEndpoint final : public UpstreamEndpoint
	{
	public:
		ZenUpstreamEndpoint(std::string_view ServiceUrl)
		{
			using namespace fmt::literals;
			m_DisplayName = "Zen - {}"_format(ServiceUrl);
			m_Client	  = new ZenStructuredCacheClient(ServiceUrl);
		}

		~ZenUpstreamEndpoint() = default;

		virtual bool IsHealthy() const override { return m_HealthOk; }

		virtual UpstreamEndpointHealth CheckHealth() override
		{
			try
			{
				ZenStructuredCacheSession Session(*m_Client);
				ZenCacheResult			  Result;

				for (int32_t Attempt = 0, MaxAttempts = 3; Attempt < MaxAttempts && !Result.Success; ++Attempt)
				{
					Result = Session.SayHello();
				}

				m_HealthOk = Result.ErrorCode == 0;

				return {.Reason = std::move(Result.Reason), .Ok = m_HealthOk};
			}
			catch (std::exception& Err)
			{
				return {.Reason = Err.what(), .Ok = false};
			}
		}

		virtual std::string_view DisplayName() const override { return m_DisplayName; }

		virtual GetUpstreamCacheResult GetCacheRecord(UpstreamCacheKey CacheKey, ZenContentType Type) override
		{
			try
			{
				ZenStructuredCacheSession Session(*m_Client);
				const ZenCacheResult	  Result = Session.GetCacheRecord(CacheKey.Bucket, CacheKey.Hash, Type);

				m_HealthOk = Result.ErrorCode == 0;

				return {.Value			= Result.Response,
						.Bytes			= Result.Bytes,
						.ElapsedSeconds = Result.ElapsedSeconds,
						.Success		= Result.Success};
			}
			catch (std::exception& Err)
			{
				return {.Error{.StatusCode = UpstreamStatusCode::Error, .Reason = Err.what()}};
			}
		}

		virtual GetUpstreamCacheResult GetCachePayload(UpstreamPayloadKey PayloadKey) override
		{
			try
			{
				ZenStructuredCacheSession Session(*m_Client);
				const ZenCacheResult	  Result =
					Session.GetCachePayload(PayloadKey.CacheKey.Bucket, PayloadKey.CacheKey.Hash, PayloadKey.PayloadId);

				m_HealthOk = Result.ErrorCode == 0;

				return {.Value			= Result.Response,
						.Bytes			= Result.Bytes,
						.ElapsedSeconds = Result.ElapsedSeconds,
						.Success		= Result.Success};
			}
			catch (std::exception& Err)
			{
				return {.Error{.StatusCode = UpstreamStatusCode::Error, .Reason = Err.what()}};
			}
		}

		virtual PutUpstreamCacheResult PutCacheRecord(const UpstreamCacheRecord& CacheRecord,
													  IoBuffer					 RecordValue,
													  std::span<IoBuffer const>	 Payloads) override
		{
			ZEN_ASSERT(CacheRecord.PayloadIds.size() == Payloads.size());
			const uint32_t MaxAttempts = 3;

			try
			{
				ZenStructuredCacheSession Session(*m_Client);
				ZenCacheResult			  Result;
				int64_t					  TotalBytes		  = 0ull;
				double					  TotalElapsedSeconds = 0.0;

				if (CacheRecord.Type == ZenContentType::kCbPackage)
				{
					CbPackage Package;
					Package.SetObject(CbObject(SharedBuffer(RecordValue)));

					for (const IoBuffer& Payload : Payloads)
					{
						if (CompressedBuffer AttachmentBuffer = CompressedBuffer::FromCompressed(SharedBuffer(Payload)))
						{
							Package.AddAttachment(CbAttachment(AttachmentBuffer));
						}
						else
						{
							return {.Reason = std::string("invalid payload buffer"), .Success = false};
						}
					}

					MemoryOutStream MemStream;
					BinaryWriter	Writer(MemStream);
					Package.Save(Writer);
					IoBuffer PackagePayload(IoBuffer::Wrap, MemStream.Data(), MemStream.Size());

					for (int32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
					{
						Result = Session.PutCacheRecord(CacheRecord.CacheKey.Bucket,
														CacheRecord.CacheKey.Hash,
														PackagePayload,
														CacheRecord.Type);

						m_HealthOk = Result.ErrorCode == 0;
					}

					TotalBytes			= Result.Bytes;
					TotalElapsedSeconds = Result.ElapsedSeconds;
				}
				else
				{
					for (size_t Idx = 0, Count = Payloads.size(); Idx < Count; Idx++)
					{
						Result.Success = false;
						for (int32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
						{
							Result = Session.PutCachePayload(CacheRecord.CacheKey.Bucket,
															 CacheRecord.CacheKey.Hash,
															 CacheRecord.PayloadIds[Idx],
															 Payloads[Idx]);

							m_HealthOk = Result.ErrorCode == 0;
						}

						TotalBytes += Result.Bytes;
						TotalElapsedSeconds += Result.ElapsedSeconds;

						if (!Result.Success)
						{
							return {.Reason			= "Failed to upload payload",
									.Bytes			= TotalBytes,
									.ElapsedSeconds = TotalElapsedSeconds,
									.Success		= false};
						}
					}

					Result.Success = false;
					for (int32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
					{
						Result =
							Session.PutCacheRecord(CacheRecord.CacheKey.Bucket, CacheRecord.CacheKey.Hash, RecordValue, CacheRecord.Type);

						m_HealthOk = Result.ErrorCode == 0;
					}

					TotalBytes += Result.Bytes;
					TotalElapsedSeconds += Result.ElapsedSeconds;
				}

				return {.Bytes = TotalBytes, .ElapsedSeconds = TotalElapsedSeconds, .Success = Result.Success};
			}
			catch (std::exception& e)
			{
				m_HealthOk = false;
				return {.Reason = std::string(e.what()), .Success = false};
			}
		}

	private:
		std::string						 m_DisplayName;
		RefPtr<ZenStructuredCacheClient> m_Client;
		std::atomic_bool				 m_HealthOk{false};
	};

}  // namespace detail

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

class UpstreamStats final
{
	static constexpr uint64_t MaxSampleCount = 100ull;

	struct StatCounters
	{
		int64_t Bytes	= {};
		int64_t Count	= {};
		double	Seconds = {};
	};

	using StatsMap = std::unordered_map<const UpstreamEndpoint*, StatCounters>;

	struct EndpointStats
	{
		mutable std::mutex Lock;
		StatsMap		   Counters;
	};

public:
	UpstreamStats() : m_Log(logging::Get("upstream")) {}

	void Add(const UpstreamEndpoint& Endpoint, const GetUpstreamCacheResult& Result)
	{
		std::unique_lock Lock(m_DownStats.Lock);

		auto& Counters = m_DownStats.Counters[&Endpoint];
		Counters.Bytes += Result.Bytes;
		Counters.Seconds += Result.ElapsedSeconds;
		Counters.Count++;

		if (Counters.Count >= MaxSampleCount)
		{
			LogStats("STATS - (downstream):"sv, m_DownStats.Counters);
			Counters = StatCounters{};
		}
	}

	void Add(const UpstreamEndpoint& Endpoint, const PutUpstreamCacheResult& Result)
	{
		std::unique_lock Lock(m_UpStats.Lock);

		auto& Counters = m_UpStats.Counters[&Endpoint];
		Counters.Bytes += Result.Bytes;
		Counters.Seconds += Result.ElapsedSeconds;
		Counters.Count++;

		if (Counters.Count >= MaxSampleCount)
		{
			LogStats("STATS - (upstream):"sv, m_UpStats.Counters);
			Counters = StatCounters{};
		}
	}

private:
	void LogStats(std::string_view What, const std::unordered_map<const UpstreamEndpoint*, StatCounters>& EndpointStats)
	{
		for (const auto& Kv : EndpointStats)
		{
			const UpstreamEndpoint& Endpoint = *Kv.first;
			const StatCounters&		Counters = Kv.second;
			const double			TotalMb	 = double(Counters.Bytes) / 1024.0 / 1024.0;

			ZEN_UNUSED(Endpoint);

			ZEN_INFO("{} Endpoint: {}, Bytes: {:.2f} MB, Time: {:.2f} s, Speed: {:.2f} MB/s, Avg: {:.2f} ms/request, Samples: {}",
					 What,
					 Kv.first->DisplayName(),
					 TotalMb,
					 Counters.Seconds,
					 TotalMb / Counters.Seconds,
					 (Counters.Seconds * 1000.0) / double(Counters.Count),
					 Counters.Count);
		}
	}

	spdlog::logger& Log() { return m_Log; }

	spdlog::logger& m_Log;
	EndpointStats	m_UpStats;
	EndpointStats	m_DownStats;
};

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

class DefaultUpstreamCache final : public UpstreamCache
{
public:
	DefaultUpstreamCache(const UpstreamCacheOptions& Options, ZenCacheStore& CacheStore, CidStore& CidStore)
	: m_Log(logging::Get("upstream"))
	, m_Options(Options)
	, m_CacheStore(CacheStore)
	, m_CidStore(CidStore)
	{
	}

	virtual ~DefaultUpstreamCache() { Shutdown(); }

	virtual bool Initialize() override
	{
		for (auto& Endpoint : m_Endpoints)
		{
			const UpstreamEndpointHealth Health = Endpoint->CheckHealth();
			if (Health.Ok)
			{
				ZEN_INFO("initialize endpoint '{}' OK", Endpoint->DisplayName());
			}
			else
			{
				ZEN_WARN("initialize endpoint '{}' FAILED, reason '{}'", Endpoint->DisplayName(), Health.Reason);
			}
		}

		m_RunState.IsRunning = !m_Endpoints.empty();

		if (m_RunState.IsRunning)
		{
			for (uint32_t Idx = 0; Idx < m_Options.ThreadCount; Idx++)
			{
				m_UpstreamThreads.emplace_back(&DefaultUpstreamCache::ProcessUpstreamQueue, this);
			}

			m_EndpointMonitorThread = std::thread(&DefaultUpstreamCache::MonitorEndpoints, this);
		}

		return m_RunState.IsRunning;
	}

	virtual void RegisterEndpoint(std::unique_ptr<UpstreamEndpoint> Endpoint) override { m_Endpoints.emplace_back(std::move(Endpoint)); }

	virtual GetUpstreamCacheResult GetCacheRecord(UpstreamCacheKey CacheKey, ZenContentType Type) override
	{
		if (m_Options.ReadUpstream)
		{
			for (auto& Endpoint : m_Endpoints)
			{
				if (Endpoint->IsHealthy())
				{
					if (GetUpstreamCacheResult Result = Endpoint->GetCacheRecord(CacheKey, Type); Result.Success)
					{
						m_Stats.Add(*Endpoint, Result);
						return Result;
					}
				}
			}
		}

		return {};
	}

	virtual GetUpstreamCacheResult GetCachePayload(UpstreamPayloadKey PayloadKey) override
	{
		if (m_Options.ReadUpstream)
		{
			for (auto& Endpoint : m_Endpoints)
			{
				if (Endpoint->IsHealthy())
				{
					if (GetUpstreamCacheResult Result = Endpoint->GetCachePayload(PayloadKey); Result.Success)
					{
						m_Stats.Add(*Endpoint, Result);
						return Result;
					}
				}
			}
		}

		return {};
	}

	virtual EnqueueResult EnqueueUpstream(UpstreamCacheRecord CacheRecord) override
	{
		if (m_RunState.IsRunning && m_Options.WriteUpstream)
		{
			if (!m_UpstreamThreads.empty())
			{
				m_UpstreamQueue.Enqueue(std::move(CacheRecord));
			}
			else
			{
				ProcessCacheRecord(std::move(CacheRecord));
			}

			return {.Success = true};
		}

		return {};
	}

private:
	void ProcessCacheRecord(UpstreamCacheRecord CacheRecord)
	{
		ZenCacheValue		  CacheValue;
		std::vector<IoBuffer> Payloads;

		if (!m_CacheStore.Get(CacheRecord.CacheKey.Bucket, CacheRecord.CacheKey.Hash, CacheValue))
		{
			ZEN_WARN("process upstream FAILED, '{}/{}', cache record doesn't exist",
					 CacheRecord.CacheKey.Bucket,
					 CacheRecord.CacheKey.Hash);
			return;
		}

		for (const IoHash& PayloadId : CacheRecord.PayloadIds)
		{
			if (IoBuffer Payload = m_CidStore.FindChunkByCid(PayloadId))
			{
				Payloads.push_back(Payload);
			}
			else
			{
				ZEN_WARN("process upstream FAILED, '{}/{}/{}', payload doesn't exist in CAS",
						 CacheRecord.CacheKey.Bucket,
						 CacheRecord.CacheKey.Hash,
						 PayloadId);
				return;
			}
		}

		for (auto& Endpoint : m_Endpoints)
		{
			if (Endpoint->IsHealthy())
			{
				const PutUpstreamCacheResult Result = Endpoint->PutCacheRecord(CacheRecord, CacheValue.Value, std::span(Payloads));
				if (Result.Success)
				{
					m_Stats.Add(*Endpoint, Result);
				}
				else
				{
					ZEN_WARN("process upstream FAILED, '{}/{}' FAILED, endpoint '{}', reason: '{}'",
							 CacheRecord.CacheKey.Bucket,
							 CacheRecord.CacheKey.Hash,
							 Endpoint->DisplayName(),
							 Result.Reason);
				}
			}
		}
	}

	void ProcessUpstreamQueue()
	{
		for (;;)
		{
			UpstreamCacheRecord CacheRecord;
			if (m_UpstreamQueue.WaitAndDequeue(CacheRecord))
			{
				try
				{
					ProcessCacheRecord(std::move(CacheRecord));
				}
				catch (std::exception& e)
				{
					ZEN_WARN("process upstream ({}/{}) FAILED '{}'", CacheRecord.CacheKey.Bucket, CacheRecord.CacheKey.Hash, e.what());
				}
			}

			if (!m_RunState.IsRunning)
			{
				break;
			}
		}
	}

	void MonitorEndpoints()
	{
		for (;;)
		{
			{
				std::unique_lock lk(m_RunState.Mutex);
				if (m_RunState.ExitSignal.wait_for(lk, m_Options.HealthCheckInterval, [this]() { return !m_RunState.IsRunning.load(); }))
				{
					break;
				}
			}

			for (auto& Endpoint : m_Endpoints)
			{
				if (!Endpoint->IsHealthy())
				{
					if (const UpstreamEndpointHealth Health = Endpoint->CheckHealth(); Health.Ok)
					{
						ZEN_INFO("health check endpoint '{}' OK", Endpoint->DisplayName(), Health.Reason);
					}
					else
					{
						ZEN_WARN("health check endpoint '{}' FAILED, reason '{}'", Endpoint->DisplayName(), Health.Reason);
					}
				}
			}
		}
	}

	void Shutdown()
	{
		if (m_RunState.Stop())
		{
			m_UpstreamQueue.CompleteAdding();
			for (std::thread& Thread : m_UpstreamThreads)
			{
				Thread.join();
			}

			m_EndpointMonitorThread.join();
			m_UpstreamThreads.clear();
			m_Endpoints.clear();
		}
	}

	spdlog::logger& Log() { return m_Log; }

	using UpstreamQueue = detail::BlockingQueue<UpstreamCacheRecord>;

	struct RunState
	{
		std::mutex				Mutex;
		std::condition_variable ExitSignal;
		std::atomic_bool		IsRunning{false};

		bool Stop()
		{
			bool Stopped = false;
			{
				std::lock_guard _(Mutex);
				Stopped = IsRunning.exchange(false);
			}
			if (Stopped)
			{
				ExitSignal.notify_all();
			}
			return Stopped;
		}
	};

	spdlog::logger&								   m_Log;
	UpstreamCacheOptions						   m_Options;
	ZenCacheStore&								   m_CacheStore;
	CidStore&									   m_CidStore;
	UpstreamQueue								   m_UpstreamQueue;
	UpstreamStats								   m_Stats;
	std::vector<std::unique_ptr<UpstreamEndpoint>> m_Endpoints;
	std::vector<std::thread>					   m_UpstreamThreads;
	std::thread									   m_EndpointMonitorThread;
	RunState									   m_RunState;
};

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

std::unique_ptr<UpstreamCache>
MakeUpstreamCache(const UpstreamCacheOptions& Options, ZenCacheStore& CacheStore, CidStore& CidStore)
{
	return std::make_unique<DefaultUpstreamCache>(Options, CacheStore, CidStore);
}

std::unique_ptr<UpstreamEndpoint>
MakeJupiterUpstreamEndpoint(const CloudCacheClientOptions& Options)
{
	return std::make_unique<detail::JupiterUpstreamEndpoint>(Options);
}

std::unique_ptr<UpstreamEndpoint>
MakeZenUpstreamEndpoint(std::string_view Url)
{
	return std::make_unique<detail::ZenUpstreamEndpoint>(Url);
}

}  // namespace zen