/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/ArrayUtils.h"

#include "nsGConfService.h"

#include "nsString.h"

#include "nsCOMPtr.h"

#include "nsComponentManagerUtils.h"

#include "nsISupportsPrimitives.h"

#include "nsIMutableArray.h"

#include "nsXULAppAPI.h"

#include "prlink.h"

#include <gconf/gconf-client.h>

using namespace mozilla;

#define GCONF_FUNCTIONS \

  FUNC(gconf_client_get_default, GConfClient*, (void)) \

  FUNC(gconf_client_get_bool, gboolean, (GConfClient*, const gchar*, GError**)) \

  FUNC(gconf_client_get_string, gchar*, (GConfClient*, const gchar*, GError**)) \

  FUNC(gconf_client_get_int, gint, (GConfClient*, const gchar*, GError**)) \

  FUNC(gconf_client_get_float, gdouble, (GConfClient*, const gchar*, GError**)) \

  FUNC(gconf_client_get_list, GSList*, (GConfClient*, const gchar*, GConfValueType, GError**)) \

  FUNC(gconf_client_set_bool, gboolean, (GConfClient*, const gchar*, gboolean, GError**)) \

  FUNC(gconf_client_set_string, gboolean, (GConfClient*, const gchar*, const gchar*, GError**)) \

  FUNC(gconf_client_set_int, gboolean, (GConfClient*, const gchar*, gint, GError**)) \

  FUNC(gconf_client_set_float, gboolean, (GConfClient*, const gchar*, gdouble, GError**)) \

  FUNC(gconf_client_unset, gboolean, (GConfClient*, const gchar*, GError**))

#define FUNC(name, type, params) \

  typedef type (*_##name##_fn) params; \

  static _##name##_fn _##name;

GCONF_FUNCTIONS

#undef FUNC

#define gconf_client_get_default _gconf_client_get_default

#define gconf_client_get_bool _gconf_client_get_bool

#define gconf_client_get_string _gconf_client_get_string

#define gconf_client_get_int _gconf_client_get_int

#define gconf_client_get_float _gconf_client_get_float

#define gconf_client_get_list _gconf_client_get_list

#define gconf_client_set_bool _gconf_client_set_bool

#define gconf_client_set_string _gconf_client_set_string

#define gconf_client_set_int _gconf_client_set_int

#define gconf_client_set_float _gconf_client_set_float

#define gconf_client_unset _gconf_client_unset

static PRLibrary *gconfLib = nullptr;

typedef void (*nsGConfFunc)();

struct nsGConfDynamicFunction {

  const char *functionName;

  nsGConfFunc *function;

};

nsGConfService::~nsGConfService()

{

  if (mClient)

    g_object_unref(mClient);

  // We don't unload gconf here because liborbit uses atexit(). In addition to

  // this, it's not a good idea to unload any gobject based library, as it

  // leaves types registered in glib's type system

}

nsresult

nsGConfService::Init()

{

#define FUNC(name, type, params) { #name, (nsGConfFunc *)&_##name },

  static const nsGConfDynamicFunction kGConfSymbols[] = {

    GCONF_FUNCTIONS

  };

#undef FUNC

  if (NS_WARN_IF(XRE_IsContentProcess())) {

    return NS_ERROR_SERVICE_NOT_AVAILABLE;

  }

  if (!gconfLib) {

    gconfLib = PR_LoadLibrary("libgconf-2.so.4");

    if (!gconfLib)

      return NS_ERROR_FAILURE;

  }

  for (auto GConfSymbol : kGConfSymbols) {

    *GConfSymbol.function =

      PR_FindFunctionSymbol(gconfLib, GConfSymbol.functionName);

    if (!*GConfSymbol.function) {

      return NS_ERROR_FAILURE;

    }

  }

  mClient = gconf_client_get_default();

  return mClient ? NS_OK : NS_ERROR_FAILURE;

}

NS_IMPL_ISUPPORTS(nsGConfService, nsIGConfService)

NS_IMETHODIMP

nsGConfService::GetBool(const nsACString &aKey, bool *aResult)

{

  GError* error = nullptr;

  *aResult = gconf_client_get_bool(mClient, PromiseFlatCString(aKey).get(),

                                   &error);

  if (error) {

    g_error_free(error);

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::GetString(const nsACString &aKey, nsACString &aResult)

{

  GError* error = nullptr;

  gchar *result = gconf_client_get_string(mClient,

                                          PromiseFlatCString(aKey).get(),

                                          &error);

  if (error) {

    g_error_free(error);

    return NS_ERROR_FAILURE;

  }

  // We do a string copy here so that the caller doesn't need to worry about

  // freeing the string with g_free().

  aResult.Assign(result);

  g_free(result);

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::GetInt(const nsACString &aKey, int32_t* aResult)

{

  GError* error = nullptr;

  *aResult = gconf_client_get_int(mClient, PromiseFlatCString(aKey).get(),

                                  &error);

  if (error) {

    g_error_free(error);

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::GetFloat(const nsACString &aKey, float* aResult)

{

  GError* error = nullptr;

  *aResult = gconf_client_get_float(mClient, PromiseFlatCString(aKey).get(),

                                    &error);

  if (error) {

    g_error_free(error);

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::GetStringList(const nsACString &aKey, nsIArray** aResult)

{

  nsCOMPtr<nsIMutableArray> items(do_CreateInstance(NS_ARRAY_CONTRACTID));

  if (!items)

    return NS_ERROR_OUT_OF_MEMORY;

  GError* error = nullptr;

  GSList* list = gconf_client_get_list(mClient, PromiseFlatCString(aKey).get(),

                                       GCONF_VALUE_STRING, &error);

  if (error) {

    g_error_free(error);

    return NS_ERROR_FAILURE;

  }

  for (GSList* l = list; l; l = l->next) {

    nsCOMPtr<nsISupportsString> obj(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID));

    if (!obj) {

      g_slist_free(list);

      return NS_ERROR_OUT_OF_MEMORY;

    }

    obj->SetData(NS_ConvertUTF8toUTF16((const char*)l->data));

    items->AppendElement(obj);

    g_free(l->data);

  }

  g_slist_free(list);

  items.forget(aResult);

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::SetBool(const nsACString &aKey, bool aValue)

{

  bool res = gconf_client_set_bool(mClient, PromiseFlatCString(aKey).get(),

                                     aValue, nullptr);

  return res ? NS_OK : NS_ERROR_FAILURE;

}

NS_IMETHODIMP

nsGConfService::SetString(const nsACString &aKey, const nsACString &aValue)

{

  bool res = gconf_client_set_string(mClient, PromiseFlatCString(aKey).get(),

                                       PromiseFlatCString(aValue).get(),

                                       nullptr);

  return res ? NS_OK : NS_ERROR_FAILURE;

}

NS_IMETHODIMP

nsGConfService::SetInt(const nsACString &aKey, int32_t aValue)

{

  bool res = gconf_client_set_int(mClient, PromiseFlatCString(aKey).get(),

                                    aValue, nullptr);

  return res ? NS_OK : NS_ERROR_FAILURE;

}

NS_IMETHODIMP

nsGConfService::SetFloat(const nsACString &aKey, float aValue)

{

  bool res = gconf_client_set_float(mClient, PromiseFlatCString(aKey).get(),

                                      aValue, nullptr);

  return res ? NS_OK : NS_ERROR_FAILURE;

}

NS_IMETHODIMP

nsGConfService::GetAppForProtocol(const nsACString &aScheme, bool *aEnabled,

                                  nsACString &aHandler)

{

  nsAutoCString key("/desktop/gnome/url-handlers/");

  key.Append(aScheme);

  key.AppendLiteral("/command");

  GError *err = nullptr;

  gchar *command = gconf_client_get_string(mClient, key.get(), &err);

  if (!err && command) {

    key.ReplaceLiteral(key.Length() - 7, 7, "enabled");

    *aEnabled = gconf_client_get_bool(mClient, key.get(), &err);

  } else {

    *aEnabled = false;

  }

  aHandler.Assign(command);

  g_free(command);

  if (err) {

    g_error_free(err);

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::HandlerRequiresTerminal(const nsACString &aScheme,

                                        bool *aResult)

{

  nsAutoCString key("/desktop/gnome/url-handlers/");

  key.Append(aScheme);

  key.AppendLiteral("/requires_terminal");

  GError *err = nullptr;

  *aResult = gconf_client_get_bool(mClient, key.get(), &err);

  if (err) {

    g_error_free(err);

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

NS_IMETHODIMP

nsGConfService::SetAppForProtocol(const nsACString &aScheme,

                                  const nsACString &aCommand)

{

  nsAutoCString key("/desktop/gnome/url-handlers/");

  key.Append(aScheme);

  key.AppendLiteral("/command");

  bool res = gconf_client_set_string(mClient, key.get(),

                                       PromiseFlatCString(aCommand).get(),

                                       nullptr);

  if (res) {

    key.ReplaceLiteral(key.Length() - 7, 7, "enabled");

    res = gconf_client_set_bool(mClient, key.get(), true, nullptr);

    if (res) {

      key.ReplaceLiteral(key.Length() - 7, 7, "needs_terminal");

      res = gconf_client_set_bool(mClient, key.get(), false, nullptr);

      if (res) {

        key.ReplaceLiteral(key.Length() - 14, 14, "command-id");

        res = gconf_client_unset(mClient, key.get(), nullptr);

      }

    }

  }

  return res ? NS_OK : NS_ERROR_FAILURE;

}