/*****************************************************************************/
// TranslatorSettings
// Written by Michael Wilber, Haiku Translation Kit Team
//
// TranslatorSettings.cpp
//
// This class manages (saves/loads/locks/unlocks) the settings
// for a Translator.
//
//
// Copyright (c) 2004 Haiku Project
//
// 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 <TranslatorFormats.h>
        // for B_TRANSLATOR_EXT_*
#include "TranslatorSettings.h"

// ---------------------------------------------------------------
// Constructor
//
// Sets the default settings, location for the settings file
// and sets the reference count to 1
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns:
// ---------------------------------------------------------------
TranslatorSettings::TranslatorSettings(const char *settingsFile,
        const TranSetting *defaults, int32 defCount)
        : fLock("TranslatorSettings 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 TranSetting *defs = fDefaults;
        for (int32 i = 0; i < fDefCount; i++) {
                switch (defs[i].dataType) {
                        case TRAN_SETTING_BOOL:
                                fSettingsMsg.AddBool(defs[i].name,
                                        static_cast<bool>(defs[i].defaultVal));
                                break;

                        case TRAN_SETTING_INT32:
                                fSettingsMsg.AddInt32(defs[i].name, defs[i].defaultVal);
                                break;

                        default:
                                // ASSERT here? Erase the bogus setting entry instead?
                                break;
                }
        }
}

// ---------------------------------------------------------------
// Acquire
//
// Returns a pointer to the TranslatorSettings and increments
// the reference count.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: pointer to this TranslatorSettings object
// ---------------------------------------------------------------
TranslatorSettings *
TranslatorSettings::Acquire()
{
        TranslatorSettings *psettings = NULL;

        fLock.Lock();
        fRefCount++;
        psettings = this;
        fLock.Unlock();

        return psettings;
}

// ---------------------------------------------------------------
// Release
//
// Decrements the reference count and deletes the
// TranslatorSettings if the reference count is zero.
//
// Preconditions:
//
// Parameters:
//
// Postconditions:
//
// Returns: pointer to this TranslatorSettings object if
// the reference count is greater than zero, returns NULL
// if the reference count is zero and the TranslatorSettings
// object has been deleted
// ---------------------------------------------------------------
TranslatorSettings *
TranslatorSettings::Release()
{
        TranslatorSettings *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:
// ---------------------------------------------------------------
TranslatorSettings::~TranslatorSettings()
{
}

// ---------------------------------------------------------------
// 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
TranslatorSettings::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
TranslatorSettings::LoadSettings(BMessage *pmsg)
{
        if (pmsg == NULL)
                return B_BAD_VALUE;

        fLock.Lock();
        const TranSetting *defaults = fDefaults;
        for (int32 i = 0; i < fDefCount; i++) {
                switch (defaults[i].dataType) {
                        case TRAN_SETTING_BOOL:
                        {
                                bool value;
                                if (pmsg->FindBool(defaults[i].name, &value) != B_OK) {
                                        if (fSettingsMsg.HasBool(defaults[i].name))
                                                break;
                                        else
                                                value = static_cast<bool>(defaults[i].defaultVal);
                                }

                                fSettingsMsg.ReplaceBool(defaults[i].name, value);
                                break;
                        }

                        case TRAN_SETTING_INT32:
                        {
                                int32 value;
                                if (pmsg->FindInt32(defaults[i].name, &value) != B_OK) {
                                        if (fSettingsMsg.HasInt32(defaults[i].name))
                                                break;
                                        else
                                                value = defaults[i].defaultVal;
                                }

                                fSettingsMsg.ReplaceInt32(defaults[i].name, value);
                                break;
                        }

                        default:
                                // TODO: ASSERT here? Erase the bogus setting entry instead?
                                break;
                }
        }

        fLock.Unlock();
        return B_OK;
}

// ---------------------------------------------------------------
// 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
TranslatorSettings::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
TranslatorSettings::GetConfigurationMessage(BMessage *pmsg)
{
        status_t result = B_BAD_VALUE;

        if (pmsg) {
                int32 i;
                for (i = 0; i < fDefCount; i++) {
                        result = pmsg->RemoveName(fDefaults[i].name);
                        if (result != B_OK && result != B_NAME_NOT_FOUND)
                                break;
                }
                if (i == fDefCount) {
                        fLock.Lock();
                        result = B_OK;

                        const TranSetting *defs = fDefaults;
                        for (i = 0; i < fDefCount && result >= B_OK; i++) {
                                switch (defs[i].dataType) {
                                        case TRAN_SETTING_BOOL:
                                                result = pmsg->AddBool(defs[i].name,
                                                        SetGetBool(defs[i].name));
                                                break;

                                        case TRAN_SETTING_INT32:
                                                result = pmsg->AddInt32(defs[i].name,
                                                        SetGetInt32(defs[i].name));
                                                break;

                                        default:
                                                // ASSERT here? Erase the bogus setting entry instead?
                                                break;
                                }
                        }

                        fLock.Unlock();
                }
        }

        return result;
}

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

// ---------------------------------------------------------------
// SetGetBool
//
// Sets the state of the bool setting identified by the given name
//
//
// Preconditions:
//
// Parameters:  name    identifies the setting to set or get
//
//                              pbool   the new value for the bool, or, if null,
//                                              it indicates that the caller wants to Get
//                                              rather than Set
//
// Postconditions:
//
// Returns: the prior value of the setting
// ---------------------------------------------------------------
bool
TranslatorSettings::SetGetBool(const char *name, bool *pbool)
{
        bool bprevValue;

        fLock.Lock();

        const TranSetting *def = FindTranSetting(name);
        if (def) {
                fSettingsMsg.FindBool(def->name, &bprevValue);
                if (pbool)
                        fSettingsMsg.ReplaceBool(def->name, *pbool);
        } else
                bprevValue = false;

        fLock.Unlock();

        return bprevValue;
}

// ---------------------------------------------------------------
// SetGetInt32
//
// Sets the state of the int32 setting identified by the given name
//
//
// Preconditions:
//
// Parameters:  name    identifies the setting to set or get
//
//                              pint32  the new value for the setting, or, if null,
//                                              it indicates that the caller wants to Get
//                                              rather than Set
//
// Postconditions:
//
// Returns: the prior value of the setting
// ---------------------------------------------------------------
int32
TranslatorSettings::SetGetInt32(const char *name, int32 *pint32)
{
        int32 prevValue;

        fLock.Lock();

        const TranSetting *def = FindTranSetting(name);
        if (def) {
                fSettingsMsg.FindInt32(def->name, &prevValue);
                if (pint32)
                        fSettingsMsg.ReplaceInt32(def->name, *pint32);
        } else
                prevValue = 0;

        fLock.Unlock();

        return prevValue;
}