/*

 * group-mixin.c - Source for GabbleGroupMixin

 * Copyright (C) 2006 Collabora Ltd.

 * 

 *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>

 *   @author Robert McQueen <robert.mcqueen@collabora.co.uk>

 *

 * 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 <stdio.h>

#include "ansi.h"

#include "debug.h"

#include "telepathy-errors.h"

#include "group-mixin.h"

#include "group-mixin-signals-marshal.h"

#define DEBUG_FLAG GABBLE_DEBUG_GROUPS

#ifdef DEBUG_FLAG

//#define DEBUG(format, ...)

#define DEBUGGING 0

#define NODE_DEBUG(n, s)

#endif /* DEBUG_FLAG */

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_VAR_FROM_TLS(offset_quark1,gabble_grp_mixin,GQuark)

	#define offset_quark1 (*GET_WSD_VAR_NAME(offset_quark1,gabble_grp_mixin, s)())	

	GET_STATIC_VAR_FROM_TLS(offset_quark,gabble_grp_mixin,GQuark)

	#define offset_quark (*GET_WSD_VAR_NAME(offset_quark,gabble_grp_mixin, s)())	

#endif

static const char *group_change_reason_str(guint reason)

{

  switch (reason)

    {

    case TP_CHANNEL_GROUP_CHANGE_REASON_NONE:

      return "unspecified reason";

    case TP_CHANNEL_GROUP_CHANGE_REASON_OFFLINE:

      return "offline";

    case TP_CHANNEL_GROUP_CHANGE_REASON_KICKED:

      return "kicked";

    case TP_CHANNEL_GROUP_CHANGE_REASON_BUSY:

      return "busy";

    case TP_CHANNEL_GROUP_CHANGE_REASON_INVITED:

      return "invited";

    case TP_CHANNEL_GROUP_CHANGE_REASON_BANNED:

      return "banned";

    default:

      return "(unknown reason code)";

    }

}

struct _GabbleGroupMixinPrivate {

    GabbleHandleSet *actors;

    GHashTable *handle_owners;

};

/**

 * gabble_group_mixin_class_get_offset_quark:

 *

 * Returns: the quark used for storing mixin offset on a GObjectClass

 */

GQuark

gabble_group_mixin_class_get_offset_quark ()

{

#ifndef EMULATOR

  static GQuark offset_quark1 = 0;

#endif

  if (!offset_quark1)

    offset_quark1 = g_quark_from_static_string("GroupMixinClassOffsetQuark");

  return offset_quark1;

}

/**

 * gabble_group_mixin_get_offset_quark:

 *

 * Returns: the quark used for storing mixin offset on a GObject

 */

GQuark

gabble_group_mixin_get_offset_quark ()

{

#ifndef EMULATOR

  static GQuark offset_quark = 0;

#endif

  if (!offset_quark)

    offset_quark = g_quark_from_static_string("GroupMixinOffsetQuark");

  return offset_quark;

}

void gabble_group_mixin_class_init (GObjectClass *obj_cls,

                                    glong offset,

                                    GabbleGroupMixinAddMemberFunc add_func,

                                    GabbleGroupMixinRemMemberFunc rem_func)

{

  GabbleGroupMixinClass *mixin_cls;

  g_assert (G_IS_OBJECT_CLASS (obj_cls));

  g_type_set_qdata (G_OBJECT_CLASS_TYPE (obj_cls),

                    GABBLE_GROUP_MIXIN_CLASS_OFFSET_QUARK,

                    GINT_TO_POINTER (offset));

  mixin_cls = GABBLE_GROUP_MIXIN_CLASS (obj_cls);

  mixin_cls->add_member = add_func;

  mixin_cls->remove_member = rem_func;

  mixin_cls->group_flags_changed_signal_id =

    g_signal_new ("group-flags-changed",

                  G_OBJECT_CLASS_TYPE (obj_cls),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  group_mixin_marshal_VOID__UINT_UINT,

                  G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);

  mixin_cls->members_changed_signal_id =

    g_signal_new ("members-changed",

                  G_OBJECT_CLASS_TYPE (obj_cls),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  group_mixin_marshal_VOID__STRING_BOXED_BOXED_BOXED_BOXED_UINT_UINT,

                  G_TYPE_NONE, 7, G_TYPE_STRING, DBUS_TYPE_G_UINT_ARRAY, DBUS_TYPE_G_UINT_ARRAY, DBUS_TYPE_G_UINT_ARRAY, DBUS_TYPE_G_UINT_ARRAY, G_TYPE_UINT, G_TYPE_UINT);

}

void gabble_group_mixin_init (GObject *obj,

                              glong offset,

                              GabbleHandleRepo *handle_repo,

                              GabbleHandle self_handle)

{

  GabbleGroupMixin *mixin;

  g_assert (G_IS_OBJECT (obj));

  g_type_set_qdata (G_OBJECT_TYPE (obj),

                    GABBLE_GROUP_MIXIN_OFFSET_QUARK,

                    GINT_TO_POINTER (offset));

  mixin = GABBLE_GROUP_MIXIN (obj);

  mixin->handle_repo = handle_repo;

  mixin->self_handle = self_handle;

  mixin->group_flags = 0;

  mixin->members = handle_set_new (handle_repo, TP_HANDLE_TYPE_CONTACT);

  mixin->local_pending = handle_set_new (handle_repo, TP_HANDLE_TYPE_CONTACT);

  mixin->remote_pending = handle_set_new (handle_repo, TP_HANDLE_TYPE_CONTACT);

  mixin->priv = g_new0 (GabbleGroupMixinPrivate, 1);

  mixin->priv->handle_owners = g_hash_table_new (g_direct_hash, g_direct_equal);

  mixin->priv->actors = handle_set_new (handle_repo, TP_HANDLE_TYPE_CONTACT);

}

static void

handle_owners_foreach_unref (gpointer key,

                             gpointer value,

                             gpointer user_data)

{

  GabbleGroupMixin *mixin = user_data;

  gabble_handle_unref (mixin->handle_repo, TP_HANDLE_TYPE_CONTACT,

                       GPOINTER_TO_UINT (key));

  gabble_handle_unref (mixin->handle_repo, TP_HANDLE_TYPE_CONTACT,

                       GPOINTER_TO_UINT (value));

}

void gabble_group_mixin_finalize (GObject *obj)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  handle_set_destroy (mixin->priv->actors);

  g_hash_table_foreach (mixin->priv->handle_owners,

                        handle_owners_foreach_unref,

                        mixin);

  g_hash_table_destroy (mixin->priv->handle_owners);

  g_free (mixin->priv);

  handle_set_destroy (mixin->members);

  handle_set_destroy (mixin->local_pending);

  handle_set_destroy (mixin->remote_pending);

}

gboolean

gabble_group_mixin_get_self_handle (GObject *obj, guint *ret, GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  if (handle_set_is_member (mixin->members, mixin->self_handle) ||

      handle_set_is_member (mixin->local_pending, mixin->self_handle) ||

      handle_set_is_member (mixin->remote_pending, mixin->self_handle))

    {

      *ret = mixin->self_handle;

    }

  else

    {

      *ret = 0;

    }

  return TRUE;

}

gboolean

gabble_group_mixin_get_group_flags (GObject *obj, guint *ret, GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  *ret = mixin->group_flags;

  return TRUE;

}

gboolean

gabble_group_mixin_add_members (GObject *obj, const GArray *contacts, const gchar *message, GError **error)

{

  GabbleGroupMixinClass *mixin_cls = GABBLE_GROUP_MIXIN_CLASS (G_OBJECT_GET_CLASS (obj));

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  guint i;

  GabbleHandle handle;

  /* reject invalid handles */

  if (!gabble_handles_are_valid (mixin->handle_repo,

                                 TP_HANDLE_TYPE_CONTACT,

                                 contacts,

                                 FALSE,

                                 error))

    return FALSE;

  /* check that adding is allowed by flags */

  for (i = 0; i < contacts->len; i++)

    {

      handle = g_array_index (contacts, GabbleHandle, i);

      if ((mixin->group_flags & TP_CHANNEL_GROUP_FLAG_CAN_ADD) == 0 &&

          !handle_set_is_member (mixin->local_pending, handle))

        {

          gabble_debug (DEBUG_FLAG, "handle %u cannot be added to members without GROUP_FLAG_CAN_ADD",

              handle);

          g_set_error (error, TELEPATHY_ERRORS, PermissionDenied,

              "handle %u cannot be added to members without GROUP_FLAG_CAN_ADD",

              handle);

          return FALSE;

        }

    }

  /* add handle by handle */

  for (i = 0; i < contacts->len; i++)

    {

      handle = g_array_index (contacts, GabbleHandle, i);

      if (handle_set_is_member (mixin->members, handle))

        {

          gabble_debug (DEBUG_FLAG, "handle %u is already a member, skipping", handle);

          continue;

        }

      if (!mixin_cls->add_member (obj, handle, message, error))

        {

          return FALSE;

        }

    }

  return TRUE;

}

gboolean

gabble_group_mixin_remove_members (GObject *obj, const GArray *contacts, const gchar *message, GError **error)

{

  GabbleGroupMixinClass *mixin_cls = GABBLE_GROUP_MIXIN_CLASS (G_OBJECT_GET_CLASS (obj));

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  guint i;

  GabbleHandle handle;

  /* reject invalid handles */

  if (!gabble_handles_are_valid (mixin->handle_repo,

                                 TP_HANDLE_TYPE_CONTACT,

                                 contacts,

                                 FALSE,

                                 error))

    return FALSE;

  /* check removing is allowed by flags */

  for (i = 0; i < contacts->len; i++)

    {

      handle = g_array_index (contacts, GabbleHandle, i);

      if (handle_set_is_member (mixin->members, handle))

        {

          if ((mixin->group_flags & TP_CHANNEL_GROUP_FLAG_CAN_REMOVE) == 0)

            {

              gabble_debug (DEBUG_FLAG, "handle %u cannot be removed from members without GROUP_FLAG_CAN_REMOVE",

                  handle);

              g_set_error (error, TELEPATHY_ERRORS, PermissionDenied,

                  "handle %u cannot be removed from members without GROUP_FLAG_CAN_REMOVE",

                  handle);

              return FALSE;

            }

        }

      else if (handle_set_is_member (mixin->remote_pending, handle))

        {

          if ((mixin->group_flags & TP_CHANNEL_GROUP_FLAG_CAN_RESCIND) == 0)

            {

              gabble_debug (DEBUG_FLAG, "handle %u cannot be removed from remote pending without GROUP_FLAG_CAN_RESCIND",

                  handle);

              g_set_error (error, TELEPATHY_ERRORS, PermissionDenied,

                  "handle %u cannot be removed from remote pending without GROUP_FLAG_CAN_RESCIND",

                  handle);

              return FALSE;

            }

        }

      else if (!handle_set_is_member (mixin->local_pending, handle))

        {

          gabble_debug (DEBUG_FLAG, "handle %u is not a current or pending member",

                   handle);

          g_set_error (error, TELEPATHY_ERRORS, NotAvailable,

              "handle %u is not a current or pending member", handle);

          return FALSE;

        }

    }

  /* remove handle by handle */

  for (i = 0; i < contacts->len; i++)

    {

      handle = g_array_index (contacts, GabbleHandle, i);

      if (!mixin_cls->remove_member (obj, handle, message, error))

        {

          return FALSE;

        }

    }

  return TRUE;

}

gboolean

gabble_group_mixin_get_members (GObject *obj, GArray **ret, GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  *ret = handle_set_to_array (mixin->members);

  return TRUE;

}

gboolean

gabble_group_mixin_get_local_pending_members (GObject *obj, GArray **ret, GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  *ret = handle_set_to_array (mixin->local_pending);

  return TRUE;

}

gboolean

gabble_group_mixin_get_remote_pending_members (GObject *obj, GArray **ret, GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  *ret = handle_set_to_array (mixin->remote_pending);

  return TRUE;

}

gboolean

gabble_group_mixin_get_all_members (GObject *obj, GArray **ret, GArray **ret1, GArray **ret2, GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  *ret = handle_set_to_array (mixin->members);

  *ret1 = handle_set_to_array (mixin->local_pending);

  *ret2 = handle_set_to_array (mixin->remote_pending);

  return TRUE;

}

gboolean

gabble_group_mixin_get_handle_owners (GObject *obj,

                                      const GArray *handles,

                                      GArray **ret,

                                      GError **error)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  GabbleGroupMixinPrivate *priv = mixin->priv;

  guint i;

  if ((mixin->group_flags &

        TP_CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES) == 0)

    {

      g_set_error (error, TELEPATHY_ERRORS, NotAvailable,

          "channel doesn't have channel specific handles");

      return FALSE;

    }

  if (!gabble_handles_are_valid (mixin->handle_repo, TP_HANDLE_TYPE_CONTACT,

                                 handles, FALSE, error))

    {

      return FALSE;

    }

  *ret = g_array_sized_new (FALSE, FALSE, sizeof (GabbleHandle), handles->len);

  for (i = 0; i < handles->len; i++)

    {

      GabbleHandle local_handle = g_array_index (handles, GabbleHandle, i);

      GabbleHandle owner_handle;

      if (!handle_set_is_member (mixin->members, local_handle))

        {

          g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,

              "handle %u is not a member", local_handle);

          g_array_free (*ret, TRUE);

          *ret = NULL;

          return FALSE;

        }

      owner_handle = GPOINTER_TO_UINT (

          g_hash_table_lookup (priv->handle_owners,

                               GUINT_TO_POINTER (local_handle)));

      g_array_append_val (*ret, owner_handle);

    }

  return TRUE;

}

#define GFTS_APPEND_FLAG_IF_SET(flag) \

  if (flags & flag) \

    { \

      if (i++ > 0) \

        g_string_append (str, "|"); \

      g_string_append (str, #flag + 22); \

    }

static gchar *

group_flags_to_string (TpChannelGroupFlags flags)

{

  gint i = 0;

  GString *str;

  str = g_string_new ("[" ANSI_BOLD_OFF);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_CAN_ADD);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_CAN_REMOVE);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_CAN_RESCIND);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_MESSAGE_ADD);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_MESSAGE_REMOVE);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_MESSAGE_ACCEPT);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_MESSAGE_REJECT);

  GFTS_APPEND_FLAG_IF_SET (TP_CHANNEL_GROUP_FLAG_MESSAGE_RESCIND);

  g_string_append (str, ANSI_BOLD_ON "]");

  return g_string_free (str, FALSE);

}

/**

 * gabble_group_mixin_change_flags:

 *

 * Request a change to be made to the flags. Emits the

 * signal with the changes which were made.

 */

void

gabble_group_mixin_change_flags (GObject *obj,

                                 TpChannelGroupFlags add,

                                 TpChannelGroupFlags remove)

{

  GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (obj);

  GabbleGroupMixinClass *mixin_cls = GABBLE_GROUP_MIXIN_CLASS (G_OBJECT_GET_CLASS (obj));

  TpChannelGroupFlags added, removed;

  added = add & ~mixin->group_flags;

  mixin->group_flags |= added;

  removed = remove & mixin->group_flags;

  mixin->group_flags &= ~removed;

  if (add != 0 || remove != 0)

    {

      gchar *str_added, *str_removed, *str_flags;

      if (DEBUGGING)

        {

          str_added = group_flags_to_string (added);

          str_removed = group_flags_to_string (removed);

          str_flags = group_flags_to_string (mixin->group_flags);

          g_message (ANSI_BOLD_ON ANSI_FG_WHITE

                  "%s: emitting group flags changed\n"