/*

 * tp-helpers.c - Source for various helper functions

 * for telepathy implementation

 *

 * Copyright (C) 2005 Collabora Ltd.

 * 

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <dbus/dbus-glib.h>

#include <stdlib.h>

#include "tp-helpers.h"

#define CM_CONFS_DIR "/usr/share/telepathy/managers/"

#define CM_CONF_SUFFIX ".manager"

#define CM_CONF_GROUP "ConnectionManager"

#define FILE_SEPARATOR ','

#define PROTO "Proto "

#ifdef EMULATOR

#include "libtelepathy_wsd_solution.h"

#endif

#ifdef EMULATOR

	GET_STATIC_VAR_FROM_TLS(bus_proxy,tp_helpers,DBusGProxy *)

	#define bus_proxy (*GET_WSD_VAR_NAME(bus_proxy,tp_helpers,s)())

	GET_STATIC_VAR_FROM_TLS(bus1,tp_helpers,DBusGConnection *)

	#define bus1 (*GET_WSD_VAR_NAME(bus1,tp_helpers,s)())	

#endif

static void _list_builder(gpointer key, gpointer value, gpointer data);

DBusGConnection *

tp_get_bus ()

{

#ifndef EMULATOR

  static DBusGConnection *bus1 = NULL;

#endif

  if (bus1 == NULL)

    {

      GError *error = NULL;

      bus1 = dbus_g_bus_get (/*DBUS_BUS_STARTER*/DBUS_BUS_SESSION, &error);

      if (bus1 == NULL)

        g_error ("Failed to connect to starter bus: %s", error->message);

    }

  return bus1;

}

DBusGProxy *

tp_get_bus_proxy ()

{

#ifndef EMULATOR

  static DBusGProxy *bus_proxy = NULL;

#endif

  if (bus_proxy == NULL)

    {

      DBusGConnection *bus = tp_get_bus ();

      bus_proxy = dbus_g_proxy_new_for_name (bus,

                                            "org.freedesktop.DBus",

                                            "/org/freedesktop/DBus",

                                            "org.freedesktop.DBus");

      if (bus_proxy == NULL)

        g_error ("Failed to get proxy object for bus.");

    }

  return bus_proxy;

}

GSList *

tp_hash_to_key_value_list(GHashTable *hash)

{

  GSList *ret = NULL;

  g_hash_table_foreach(hash, _list_builder, &ret);

  return ret;

}

void

tp_key_value_list_free(GSList *list)

{

  GSList *iter;

  for (iter = list; iter; iter = g_slist_next(iter))

  {

    g_free(iter->data);

  }

  g_slist_free(list);

}

static void _list_builder(gpointer key, gpointer value, gpointer data)

{

  GSList **list = (GSList **)data;

  TpKeyValue *kv = g_new0(TpKeyValue, 1);

  kv->key = key;

  kv->value = value;

  *list = g_slist_prepend(*list, kv);

}

GSList *tp_connmgr_list_cms(void)

{

  GError *error = NULL;

  GDir *dir;

  const gchar *filename;

  gchar **name;

  gchar *absolute_filepath;

  GSList *cms = NULL;

  /* Read the configuration file directory */

  if ((dir = g_dir_open(CM_CONFS_DIR, 0, &error)) == NULL)

  {

    g_printerr("Error opening directory %s: %s", CM_CONFS_DIR,

        error->message);

    return NULL;

  }

  while ((filename = g_dir_read_name(dir)) != NULL)

    /* Skip the file if it doesn't contain the required file suffix */

    if (g_str_has_suffix(filename, CM_CONF_SUFFIX))

    {

      absolute_filepath = g_strconcat(CM_CONFS_DIR, filename, NULL);

      name = g_strsplit(filename, ".", 0);

      cms = g_slist_append(cms, *name);

    }

  return cms;

}

TpConnMgrInfo *tp_connmgr_get_info(gchar *cm)

{

  GError *error = NULL;

  GKeyFile *file;

  gsize len;

  gchar *absolute_filepath;

  gchar **protocols;

  TpConnMgrInfo *cm_info = (TpConnMgrInfo *)malloc(sizeof(TpConnMgrInfo));

  cm_info->protocol_info = g_hash_table_new(g_str_hash, g_str_equal);

  absolute_filepath = g_strconcat(CM_CONFS_DIR, cm, CM_CONF_SUFFIX, NULL);

  file = g_key_file_new();

  if (!g_key_file_load_from_file

      (file, absolute_filepath, G_KEY_FILE_NONE, &error))

  {

    /* handle error */

    g_printerr("%s", error->message);

    g_error_free(error);

    return NULL;

  }

  g_key_file_set_list_separator(file, FILE_SEPARATOR);

  cm_info->name = g_key_file_get_string(file, CM_CONF_GROUP,

            "Name", &error);

  if (!(cm_info->name))

  {

    /* handle error and free dynamic memory */

    g_printerr("%s", error->message);

    g_error_free(error);

    g_key_file_free(file);

    g_free(absolute_filepath);

    free(cm_info);

    return NULL;

  }

  cm_info->bus_name = g_key_file_get_string(file, CM_CONF_GROUP,

            "BusName", &error);

  if (!(cm_info->bus_name))

  {

    /* handle error and free dynamic memory */

    g_printerr("%s", error->message);

    g_error_free(error);

    g_key_file_free(file);

    g_free(absolute_filepath);

    g_free(cm_info->name);

    free(cm_info);

    return NULL;

  }

  cm_info->object_path = g_key_file_get_string(file,CM_CONF_GROUP,

            "ObjectPath", &error);

  if (!(cm_info->object_path))

  {

    /* handle error and free dynamic memory */

    g_printerr("%s", error->message);

    g_error_free(error);

    g_key_file_free(file);

    g_free(absolute_filepath);

    g_free(cm_info->name);

    g_free(cm_info->bus_name);

    free(cm_info);

    return NULL;

  }

  cm_info->protocols = g_key_file_get_string_list(file, CM_CONF_GROUP, 

                              "Protos", &len, &error);

  if (!(cm_info->protocols))

  {

    /* handle error and free dynamic memory */

    g_printerr("%s", error->message);

    g_error_free(error);

    g_key_file_free(file);

    g_free(absolute_filepath);

    g_free(cm_info->name);

    g_free(cm_info->bus_name);

    g_free(cm_info->object_path);

    free(cm_info);

    return NULL;

  }

  for(protocols=cm_info->protocols; *protocols; protocols++)

  {

    gchar **keys;

    gchar *key_value;

    gchar *proto_group =  g_strconcat(PROTO, *protocols, NULL);

    TpConnMgrProtInfo *cm_prot_info = 

                       (TpConnMgrProtInfo *)malloc(sizeof(TpConnMgrProtInfo));

    cm_prot_info->default_params = g_hash_table_new(g_str_hash, g_str_equal);

    cm_prot_info->mandatory_params = g_key_file_get_string_list(file, 

                                   proto_group, "MandatoryParams", &len, &error);

    if (!(cm_prot_info->mandatory_params))

    {

      g_printerr("%s", error->message);

      g_error_free(error);

    }

    cm_prot_info->optional_params = g_key_file_get_string_list(file, 

                                   proto_group, "OptionalParams", &len, &error);

    if (!(cm_prot_info->optional_params))

    {

      g_printerr("%s", error->message);

      g_error_free(error);

    }

    keys = g_key_file_get_keys (file, proto_group, &len, &error);

    if (!(keys))

    {

      g_printerr("%s", error->message);

      g_error_free(error);

    }

    else

    {

      for(; *keys; keys++)

      {

        if(g_str_has_prefix(*keys, "default"))

        {

          key_value = g_key_file_get_string(file, proto_group, 

                                                   *keys, &error);

          if (!(key_value))

          {

            g_printerr("%s", error->message);

            g_error_free(error);

          }

          else

            g_hash_table_insert(cm_prot_info->default_params, 

                                g_strdup(*keys), key_value);

        }

      }

   }

   g_hash_table_insert(cm_info->protocol_info, g_strdup(*protocols), 

                        cm_prot_info);

  }

  g_key_file_free(file);

  g_free(absolute_filepath);

  return cm_info;

}