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

#pragma once

namespace UE::IoStore::HTTP
{

////////////////////////////////////////////////////////////////////////////////
struct FMessageOffsets
{
	uint8	StatusCode;
	uint8	Message;
	uint16	Headers;
};

static int32 ParseMessage(FAnsiStringView Message, FMessageOffsets& Out)
{
	const FAnsiStringView Protocol("HTTP/1.1 ");

	// Check there's enough data
	if (Message.Len() < Protocol.Len() + 1) // "+1" accounts for at least one digit
	{
		return -1;
	}

	const char* Cursor = Message.GetData();

	// Check for the expected protocol
	if (FAnsiStringView(Cursor, 9) != Protocol)
	{
		return -1;
	}
	int32 i = Protocol.Len();

	// Trim left and tightly reject anything adventurous
	for (int n = 32; i < n && Cursor[i] == ' '; ++i);
	Out.StatusCode = uint8(i);

	// At least one status line digit. (Note to self; expect exactly three)
	for (int n = 32; i < n && uint32(Cursor[i] - 0x30) <= 9; ++i);
	if (uint32(i - Out.StatusCode - 1) > 32)
	{
		return -1;
	}

	// Trim left
	for (int n = 32; i < n && Cursor[i] == ' '; ++i);
	Out.Message = uint8(i);

	// Extra conservative length allowance
	if (i > 32)
	{
		return -1;
	}

	// Find \r\n
	for (; Cursor[i] != '\r'; ++i)
	{
		if (i >= 2048)
		{
			return -1;
		}
	}
	if (Cursor[i + 1] != '\n')
	{
		return -1;
	}
	Out.Headers = uint16(i + 2);

	return 1;
}



////////////////////////////////////////////////////////////////////////////////
template <typename LambdaType>
static void EnumerateHeaders(FAnsiStringView Headers, LambdaType&& Lambda)
{
	// NB. here we are assuming that we will be dealing with servers that will
	// not be returning headers with "obsolete line folding".

	auto IsOws = [] (int32 c) { return (c == ' ') | (c == '\t'); };

	const char* Cursor = Headers.GetData();
	const char* End = Cursor + Headers.Len();
	do
	{
		int32 ColonIndex = 0;
		for (; Cursor + ColonIndex < End; ++ColonIndex)
		{
			if (Cursor[ColonIndex] == ':')
			{
				break;
			}
		}

		Cursor += ColonIndex;

		const char* Right = Cursor + 1;
		while (Right + 1 < End)
		{
			if (Right[0] != '\r' || Right[1] != '\n')
			{
				Right += 1 + (Right[1] != '\r');
				continue;
			}

			FAnsiStringView Name(Cursor - ColonIndex, ColonIndex);

			const char* Left = Cursor + 1;
			for (; IsOws(Left[0]); ++Left);

			Cursor = Right;
			for (; Cursor > Left + 1 && IsOws(Cursor[-1]); --Cursor);

			FAnsiStringView Value (Left, int32(ptrdiff_t(Cursor - Left)));

			if (!Lambda(Name, Value))
			{
				Right = End;
			}

			break;
		}

		Cursor = Right + 2;
	} while (Cursor < End);
}



namespace DetailOne
{

////////////////////////////////////////////////////////////////////////////////
class FBase
{
public:
					FBase();

protected:
	using FMutableSection = FBuffer::FMutableSection;

	const char*		GetData() const;
	uint32			GetSize() const;
	FMutableSection	GetMutableFree(uint32 MinSize, uint32 PageSize=256);
	void			AdvanceUsed(uint32 Delta);

private:
	FBuffer			Buffer;
	char			Data[256];
};

////////////////////////////////////////////////////////////////////////////////
FBase::FBase()
: Buffer(Data, sizeof(Data)) // -V670
{
}

////////////////////////////////////////////////////////////////////////////////
const char* FBase::GetData() const
{
	return Buffer.GetData();
}

////////////////////////////////////////////////////////////////////////////////
uint32 FBase::GetSize() const
{
	return Buffer.GetSize();
}

////////////////////////////////////////////////////////////////////////////////
FBase::FMutableSection FBase::GetMutableFree(uint32 MinSize, uint32 PageSize)
{
	return Buffer.GetMutableFree(MinSize, PageSize);
}

////////////////////////////////////////////////////////////////////////////////
void FBase::AdvanceUsed(uint32 Delta)
{
	return Buffer.AdvanceUsed(Delta);
}



////////////////////////////////////////////////////////////////////////////////
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);

private:
	FRequest&		operator << (FAnsiStringView Value);
	uint16			HeaderLeft;
	uint16			AlreadySent = 0;
	int16			HeaderRight = -1;
	int8			MethodLength = -1;
	uint8			_Unnused;
};

////////////////////////////////////////////////////////////////////////////////
void FRequest::Begin(FAnsiStringView Host, FAnsiStringView Method, FAnsiStringView Path)
{
	check(MethodLength < 0);
	AlreadySent = uint16(GetSize());
	*this << Method << " " << Path << " HTTP/1.1" "\r\n";
	MethodLength = int8(Method.Len());
	HeaderLeft = uint16(GetSize());

	AddHeader("Host", Host);
}

////////////////////////////////////////////////////////////////////////////////
void FRequest::AddHeader(FAnsiStringView Key, FAnsiStringView Value)
{
	check(HeaderRight < 0);
	*this << Key << ":" << Value << "\r\n";
}

////////////////////////////////////////////////////////////////////////////////
FTransactId FRequest::End(bool bKeepAlive)
{
	// HTTP/1.1 is persistent by default thus "Connection" header isn't required
	// unless we want to opt in to a single transaction.
	if (!bKeepAlive)
	{
		AddHeader("Connection", "close");
	}

	*this << "\r\n";
	HeaderRight = int16(GetSize());
	return 1;
}

////////////////////////////////////////////////////////////////////////////////
FRequest& FRequest::operator << (FAnsiStringView Value)
{
	uint32 Length = uint32(Value.Len());
	FBuffer::FMutableSection Section = GetMutableFree(Length);
	::memcpy(Section.Data, Value.GetData(), Length);
	AdvanceUsed(Length);
	return *this;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FRequest::TrySendRequest(FTlsPeer& Peer)
{
	const char* SendData = GetData();
	int32 SendSize = GetSize();

	SendData += AlreadySent;
	SendSize -= AlreadySent;
	check(SendSize > 0);

	FOutcome Outcome = Peer.Send(SendData, SendSize);
	if (!Outcome.IsOk())
	{
		return Outcome;
	}

	int32 Result = Outcome.GetResult();
	AlreadySent += uint16(Result);
	if (AlreadySent == GetSize())
	{
		return FOutcome::Ok();
	}

	check(AlreadySent < GetSize());
	return FOutcome::Waiting();
}



////////////////////////////////////////////////////////////////////////////////
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;

protected:
	const char*		GetMessageRight() const;

private:
	FOutcome		Parse();
	int64			ContentLength = -1;
	FMessageOffsets	Offsets = {};
	int16			MessageLeft = -1;
	int16			MessageRight = -1;
	uint16			StatusCode = 0;
	uint8			bKeepAlive : 1;
	uint8			bChunked : 1;
	uint8			_Unused : 7;
};

////////////////////////////////////////////////////////////////////////////////
bool FStatusHeaders::IsKeepAlive() const
{
	return (MessageRight > 0) ? bKeepAlive : true;
}

////////////////////////////////////////////////////////////////////////////////
uint32 FStatusHeaders::GetStatusCode() const
{
	check(StatusCode >= 100);
	return StatusCode;
}

////////////////////////////////////////////////////////////////////////////////
FAnsiStringView	FStatusHeaders::GetStatusMessage() const
{
	check(Offsets.Message > 0);
	const char* Cursor = GetData() + MessageLeft;
	return FAnsiStringView(Cursor + Offsets.Message, Offsets.Headers - Offsets.Message);
}

////////////////////////////////////////////////////////////////////////////////
int64 FStatusHeaders::GetContentLength() const
{
	check(Offsets.Headers > 0);
	return ContentLength;
}

////////////////////////////////////////////////////////////////////////////////
bool FStatusHeaders::IsChunked() const
{
	check(MessageRight > 0);
	return bChunked;
}

////////////////////////////////////////////////////////////////////////////////
void FStatusHeaders::ReadHeaders(FResponse::FHeaderSink Sink) const
{
	uint32 Offset = MessageLeft + Offsets.Headers;
	uint32 Length = MessageRight - Offset - 2; // "-2" trims off '\r\n' that signals end of headers
	const char* Cursor = GetData() + Offset;
	FAnsiStringView Headers(Cursor, Length);
	UE::IoStore::HTTP::EnumerateHeaders(Headers, Sink);
}

////////////////////////////////////////////////////////////////////////////////
const char* FStatusHeaders::GetMessageRight() const
{
	return GetData() + MessageRight;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FStatusHeaders::TryRecvResponse(FTlsPeer& Peer)
{
	auto FindMessageTerminal = [] (const char* Cursor, int32 Length)
	{
		for (int32 i = 4; i <= Length; ++i)
		{
			uint32 Candidate;
			::memcpy(&Candidate, Cursor + i - 4, sizeof(Candidate));
			if (Candidate == 0x0a0d0a0d)
			{
				return i;
			}

			i += (Cursor[i - 1] > 0x0d) ? 3 : 0;
		}

		return -1;
	};

	if (MessageLeft < 0)
	{
		MessageLeft = int16(GetSize());
		bKeepAlive = true;
		bChunked = false;
	}

	while (true)
	{
		static const uint32 PageSize = 256;
		static const uint32 MaxHeaderSize = 8 << 10;

		auto [Dest, DestSize] = GetMutableFree(0, PageSize);
		FOutcome Outcome = Peer.Recv(Dest, DestSize);
		if (!Outcome.IsOk())
		{
			return Outcome;
		}

		int32 Result = Outcome.GetResult();
		AdvanceUsed(Result);

		// Rewind a little to cover cases where the terminal is fragmented across
		// recv() calls
		uint32 DestBias = 0;
		if (Dest - 3 >= GetData() + MessageLeft)
		{
			Dest -= (DestBias = 3);
		}

		int32 MessageEnd = FindMessageTerminal(Dest, Result + DestBias);
		if (MessageEnd < 0)
		{
			if (GetSize() - MessageLeft > MaxHeaderSize)
			{
				return FOutcome::Error("Headers have grown larger than expected");
			}

			continue;
		}

		MessageRight = int16(ptrdiff_t(Dest + MessageEnd - GetData()));
		return Parse();
	}
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FStatusHeaders::Parse()
{
	const char* Cursor = GetData() + MessageLeft;
	FAnsiStringView MessageView(Cursor, MessageRight - MessageLeft);

	if (ParseMessage(MessageView, Offsets) < 0)
	{
		return FOutcome::Error("Failed to parse message status");
	}

	FAnsiStringView StatusCodeView(
		Cursor + Offsets.StatusCode,
		Offsets.Message - Offsets.StatusCode
	);
	StatusCode = uint16(CrudeToInt(StatusCodeView));
	if (!IsStatusCodeOk(StatusCode))
	{
		return FOutcome::Error("Invalid status code", StatusCode);
	}

	static const uint32 Flag_Length		= 1 << 0;
	static const uint32 Flag_XferEnc	= 1 << 1;
	static const uint32 Flag_Connection = 1 << 2;
	static const uint32 Flag_All		= 0x07;
	uint32 Flags = 0;

	ReadHeaders(
		[this, &Flags] (FAnsiStringView Name, FAnsiStringView Value) mutable
		{
			// todo; may need smarter value handling; ;/, separated options & key-value pairs (ex. in rfc2068)

			if (Name.Equals("Content-Length", ESearchCase::IgnoreCase))
			{
				ContentLength = int32(CrudeToInt(Value));
				Flags |= Flag_Length;
			}

			else if (Name.Equals("Transfer-Encoding", ESearchCase::IgnoreCase))
			{
				bChunked = Value.Equals("chunked", ESearchCase::IgnoreCase);
				Flags |= Flag_XferEnc;
			}

			else if (Name.Equals("Connection", ESearchCase::IgnoreCase))
			{
				bKeepAlive = !Value.Equals("close", ESearchCase::IgnoreCase);
				Flags |= Flag_Connection;
			}

			return Flags != Flag_All;
		}
	);

	if (Flags & Flag_XferEnc)
	{
		if (!bChunked)				return FOutcome::Error("Unsupported Transfer-Encoding");
		if (Flags & Flag_Length)	return FOutcome::Error("Chunked yet with length");
		ContentLength = -1;
	}
	else if (uint32 Overshoot = GetSize() - MessageRight; Flags & Flag_Length)
	{
		if (ContentLength < 0)			return FOutcome::Error("Invalid Content-Length field", uint32(ContentLength));
		if (Overshoot > ContentLength)	return FOutcome::Error("More data received that expected");
	}
	else if (Overshoot)
	{
		return FOutcome::Error("Received content when none was expected");
	}
	else
	{
		ContentLength = 0;
	}

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

	return FOutcome::Ok();
}



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

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

private:
	enum class EState : uint8 { Init, Recv, Prologue, Chunk, Epilogue, Done };

	FOutcome			Gather(FMutableMemoryView Dest, FTlsPeer& Peer);
	FOutcome			Init(FMutableMemoryView Dest, FTlsPeer& Peer);
	FOutcome			Recv(FMutableMemoryView Dest, FTlsPeer& Peer);
	FOutcome			Prologue(FMutableMemoryView Dest, FTlsPeer& Peer);
	FOutcome			Chunk(FMutableMemoryView Dest, FTlsPeer& Peer);
	FOutcome			Epilogue(FMutableMemoryView Dest, FTlsPeer& Peer);
	FMemoryView			Overspill;
	FMutableMemoryView	Scratch;
	int64				Remaining = 0;
	EState				State = EState::Init;

	enum
	{
		HeaderBufSize	= 32,
		CrLfLength		= 2,
		EndOfXfer		= -1,
	};
};

////////////////////////////////////////////////////////////////////////////////
int64 FBody::GetRemaining() const
{
	return (State == EState::Recv) ? Remaining : -1;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::TryRecv(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	if (Dest.GetSize() == 0)
	{
		return FOutcome::Error("Empty destination");
	}

	FOutcome Outcome = FOutcome::None();

	switch (State)
	{
	case EState::Init:	Outcome = Init(Dest, Peer);		break;
	case EState::Recv:	Outcome = Recv(Dest, Peer);		break;
	default:			Outcome = Gather(Dest, Peer);	break;
	case EState::Done:	Outcome = FOutcome::Error("Transaction is complete"); break;
	}

	if (Outcome.IsOk())
	{
		State = EState::Done;
	}

	return Outcome;
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::Gather(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	FOutcome Outcome = FOutcome::None();

	bool bDone = false;
	int32 Size = 0;
	do
	{
		switch (State)
		{
		case EState::Prologue:	Outcome = Prologue(Dest, Peer); break;
		case EState::Chunk:		Outcome = Chunk(Dest, Peer);	break;
		case EState::Epilogue:	Outcome = Epilogue(Dest, Peer);	break;
		default:				Outcome = FOutcome::Error("Unexpected try-chunked state"); break;
		}

		if (Outcome.IsError())
		{
			return Outcome;
		}

		bDone = Outcome.IsOk();
		int32 Result = Outcome.GetResult();
		if (Result == 0)
		{
			break;
		}

		Size += Result;
		Dest = Dest.Mid(Result);
	}
	while (!Dest.IsEmpty());

	return bDone ? FOutcome::Ok(Size) : FOutcome::Waiting(Size);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::Init(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	const char* DataEnd = GetData() + GetSize();
	const char* MessageEnd = GetMessageRight();
	uint32 AlreadyReceived = uint32(ptrdiff_t(DataEnd - MessageEnd));
	if (AlreadyReceived < HeaderBufSize)
	{
		GetMutableFree(HeaderBufSize, HeaderBufSize);
		MessageEnd = GetMessageRight();
	}

	if (AlreadyReceived)
	{
		Overspill = { (const uint8*)MessageEnd, AlreadyReceived };
	}

	Scratch = { (uint8*)MessageEnd, HeaderBufSize };
	
	if (IsChunked())
	{
		check(Remaining == 0);
		State = EState::Prologue;
	}
	else
	{
		Remaining = GetContentLength();
		check(Remaining > 0);
		State = EState::Recv;
	}

	return TryRecv(Dest, Peer);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::Recv(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	int64 OverspillSize = Overspill.GetSize();
	if (OverspillSize != 0)
	{
		int64 Size = FMath::Min<int64>(Dest.GetSize(), OverspillSize);
		::memcpy(Dest.GetData(), Overspill.GetData(), Size);
		Dest = Dest.Mid(Size);
		Overspill = Overspill.Mid(Size);
		Remaining -= Size;
		if (Remaining == 0 || Dest.IsEmpty())
		{
			int32 Result = int32(Size);
			return Remaining ? FOutcome::WaitBuffer(Result) : FOutcome::Ok(Result);
		}
	}

	auto* Cursor = (char*)(Dest.GetData());
	uint32 Size = uint32(FMath::Min<int64>(Dest.GetSize(), Remaining));
	FOutcome Outcome = Peer.Recv(Cursor, Size);
	if (Outcome.IsError())
	{
		return Outcome;
	}

	if (Outcome.IsWaiting())
	{
		check(Outcome.GetResult() == 0);
		return FOutcome::Waiting(int32(OverspillSize));
	}

	int32 Result = Outcome.GetResult();
	Remaining -= Result;
	if (Remaining < 0)
	{
		return FOutcome::Error("Unexpectedly received too much", int32(Remaining));
	}

	Result += int32(OverspillSize);

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

	if (Result == Dest.GetSize())
	{
		return FOutcome::WaitBuffer(Result);
	}

	return FOutcome::Waiting(Result);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::Prologue(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	auto FindHeader = [] (const char* Cursor, int32 Size)
	{
		// Base-16 size
		int32 HexDigLen = 0;
		for (; HexDigLen < Size; ++HexDigLen)
		{
			uint32 c = Cursor[HexDigLen];
			if ((c - '0' >= 10) & (c - 'a' >= 6) & (c - 'A' >= 6))
			{
				break;
			}
			continue;
		}

		int32 Delta = Size - HexDigLen;

		if (HexDigLen >= HeaderBufSize - 2)	return FOutcome::Error("Chunk size too large");
		if (HexDigLen == 0)					return FOutcome::Error("Invalid chunk header");
		if (Delta < 1)						return FOutcome::Waiting();
		if (Cursor[HexDigLen] != '\r')		return FOutcome::Error("Chunk extensions are not supported (ERREXT)");
		if (Delta < 2)						return FOutcome::Waiting();
		if (Cursor[HexDigLen + 1] != '\n')	return FOutcome::Error("Invalid chunk CRLF");

		return FOutcome::Ok(HexDigLen + 2);
	};

	const char* Header = nullptr;
	FOutcome Outcome = FOutcome::None();
	int32 HeaderLength = 0;

	uint32 OverspillSize = uint32(Overspill.GetSize());
	if (OverspillSize != 0)
	{
		// We try all the overspill first - we don't know how much we're expecting
		// and overspill could contain both header and all data (thus further recvs
		// could falsely hang us up).
		Header = (char*)Overspill.GetData();

		Outcome = FindHeader(Header, OverspillSize);
		if (Outcome.IsError())
		{
			return Outcome;
		}

		HeaderLength = Outcome.GetResult();
		Overspill = Overspill.Mid(HeaderLength);
	}

	if (HeaderLength == 0)
	{
		FMutableMemoryView View = Scratch;

		if (OverspillSize != 0)
		{
			if (OverspillSize > uint32(View.GetSize()))
			{
				return FOutcome::Error("Unexpectedly large overspill");
			}
			std::memmove(View.GetData(), Overspill.GetData(), OverspillSize);
			View = View.Mid(OverspillSize);
		}

		if (!View.IsEmpty())
		{
			char* Cursor = (char*)View.GetData();
			Outcome = Peer.Recv(Cursor, uint32(View.GetSize()));
			if (!Outcome.IsOk())
			{
				return Outcome;
			}
			View = Scratch.Left(OverspillSize + Outcome.GetResult());
		}

		char* Cursor = (char*)View.GetData();
		Outcome = FindHeader(Cursor, uint32(View.GetSize()));
		if (!Outcome.IsOk())
		{
			return Outcome;
		}

		check(View.GetData() == Scratch.GetData());
		Header = (char*)Scratch.GetData();
		HeaderLength = Outcome.GetResult();
		Overspill = View.Mid(HeaderLength);
	}

	// Read chunk size
	Header += Remaining;
	int64 ChunkSize = CrudeToInt<16>(FAnsiStringView(Header, HeaderLength));
	if (ChunkSize < 0)			return FOutcome::Error("Unparsable chunk size");
	if (ChunkSize > 16 << 20)	return FOutcome::Error("Unacceptable chunk size");

	if (ChunkSize == 0)
	{
		Remaining = EndOfXfer;
		::memset(Scratch.GetData(), 0, CrLfLength);
		State = EState::Epilogue;
		return Epilogue(Dest, Peer);
	}

	Remaining = ChunkSize;
	State = EState::Chunk;
	return Chunk(Dest, Peer);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::Chunk(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	check(Remaining != 0);

	Dest = Dest.Left(Remaining);
	FOutcome Outcome = Recv(Dest, Peer);
	if (!Outcome.IsOk())
	{
		return Outcome;
	}

	check(Remaining == 0);
	::memset(Scratch.GetData(), 0, CrLfLength);
	State = EState::Epilogue;

	int32 Result = Outcome.GetResult();
	return FOutcome::WaitBuffer(Result);
}

////////////////////////////////////////////////////////////////////////////////
FOutcome FBody::Epilogue(FMutableMemoryView Dest, FTlsPeer& Peer)
{
	auto* Cursor = (uint8*)(Scratch.GetData());

	FMutableMemoryView CrLfBuffer(Cursor, CrLfLength);
	if (Cursor[0] != 0)
	{
		CrLfBuffer = { Cursor + 1, 1 };
	}

	check(Remaining <= 0);

	int64 RemainingCache = Remaining;
	Remaining = CrLfBuffer.GetSize();
	FOutcome Outcome = Recv(CrLfBuffer, Peer);
	if (!Outcome.IsOk())
	{
		Remaining = RemainingCache;
		return Outcome;
	}

	if (Cursor[0] != '\r' || Cursor[1] != '\n')
	{
		return FOutcome::Error("Trailing headers are not supported (ERRTRAIL)");
	}

	if (RemainingCache > EndOfXfer)
	{
		State = EState::Prologue;
		return Prologue(Dest, Peer);
	}

	return FOutcome::Ok();
}

} // namespace DetailOne



////////////////////////////////////////////////////////////////////////////////
class FTransactionOne
	: public DetailOne::FBody
{
public:
	using DetailOne::FBody::FBody;
};



////////////////////////////////////////////////////////////////////////////////
FOutcome HandshakeOne(FTlsPeer&, void*)
{
	return FOutcome::Ok();
}

////////////////////////////////////////////////////////////////////////////////
FOutcome TickOne(FTlsPeer&, void*)
{
	return FOutcome::Ok(1);
}

////////////////////////////////////////////////////////////////////////////////
void GoAwayOne(FTlsPeer&, void*)
{
}



////////////////////////////////////////////////////////////////////////////////
class FTransaction
{
public:
#define TR_METHOD(x, ...) \
	template <typename... Arg> auto x(Arg&&... Args) __VA_ARGS__ { \
		if (auto Self = UPTRINT(this); Self & 1) \
			return ((FTransactionTwo*)(Self ^ 1))->x(Forward<Arg>(Args)...); \
		return ((FTransactionOne*)this)->x(Forward<Arg>(Args)...); \
	}
	TR_METHOD(Begin)
	TR_METHOD(AddHeader)
	TR_METHOD(End)
	TR_METHOD(TrySendRequest)
	TR_METHOD(TryRecvResponse)
	TR_METHOD(IsKeepAlive, const)
	TR_METHOD(GetStatusCode, const)
	TR_METHOD(GetStatusMessage, const)
	TR_METHOD(GetContentLength, const)
	TR_METHOD(IsChunked, const)
	TR_METHOD(ReadHeaders, const)
	TR_METHOD(GetRemaining, const)
	TR_METHOD(TryRecv)
#undef TR_METHOD

private:
	friend class FTransactRef;

	void Destruct()
	{
		if (auto Self = UPTRINT(this); Self & 1)
		{
			void* Addr = (void*)(Self ^ 1);
			((FTransactionTwo*)Addr)->~FTransactionTwo();
			FMemory::Free(Addr);
			return;
		}

		((FTransactionOne*)this)->~FTransactionOne();
		FMemory::Free(this);
	}
};



////////////////////////////////////////////////////////////////////////////////
class FTransactRef
{
public:
						FTransactRef() = default;
						~FTransactRef();
						FTransactRef(UPTRINT Ptr, int32 Ver);
						FTransactRef(FTransactRef&&) = delete;
						FTransactRef(const FTransactRef&) = delete;
	void				operator = (const FTransactRef& Rhs) = delete;
	void				operator = (FTransactRef&& Rhs);
	const FTransaction*	operator -> () const;
	FTransaction*		operator -> ();
	bool				IsValid() const;

private:
	const FTransaction*	Get() const;
	FTransaction*		Get();
	UPTRINT				Self = 0;
};

////////////////////////////////////////////////////////////////////////////////
FTransactRef::FTransactRef(UPTRINT Ptr, int32 Ver)
: Self(Ptr | (Ver == 2))
{
	check((Ptr & 1) == 0);
}

////////////////////////////////////////////////////////////////////////////////
void FTransactRef::operator = (FTransactRef&& Rhs)
{
	Swap(Self, Rhs.Self);
}

////////////////////////////////////////////////////////////////////////////////
const FTransaction*	FTransactRef::operator -> () const
{
	return Get();
}

////////////////////////////////////////////////////////////////////////////////
FTransaction* FTransactRef::operator -> ()		
{
	return Get();
}

////////////////////////////////////////////////////////////////////////////////
bool FTransactRef::IsValid() const		
{
	return Get() != nullptr;
}

////////////////////////////////////////////////////////////////////////////////
const FTransaction* FTransactRef::Get() const			
{
	return (FTransaction*)Self;
}

////////////////////////////////////////////////////////////////////////////////
FTransaction* FTransactRef::Get()				
{
	return (FTransaction*)Self;
}

////////////////////////////////////////////////////////////////////////////////
FTransactRef::~FTransactRef()
{
	if (Self == 0)
	{
		return;
	}

	Get()->Destruct();
}



////////////////////////////////////////////////////////////////////////////////
FTransactRef CreateTransactOne(void*&)
{
	void* Ptr = FMemory::Malloc(sizeof(FTransactionOne), alignof(FTransactionOne));
	new (Ptr) FTransactionOne();
	return FTransactRef(UPTRINT(Ptr), 1);
}

////////////////////////////////////////////////////////////////////////////////
FTransactRef CreateTransactTwo(void* PeerData)
{
#if IAS_HTTP_WITH_TWO
	using namespace DetailTwo;

	auto* Driver = (FDriverNg*)PeerData;

	void* Ptr = FMemory::Malloc(sizeof(FTransactionTwo), alignof(FTransactionTwo));
	new (Ptr) FTransactionTwo(*Driver);

	return FTransactRef(UPTRINT(Ptr), 2);
#else
	return FTransactRef();
#endif
}

} // namespace UE::IoStore::HTTP