// Settings.cpp
//
// Copyright (c) 2003, Ingo Weinhold (bonefish@cs.tu-berlin.de)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// You can alternatively use *this file* under the terms of the the MIT
// license included in this package.

#include <new>

#include "Settings.h"
#include "Debug.h"

using std::nothrow;

/*!
        \class Settings
        \brief Manages the ReiserFS settings.
*/

static const char *kFSName = "reiserfs";

// defaults
static const char *kDefaultDefaultVolumeName = "ReiserFS untitled";
static const bool kDefaultHideEsoteric  = true;

// constructor
Settings::Settings()
        :
        fDefaultVolumeName(),
        fVolumeName(),
        fHideEsoteric(kDefaultHideEsoteric),
        fHiddenEntries(5)
{
}

// destructor
Settings::~Settings()
{
        Unset();
}

// SetTo
status_t
Settings::SetTo(const char *volumeName)
{
        // unset
        Unset();
        // load the driver settings and find the entry for the volume
        void *settings = load_driver_settings(kFSName);
        const driver_parameter *volume = NULL;
        const driver_settings *ds = get_driver_settings(settings);
        if (ds && volumeName)
                volume = _FindVolumeParameter(ds, volumeName);
        // init the object and unload the settings
        _Init(ds, volume);
        unload_driver_settings(settings);
        return B_OK;
}

// SetTo
status_t
Settings::SetTo(off_t volumeOffset, off_t volumeSize)
{
        PRINT(("Settings::SetTo(%" B_PRIdOFF ", %" B_PRIdOFF ")\n", volumeOffset,
                volumeSize));
        // unset
        Unset();
        // load the driver settings and find the entry for the volume
        void *settings = load_driver_settings(kFSName);
        const driver_parameter *volume = NULL;
        const driver_settings *ds = get_driver_settings(settings);
        if (ds)
                volume = _FindVolumeParameter(ds, volumeOffset, volumeSize);
        // init the object and unload the settings
        _Init(ds, volume);
        unload_driver_settings(settings);
        PRINT(("Settings::SetTo(%" B_PRIdOFF ", %" B_PRIdOFF ") done: B_OK\n",
                volumeOffset, volumeSize));
        return B_OK;
}

// Unset
void
Settings::Unset()
{
        fDefaultVolumeName.Unset();
        fVolumeName.Unset();
        fHideEsoteric = kDefaultHideEsoteric;
        fHiddenEntries.MakeEmpty();
}

// GetDefaultVolumeName
const char *
Settings::GetDefaultVolumeName() const
{
        if (fDefaultVolumeName.GetLength() > 0)
                return fDefaultVolumeName.GetString();
        return kDefaultDefaultVolumeName;
}

// GetVolumeName
const char *
Settings::GetVolumeName() const
{
        if (fVolumeName.GetLength() > 0)
                return fVolumeName.GetString();
        return GetDefaultVolumeName();
}

// GetHideEsoteric
bool
Settings::GetHideEsoteric() const
{
        return fHideEsoteric;
}

// HiddenEntryAt
const char *
Settings::HiddenEntryAt(int32 index) const
{
        const char *entry = NULL;
        if (index >= 0 && index < fHiddenEntries.CountItems())
                entry = fHiddenEntries.ItemAt(index).GetString();
        return entry;
}

// Dump
void
Settings::Dump()
{
#if DEBUG
        PRINT(("Settings:\n"));
        PRINT(("  default volume name:   `%s'\n", GetDefaultVolumeName()));
        PRINT(("  volume name:           `%s'\n", GetVolumeName()));
        PRINT(("  hide esoteric entries: %d\n", GetHideEsoteric()));
        PRINT(("  %" B_PRId32 " hidden entries:\n", fHiddenEntries.CountItems()));
        for (int32 i = 0; const char *entry = HiddenEntryAt(i); i++)
                PRINT(("    `%s'\n", entry));
#endif
}

// _Init
status_t
Settings::_Init(const driver_settings *settings,
                                const driver_parameter *volume)
{
PRINT(("Settings::_Init(%p, %p)\n", settings, volume));
        status_t error = B_OK;
        // get the global values
        fDefaultVolumeName.SetTo(_GetParameterValue(settings,
                "default_volume_name", (const char*)NULL, NULL));
PRINT(("  default_volume_name is: `%s'\n", fDefaultVolumeName.GetString()));
        fHideEsoteric = _GetParameterValue(settings, "hide_esoteric_entries",
                                                                                kDefaultHideEsoteric,
                                                                                kDefaultHideEsoteric);
PRINT(("  hide_esoteric_entries is: %d\n", fHideEsoteric));
        // get the per volume settings
        if (volume) {
PRINT(("  getting volume parameters:\n"));
                fVolumeName.SetTo(_GetParameterValue(volume, "name", (const char*)NULL,
                                                                                                NULL));
PRINT(("    name is: `%s'\n", fVolumeName.GetString()));
                fHideEsoteric = _GetParameterValue(volume, "hide_esoteric_entries",
                                                                                        fHideEsoteric, fHideEsoteric);
PRINT(("    hide_esoteric_entries is: %d\n", fHideEsoteric));
                int32 cookie = 0;
                while (const driver_parameter *parameter
                                = _FindNextParameter(volume, "hide_entries", cookie)) {
                        for (int32 i = 0; i < parameter->value_count; i++)
{
                                fHiddenEntries.AddItem(parameter->values[i]);
PRINT(("    hidden entry: `%s'\n", parameter->values[i]));
}
                }
        }
        // check the values
PRINT(("  checking volume names...'\n"));
        _CheckVolumeName(fDefaultVolumeName);
        _CheckVolumeName(fVolumeName);
PRINT(("  checking hidden entry names...'\n"));
        for (int32 i = fHiddenEntries.CountItems(); i >= 0; i--) {
                String &entry = fHiddenEntries.ItemAt(i);
                if (!_CheckEntryName(entry.GetString()))
{
PRINT(("    ignoring: `%s'\n", entry.GetString()));
                        fHiddenEntries.RemoveItem(i);
}
        }
PRINT(("Settings::_Init() done: %s\n", strerror(error)));
        return error;
}

// _FindVolumeParameter
const driver_parameter *
Settings::_FindVolumeParameter(const driver_settings *settings,
                                                                const char *name)
{
        if (settings) {
                int32 cookie = 0;
                while (const driver_parameter *parameter
                                = _FindNextParameter(settings, "volume", cookie)) {
                        if (parameter->value_count == 1
                                && !strcmp(parameter->values[0], name)) {
                                return parameter;
                        }
                }
        }
        return NULL;
}

// _FindVolumeParameter
const driver_parameter *
Settings::_FindVolumeParameter(const driver_settings *settings,
                                                                off_t offset, off_t size)
{
        PRINT(("Settings::_FindVolumeParameter(%" B_PRIdOFF ", %" B_PRIdOFF ")\n",
                offset, size));
        if (settings) {
                int32 cookie = 0;
                while (const driver_parameter *parameter
                                = _FindNextParameter(settings, "volume", cookie)) {
                        if (_GetParameterValue(parameter, "offset", offset + 1, offset + 1)
                                        == offset
                                && _GetParameterValue(parameter, "size", size + 1, size + 1)
                                        == size) {
                                PRINT(("Settings::_FindVolumeParameter() done: found parameter:"
                                        " index: %" B_PRId32 ", (%p)\n", cookie - 1, parameter));
                                return parameter;
                        }
                }
        }
        PRINT(("Settings::_FindVolumeParameter() done: failed\n"));
        return NULL;
}

// _CheckVolumeName
void
Settings::_CheckVolumeName(String &name)
{
        // truncate, if it is too long
        if (name.GetLength() >= B_FILE_NAME_LENGTH) {
                char buffer[B_FILE_NAME_LENGTH];
                memcpy(buffer, name.GetString(), B_FILE_NAME_LENGTH - 1);
                name.SetTo(buffer, B_FILE_NAME_LENGTH - 1);
        }
        // check for bad characters
        bool invalid = false;
        const char *string = name.GetString();
        for (int32 i = 0; !invalid && i < name.GetLength(); i++) {
                if (string[i] == '/')   // others?
                        invalid = true;
        }
        if (invalid)
                name.Unset();
}

// _CheckEntryName
bool
Settings::_CheckEntryName(const char *name)
{
        int32 len = (name ? strlen(name) : 0);
        // any further restictions?
        return (len > 0);
}