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

#pragma once

namespace UE::IoStore::HTTP
{

////////////////////////////////////////////////////////////////////////////////
using FTransactId = uint32;

////////////////////////////////////////////////////////////////////////////////
bool IsContentless(uint32 StatusCode)
{
	return (StatusCode < 200) | (StatusCode == 204) | (StatusCode == 304);
}

////////////////////////////////////////////////////////////////////////////////
bool IsStatusCodeOk(uint32 StatusCode)
{
	enum { MinCode = 100, MaxCode = 999 };
	return uint32(StatusCode - MinCode) <= uint32(MaxCode - MinCode);
}

} // namespace UE::IoStore::HTTP



////////////////////////////////////////////////////////////////////////////////
#if !defined(WITH_NGHTTP2)
#	define WITH_NGHTTP2 0
#	if defined(__has_include)
#		if __has_include(<nghttp2/nghttp2.h>)
#			undef WITH_NGHTTP2
#			define WITH_NGHTTP2 1
#		endif
#	endif
#endif

#if !defined(IAS_HTTP_WITH_TWO)
#	define IAS_HTTP_WITH_TWO WITH_NGHTTP2
#endif

#if IAS_HTTP_WITH_TWO

////////////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
#	define	NGHTTP2_NO_SSIZE_T
#endif
#if PLATFORM_MICROSOFT & !defined(NGHTTP2_STATICLIB)
#	define NGHTTP2_STATICLIB
#endif

#include <nghttp2/nghttp2.h>

#if PLATFORM_MICROSOFT & !defined(NGHTTP2_STATICLIB)
#	undef NGHTTP2_STATICLIB
#endif
#if defined(_MSC_VER)
#	undef NGHTTP2_NO_SSIZE_T
#endif

namespace UE::IoStore::HTTP
{

namespace DetailTwo
{

////////////////////////////////////////////////////////////////////////////////
struct FFrame
{
	enum class EType : uint8
	{
		Data,			// = 0x00,
		Headers,		// = 0x01,
		Priority,		// = 0x02,
		RstStream,		// = 0x03,
		Settings,		// = 0x04,
		PushPromise,	// = 0x05,
		Ping,			// = 0x06,
		Goaway,			// = 0x07,
		WindowUpdate,	// = 0x08,
		Continuation,	// = 0x09,
		_Num,
	};

	enum : uint8
	{
		Flag_Padding	= 0x08,
		Flag_EndHeaders	= 0x04,
		Flag_EndStream	= 0x01,
	};

	uint8	Size[3];
	EType	Type;
	uint8	Flags;
	uint8	Id[4];

	int32	IsPertinent() const	{ return (Id[3] & 1) != 0; }
	uint32	GetSize() const		{ return (Size[0] << 16u) | (Size[1] << 8u) | Size[2]; }
	uint32	GetId() const		{ return (Id[0] << 24u) | (Id[1] << 16u) | (Id[2] << 8u) | Id[3]; }
	uint32	GetIdFast() const	{ return Id[3]; }
};
static_assert(sizeof(FFrame) == 9);



////////////////////////////////////////////////////////////////////////////////
class FBufferNg
{
public:
					FBufferNg() = default;
					~FBufferNg()							{ if (Inner != nullptr) nghttp2_rcbuf_decref(Inner); }
					FBufferNg(nghttp2_rcbuf* InRcBuf)		{ nghttp2_rcbuf_incref(Inner = InRcBuf); }
					FBufferNg(FBufferNg&& Rhs)				{ Swap(Inner, Rhs.Inner); }
					FBufferNg(const FBufferNg&) = delete;
	FBufferNg&		operator = (FBufferNg&& Rhs)			{ Swap(Inner, Rhs.Inner); return *this; }
	FBufferNg&		operator = (const FBufferNg&) = delete;

	FAnsiStringView	Get() const
	{
		check(Inner != nullptr);
		nghttp2_vec Ret = nghttp2_rcbuf_get_buf(Inner);
		return { (char*)(Ret.base), int32(Ret.len) };
	}

private:
	nghttp2_rcbuf*	Inner = nullptr;
};

////////////////////////////////////////////////////////////////////////////////
struct FHeaderNg
{
	FBufferNg	Key;
	FBufferNg	Value;
};



////////////////////////////////////////////////////////////////////////////////
class FDriverHeaders
{
public:
						FDriverHeaders() = default;
	void				Add(FAnsiStringView Key, FAnsiStringView Value);

private:
	friend class FDriverNg;

	const nghttp2_nv*	GetData() const	{ return Headers.GetData(); }
	int32 				Num() const		{ return Headers.Num(); }
	TArray<nghttp2_nv>	Headers;

	UE_NONCOPYABLE(FDriverHeaders);
};

////////////////////////////////////////////////////////////////////////////////
void FDriverHeaders::Add(FAnsiStringView Key, FAnsiStringView Value)
{
	nghttp2_nv Header{
		(uint8*)Key.GetData(),
		(uint8*)Value.GetData(),
		size_t(Key.Len()),
		size_t(Value.Len()),
		NGHTTP2_NV_FLAG_NO_COPY_NAME | NGHTTP2_NV_FLAG_NO_COPY_VALUE,
	};
	Headers.Add(MoveTemp(Header));
}



////////////////////////////////////////////////////////////////////////////////
class FDriverNg
{
public:
						FDriverNg(FTlsPeer& Peer);
	bool				IsUsingTls() const;
	void				GoAway(FTlsPeer& Peer);
	FOutcome			Handshake(FTlsPeer& Peer);
	FOutcome			GetTransactId(FTlsPeer& Peer);
	FTransactId			Submit(const FDriverHeaders& Headers);
	FOutcome			Send(FTlsPeer& Peer);
	FOutcome			RecvResponse(FTlsPeer& Peer, TArray<FHeaderNg>* Sink);
	FOutcome			RecvBody(FTlsPeer& Peer, FMutableMemoryView Dest);

private:
	FOutcome			Tick(FTlsPeer& Peer);
	FOutcome			TickInner(FTlsPeer& Peer);
	FOutcome			PumpSend(FTlsPeer& Peer);
	FOutcome			PumpRecv(FTlsPeer& Peer, FMemoryView Data);
	int32 				OnHeader(nghttp2_rcbuf* Name, nghttp2_rcbuf* Value);
	nghttp2_session*	Session;
	TArray<FHeaderNg>*	ResponseHeaders = nullptr;
	FMemoryView			SendPending;
	int32				RecvRemaining;
	bool				bWithTls;
	uint8				RecvBuffer[512 - sizeof(FFrame)];
	union
	{
		FFrame			RecvFrame;
		uint8			RecvFrameData[sizeof(RecvFrame)];
	};

	UE_NONCOPYABLE(FDriverNg);
};

////////////////////////////////////////////////////////////////////////////////
FDriverNg::FDriverNg(FTlsPeer& Peer)
: bWithTls(Peer.IsUsingTls())
{
	struct FStaticsNg
	{
		~FStaticsNg()
		{
			nghttp2_session_callbacks_del(Instance);
		}
		nghttp2_session_callbacks* Instance = nullptr;
	};

	static FStaticsNg Statics;
	if (Statics.Instance == nullptr)
	{
		nghttp2_session_callbacks* Callbacks;
		nghttp2_session_callbacks_new(&Callbacks);

		nghttp2_session_callbacks_set_on_header_callback2(
			Callbacks,
			[] (nghttp2_session*, const nghttp2_frame*, nghttp2_rcbuf* Name, nghttp2_rcbuf* Value, uint8_t, void* UserData) -> int32
			{
				auto* This = (FDriverNg*)UserData;
				return This->OnHeader(Name, Value);
			}
		);

		Statics.Instance = Callbacks;
	}

	static nghttp2_mem Mem = {
		.mem_user_data	= nullptr,
		.malloc			= [] (size_t Size, void*)				{ return FMemory::Malloc(Size); },
		.free			= [] (void* Ptr, void*)					{ return FMemory::Free(Ptr); },
		.calloc			= [] (size_t Count, size_t Size, void*) { return FMemory::MallocZeroed(Count * Size); },
		.realloc		= [] (void* Ptr, size_t Size, void*)	{ return FMemory::Realloc(Ptr, Size); },
	};

	RecvRemaining = 0 - int32(sizeof(RecvFrame));

	nghttp2_session_client_new3(&Session, Statics.Instance, this, nullptr, &Mem);

	// Perhaps in the future a window size can be picked - or adjusted - by
	// monitoring latency and throughput.
	/*
	nghttp2_session_set_local_window_size(Session, 0, 0, 256 << 10);
	*/
}

////////////////////////////////////////////////////////////////////////////////
void FDriverNg::GoAway(FTlsPeer& Peer)
{
	if (Session != nullptr)
	{
		nghttp2_session_terminate_session(Session, NGHTTP2_NO_ERROR);
		PumpSend(Peer);
		nghttp2_session_del(Session);
	}
}

////////////////////////////////////////////////////////////////////////////////
bool FDriverNg::IsUsingTls() const
{
	return bWithTls;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::PumpSend(FTlsPeer& Peer)
{
	for (uint32 Sent = 0;;)
	{
		if (SendPending.IsEmpty())
		{
			const uint8* Data = nullptr;
			int32 Result = int32(nghttp2_session_mem_send2(Session, &Data));
			if (Result < 0)
			{
				const char* Message = nghttp2_strerror(Result);
				return FOutcome::Error(Message);
			}

			if (Result == 0)
			{
				return FOutcome::Ok(Sent);
			}

			SendPending = { Data, uint32(Result) };
		}

		const char* Data = (char*)(SendPending.GetData());
		uint32 Size = uint32(SendPending.GetSize());
		FOutcome Outcome = Peer.Send((char*)Data, Size);
		if (Outcome.IsError())
		{
			return Outcome;
		}

		if (Outcome.IsOk())
		{
			int32 Result = Outcome.GetResult();
			Sent += Result;

			SendPending = SendPending.Mid(Result);
			if (SendPending.IsEmpty())
			{
				continue;
			}
		}

		check(!SendPending.IsEmpty());
		return FOutcome::Waiting();
	}
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::PumpRecv(FTlsPeer& Peer, FMemoryView Data)
{
	int32 Result = int32(nghttp2_session_mem_recv2(Session, (uint8*)Data.GetData(), Data.GetSize()));

	if (Result < 0)
	{
		const char* Message = nghttp2_strerror(Result);
		return FOutcome::Error(Message);
	}

	if (Result != int32(Data.GetSize()))
	{
		return FOutcome::Error("Not enough data consumed");
	}

	if (nghttp2_session_want_write(Session))
	{
		// We'll not care about the outcome here. If an error occurred it will
		// surface later and data-waits will solved themselves later.
		PumpSend(Peer);
	}

	return FOutcome::Ok();
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::Handshake(FTlsPeer& Peer)
{
	nghttp2_submit_settings(Session, NGHTTP2_FLAG_NONE, nullptr, 0);
	FOutcome Outcome = PumpSend(Peer);
	return Outcome.IsError() ? Outcome : FOutcome::Ok();
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::GetTransactId(FTlsPeer& Peer)
{
	if (RecvRemaining >= 0 && RecvFrame.IsPertinent())
	{
		uint32 Id = RecvFrame.GetId();
		return FOutcome::Ok(Id);
	}

	return Tick(Peer);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::Tick(FTlsPeer& Peer)
{
	while (true)
	{
		FOutcome Outcome = TickInner(Peer);
		if (!Outcome.IsWaiting() || (Outcome.GetResult() == 0))
		{
			return Outcome;
		}
	}
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::TickInner(FTlsPeer& Peer)
{
	FMutableMemoryView Dest(RecvBuffer, sizeof(RecvBuffer) + sizeof(RecvFrame));
	if (RecvRemaining < 0)
	{
		Dest = Dest.Right(0 - RecvRemaining);
	}
	else if (RecvRemaining <= int32(sizeof(RecvBuffer)))
	{
		Dest = Dest.Right(RecvRemaining + sizeof(RecvFrame));
	}
	else
	{
		Dest = Dest.Left(sizeof(RecvBuffer));
	}

	FOutcome Outcome = Peer.Recv((char*)(Dest.GetData()), int32(Dest.GetSize()));
	if (!Outcome.IsOk())
	{
		return Outcome;
	}

	int32 Result = Outcome.GetResult();
	Dest = Dest.Left(Result);

	FMutableMemoryView FrameView;
	if (const uint8* End = (uint8*)(Dest.GetDataEnd()); End > RecvFrameData)
	{
		FrameView = FMutableMemoryView(RecvFrameData, End - RecvFrameData);
		Dest = Dest.LeftChop(FrameView.GetSize());
	}

	if (!Dest.IsEmpty() && (Outcome = PumpRecv(Peer, Dest)).IsError())
	{
		return Outcome;
	}

	if (FrameView.IsEmpty())
	{
		check(RecvRemaining >= int32(Dest.GetSize()));
		if ((RecvRemaining -= int32(Dest.GetSize())) == 0)
		{
			RecvRemaining = 0 - int32(sizeof(RecvFrame));
		}
		return FOutcome::Waiting(Dest.GetDataEnd() == RecvFrameData);
	}

	if (Result = int32(FrameView.GetSize() - sizeof(RecvFrame)); Result < 0)
	{
		RecvRemaining = Result;
		return FOutcome::Waiting();
	}

	if ((Outcome = PumpRecv(Peer, FrameView)).IsError())
	{
		return Outcome;
	}

	RecvRemaining = RecvFrame.GetSize();
	if (RecvFrame.IsPertinent())
	{
		uint32 Id = RecvFrame.GetId();
		return FOutcome::Ok(Id);
	}

	if (RecvRemaining == 0)
	{
		RecvRemaining = 0 - int32(sizeof(RecvFrame));
	}

	return FOutcome::Waiting(1);
}

////////////////////////////////////////////////////////////////////////////////
FTransactId FDriverNg::Submit(const FDriverHeaders& Headers)
{
	return nghttp2_submit_request2(Session, nullptr, Headers.GetData(),
		Headers.Num(), nullptr, this);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::Send(FTlsPeer& Peer)
{
	return PumpSend(Peer);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::RecvResponse(FTlsPeer& Peer, TArray<FHeaderNg>* Sink)
{
	if (RecvFrame.Type == FFrame::EType::RstStream)
	{
		return FOutcome::Error("Received stream reset");
	}

	// Assume if we're filling we are expecting something
	check(RecvRemaining > 0);
	check(RecvFrame.Type == FFrame::EType::Headers);

	ResponseHeaders = Sink;
	ON_SCOPE_EXIT { ResponseHeaders = nullptr; };

	while (true)
	{
		int32 EndOfHeaders = (RecvFrame.Flags & FFrame::Flag_EndHeaders);
		uint32 ThisId = RecvFrame.GetId();

		if (EndOfHeaders)
		{
			RecvFrame = {};
		}

		FOutcome Outcome = Tick(Peer); 
		if (Outcome.IsError())				return Outcome;
		if (EndOfHeaders)					return FOutcome::Ok();
		if (Outcome.GetResult() != ThisId)	return FOutcome::WaitStream();
	}
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FDriverNg::RecvBody(FTlsPeer& Peer, FMutableMemoryView Dest)
{
	if (RecvFrame.Type == FFrame::EType::RstStream)
	{
		return FOutcome::Error("Received stream reset");
	}

	check(RecvRemaining >= 0);
	check(RecvFrame.Type == FFrame::EType::Data);

	for (uint32 RecvSize = 0;;)
	{
		int32 EndOfStream = (RecvFrame.Flags & FFrame::Flag_EndStream);

		FMutableMemoryView View = Dest.Left(RecvRemaining);
		if (View.IsEmpty())
		{
			if (EndOfStream)
			{
				RecvFrame = {};
				return FOutcome::Ok(RecvSize);
			}

			return FOutcome::WaitBuffer(RecvSize);
		}

		FOutcome Outcome = Peer.Recv((char*)View.GetData(), int32(View.GetSize()));
		if (!Outcome.IsOk())
		{
			if (Outcome.IsError())
			{
				return Outcome;
			}
			return FOutcome::Waiting(RecvSize);
		}

		int32 Result = Outcome.GetResult();
		RecvRemaining -= Result;
		RecvSize += Result;
		Dest = Dest.Mid(Result);

		if ((Outcome = PumpRecv(Peer, View.Left(Result))).IsError())
		{
			return Outcome;
		}

		// more of this frame to go?
		if (RecvRemaining > 0)
		{
			continue;
		}

		RecvRemaining = 0 - int32(sizeof(RecvFrame)) - RecvRemaining;

		// End of the road?
		if (EndOfStream)
		{
			RecvFrame = {};
			return FOutcome::Ok(RecvSize);
		}

		uint32 ThisId = RecvFrame.GetId();
		Outcome = Tick(Peer);
		if (Outcome.IsError())				return Outcome;
		if (ThisId != Outcome.GetResult())	return FOutcome::WaitBuffer(RecvSize);
	}
}

////////////////////////////////////////////////////////////////////////////////
int32 FDriverNg::OnHeader(nghttp2_rcbuf* Name, nghttp2_rcbuf* Value)
{
	if (ResponseHeaders == nullptr)
	{
		return NGHTTP2_ERR_CALLBACK_FAILURE;
	}

	FHeaderNg Header(Name, Value);
	ResponseHeaders->Add(MoveTemp(Header));
	return 0;
}



////////////////////////////////////////////////////////////////////////////////
class FBase
{
public:
					FBase(FDriverNg& InDriver);

protected:
	FDriverNg&		GetDriver();

private:
	FDriverNg&		Driver;
};

////////////////////////////////////////////////////////////////////////////////
FBase::FBase(FDriverNg& InDriver)
: Driver(InDriver)
{
}

////////////////////////////////////////////////////////////////////////////////
FDriverNg& FBase::GetDriver()
{
	return Driver;
}



////////////////////////////////////////////////////////////////////////////////
class FRequest
	: public FBase
{
public:
	using FBase::FBase;

	void			Begin(FAnsiStringView Host, FAnsiStringView Method, FAnsiStringView Path);
	void			AddHeader(FAnsiStringView Key, FAnsiStringView Value);
	FTransactId		End(bool bKeepAlive);
	FOutcome		TrySendRequest(FTlsPeer& Peer);

protected:
	FTransactId		GetTransactId() const;

private:
	FDriverHeaders	RequestHeaders;
	FTransactId		Id;
};

////////////////////////////////////////////////////////////////////////////////
void FRequest::Begin(FAnsiStringView Host, FAnsiStringView Method, FAnsiStringView Path)
{
	FAnsiStringView Scheme = GetDriver().IsUsingTls() ? "https" : "http";
	RequestHeaders.Add(":method", Method);
	RequestHeaders.Add(":path", Path);
	RequestHeaders.Add(":authority", Host);
	RequestHeaders.Add(":scheme", Scheme);
}

////////////////////////////////////////////////////////////////////////////////
void FRequest::AddHeader(FAnsiStringView Key, FAnsiStringView Value)
{
	check(!Key.Equals("connection", ESearchCase::IgnoreCase));

#if UE_BUILD_DEVELOPMENT
	for (uint32 Char : Key)
	{
		if (uint32(Char - 'A') > uint32('Z' - 'A'))
		{
			check("header keys must be lowercase");
		}
	}
#endif
	RequestHeaders.Add(Key, Value);
}

////////////////////////////////////////////////////////////////////////////////
FTransactId FRequest::GetTransactId() const
{
	return Id;
}

////////////////////////////////////////////////////////////////////////////////
FTransactId FRequest::End(bool /*bKeepAlive*/)
{
	Id = GetDriver().Submit(RequestHeaders);
	return Id;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FRequest::TrySendRequest(FTlsPeer& Peer)
{
	return GetDriver().Send(Peer);
}



////////////////////////////////////////////////////////////////////////////////
class FStatusHeaders
	: public FRequest
{
public:
	using FRequest::FRequest;

	FOutcome			TryRecvResponse(FTlsPeer& Peer);
	bool				IsKeepAlive() const;
	uint32				GetStatusCode() const;
	FAnsiStringView		GetStatusMessage() const;
	int64				GetContentLength() const;
	bool				IsChunked() const;
	void				ReadHeaders(FResponse::FHeaderSink Sink) const;

private:
	TArray<FHeaderNg>	ResponseHeaders;
	int64				ContentLength = -1;
	uint32				StatusCode = 0;
};

////////////////////////////////////////////////////////////////////////////////
bool FStatusHeaders::IsKeepAlive() const
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////
uint32 FStatusHeaders::GetStatusCode() const
{
	return StatusCode;
}

////////////////////////////////////////////////////////////////////////////////
FAnsiStringView	FStatusHeaders::GetStatusMessage() const
{
	return "";
}

////////////////////////////////////////////////////////////////////////////////
int64 FStatusHeaders::GetContentLength() const
{
	return ContentLength;
}

////////////////////////////////////////////////////////////////////////////////
bool FStatusHeaders::IsChunked() const
{
	return ContentLength < 0;
}

////////////////////////////////////////////////////////////////////////////////
void FStatusHeaders::ReadHeaders(FResponse::FHeaderSink Sink) const
{
	for (const FHeaderNg& Header : ResponseHeaders)
	{
		FAnsiStringView Key = Header.Key.Get();
		FAnsiStringView Value = Header.Value.Get();
		if (!Sink(Key, Value))
		{
			break;
		}
	}
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FStatusHeaders::TryRecvResponse(FTlsPeer& Peer)
{
	FOutcome Outcome = GetDriver().RecvResponse(Peer, &ResponseHeaders);
	if (!Outcome.IsOk())
	{
		return Outcome;
	}

	enum : uint32 {
		Flag_Code	= 1 << 0,
		Flag_Length = 1 << 1,
		Flag_All	= Flag_Code | Flag_Length,
	};
	uint32 Flags = 0;
	for (const FHeaderNg& Header : ResponseHeaders)
	{
		if (Flags == Flag_All)
		{
			break;
		}

		FAnsiStringView Key = Header.Key.Get();
		FAnsiStringView Value = Header.Value.Get();

		if ((Flags ^ Flag_Code) && (Key == ":status"))
		{
			StatusCode = uint32(CrudeToInt(Value));
			Flags |= Flag_Code;
		}
		else if ((Flags ^ Flag_Length) && (Key == "content-length"))
		{
			ContentLength = CrudeToInt(Value);
			Flags |= Flag_Length;
		}
	}

	if ((Flags & Flag_Code) == 0 || !IsStatusCodeOk(StatusCode))
	{
		return FOutcome::Error("Invalid status code", StatusCode);
	}

	if (IsContentless(StatusCode))
	{
		ContentLength = 0;
	}

	return FOutcome::Ok();
}



////////////////////////////////////////////////////////////////////////////////
class FBody
	: public FStatusHeaders
{
public:
	using FStatusHeaders::FStatusHeaders;

	int64			GetRemaining() const;
	FOutcome		TryRecv(FMutableMemoryView Dest, FTlsPeer& Peer);

private:
	int64			Remaining = -1;
};

////////////////////////////////////////////////////////////////////////////////
int64 FBody::GetRemaining() const
{
	return Remaining;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::TryRecv(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	if (!IsChunked())
	{
		if (Remaining < 0)
		{
			Remaining = GetContentLength();
		}
		Dest = Dest.Left(Remaining);
	}

	FOutcome Outcome = GetDriver().RecvBody(Peer, Dest);
	if (Outcome.IsError())
	{
		return Outcome;
	}

	Remaining -= Outcome.GetResult();
	return Outcome;
}

} // namespace DetailTwo



////////////////////////////////////////////////////////////////////////////////
class FTransactionTwo
	: public DetailTwo::FBody
{
public:
	using DetailTwo::FBody::FBody;
};



////////////////////////////////////////////////////////////////////////////////
FOutcome HandshakeTwo(FTlsPeer& Peer, void*& PeerData)
{
	using namespace DetailTwo;

	if (PeerData == nullptr)
	{
		PeerData = new FDriverNg(Peer);
	}

	auto* Driver = (FDriverNg*)PeerData;
	return Driver->Handshake(Peer);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome TickTwo(FTlsPeer& Peer, void* PeerData)
{
	using namespace DetailTwo;

	auto* Driver = (FDriverNg*)PeerData;
	return Driver->GetTransactId(Peer);
}

////////////////////////////////////////////////////////////////////////////////
void GoAwayTwo(FTlsPeer& Peer, void* PeerData)
{
	using namespace DetailTwo;

	auto* Driver = (FDriverNg*)PeerData;
	if (Driver == nullptr)
	{
		return;
	}

	Driver->GoAway(Peer);
	delete Driver;
}

} // namespace UE::IoStore::HTTP

#else // IAS_HTTP_WITH_TWO

////////////////////////////////////////////////////////////////////////////////
namespace UE::IoStore::HTTP {

class FTransactionTwo
{
public:
	void			Begin(...)									{}
	void			AddHeader(...)								{}
	FTransactId		End(...)									{ return 0; }
	FOutcome		TrySendRequest(FTlsPeer&)					{ return FOutcome::None(); }
	FOutcome		TryRecvResponse(FTlsPeer&)					{ return FOutcome::None(); }
	bool			IsKeepAlive() const							{ return false; }
	uint32			GetStatusCode() const						{ return 0; }
	FAnsiStringView	GetStatusMessage() const					{ return {}; }
	int64			GetContentLength() const					{ return -1; }
	bool			IsChunked() const							{ return false; }
	int64			GetRemaining() const						{ return -1; }
	void			ReadHeaders(FResponse::FHeaderSink) const	{}
	FOutcome		TryRecv(FMutableMemoryView, FTlsPeer&)		{ return FOutcome::None(); }
};
FOutcome HandshakeTwo(FTlsPeer&, void*&)	{ return FOutcome::None(); }
FOutcome TickTwo(FTlsPeer&, void*)			{ return FOutcome::None(); }
void GoAwayTwo(FTlsPeer&, void*)			{}

} // namespace UE::IoStore::HTTP

#endif // IAS_HTTP_WITH_TWO