/*
 * Copyright 2000, Georges-Edouard Berenger. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "Preferences.h"
#include "Utilities.h"

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

#include <Alert.h>
#include <Catalog.h>
#include <Directory.h>
#include <File.h>
#include <FindDirectory.h>
#include <Locker.h>
#include <Mime.h>
#include <Path.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "ProcessController"

Preferences::Preferences(const char* name, const char* signature, bool doSave)
        : BMessage('Pref'), BLocker("Preferences", true),
        fSavePreferences(doSave)
{
        fNewPreferences = false;
        fSettingsFile = 0;
        BPath prefpath;
        fName = strdup(name);
        if (signature)
                fSignature = strdup(signature);
        else
                fSignature = NULL;

        if (find_directory(B_USER_SETTINGS_DIRECTORY, &prefpath) == B_OK) {
                BDirectory prefdir(prefpath.Path());
                BEntry entry;
                prefdir.FindEntry(fName, &entry);

                BFile file(&entry, B_READ_ONLY);
                if (file.InitCheck() == B_OK)
                        Unflatten(&file);
                else
                        fNewPreferences = true;
        }
}


Preferences::Preferences(const entry_ref &ref, const char* signature, bool doSave)
        : BMessage('Pref'), BLocker("Preferences", true),
        fSavePreferences(doSave)
{
        fSettingsFile = new entry_ref(ref);
        fNewPreferences = false;
        BPath prefpath;
        fName = NULL;
        if (signature)
                fSignature = strdup(signature);
        else
                fSignature = NULL;

        BFile file(fSettingsFile, B_READ_ONLY);
        if (file.InitCheck() == B_OK)
                Unflatten(&file);
        else
                fNewPreferences = true;
}


Preferences::~Preferences()
{
        if (fSavePreferences) {
                BFile file;
                if (fSettingsFile)
                        file.SetTo(fSettingsFile, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
                else {
                        BPath prefpath;
                        if (find_directory(B_USER_SETTINGS_DIRECTORY, &prefpath, true) == B_OK) {
                                BDirectory prefdir(prefpath.Path());
                                prefdir.CreateFile(fName, &file, false);
                        }
                }

                if (file.InitCheck () == B_OK) {
                        Flatten(&file);
                        if (fSignature) {
                                file.WriteAttr("BEOS:TYPE", B_MIME_STRING_TYPE, 0, fSignature,
                                        strlen(fSignature) + 1);
                        }
                } else {
                        // implement saving somewhere else!
                        BString error;
                        snprintf(error.LockBuffer(256), 256,
                                B_TRANSLATE("Your setting file could not be saved!\n(%s)"),
                                strerror(file.InitCheck()));
                        error.UnlockBuffer();
                        BAlert *alert = new BAlert(B_TRANSLATE("Error saving file"),
                                error.String(), B_TRANSLATE("Damned!"), NULL, NULL,
                                B_WIDTH_AS_USUAL, B_STOP_ALERT);
                        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                        alert->Go();
                }
        }
        delete fSettingsFile;
        free(fName);
        free(fSignature);
}


status_t
Preferences::MakeEmpty()
{
        Lock();
        status_t status = BMessage::MakeEmpty();
        Unlock();
        return status;
}


void
Preferences::SaveWindowPosition(BWindow* window, const char* name)
{
        Lock();

        BRect rect = window->Frame();
        if (HasPoint(name))
                ReplacePoint(name, rect.LeftTop());
        else
                AddPoint(name, rect.LeftTop());

        Unlock();
}


void
Preferences::LoadWindowPosition(BWindow* window, const char* name)
{
        Lock();

        BPoint p;
        if (FindPoint(name, &p) == B_OK) {
                window->MoveTo(p);
                make_window_visible(window);
        }

        Unlock();
}


void
Preferences::SaveWindowFrame(BWindow* window, const char* name)
{
        Lock();

        BRect rect = window->Frame();
        if (HasRect(name))
                ReplaceRect(name, rect);
        else
                AddRect(name, rect);

        Unlock();
}


void
Preferences::LoadWindowFrame(BWindow* window, const char* name)
{
        Lock();

        BRect frame;
        if (FindRect(name, &frame) == B_OK) {
                window->MoveTo(frame.LeftTop());
                window->ResizeTo(frame.Width(), frame.Height());
                make_window_visible(window);
        }

        Unlock();
}


void
Preferences::SaveInt32(int32 value, const char* name)
{
        Lock();

        if (HasInt32(name))
                ReplaceInt32(name, value);
        else
                AddInt32(name, value);

        Unlock();
}


bool
Preferences::ReadInt32(int32 &val, const char* name)
{
        Lock();
        int32 readVal;
        bool found = FindInt32(name, &readVal) == B_OK;
        if (found)
                val = readVal;
        Unlock();
        return found;
}


void
Preferences::SaveFloat(float val, const char* name)
{
        Lock();
        if (HasFloat(name))
                ReplaceFloat(name, val);
        else
                AddFloat(name, val);
        Unlock();
}


bool
Preferences::ReadFloat(float &val, const char* name)
{
        Lock();
        float readVal;
        bool found = FindFloat(name, &readVal) == B_OK;
        if (found)
                val = readVal;
        Unlock();
        return found;
}


void
Preferences::SaveRect(BRect& rect, const char* name)
{
        Lock();
        if (HasRect(name))
                ReplaceRect(name, rect);
        else
                AddRect(name, rect);
        Unlock();
}


BRect &
Preferences::ReadRect(BRect& rect, const char* name)
{
        Lock();
        BRect loaded;
        if (FindRect(name, &loaded) == B_OK)
                rect = loaded;
        Unlock();
        return rect;
}


void
Preferences::SaveString(BString &string, const char* name)
{
        Lock();
        if (HasString(name))
                ReplaceString(name, string);
        else
                AddString(name, string);
        Unlock();
}


void
Preferences::SaveString(const char* string, const char* name)
{
        Lock();
        if (HasString(name))
                ReplaceString(name, string);
        else
                AddString(name, string);
        Unlock();
}


bool
Preferences::ReadString(BString &string, const char* name)
{
        Lock();
        bool loaded = FindString(name, &string) == B_OK;
        Unlock();
        return loaded;
}