/*
 * Copyright 1998-1999 Be, Inc. All Rights Reserved.
 * Copyright 2003-2019 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "Settings.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Catalog.h>
#include <Debug.h>
#include <Locale.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Settings"


Settings* settings = NULL;


StringValueSetting::StringValueSetting(const char* name,
	const char* defaultValue, const char* valueExpectedErrorString,
	const char* wrongValueErrorString)
	:
	SettingsArgvDispatcher(name),
	fDefaultValue(defaultValue),
	fValueExpectedErrorString(valueExpectedErrorString),
	fWrongValueErrorString(wrongValueErrorString),
	fValue(strdup(defaultValue))
{
}


StringValueSetting::~StringValueSetting()
{
	free(fValue);
}


void
StringValueSetting::ValueChanged(const char* newValue)
{
	if (newValue == fValue)
		// guard against self assingment
		return;

	free(fValue);
	fValue = strdup(newValue);
}


const char*
StringValueSetting::Value() const
{
	return fValue;
}


void
StringValueSetting::SaveSettingValue(Settings* settings)
{
	printf("-----StringValueSetting::SaveSettingValue %s %s\n", Name(), fValue);
	settings->Write("\"%s\"", fValue);
}


bool
StringValueSetting::NeedsSaving() const
{
	// needs saving if different than default
	return strcmp(fValue, fDefaultValue) != 0;
}


const char*
StringValueSetting::Handle(const char* const *argv)
{
	if (*++argv == NULL)
		return fValueExpectedErrorString;

	ValueChanged(*argv);
	return 0;
}


//	#pragma mark -


EnumeratedStringValueSetting::EnumeratedStringValueSetting(const char* name,
	const char* defaultValue, StringEnumerator enumerator,
	const char* valueExpectedErrorString,
	const char* wrongValueErrorString)
	:
	StringValueSetting(name, defaultValue, valueExpectedErrorString,
		wrongValueErrorString),
	fEnumerator(enumerator)
{
}


void
EnumeratedStringValueSetting::ValueChanged(const char* newValue)
{
#if DEBUG
	// must be one of the enumerated values
	ASSERT(_ValidateString(newValue));
#endif
	StringValueSetting::ValueChanged(newValue);
}


const char*
EnumeratedStringValueSetting::Handle(const char* const *argv)
{
	if (*++argv == NULL)
		return fValueExpectedErrorString;

	printf("---EnumeratedStringValueSetting::Handle %s %s\n", *(argv-1), *argv);
	if (!_ValidateString(*argv))
		return fWrongValueErrorString;

	ValueChanged(*argv);
	return 0;
}


bool
EnumeratedStringValueSetting::_ValidateString(const char* string)
{
	for (int32 i = 0;; i++) {
		const char* enumString = fEnumerator(i);
		if (enumString == NULL)
			return false;
		if (strcmp(enumString, string) == 0)
			return true;
	}
	return false;
}


//	#pragma mark -


ScalarValueSetting::ScalarValueSetting(const char* name, int32 defaultValue,
	const char* valueExpectedErrorString, const char* wrongValueErrorString,
	int32 min, int32 max)
	:
	SettingsArgvDispatcher(name),
	fDefaultValue(defaultValue),
	fValue(defaultValue),
	fMax(max),
	fMin(min),
	fValueExpectedErrorString(valueExpectedErrorString),
	fWrongValueErrorString(wrongValueErrorString)
{
}


ScalarValueSetting::~ScalarValueSetting()
{
}


void
ScalarValueSetting::ValueChanged(int32 newValue)
{
	ASSERT(newValue > fMin);
	ASSERT(newValue < fMax);
	fValue = newValue;
}


int32
ScalarValueSetting::Value() const
{
	return fValue;
}


void
ScalarValueSetting::GetValueAsString(char* buffer) const
{
	sprintf(buffer, "%" B_PRId32, fValue);
}


const char*
ScalarValueSetting::Handle(const char* const *argv)
{
	if (*++argv == NULL)
		return fValueExpectedErrorString;

	int32 newValue = atoi(*argv);
	if (newValue < fMin || newValue > fMax)
		return fWrongValueErrorString;

	fValue = newValue;
	return 0;
}


void
ScalarValueSetting::SaveSettingValue(Settings* settings)
{
	settings->Write("%" B_PRId32, fValue);
}


bool
ScalarValueSetting::NeedsSaving() const
{
	return fValue != fDefaultValue;
}


//	#pragma mark -


BooleanValueSetting::BooleanValueSetting(const char* name, bool defaultValue)
	:
	ScalarValueSetting(name, defaultValue, 0, 0)
{
}


BooleanValueSetting::~BooleanValueSetting()
{
}


bool
BooleanValueSetting::Value() const
{
	return fValue;
}


const char*
BooleanValueSetting::Handle(const char* const *argv)
{
	if (*++argv == NULL) {
		return B_TRANSLATE_COMMENT("on or off expected","Do not translate "
			"'on' and 'off'");
	}

	if (strcmp(*argv, "on") == 0)
		fValue = true;
	else if (strcmp(*argv, "off") == 0)
		fValue = false;
	else {
		return B_TRANSLATE_COMMENT("on or off expected", "Do not translate "
		"'on' and 'off'");
	}

	return 0;
}


void
BooleanValueSetting::SaveSettingValue(Settings* settings)
{
	settings->Write(fValue ? "on" : "off");
}