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

#ifndef _HTTP_RESULT_PRIVATE_H_
#define _HTTP_RESULT_PRIVATE_H_


#include <memory>
#include <optional>
#include <string>

#include <DataIO.h>
#include <ExclusiveBorrow.h>
#include <OS.h>
#include <String.h>


namespace BPrivate {

namespace Network {

struct HttpResultPrivate {
	// Read-only properties (multi-thread safe)
	const	int32				id;

	// Locking and atomic variables
	enum { kNoData = 0, kStatusReady, kHeadersReady, kBodyReady, kError };
			int32				requestStatus = kNoData;
			int32				canCancel = 0;
			sem_id				data_wait;

	// Data
			std::optional<BHttpStatus> status;
			std::optional<BHttpFields> fields;
			std::optional<BHttpBody> body;
			std::optional<std::exception_ptr> error;

	// Interim body storage (used while the request is running)
			BString				bodyString;
			BBorrow<BDataIO>	bodyTarget;

	// Utility functions
								HttpResultPrivate(int32 identifier);
			int32				GetStatusAtomic();
			bool				CanCancel();
			void				SetCancel();
			void				SetError(std::exception_ptr e);
			void				SetStatus(BHttpStatus&& s);
			void				SetFields(BHttpFields&& f);
			void				SetBody();
			size_t				WriteToBody(const void* buffer, size_t size);
};


inline HttpResultPrivate::HttpResultPrivate(int32 identifier)
	:
	id(identifier)
{
	std::string name = "httpresult:" + std::to_string(identifier);
	data_wait = create_sem(1, name.c_str());
	if (data_wait < B_OK)
		throw BRuntimeError(__PRETTY_FUNCTION__, "Cannot create internal sem for httpresult");
}


inline int32
HttpResultPrivate::GetStatusAtomic()
{
	return atomic_get(&requestStatus);
}


inline bool
HttpResultPrivate::CanCancel()
{
	return atomic_get(&canCancel) == 1;
}


inline void
HttpResultPrivate::SetCancel()
{
	atomic_set(&canCancel, 1);
}


inline void
HttpResultPrivate::SetError(std::exception_ptr e)
{
	// Release any held body target borrow
	bodyTarget.Return();

	error = e;
	atomic_set(&requestStatus, kError);
	release_sem(data_wait);
}


inline void
HttpResultPrivate::SetStatus(BHttpStatus&& s)
{
	status = std::move(s);
	atomic_set(&requestStatus, kStatusReady);
	release_sem(data_wait);
}


inline void
HttpResultPrivate::SetFields(BHttpFields&& f)
{
	fields = std::move(f);
	atomic_set(&requestStatus, kHeadersReady);
	release_sem(data_wait);
}


inline void
HttpResultPrivate::SetBody()
{
	if (bodyTarget.HasValue()) {
		body = BHttpBody{};
		bodyTarget.Return();
	} else
		body = BHttpBody{std::move(bodyString)};

	atomic_set(&requestStatus, kBodyReady);
	release_sem(data_wait);
}


inline size_t
HttpResultPrivate::WriteToBody(const void* buffer, size_t size)
{
	// TODO: when the support for a shared BMemoryRingIO is here, choose
	// between one or the other depending on which one is available.
	if (bodyTarget.HasValue()) {
		auto result = bodyTarget->Write(buffer, size);
		if (result < 0)
			throw BSystemError("BDataIO::Write()", result);
		return result;
	} else {
		bodyString.Append(reinterpret_cast<const char*>(buffer), size);
		return size;
	}
}


} // namespace Network

} // namespace BPrivate

#endif // _HTTP_RESULT_PRIVATE_H_