/*
 * Copyright 2022 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#ifndef _B_HTTP_PARSER_H_
#define _B_HTTP_PARSER_H_


#include <functional>
#include <optional>

#include <HttpResult.h>

#include "HttpBuffer.h"

class BMallocIO;

namespace BPrivate {

namespace Network {

using HttpTransferFunction = std::function<size_t(const std::byte*, size_t)>;


enum class HttpInputStreamState { StatusLine, Fields, Body, Done };


enum class HttpBodyType { NoContent, Chunked, FixedSize, VariableSize };


struct BodyParseResult {
			size_t		bytesParsed;
			size_t		bytesWritten;
			bool		complete;
};


class HttpBodyParser;


class HttpParser
{
public:
								HttpParser(){};

	// Explicitly mark request as having no content
			void				SetNoContent() noexcept;

	// Parse data from response
			bool				ParseStatus(HttpBuffer& buffer, BHttpStatus& status);
			bool				ParseFields(HttpBuffer& buffer, BHttpFields& fields);
			size_t				ParseBody(HttpBuffer& buffer, HttpTransferFunction writeToBody,
									bool readEnd);
			HttpInputStreamState State() const noexcept { return fStreamState; }

	// Details on the body status
			bool				HasContent() const noexcept;
			std::optional<off_t> BodyBytesTotal() const noexcept;
			off_t				BodyBytesTransferred() const noexcept;
			bool				Complete() const noexcept;

private:
			off_t				fHeaderBytes = 0;
			BHttpStatus			fStatus;
			HttpInputStreamState fStreamState = HttpInputStreamState::StatusLine;

	// Body
			HttpBodyType		fBodyType = HttpBodyType::VariableSize;
			std::unique_ptr<HttpBodyParser> fBodyParser = nullptr;
};


class HttpBodyParser
{
public:
	virtual						BodyParseResult ParseBody(HttpBuffer& buffer,
									HttpTransferFunction writeToBody, bool readEnd) = 0;

	virtual	std::optional<off_t> TotalBodySize() const noexcept;

			off_t				TransferredBodySize() const noexcept;

protected:
			off_t				fTransferredBodySize = 0;
};


class HttpRawBodyParser : public HttpBodyParser
{
public:
								HttpRawBodyParser();
								HttpRawBodyParser(off_t bodyBytesTotal);
	virtual	BodyParseResult		ParseBody(HttpBuffer& buffer, HttpTransferFunction writeToBody,
									bool readEnd) override;
	virtual	std::optional<off_t> TotalBodySize() const noexcept override;

private:
			std::optional<off_t> fBodyBytesTotal;
};


class HttpChunkedBodyParser : public HttpBodyParser
{
public:
	virtual BodyParseResult ParseBody(
		HttpBuffer& buffer, HttpTransferFunction writeToBody, bool readEnd) override;

private:
	enum { ChunkSize, ChunkEnd, Chunk, Trailers, Complete } fChunkParserState = ChunkSize;
	off_t fRemainingChunkSize = 0;
	bool fLastChunk = false;
};


class HttpBodyDecompression : public HttpBodyParser
{
public:
								HttpBodyDecompression(std::unique_ptr<HttpBodyParser> bodyParser);
	virtual	BodyParseResult		ParseBody(HttpBuffer& buffer, HttpTransferFunction writeToBody,
									bool readEnd) override;

	virtual	std::optional<off_t> TotalBodySize() const noexcept;

private:
			std::unique_ptr<HttpBodyParser> fBodyParser;
			std::unique_ptr<BMallocIO> fDecompressorStorage;
			std::unique_ptr<BDataIO> fDecompressingStream;
};


} // namespace Network

} // namespace BPrivate

#endif // _B_HTTP_PARSER_H_