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

#include <NetServicesDefs.h>


namespace BPrivate {

namespace Network {


// #pragma mark -- BUnsupportedProtocol


BUnsupportedProtocol::BUnsupportedProtocol(
	const char* origin, BUrl url, BStringList supportedProtocols)
	:
	BError(origin),
	fUrl(std::move(url)),
	fSupportedProtocols(std::move(supportedProtocols))
{
}


BUnsupportedProtocol::BUnsupportedProtocol(BString origin, BUrl url, BStringList supportedProtocols)
	:
	BError(std::move(origin)),
	fUrl(std::move(url)),
	fSupportedProtocols(std::move(supportedProtocols))
{
}


const char*
BUnsupportedProtocol::Message() const noexcept
{
	return "Unsupported Protocol";
}


const BUrl&
BUnsupportedProtocol::Url() const
{
	return fUrl;
}


const BStringList&
BUnsupportedProtocol::SupportedProtocols() const
{
	return fSupportedProtocols;
}


// #pragma mark -- BInvalidUrl


BInvalidUrl::BInvalidUrl(const char* origin, BUrl url)
	:
	BError(origin),
	fUrl(std::move(url))
{
}


BInvalidUrl::BInvalidUrl(BString origin, BUrl url)
	:
	BError(std::move(origin)),
	fUrl(std::move(url))
{
}


const char*
BInvalidUrl::Message() const noexcept
{
	return "Invalid URL";
}


const BUrl&
BInvalidUrl::Url() const
{
	return fUrl;
}


// #pragma mark -- BNetworkRequestError


BNetworkRequestError::BNetworkRequestError(
	const char* origin, ErrorType type, status_t errorCode, const BString& customMessage)
	:
	BError(origin),
	fErrorType(type),
	fErrorCode(errorCode),
	fCustomMessage(customMessage)
{
}


BNetworkRequestError::BNetworkRequestError(
	const char* origin, ErrorType type, const BString& customMessage)
	:
	BError(origin),
	fErrorType(type),
	fCustomMessage(customMessage)
{
}


const char*
BNetworkRequestError::Message() const noexcept
{
	switch (fErrorType) {
		case HostnameError:
			return "Cannot resolving hostname";
		case NetworkError:
			return "Network error during operation";
		case ProtocolError:
			return "Protocol error";
		case SystemError:
			return "System error";
		case Canceled:
			return "Network request was canceled";
	}
	// Unreachable
	return "Network request error";
}


BString
BNetworkRequestError::DebugMessage() const
{
	BString debugMessage;
	debugMessage << "[" << Origin() << "] " << Message();
	if (fErrorCode != B_OK) {
		debugMessage << "\n\tUnderlying System Error: " << fErrorCode << " ("
					 << strerror(fErrorCode) << ")";
	}
	if (fCustomMessage.Length() > 0) {
		debugMessage << "\n\tAdditional Info: " << fCustomMessage;
	}
	return debugMessage;
}


BNetworkRequestError::ErrorType
BNetworkRequestError::Type() const noexcept
{
	return fErrorType;
}


status_t
BNetworkRequestError::ErrorCode() const noexcept
{
	return fErrorCode;
}


const char*
BNetworkRequestError::CustomMessage() const noexcept
{
	return fCustomMessage.String();
}


// #pragma mark -- Public functions


static const char* kBase64Symbols
	= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";


BString
encode_to_base64(const BString& string)
{
	BString result;
	BString tmpString = string;

	while (tmpString.Length()) {
		char in[3] = {0, 0, 0};
		char out[4] = {0, 0, 0, 0};
		int8 remaining = tmpString.Length();

		tmpString.MoveInto(in, 0, 3);

		out[0] = (in[0] & 0xFC) >> 2;
		out[1] = ((in[0] & 0x03) << 4) | ((in[1] & 0xF0) >> 4);
		out[2] = ((in[1] & 0x0F) << 2) | ((in[2] & 0xC0) >> 6);
		out[3] = in[2] & 0x3F;

		for (int i = 0; i < 4; i++)
			out[i] = kBase64Symbols[(int) out[i]];

		//  Add padding if the input length is not a multiple
		// of 3
		switch (remaining) {
			case 1:
				out[2] = '=';
				// Fall through
			case 2:
				out[3] = '=';
				break;
		}

		result.Append(out, 4);
	}

	return result;
}


// #pragma mark -- message constants
namespace UrlEventData {
const char* Id = "url:identifier";
const char* HostName = "url:hostname";
const char* NumBytes = "url:numbytes";
const char* TotalBytes = "url:totalbytes";
const char* Success = "url:success";
const char* DebugType = "url:debugtype";
const char* DebugMessage = "url:debugmessage";
} // namespace UrlEventData


// #pragma mark -- Private functions and data


static int32 gRequestIdentifier = 1;


int32
get_netservices_request_identifier()
{
	return atomic_add(&gRequestIdentifier, 1);
}


} // namespace Network

} // namespace BPrivate