/*
 * Copyright 2015, Rene Gollent, rene@gollent.com.
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#include "IntegerValueFormatter.h"

#include <new>

#include <ctype.h>

#include "IntegerFormatter.h"
#include "IntegerValue.h"


// #pragma mark - IntegerValueFormatter


IntegerValueFormatter::IntegerValueFormatter(Config* config)
	:
	ValueFormatter(),
	fConfig(config)
{
	if (fConfig != NULL)
		fConfig->AcquireReference();
}


IntegerValueFormatter::~IntegerValueFormatter()
{
	if (fConfig != NULL)
		fConfig->ReleaseReference();
}


Settings*
IntegerValueFormatter::GetSettings() const
{
	return fConfig != NULL ? fConfig->GetSettings() : NULL;
}


status_t
IntegerValueFormatter::FormatValue(Value* _value, BString& _output)
{
	IntegerValue* value = dynamic_cast<IntegerValue*>(_value);
	if (value == NULL)
		return B_BAD_VALUE;

	// format the value
	integer_format format = fConfig != NULL
		? fConfig->IntegerFormat() : INTEGER_FORMAT_DEFAULT;
	char buffer[32];
	if (!IntegerFormatter::FormatValue(value->GetValue(), format,  buffer,
			sizeof(buffer))) {
		return B_BAD_VALUE;
	}

	_output.SetTo(buffer);

	return B_OK;
}


bool
IntegerValueFormatter::SupportsValidation() const
{
	return true;
}


bool
IntegerValueFormatter::ValidateFormattedValue(const BString& input,
	type_code type) const
{
	::Value* value = NULL;
	return _PerformValidation(input, type, value, false) == B_OK;
}


status_t
IntegerValueFormatter::GetValueFromFormattedInput(const BString& input,
	type_code type, Value*& _output) const
{
	return _PerformValidation(input, type, _output, true);
}


status_t
IntegerValueFormatter::_PerformValidation(const BString& input, type_code type,
	::Value*& _output, bool wantsValue) const
{
	integer_format format;
	if (fConfig != NULL)
		format = fConfig->IntegerFormat();
	else {
		bool isSigned;
		if (BVariant::TypeIsInteger(type, &isSigned)) {
			format = isSigned ? INTEGER_FORMAT_SIGNED
				: INTEGER_FORMAT_UNSIGNED;
		} else
			return B_BAD_VALUE;
	}

	status_t error = B_OK;
	if (format == INTEGER_FORMAT_UNSIGNED
		|| format >= INTEGER_FORMAT_HEX_DEFAULT) {
		error = _ValidateUnsigned(input, type, _output, format, wantsValue);
	} else
		error = _ValidateSigned(input, type, _output, wantsValue);

	return error;
}


status_t
IntegerValueFormatter::_ValidateSigned(const BString& input, type_code type,
	::Value*& _output, bool wantsValue) const
{
	const char* text = input.String();
	char *parseEnd = NULL;
	intmax_t parsedValue = strtoimax(text, &parseEnd, 10);
	if (parseEnd - text < input.Length() && !isspace(*parseEnd))
		return B_NO_MEMORY;

	BVariant newValue;
	switch (type) {
		case B_INT8_TYPE:
		{
			if (parsedValue < INT8_MIN || parsedValue > INT8_MAX)
				return B_BAD_VALUE;

			newValue.SetTo((int8)parsedValue);
			break;
		}
		case B_INT16_TYPE:
		{
			if (parsedValue < INT16_MIN || parsedValue > INT16_MAX)
				return B_BAD_VALUE;

			newValue.SetTo((int16)parsedValue);
			break;
		}
		case B_INT32_TYPE:
		{
			if (parsedValue < INT32_MIN || parsedValue > INT32_MAX)
				return B_BAD_VALUE;

			newValue.SetTo((int32)parsedValue);
			break;
		}
		case B_INT64_TYPE:
		{
			newValue.SetTo((int64)parsedValue);
			break;
		}
		default:
			return B_BAD_VALUE;
	}

	if (wantsValue) {
		_output = new(std::nothrow) IntegerValue(newValue);
		if (_output == NULL)
			return B_NO_MEMORY;
	}

	return B_OK;
}


status_t
IntegerValueFormatter::_ValidateUnsigned(const BString& input, type_code type,
	::Value*& _output, integer_format format, bool wantsValue) const
{
	const char* text = input.String();
	int32 base = format == INTEGER_FORMAT_UNSIGNED ? 10 : 16;

	char *parseEnd = NULL;
	uintmax_t parsedValue = strtoumax(text, &parseEnd, base);
	if (parseEnd - text < input.Length() && !isspace(*parseEnd))
		return B_BAD_VALUE;

	BVariant newValue;
	switch (type) {
		case B_UINT8_TYPE:
		{
			if (parsedValue > UINT8_MAX)
				return B_BAD_VALUE;

			newValue.SetTo((uint8)parsedValue);
			break;
		}
		case B_UINT16_TYPE:
		{
			if (parsedValue > UINT16_MAX)
				return B_BAD_VALUE;

			newValue.SetTo((uint16)parsedValue);
			break;
		}
		case B_UINT32_TYPE:
		{
			if (parsedValue > UINT32_MAX)
				return B_BAD_VALUE;

			newValue.SetTo((uint32)parsedValue);
			break;
		}
		case B_UINT64_TYPE:
		{
			newValue.SetTo((uint64)parsedValue);
			break;
		}
		default:
			return B_BAD_VALUE;
	}

	if (wantsValue) {
		_output = new(std::nothrow) IntegerValue(newValue);
		if (_output == NULL)
			return B_NO_MEMORY;
	}

	return B_OK;
}



// #pragma mark - Config


IntegerValueFormatter::Config::~Config()
{
}