/*
 * Copyright 2022 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Niels Sascha Reedijk, niels.reedijk@gmail.com
 */

#include "HttpSerializer.h"

#include <DataIO.h>
#include <HttpRequest.h>
#include <NetServicesDefs.h>

#include "HttpBuffer.h"

using namespace std::literals;
using namespace BPrivate::Network;


/*!
	\brief Set the \a request to serialize, and load the initial data into the \a buffer.
*/
void
HttpSerializer::SetTo(HttpBuffer& buffer, const BHttpRequest& request)
{
	buffer.Clear();
	request.SerializeHeaderTo(buffer);
	fState = HttpSerializerState::Header;

	if (auto requestBody = request.RequestBody()) {
		fBody = requestBody->input.get();
		if (requestBody->size) {
			fBodySize = *(requestBody->size);
		}
	}
}


/*!
	\brief Transfer the HTTP request to \a target while using \a buffer for intermediate storage.

	\returns The number of body bytes written during the call.
*/
size_t
HttpSerializer::Serialize(HttpBuffer& buffer, BDataIO* target)
{
	bool finishing = false;
	size_t bodyBytesWritten = 0;
	while (!finishing) {
		switch (fState) {
			case HttpSerializerState::Uninitialized:
				throw BRuntimeError(__PRETTY_FUNCTION__, "Invalid state: Uninitialized");

			case HttpSerializerState::Header:
				_WriteToTarget(buffer, target);
				if (buffer.RemainingBytes() > 0) {
					// There are more bytes to be processed; wait for the next iteration
					return 0;
				}

				if (fBody == nullptr) {
					fState = HttpSerializerState::Done;
					return 0;
				} else if (_IsChunked())
					// fState = HttpSerializerState::ChunkHeader;
					throw BRuntimeError(
						__PRETTY_FUNCTION__, "Chunked serialization not implemented");
				else
					fState = HttpSerializerState::Body;
				break;

			case HttpSerializerState::Body:
			{
				auto bytesWritten = _WriteToTarget(buffer, target);
				bodyBytesWritten += bytesWritten;
				fTransferredBodySize += bytesWritten;
				if (buffer.RemainingBytes() > 0) {
					// did not manage to write all the bytes in the buffer; continue in the next
					// round
					finishing = true;
					break;
				}

				if (fBodySize && fBodySize.value() == fTransferredBodySize) {
					fState = HttpSerializerState::Done;
					finishing = true;
				}
				break;
			}

			case HttpSerializerState::Done:
			default:
				finishing = true;
				continue;
		}

		// Load more data into the buffer
		std::optional<size_t> maxReadSize = std::nullopt;
		if (fBodySize)
			maxReadSize = fBodySize.value() - fTransferredBodySize;
		buffer.ReadFrom(fBody, maxReadSize);
	}

	return bodyBytesWritten;
}


bool
HttpSerializer::_IsChunked() const noexcept
{
	return fBodySize == std::nullopt;
}


size_t
HttpSerializer::_WriteToTarget(HttpBuffer& buffer, BDataIO* target) const
{
	size_t bytesWritten = 0;
	buffer.WriteTo([target, &bytesWritten](const std::byte* buffer, size_t size) {
		ssize_t result = B_INTERRUPTED;
		while (result == B_INTERRUPTED) {
			result = target->Write(buffer, size);
		}

		if (result <= 0 && result != B_WOULD_BLOCK) {
			throw BNetworkRequestError(
				__PRETTY_FUNCTION__, BNetworkRequestError::NetworkError, result);
		} else if (result > 0) {
			bytesWritten += result;
			return size_t(result);
		} else {
			return size_t(0);
		}
	});

	return bytesWritten;
}