/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "DebuggerSettingsManager.h"

#include <new>

#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>

#include <AutoDeleter.h>
#include <AutoLocker.h>

#include "TeamSettings.h"


static const char* const kSettingsDirPath               = "Debugger";
static const char* const kGlobalSettingsName    = "Global";
static const int32 kMaxRecentTeamSettings               = 10;


DebuggerSettingsManager::DebuggerSettingsManager()
        :
        SettingsManager(),
        fLock("settings manager"),
        fRecentTeamSettings(kMaxRecentTeamSettings),
        fUiSettingsFactory(NULL)
{
}


DebuggerSettingsManager::~DebuggerSettingsManager()
{
        _Unset();
}


status_t
DebuggerSettingsManager::Init(TeamUiSettingsFactory* factory)
{
        // check the lock
        status_t error = fLock.InitCheck();
        if (error != B_OK)
                return error;

        fUiSettingsFactory = factory;

        // get and create our settings directory
        if (find_directory(B_USER_SETTINGS_DIRECTORY, &fSettingsPath, true) == B_OK
                && fSettingsPath.Append(kSettingsDirPath) == B_OK
                && create_directory(fSettingsPath.Path(), 0700) == B_OK
                && fSettingsPath.Append(kGlobalSettingsName) == B_OK) {
                // load the settings
                _LoadSettings();
        } else {
                // something went wrong -- clear the path
                fSettingsPath.Unset();
        }

        return B_OK;
}


status_t
DebuggerSettingsManager::LoadTeamSettings(const char* teamName, TeamSettings& settings)
{
        AutoLocker<BLocker> locker(fLock);

        int32 index = _TeamSettingsIndex(teamName);
        if (index < 0)
                return B_ENTRY_NOT_FOUND;

        try {
                settings = *fRecentTeamSettings.ItemAt(index);
                return B_OK;
        } catch (std::bad_alloc&) {
                return B_NO_MEMORY;
        }
}


status_t
DebuggerSettingsManager::SaveTeamSettings(const TeamSettings& _settings)
{
        AutoLocker<BLocker> locker(fLock);

        TeamSettings* settings;
        int32 index = _TeamSettingsIndex(_settings.TeamName());
        if (index >= 0) {
                settings = fRecentTeamSettings.RemoveItemAt(index);
        } else {
                settings = new(std::nothrow) TeamSettings;
                if (settings == NULL)
                        return B_NO_MEMORY;

                // enforce recent limit
                while (fRecentTeamSettings.CountItems() >= kMaxRecentTeamSettings)
                        delete fRecentTeamSettings.RemoveItemAt(0);

        }
        ObjectDeleter<TeamSettings> settingsDeleter(settings);

        try {
                *settings = _settings;
                if (!fRecentTeamSettings.AddItem(settings))
                        return B_NO_MEMORY;
                settingsDeleter.Detach();

                return _SaveSettings();
        } catch (std::bad_alloc&) {
                return B_NO_MEMORY;
        }
}


void
DebuggerSettingsManager::_Unset()
{
        fRecentTeamSettings.MakeEmpty();
}


status_t
DebuggerSettingsManager::_LoadSettings()
{
        _Unset();

        if (fSettingsPath.Path() == NULL)
                return B_ENTRY_NOT_FOUND;

        // read the settings file
        BFile file;
        status_t error = file.SetTo(fSettingsPath.Path(), B_READ_ONLY);
        if (error != B_OK)
                return error;

        BMessage archive;
        error = archive.Unflatten(&file);
        if (error != B_OK)
                return error;

        // unarchive the recent team settings
        BMessage childArchive;
        for (int32 i = 0; archive.FindMessage("teamSettings", i, &childArchive)
                        == B_OK; i++) {
                TeamSettings* settings = new(std::nothrow) TeamSettings;
                if (settings == NULL)
                        return B_NO_MEMORY;

                error = settings->SetTo(childArchive, *fUiSettingsFactory);
                if (error != B_OK) {
                        delete settings;
                        continue;
                }

                if (!fRecentTeamSettings.AddItem(settings)) {
                        delete settings;
                        return B_NO_MEMORY;
                }
        }

        return B_OK;
}


status_t
DebuggerSettingsManager::_SaveSettings()
{
        if (fSettingsPath.Path() == NULL)
                return B_ENTRY_NOT_FOUND;

        // archive the recent team settings
        BMessage archive;
        for (int32 i = 0; TeamSettings* settings = fRecentTeamSettings.ItemAt(i);
                        i++) {
                BMessage childArchive;
                status_t error = settings->WriteTo(childArchive);
                if (error != B_OK)
                        return error;

                error = archive.AddMessage("teamSettings", &childArchive);
                if (error != B_OK)
                        return error;
        }

        // open the settings file
        BFile file;
        status_t error = file.SetTo(fSettingsPath.Path(),
                B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
        if (error != B_OK)
                return error;

        return archive.Flatten(&file);
}


int32
DebuggerSettingsManager::_TeamSettingsIndex(const char* teamName) const
{
        for (int32 i = 0; TeamSettings* settings = fRecentTeamSettings.ItemAt(i);
                        i++) {
                if (settings->TeamName() == teamName)
                        return i;
        }

        return -1;
}