/*
 * Copyright 2010-2013 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Christophe Huriaux, c.huriaux@gmail.com
 */


#include <HttpForm.h>

#include <cstdlib>
#include <cstring>
#include <ctime>

#include <File.h>
#include <NodeInfo.h>
#include <TypeConstants.h>
#include <Url.h>


static int32 kBoundaryRandomSize = 16;

using namespace std;
using namespace BPrivate::Network;


// #pragma mark - BHttpFormData


BHttpFormData::BHttpFormData()
	:
	fDataType(B_HTTPFORM_STRING),
	fCopiedBuffer(false),
	fFileMark(false),
	fBufferValue(NULL),
	fBufferSize(0)
{
}


BHttpFormData::BHttpFormData(const BString& name, const BString& value)
	:
	fDataType(B_HTTPFORM_STRING),
	fCopiedBuffer(false),
	fFileMark(false),
	fName(name),
	fStringValue(value),
	fBufferValue(NULL),
	fBufferSize(0)
{
}


BHttpFormData::BHttpFormData(const BString& name, const BPath& file)
	:
	fDataType(B_HTTPFORM_FILE),
	fCopiedBuffer(false),
	fFileMark(false),
	fName(name),
	fPathValue(file),
	fBufferValue(NULL),
	fBufferSize(0)
{
}


BHttpFormData::BHttpFormData(const BString& name, const void* buffer,
	ssize_t size)
	:
	fDataType(B_HTTPFORM_BUFFER),
	fCopiedBuffer(false),
	fFileMark(false),
	fName(name),
	fBufferValue(buffer),
	fBufferSize(size)
{
}


BHttpFormData::BHttpFormData(const BHttpFormData& other)
	:
	fCopiedBuffer(false),
	fFileMark(false),
	fBufferValue(NULL),
	fBufferSize(0)
{
	*this = other;
}


BHttpFormData::~BHttpFormData()
{
	if (fCopiedBuffer)
		delete[] reinterpret_cast<const char*>(fBufferValue);
}


// #pragma mark - Retrieve data informations


bool
BHttpFormData::InitCheck() const
{
	if (fDataType == B_HTTPFORM_BUFFER)
		return fBufferValue != NULL;

	return true;
}


const BString&
BHttpFormData::Name() const
{
	return fName;
}


const BString&
BHttpFormData::String() const
{
	return fStringValue;
}


const BPath&
BHttpFormData::File() const
{
	return fPathValue;
}


const void*
BHttpFormData::Buffer() const
{
	return fBufferValue;
}


ssize_t
BHttpFormData::BufferSize() const
{
	return fBufferSize;
}


bool
BHttpFormData::IsFile() const
{
	return fFileMark;
}


const BString&
BHttpFormData::Filename() const
{
	return fFilename;
}


const BString&
BHttpFormData::MimeType() const
{
	return fMimeType;
}


form_content_type
BHttpFormData::Type() const
{
	return fDataType;
}


// #pragma mark - Change behavior


status_t
BHttpFormData::MarkAsFile(const BString& filename, const BString& mimeType)
{
	if (fDataType == B_HTTPFORM_UNKNOWN || fDataType == B_HTTPFORM_FILE)
		return B_ERROR;

	fFilename = filename;
	fMimeType = mimeType;
	fFileMark = true;

	return B_OK;
}


void
BHttpFormData::UnmarkAsFile()
{
	fFilename.Truncate(0, true);
	fMimeType.Truncate(0, true);
	fFileMark = false;
}


status_t
BHttpFormData::CopyBuffer()
{
	if (fDataType != B_HTTPFORM_BUFFER)
		return B_ERROR;

	char* copiedBuffer = new(std::nothrow) char[fBufferSize];
	if (copiedBuffer == NULL)
		return B_NO_MEMORY;

	memcpy(copiedBuffer, fBufferValue, fBufferSize);
	fBufferValue = copiedBuffer;
	fCopiedBuffer = true;

	return B_OK;
}


BHttpFormData&
BHttpFormData::operator=(const BHttpFormData& other)
{
	fDataType = other.fDataType;
	fCopiedBuffer = false;
	fFileMark = other.fFileMark;
	fName = other.fName;
	fStringValue = other.fStringValue;
	fPathValue = other.fPathValue;
	fBufferValue = other.fBufferValue;
	fBufferSize = other.fBufferSize;
	fFilename = other.fFilename;
	fMimeType = other.fMimeType;

	if (other.fCopiedBuffer)
		CopyBuffer();

	return *this;
}


// #pragma mark - BHttpForm


BHttpForm::BHttpForm()
	:
	fType(B_HTTP_FORM_URL_ENCODED)
{
}


BHttpForm::BHttpForm(const BHttpForm& other)
	:
	fFields(other.fFields),
	fType(other.fType),
	fMultipartBoundary(other.fMultipartBoundary)
{
}


BHttpForm::BHttpForm(const BString& formString)
	:
	fType(B_HTTP_FORM_URL_ENCODED)
{
	ParseString(formString);
}


BHttpForm::~BHttpForm()
{
	Clear();
}


// #pragma mark - Form string parsing


void
BHttpForm::ParseString(const BString& formString)
{
	int32 index = 0;

	while (index < formString.Length())
		_ExtractNameValuePair(formString, &index);
}


BString
BHttpForm::RawData() const
{
	BString result;

	if (fType == B_HTTP_FORM_URL_ENCODED) {
		for (FormStorage::const_iterator it = fFields.begin();
			it != fFields.end(); it++) {
			const BHttpFormData* currentField = &it->second;

			switch (currentField->Type()) {
				case B_HTTPFORM_UNKNOWN:
					break;

				case B_HTTPFORM_STRING:
					result << '&' << BUrl::UrlEncode(currentField->Name())
						<< '=' << BUrl::UrlEncode(currentField->String());
					break;

				case B_HTTPFORM_FILE:
					break;

				case B_HTTPFORM_BUFFER:
					// Send the buffer only if its not marked as a file
					if (!currentField->IsFile()) {
						result << '&' << BUrl::UrlEncode(currentField->Name())
							<< '=';
						result.Append(
							reinterpret_cast<const char*>(currentField->Buffer()),
							currentField->BufferSize());
					}
					break;
			}
		}

		result.Remove(0, 1);
	} else if (fType == B_HTTP_FORM_MULTIPART) {
		//  Very slow and memory consuming method since we're caching the
		// file content, this should be preferably handled by the protocol
		for (FormStorage::const_iterator it = fFields.begin();
			it != fFields.end(); it++) {
			const BHttpFormData* currentField = &it->second;
			result << _GetMultipartHeader(currentField);

			switch (currentField->Type()) {
				case B_HTTPFORM_UNKNOWN:
					break;

				case B_HTTPFORM_STRING:
					result << currentField->String();
					break;

				case B_HTTPFORM_FILE:
				{
					BFile upFile(currentField->File().Path(), B_READ_ONLY);
					char readBuffer[1024];
					ssize_t readSize;

					readSize = upFile.Read(readBuffer, 1024);

					while (readSize > 0) {
						result.Append(readBuffer, readSize);
						readSize = upFile.Read(readBuffer, 1024);
					}
					break;
				}

				case B_HTTPFORM_BUFFER:
					result.Append(
						reinterpret_cast<const char*>(currentField->Buffer()),
						currentField->BufferSize());
					break;
			}

			result << "\r\n";
		}

		result << "--" << fMultipartBoundary << "--\r\n";
	}

	return result;
}


// #pragma mark - Form add


status_t
BHttpForm::AddString(const BString& fieldName, const BString& value)
{
	BHttpFormData formData(fieldName, value);
	if (!formData.InitCheck())
		return B_ERROR;

	fFields.insert(pair<BString, BHttpFormData>(fieldName, formData));
	return B_OK;
}


status_t
BHttpForm::AddInt(const BString& fieldName, int32 value)
{
	BString strValue;
	strValue << value;

	return AddString(fieldName, strValue);
}


status_t
BHttpForm::AddFile(const BString& fieldName, const BPath& file)
{
	BHttpFormData formData(fieldName, file);
	if (!formData.InitCheck())
		return B_ERROR;

	fFields.insert(pair<BString, BHttpFormData>(fieldName, formData));

	if (fType != B_HTTP_FORM_MULTIPART)
		SetFormType(B_HTTP_FORM_MULTIPART);
	return B_OK;
}


status_t
BHttpForm::AddBuffer(const BString& fieldName, const void* buffer,
	ssize_t size)
{
	BHttpFormData formData(fieldName, buffer, size);
	if (!formData.InitCheck())
		return B_ERROR;

	fFields.insert(pair<BString, BHttpFormData>(fieldName, formData));
	return B_OK;
}


status_t
BHttpForm::AddBufferCopy(const BString& fieldName, const void* buffer,
	ssize_t size)
{
	BHttpFormData formData(fieldName, buffer, size);
	if (!formData.InitCheck())
		return B_ERROR;

	// Copy the buffer of the inserted form data copy to
	// avoid an unneeded copy of the buffer upon insertion
	pair<FormStorage::iterator, bool> insertResult
		= fFields.insert(pair<BString, BHttpFormData>(fieldName, formData));

	return insertResult.first->second.CopyBuffer();
}


// #pragma mark - Mark a field as a filename


void
BHttpForm::MarkAsFile(const BString& fieldName, const BString& filename,
	const BString& mimeType)
{
	FormStorage::iterator it = fFields.find(fieldName);

	if (it == fFields.end())
		return;

	it->second.MarkAsFile(filename, mimeType);
	if (fType != B_HTTP_FORM_MULTIPART)
		SetFormType(B_HTTP_FORM_MULTIPART);
}


void
BHttpForm::MarkAsFile(const BString& fieldName, const BString& filename)
{
	MarkAsFile(fieldName, filename, "");
}


void
BHttpForm::UnmarkAsFile(const BString& fieldName)
{
	FormStorage::iterator it = fFields.find(fieldName);

	if (it == fFields.end())
		return;

	it->second.UnmarkAsFile();
}


// #pragma mark - Change form type


void
BHttpForm::SetFormType(form_type type)
{
	fType = type;

	if (fType == B_HTTP_FORM_MULTIPART)
		_GenerateMultipartBoundary();
}


// #pragma mark - Form test


bool
BHttpForm::HasField(const BString& name) const
{
	return (fFields.find(name) != fFields.end());
}


// #pragma mark - Form retrieve


BString
BHttpForm::GetMultipartHeader(const BString& fieldName) const
{
	FormStorage::const_iterator it = fFields.find(fieldName);

	if (it == fFields.end())
		return BString("");

	return _GetMultipartHeader(&it->second);
}


form_type
BHttpForm::GetFormType() const
{
	return fType;
}


const BString&
BHttpForm::GetMultipartBoundary() const
{
	return fMultipartBoundary;
}


BString
BHttpForm::GetMultipartFooter() const
{
	BString result = "--";
	result << fMultipartBoundary << "--\r\n";
	return result;
}


ssize_t
BHttpForm::ContentLength() const
{
	if (fType == B_HTTP_FORM_URL_ENCODED)
		return RawData().Length();

	ssize_t contentLength = 0;

	for (FormStorage::const_iterator it = fFields.begin();
		it != fFields.end(); it++) {
		const BHttpFormData* c = &it->second;
		contentLength += _GetMultipartHeader(c).Length();

		switch (c->Type()) {
			case B_HTTPFORM_UNKNOWN:
				break;

			case B_HTTPFORM_STRING:
				contentLength += c->String().Length();
				break;

			case B_HTTPFORM_FILE:
			{
				BFile upFile(c->File().Path(), B_READ_ONLY);
				upFile.Seek(0, SEEK_END);
				contentLength += upFile.Position();
				break;
			}

			case B_HTTPFORM_BUFFER:
				contentLength += c->BufferSize();
				break;
		}

		contentLength += 2;
	}

	contentLength += fMultipartBoundary.Length() + 6;

	return contentLength;
}


// #pragma mark Form iterator


BHttpForm::Iterator
BHttpForm::GetIterator()
{
	return BHttpForm::Iterator(this);
}


// #pragma mark - Form clear


void
BHttpForm::Clear()
{
	fFields.clear();
}


// #pragma mark - Overloaded operators


BHttpFormData&
BHttpForm::operator[](const BString& name)
{
	if (!HasField(name))
		AddString(name, "");

	return fFields[name];
}


void
BHttpForm::_ExtractNameValuePair(const BString& formString, int32* index)
{
	// Look for a name=value pair
	int16 firstAmpersand = formString.FindFirst("&", *index);
	int16 firstEqual = formString.FindFirst("=", *index);

	BString name;
	BString value;

	if (firstAmpersand == -1) {
		if (firstEqual != -1) {
			formString.CopyInto(name, *index, firstEqual - *index);
			formString.CopyInto(value, firstEqual + 1,
				formString.Length() - firstEqual - 1);
		} else
			formString.CopyInto(value, *index,
				formString.Length() - *index);

		*index = formString.Length() + 1;
	} else {
		if (firstEqual != -1 && firstEqual < firstAmpersand) {
			formString.CopyInto(name, *index, firstEqual - *index);
			formString.CopyInto(value, firstEqual + 1,
				firstAmpersand - firstEqual - 1);
		} else
			formString.CopyInto(value, *index, firstAmpersand - *index);

		*index = firstAmpersand + 1;
	}

	AddString(name, value);
}


void
BHttpForm::_GenerateMultipartBoundary()
{
	fMultipartBoundary = "----------------------------";

	srand(time(NULL));
		// TODO: Maybe a more robust way to seed the random number
		// generator is needed?

	for (int32 i = 0; i < kBoundaryRandomSize; i++)
		fMultipartBoundary << (char)(rand() % 10 + '0');
}


// #pragma mark - Field information access by std iterator


BString
BHttpForm::_GetMultipartHeader(const BHttpFormData* element) const
{
	BString result;
	result << "--" << fMultipartBoundary << "\r\n";
	result << "Content-Disposition: form-data; name=\"" << element->Name()
		<< '"';

	switch (element->Type()) {
		case B_HTTPFORM_UNKNOWN:
			break;

		case B_HTTPFORM_FILE:
		{
			result << "; filename=\"" << element->File().Leaf() << '"';

			BNode fileNode(element->File().Path());
			BNodeInfo fileInfo(&fileNode);

			result << "\r\nContent-Type: ";
			char tempMime[128];
			if (fileInfo.GetType(tempMime) == B_OK)
				result << tempMime;
			else
				result << "application/octet-stream";

			break;
		}

		case B_HTTPFORM_STRING:
		case B_HTTPFORM_BUFFER:
			if (element->IsFile()) {
				result << "; filename=\"" << element->Filename() << '"';

				if (element->MimeType().Length() > 0)
					result << "\r\nContent-Type: " << element->MimeType();
				else
					result << "\r\nContent-Type: text/plain";
			}
			break;
	}

	result << "\r\n\r\n";

	return result;
}


// #pragma mark - Iterator


BHttpForm::Iterator::Iterator(BHttpForm* form)
	:
	fElement(NULL)
{
	fForm = form;
	fStdIterator = form->fFields.begin();
	_FindNext();
}


BHttpForm::Iterator::Iterator(const Iterator& other)
{
	*this = other;
}


bool
BHttpForm::Iterator::HasNext() const
{
	return fStdIterator != fForm->fFields.end();
}


BHttpFormData*
BHttpForm::Iterator::Next()
{
	BHttpFormData* element = fElement;
	_FindNext();
	return element;
}


void
BHttpForm::Iterator::Remove()
{
	fForm->fFields.erase(fStdIterator);
	fElement = NULL;
}


BString
BHttpForm::Iterator::MultipartHeader()
{
	return fForm->_GetMultipartHeader(fPrevElement);
}


BHttpForm::Iterator&
BHttpForm::Iterator::operator=(const Iterator& other)
{
	fForm = other.fForm;
	fStdIterator = other.fStdIterator;
	fElement = other.fElement;
	fPrevElement = other.fPrevElement;

	return *this;
}


void
BHttpForm::Iterator::_FindNext()
{
	fPrevElement = fElement;

	if (fStdIterator != fForm->fFields.end()) {
		fElement = &fStdIterator->second;
		fStdIterator++;
	} else
		fElement = NULL;
}