/*****************************************************************************/
// LiveSettings
// Written by Michael Wilber
//
// LiveSettings.cpp
//
// This class manages (saves/loads/locks/unlocks) a collection of BMessage
// based settings. This class allows you to share settings between different
// classes in different threads and receive notifications when the settings
// change. This class makes it easy to share settings between a Translator
// and its config panel or a Screen Saver and its config panel.
//
//
// Copyright (C) Haiku
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
// and/or sell copies of the Software, and to permit persons to whom the 
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included 
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/

#include <string.h>
#include <File.h>
#include <FindDirectory.h>
#include "LiveSettings.h"

// ---------------------------------------------------------------
// Constructor
//
// Sets the default settings, location for the settings file
// and sets the reference count to 1
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
LiveSettings::LiveSettings(const char *settingsFile,
	LiveSetting *defaults, int32 defCount)
	: fLock("LiveSettings Lock")
{
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &fSettingsPath))
		fSettingsPath.SetTo("/tmp");
	fSettingsPath.Append(settingsFile);
	
	fRefCount = 1;
	
	if (defCount > 0) {
		fDefaults = defaults;
		fDefCount = defCount;
	} else {
		fDefaults = NULL;
		fDefCount = 0;
	}
	
	// Add Default Settings
	// (Used when loading from the settings file or from
	// a BMessage fails)
	const LiveSetting *defs = fDefaults;
	for (int32 i = 0; i < fDefCount; i++)
		defs[i].AddReplaceValue(&fSettingsMsg);
}

// ---------------------------------------------------------------
// Acquire
//
// Returns a pointer to the LiveSettings and increments
// the reference count. 
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: pointer to this LiveSettings object
// ---------------------------------------------------------------
LiveSettings *
LiveSettings::Acquire()
{
	LiveSettings *psettings = NULL;
	
	fLock.Lock();
	fRefCount++;
	psettings = this;
	fLock.Unlock();
	
	return psettings;
}

// ---------------------------------------------------------------
// Release
//
// Decrements the reference count and deletes the
// LiveSettings if the reference count is zero.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: pointer to this LiveSettings object if
// the reference count is greater than zero, returns NULL
// if the reference count is zero and the LiveSettings
// object has been deleted
// ---------------------------------------------------------------
LiveSettings *
LiveSettings::Release()
{
	LiveSettings *psettings = NULL;
	
	fLock.Lock();
	fRefCount--;
	if (fRefCount > 0) {
		psettings = this;
		fLock.Unlock();
	} else
		delete this;
			// delete this object and
			// release locks
	
	return psettings;	
}

// ---------------------------------------------------------------
// Destructor
//
// Does nothing!
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
LiveSettings::~LiveSettings()
{
	fObservers.clear();
}

// returns true if observer was added sucessfully, 
// false if observer already in the list or error
bool
LiveSettings::AddObserver(LiveSettingsObserver *observer)
{
	fLock.Lock();
	
	bool bAdd = true;
	ObserverList::iterator I = fObservers.begin();
	while (I != fObservers.end()) {
		if (*I == observer) {
			bAdd = false;
			break;
		}
		I++;
	}
	
	if (bAdd == true)
		fObservers.push_back(observer);
	
	fLock.Unlock();
	
	return bAdd;
}

// returns true if observer was removed successfully,
// false if observer not found or error		
bool
LiveSettings::RemoveObserver(LiveSettingsObserver *observer)
{
	fLock.Lock();
	
	bool bRemove = false;
	ObserverList::iterator I = fObservers.begin();
	while (I != fObservers.end()) {
		if (*I == observer) {
			bRemove = true;
			break;
		}
		I++;
	}
	
	if (bRemove == true)
		fObservers.erase(I);
	
	fLock.Unlock();
	
	return bRemove;
}

void
LiveSettings::NotifySettingChanged(uint32 setting)
{
	fLock.Lock();
	ObserverList listCopy = fObservers;
	fLock.Unlock();
	
	ObserverList::iterator I = listCopy.begin();
	while (I != listCopy.end()) {
		(*I)->SettingChanged(setting);
		I++;
	}
}		

// ---------------------------------------------------------------
// LoadSettings
//
// Loads the settings by reading them from the default
// settings file.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: B_OK if there were no errors or an error code from
// BFile::SetTo() or BMessage::Unflatten() if there were errors
// ---------------------------------------------------------------
status_t
LiveSettings::LoadSettings()
{
	status_t result;
	
	fLock.Lock();
	
	// Don't try to open the settings file if there are
	// no settings that need to be loaded
	if (fDefCount > 0) {
		BFile settingsFile;
		result = settingsFile.SetTo(fSettingsPath.Path(), B_READ_ONLY);
		if (result == B_OK) {
			BMessage msg;
			result = msg.Unflatten(&settingsFile);
			if (result == B_OK)
				result = LoadSettings(&msg);
		}
	} else
		result = B_OK;
	
	fLock.Unlock();
	
	return result;
}

// ---------------------------------------------------------------
// LoadSettings
//
// Loads the settings from a BMessage passed to the function.
//
// Preconditions:
//
// Parameters:	pmsg	pointer to BMessage that contains the
//						settings
//
// Postconditions:
//
// Returns: B_BAD_VALUE if pmsg is NULL or invalid options
// have been found, B_OK if there were no
// errors or an error code from BMessage::FindBool() or
// BMessage::ReplaceBool() if there were other errors
// ---------------------------------------------------------------
status_t
LiveSettings::LoadSettings(BMessage *pmsg)
{
	status_t result = B_OK;
	
	if (pmsg) {
		
		fLock.Lock();
		
		const LiveSetting *defs = fDefaults;
		for (int32 i = 0; i < fDefCount; i++)
			defs[i].AddReplaceValue(&fSettingsMsg, pmsg);

		fLock.Unlock();
	}
	
	return result;
}

// ---------------------------------------------------------------
// SaveSettings
//
// Saves the settings as a flattened BMessage to the default
// settings file
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: B_OK if no errors or an error code from BFile::SetTo()
// or BMessage::Flatten() if there were errors
// ---------------------------------------------------------------
status_t
LiveSettings::SaveSettings()
{
	status_t result;
	
	fLock.Lock();
	
	// Only write out settings file if there are
	// actual settings stored by this object
	if (fDefCount > 0) {
		BFile settingsFile;
		result = settingsFile.SetTo(fSettingsPath.Path(),
			B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
		if (result == B_OK)
			result = fSettingsMsg.Flatten(&settingsFile);
	} else
		result = B_OK;
		
	fLock.Unlock();
	
	return result;
}

// ---------------------------------------------------------------
// GetConfigurationMessage
//
// Saves the current settings to the BMessage passed to the
// function
//
// Preconditions:
//
// Parameters:	pmsg	pointer to BMessage where the settings
//						will be stored
//
// Postconditions:
//
// Returns: B_OK if there were no errors or an error code from
// BMessage::RemoveName() or BMessage::AddBool() if there were
// errors
// ---------------------------------------------------------------
status_t
LiveSettings::GetConfigurationMessage(BMessage *pmsg)
{
	status_t result = B_BAD_VALUE;
	
	if (pmsg) {
		int32 i;
		for (i = 0; i < fDefCount; i++) {
			result = pmsg->RemoveName(fDefaults[i].GetName());
			if (result != B_OK && result != B_NAME_NOT_FOUND)
				break;
		}
		if (i == fDefCount) {
			fLock.Lock();
			result = B_OK;
			
			BString tempStr;
			const LiveSetting *defs = fDefaults;
			for (i = 0; i < fDefCount && result >= B_OK; i++)
				defs[i].AddReplaceValue(pmsg, &fSettingsMsg);
				
			fLock.Unlock();
		}
	}
	
	return result;
}

// ---------------------------------------------------------------
// FindLiveSetting
//
// Returns a pointer to the LiveSetting with the given name
//
//
// Preconditions:
//
// Parameters:	name	name of the LiveSetting to find
//
//
// Postconditions:
//
// Returns: NULL if the LiveSetting cannot be found, or a pointer
//          to the desired LiveSetting if it is found
// ---------------------------------------------------------------
const LiveSetting *
LiveSettings::FindLiveSetting(const char *name)
{
	for (int32 i = 0; i < fDefCount; i++) {
		if (!strcmp(fDefaults[i].GetName(), name))
			return fDefaults + i;
	}
	return NULL;
}

bool
LiveSettings::SetGetBool(const char *name, bool *pVal /*= NULL*/)
{
	bool bPrevVal = false;
	GetValue<bool>(name, bPrevVal);
	if (pVal != NULL)
		SetValue<bool>(name, *pVal);

	return bPrevVal;
}

int32
LiveSettings::SetGetInt32(const char *name, int32 *pVal /*= NULL*/)
{
	int32 iPrevVal = 0;
	GetValue<int32>(name, iPrevVal);
	if (pVal != NULL)
		SetValue<int32>(name, *pVal);
	
	return iPrevVal;
}

void
LiveSettings::SetString(const char *name, const BString &str)
{
	SetValue<BString>(name, str);
}
	
void
LiveSettings::GetString(const char *name, BString &str)
{
	GetValue<BString>(name, str);
}

template <class T>
bool
LiveSettings::SetValue(const char *name, const T &val)
{
	bool bResult = false, bChanged = false;
	fLock.Lock();
	
	const LiveSetting *def = FindLiveSetting(name);
	if (def) {
		bResult = def->AddReplaceValue(&fSettingsMsg, val);
		bChanged = true;
	}
		
	fLock.Unlock();
	
	if (bChanged == true)
		NotifySettingChanged(def->GetId());
		
	return bResult;
}

template <class T>
bool
LiveSettings::GetValue(const char *name, T &val)
{
	fLock.Lock();
	
	bool bResult = false;
	const LiveSetting *def = FindLiveSetting(name);
	if (def)
		bResult = def->GetValue(&fSettingsMsg, val);
		
	fLock.Unlock();
	
	return bResult;
}