#include <gio/gio.h>

#include <gio/gunixsocketaddress.h>

#include <glib/gstdio.h>

#include <string.h>

#include "gdbus-sessionbus.h"

static gboolean

time_out (gpointer unused G_GNUC_UNUSED)

{

  g_error ("Timed out");

  /* not reached */

  return FALSE;

}

static guint

add_timeout (guint seconds)

{

#ifdef G_OS_UNIX

  /* Safety-catch against the main loop having blocked */

  alarm (seconds + 5);

#endif

  return g_timeout_add_seconds (seconds, time_out, NULL);

}

static void

cancel_timeout (guint timeout_id)

{

#ifdef G_OS_UNIX

  alarm (0);

#endif

  g_source_remove (timeout_id);

}

/* Markup printing {{{1 */

/* This used to be part of GLib, but it was removed before the stable

 * release because it wasn't generally useful.  We want it here, though.

 */

static void

indent_string (GString *string,

               gint     indent)

{

  while (indent--)

    g_string_append_c (string, ' ');

}

static GString *

g_menu_markup_print_string (GString    *string,

                            GMenuModel *model,

                            gint        indent,

                            gint        tabstop)

{

  gboolean need_nl = FALSE;

  gint i, n;

  if G_UNLIKELY (string == NULL)

    string = g_string_new (NULL);

  n = g_menu_model_get_n_items (model);

  for (i = 0; i < n; i++)

    {

      GMenuAttributeIter *attr_iter;

      GMenuLinkIter *link_iter;

      GString *contents;

      GString *attrs;

      attr_iter = g_menu_model_iterate_item_attributes (model, i);

      link_iter = g_menu_model_iterate_item_links (model, i);

      contents = g_string_new (NULL);

      attrs = g_string_new (NULL);

      while (g_menu_attribute_iter_next (attr_iter))

        {

          const char *name = g_menu_attribute_iter_get_name (attr_iter);

          GVariant *value = g_menu_attribute_iter_get_value (attr_iter);

          if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))

            {

              gchar *str;

              str = g_markup_printf_escaped (" %s='%s'", name, g_variant_get_string (value, NULL));

              g_string_append (attrs, str);

              g_free (str);

            }

          else

            {

              gchar *printed;

              gchar *str;

              const gchar *type;

              printed = g_variant_print (value, TRUE);

              type = g_variant_type_peek_string (g_variant_get_type (value));

              str = g_markup_printf_escaped ("<attribute name='%s' type='%s'>%s</attribute>\n", name, type, printed);

              indent_string (contents, indent + tabstop);

              g_string_append (contents, str);

              g_free (printed);

              g_free (str);

            }

          g_variant_unref (value);

        }

      g_object_unref (attr_iter);

      while (g_menu_link_iter_next (link_iter))

        {

          const gchar *name = g_menu_link_iter_get_name (link_iter);

          GMenuModel *menu = g_menu_link_iter_get_value (link_iter);

          gchar *str;

          if (contents->str[0])

            g_string_append_c (contents, '\n');

          str = g_markup_printf_escaped ("<link name='%s'>\n", name);

          indent_string (contents, indent + tabstop);

          g_string_append (contents, str);

          g_free (str);

          g_menu_markup_print_string (contents, menu, indent + 2 * tabstop, tabstop);

          indent_string (contents, indent + tabstop);

          g_string_append (contents, "</link>\n");

          g_object_unref (menu);

        }

      g_object_unref (link_iter);

      if (contents->str[0])

        {

          indent_string (string, indent);

          g_string_append_printf (string, "<item%s>\n", attrs->str);

          g_string_append (string, contents->str);

          indent_string (string, indent);

          g_string_append (string, "</item>\n");

          need_nl = TRUE;

        }

      else

        {

          if (need_nl)

            g_string_append_c (string, '\n');

          indent_string (string, indent);

          g_string_append_printf (string, "<item%s/>\n", attrs->str);

          need_nl = FALSE;

        }

      g_string_free (contents, TRUE);

      g_string_free (attrs, TRUE);

    }

  return string;

}

/* TestItem {{{1 */

/* This utility struct is used by both the RandomMenu and MirrorMenu

 * class implementations below.

 */

typedef struct {

  GHashTable *attributes;

  GHashTable *links;

} TestItem;

static TestItem *

test_item_new (GHashTable *attributes,

               GHashTable *links)

{

  TestItem *item;

  item = g_slice_new (TestItem);

  item->attributes = g_hash_table_ref (attributes);

  item->links = g_hash_table_ref (links);

  return item;

}

static void

test_item_free (gpointer data)

{

  TestItem *item = data;

  g_hash_table_unref (item->attributes);

  g_hash_table_unref (item->links);

  g_slice_free (TestItem, item);

}

/* RandomMenu {{{1 */

#define MAX_ITEMS 5

#define TOP_ORDER 4

typedef struct {

  GMenuModel parent_instance;

  GSequence *items;

  gint order;

} RandomMenu;

typedef GMenuModelClass RandomMenuClass;

static GType random_menu_get_type (void);

G_DEFINE_TYPE (RandomMenu, random_menu, G_TYPE_MENU_MODEL)

static gboolean

random_menu_is_mutable (GMenuModel *model)

{

  return TRUE;

}

static gint

random_menu_get_n_items (GMenuModel *model)

{

  RandomMenu *menu = (RandomMenu *) model;

  return g_sequence_get_length (menu->items);

}

static void

random_menu_get_item_attributes (GMenuModel  *model,

                                 gint         position,

                                 GHashTable **table)

{

  RandomMenu *menu = (RandomMenu *) model;

  TestItem *item;

  item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));

  *table = g_hash_table_ref (item->attributes);

}

static void

random_menu_get_item_links (GMenuModel  *model,

                            gint         position,

                            GHashTable **table)

{

  RandomMenu *menu = (RandomMenu *) model;

  TestItem *item;

  item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));

  *table = g_hash_table_ref (item->links);

}

static void

random_menu_finalize (GObject *object)

{

  RandomMenu *menu = (RandomMenu *) object;

  g_sequence_free (menu->items);

  G_OBJECT_CLASS (random_menu_parent_class)

    ->finalize (object);

}

static void

random_menu_init (RandomMenu *menu)

{

}

static void

random_menu_class_init (GMenuModelClass *class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (class);

  class->is_mutable = random_menu_is_mutable;

  class->get_n_items = random_menu_get_n_items;

  class->get_item_attributes = random_menu_get_item_attributes;

  class->get_item_links = random_menu_get_item_links;

  object_class->finalize = random_menu_finalize;

}

static RandomMenu * random_menu_new (GRand *rand, gint order);

static void

random_menu_change (RandomMenu *menu,

                    GRand      *rand)

{

  gint position, removes, adds;

  GSequenceIter *point;

  gint n_items;

  gint i;

  n_items = g_sequence_get_length (menu->items);

  do

    {

      position = g_rand_int_range (rand, 0, n_items + 1);

      removes = g_rand_int_range (rand, 0, n_items - position + 1);

      adds = g_rand_int_range (rand, 0, MAX_ITEMS - (n_items - removes) + 1);

    }

  while (removes == 0 && adds == 0);

  point = g_sequence_get_iter_at_pos (menu->items, position + removes);

  if (removes)

    {

      GSequenceIter *start;

      start = g_sequence_get_iter_at_pos (menu->items, position);

      g_sequence_remove_range (start, point);

    }

  for (i = 0; i < adds; i++)

    {

      const gchar *label;

      GHashTable *links;

      GHashTable *attributes;

      attributes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);

      links = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref);

      if (menu->order > 0 && g_rand_boolean (rand))

        {

          RandomMenu *child;

	  const gchar *subtype;

          child = random_menu_new (rand, menu->order - 1);

          if (g_rand_boolean (rand))

            {

              subtype = G_MENU_LINK_SECTION;

              /* label some section headers */

              if (g_rand_boolean (rand))

                label = "Section";

              else

                label = NULL;

            }

          else

            {

              /* label all submenus */

              subtype = G_MENU_LINK_SUBMENU;

              label = "Submenu";

            }

          g_hash_table_insert (links, g_strdup (subtype), child);

        }

      else

        /* label all terminals */

        label = "Menu Item";

      if (label)

        g_hash_table_insert (attributes, g_strdup ("label"), g_variant_ref_sink (g_variant_new_string (label)));

      g_sequence_insert_before (point, test_item_new (attributes, links));

      g_hash_table_unref (links);

      g_hash_table_unref (attributes);

    }

  g_menu_model_items_changed (G_MENU_MODEL (menu), position, removes, adds);

}

static RandomMenu *

random_menu_new (GRand *rand,

                 gint   order)

{

  RandomMenu *menu;

  menu = g_object_new (random_menu_get_type (), NULL);

  menu->items = g_sequence_new (test_item_free);

  menu->order = order;

  random_menu_change (menu, rand);

  return menu;

}

/* MirrorMenu {{{1 */

typedef struct {

  GMenuModel parent_instance;

  GMenuModel *clone_of;

  GSequence *items;

  gulong handler_id;

} MirrorMenu;

typedef GMenuModelClass MirrorMenuClass;

static GType mirror_menu_get_type (void);

G_DEFINE_TYPE (MirrorMenu, mirror_menu, G_TYPE_MENU_MODEL)

static gboolean

mirror_menu_is_mutable (GMenuModel *model)

{

  MirrorMenu *menu = (MirrorMenu *) model;

  return menu->handler_id != 0;

}

static gint

mirror_menu_get_n_items (GMenuModel *model)

{

  MirrorMenu *menu = (MirrorMenu *) model;

  return g_sequence_get_length (menu->items);

}

static void

mirror_menu_get_item_attributes (GMenuModel  *model,

                                 gint         position,

                                 GHashTable **table)

{

  MirrorMenu *menu = (MirrorMenu *) model;

  TestItem *item;

  item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));

  *table = g_hash_table_ref (item->attributes);

}

static void

mirror_menu_get_item_links (GMenuModel  *model,

                            gint         position,

                            GHashTable **table)

{

  MirrorMenu *menu = (MirrorMenu *) model;

  TestItem *item;

  item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));

  *table = g_hash_table_ref (item->links);

}

static void

mirror_menu_finalize (GObject *object)

{

  MirrorMenu *menu = (MirrorMenu *) object;

  if (menu->handler_id)

    g_signal_handler_disconnect (menu->clone_of, menu->handler_id);

  g_sequence_free (menu->items);

  g_object_unref (menu->clone_of);

  G_OBJECT_CLASS (mirror_menu_parent_class)

    ->finalize (object);

}

static void

mirror_menu_init (MirrorMenu *menu)

{

}

static void

mirror_menu_class_init (GMenuModelClass *class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (class);

  class->is_mutable = mirror_menu_is_mutable;

  class->get_n_items = mirror_menu_get_n_items;

  class->get_item_attributes = mirror_menu_get_item_attributes;

  class->get_item_links = mirror_menu_get_item_links;

  object_class->finalize = mirror_menu_finalize;

}

static MirrorMenu * mirror_menu_new (GMenuModel *clone_of);

static void

mirror_menu_changed (GMenuModel *model,

                     gint        position,

                     gint        removed,

                     gint        added,

                     gpointer    user_data)

{

  MirrorMenu *menu = user_data;

  GSequenceIter *point;

  gint i;

  g_assert (model == menu->clone_of);

  point = g_sequence_get_iter_at_pos (menu->items, position + removed);

  if (removed)

    {

      GSequenceIter *start;

      start = g_sequence_get_iter_at_pos (menu->items, position);

      g_sequence_remove_range (start, point);

    }

  for (i = position; i < position + added; i++)

    {

      GMenuAttributeIter *attr_iter;

      GMenuLinkIter *link_iter;

      GHashTable *links;

      GHashTable *attributes;

      const gchar *name;

      GMenuModel *child;

      GVariant *value;

      attributes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);

      links = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref);

      attr_iter = g_menu_model_iterate_item_attributes (model, i);

      while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))

        {

          g_hash_table_insert (attributes, g_strdup (name), value);

        }

      g_object_unref (attr_iter);

      link_iter = g_menu_model_iterate_item_links (model, i);

      while (g_menu_link_iter_get_next (link_iter, &name, &child))

        {

          g_hash_table_insert (links, g_strdup (name), mirror_menu_new (child));

          g_object_unref (child);

        }

      g_object_unref (link_iter);

      g_sequence_insert_before (point, test_item_new (attributes, links));

      g_hash_table_unref (attributes);

      g_hash_table_unref (links);

    }

  g_menu_model_items_changed (G_MENU_MODEL (menu), position, removed, added);

}

static MirrorMenu *

mirror_menu_new (GMenuModel *clone_of)

{

  MirrorMenu *menu;

  menu = g_object_new (mirror_menu_get_type (), NULL);

  menu->items = g_sequence_new (test_item_free);

  menu->clone_of = g_object_ref (clone_of);

  if (g_menu_model_is_mutable (clone_of))

    menu->handler_id = g_signal_connect (clone_of, "items-changed", G_CALLBACK (mirror_menu_changed), menu);

  mirror_menu_changed (clone_of, 0, 0, g_menu_model_get_n_items (clone_of), menu);

  return menu;

}

/* check_menus_equal(), assert_menus_equal() {{{1 */

static gboolean

check_menus_equal (GMenuModel *a,

                   GMenuModel *b)

{

  gboolean equal = TRUE;

  gint a_n, b_n;

  gint i;

  a_n = g_menu_model_get_n_items (a);

  b_n = g_menu_model_get_n_items (b);

  if (a_n != b_n)

    return FALSE;

  for (i = 0; i < a_n; i++)

    {

      GMenuAttributeIter *attr_iter;

      GVariant *a_value, *b_value;

      GMenuLinkIter *link_iter;

      GMenuModel *a_menu, *b_menu;

      const gchar *name;

      attr_iter = g_menu_model_iterate_item_attributes (a, i);

      while (g_menu_attribute_iter_get_next (attr_iter, &name, &a_value))

        {

          b_value = g_menu_model_get_item_attribute_value (b, i, name, NULL);

          equal &= b_value && g_variant_equal (a_value, b_value);

          if (b_value)

            g_variant_unref (b_value);

          g_variant_unref (a_value);

        }

      g_object_unref (attr_iter);

      attr_iter = g_menu_model_iterate_item_attributes (b, i);

      while (g_menu_attribute_iter_get_next (attr_iter, &name, &b_value))

        {

          a_value = g_menu_model_get_item_attribute_value (a, i, name, NULL);

          equal &= a_value && g_variant_equal (a_value, b_value);

          if (a_value)

            g_variant_unref (a_value);

          g_variant_unref (b_value);

        }

      g_object_unref (attr_iter);

      link_iter = g_menu_model_iterate_item_links (a, i);

      while (g_menu_link_iter_get_next (link_iter, &name, &a_menu))

        {

          b_menu = g_menu_model_get_item_link (b, i, name);

          equal &= b_menu && check_menus_equal (a_menu, b_menu);

          if (b_menu)

            g_object_unref (b_menu);

          g_object_unref (a_menu);

        }

      g_object_unref (link_iter);

      link_iter = g_menu_model_iterate_item_links (b, i);

      while (g_menu_link_iter_get_next (link_iter, &name, &b_menu))

        {

          a_menu = g_menu_model_get_item_link (a, i, name);

          equal &= a_menu && check_menus_equal (a_menu, b_menu);

          if (a_menu)

            g_object_unref (a_menu);

          g_object_unref (b_menu);

        }

      g_object_unref (link_iter);

    }

  return equal;

}

static void

assert_menus_equal (GMenuModel *a,

                    GMenuModel *b)

{

  if (!check_menus_equal (a, b))

    {

      GString *string;

      string = g_string_new ("\n  \n");

      g_menu_markup_print_string (string, G_MENU_MODEL (a), 4, 2);

      g_string_append (string, "  \n\n-------------\n  \n");

      g_menu_markup_print_string (string, G_MENU_MODEL (b), 4, 2);

      g_string_append (string, "  \n");

      g_error ("%s", string->str);

    }

}

static void

assert_menuitem_equal (GMenuItem  *item,

                       GMenuModel *model,

                       gint        index)

{

  GMenuAttributeIter *attr_iter;

  GMenuLinkIter *link_iter;

  const gchar *name;

  GVariant *value;

  GMenuModel *linked_model;

  /* NOTE we can't yet test whether item has attributes or links that

   * are not in the model, because there's no iterator API for menu

   * items */

  attr_iter = g_menu_model_iterate_item_attributes (model, index);

  while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))

    {

      GVariant *item_value;

      item_value = g_menu_item_get_attribute_value (item, name, g_variant_get_type (value));

      g_assert (item_value && g_variant_equal (item_value, value));

      g_variant_unref (item_value);

      g_variant_unref (value);

    }

  link_iter = g_menu_model_iterate_item_links (model, index);

  while (g_menu_link_iter_get_next (link_iter, &name, &linked_model))

    {

      GMenuModel *item_linked_model;

      item_linked_model = g_menu_item_get_link (item, name);

      g_assert (linked_model == item_linked_model);

      g_object_unref (item_linked_model);

      g_object_unref (linked_model);

    }

  g_object_unref (attr_iter);

  g_object_unref (link_iter);

}

/* Test cases {{{1 */

static void

test_equality (void)

{

  GRand *randa, *randb;

  guint32 seed;

  gint i;

  seed = g_test_rand_int ();

  randa = g_rand_new_with_seed (seed);

  randb = g_rand_new_with_seed (seed);

  for (i = 0; i < 500; i++)

    {

      RandomMenu *a, *b;

      a = random_menu_new (randa, TOP_ORDER);

      b = random_menu_new (randb, TOP_ORDER);

      assert_menus_equal (G_MENU_MODEL (a), G_MENU_MODEL (b));

      g_object_unref (b);

      g_object_unref (a);

    }

  g_rand_int (randa);

  for (i = 0; i < 500;)

    {

      RandomMenu *a, *b;

      a = random_menu_new (randa, TOP_ORDER);

      b = random_menu_new (randb, TOP_ORDER);

      if (check_menus_equal (G_MENU_MODEL (a), G_MENU_MODEL (b)))

        {

          /* by chance, they may really be equal.  double check. */

          GString *as, *bs;

          as = g_menu_markup_print_string (NULL, G_MENU_MODEL (a), 4, 2);

          bs = g_menu_markup_print_string (NULL, G_MENU_MODEL (b), 4, 2);

          g_assert_cmpstr (as->str, ==, bs->str);

          g_string_free (bs, TRUE);

          g_string_free (as, TRUE);

          /* we're here because randa and randb just generated equal

           * menus.  they may do it again, so throw away randb and make

           * a fresh one.

           */

          g_rand_free (randb);

          randb = g_rand_new_with_seed (g_rand_int (randa));

        }

      else

        /* make sure we get enough unequals (ie: no GRand failure) */

        i++;

      g_object_unref (b);

      g_object_unref (a);

    }

  g_rand_free (randb);

  g_rand_free (randa);

}

static void

test_random (void)

{

  RandomMenu *random;

  MirrorMenu *mirror;

  GRand *rand;

  gint i;

  rand = g_rand_new_with_seed (g_test_rand_int ());

  random = random_menu_new (rand, TOP_ORDER);

  mirror = mirror_menu_new (G_MENU_MODEL (random));

  for (i = 0; i < 500; i++)

    {

      assert_menus_equal (G_MENU_MODEL (random), G_MENU_MODEL (mirror));

      random_menu_change (random, rand);

    }

  g_object_unref (mirror);

  g_object_unref (random);

  g_rand_free (rand);

}

typedef struct

{

  GDBusConnection *client_connection;

  GDBusConnection *server_connection;

  GDBusServer *server;

  GThread *service_thread;

  GMutex service_loop_lock;

  GCond service_loop_cond;

  GMainLoop *service_loop;

  GMainLoop *loop;

} PeerConnection;

static gboolean

on_new_connection (GDBusServer *server,

                   GDBusConnection *connection,

                   gpointer user_data)

{

  PeerConnection *data = user_data;

  data->server_connection = g_object_ref (connection);

  g_main_loop_quit (data->loop);

  return TRUE;

}

static void

create_service_loop (GMainContext   *service_context,

                     PeerConnection *data)

{

  g_assert (data->service_loop == NULL);

  g_mutex_lock (&data->service_loop_lock);

  data->service_loop = g_main_loop_new (service_context, FALSE);

  g_cond_broadcast (&data->service_loop_cond);

  g_mutex_unlock (&data->service_loop_lock);

}

static void

teardown_service_loop (PeerConnection *data)

{

  g_mutex_lock (&data->service_loop_lock);

  g_clear_pointer (&data->service_loop, g_main_loop_unref);

  g_mutex_unlock (&data->service_loop_lock);

}

static void

await_service_loop (PeerConnection *data)

{

  g_mutex_lock (&data->service_loop_lock);

  while (data->service_loop == NULL)

    g_cond_wait (&data->service_loop_cond, &data->service_loop_lock);

  g_mutex_unlock (&data->service_loop_lock);

}

static gpointer

service_thread_func (gpointer user_data)

{

  PeerConnection *data = user_data;

  GMainContext *service_context;

  GError *error;

  gchar *address;

  gchar *tmpdir;

  GDBusServerFlags flags;

  gchar *guid;

  service_context = g_main_context_new ();

  g_main_context_push_thread_default (service_context);

  tmpdir = NULL;

  flags = G_DBUS_SERVER_FLAGS_NONE;

#ifdef G_OS_UNIX

  if (g_unix_socket_address_abstract_names_supported ())

    address = g_strdup ("unix:tmpdir=/tmp/test-dbus-peer");

  else

    {

      tmpdir = g_dir_make_tmp ("test-dbus-peer-XXXXXX", NULL);

      address = g_strdup_printf ("unix:tmpdir=%s", tmpdir);

    }

#else

  address = g_strdup ("nonce-tcp:");

  flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;

#endif

  guid = g_dbus_generate_guid ();

  error = NULL;

  data->server = g_dbus_server_new_sync (address,

                                         flags,

                                         guid,

                                         NULL,

                                         NULL,

                                         &error);

  g_assert_no_error (error);

  g_free (address);

  g_free (guid);

  g_signal_connect (data->server,

                    "new-connection",

                    G_CALLBACK (on_new_connection),

                    data);

  g_dbus_server_start (data->server);

  create_service_loop (service_context, data);

  g_main_loop_run (data->service_loop);

  g_main_context_pop_thread_default (service_context);

  teardown_service_loop (data);

  g_main_context_unref (service_context);

  if (tmpdir)

    {

      g_rmdir (tmpdir);

      g_free (tmpdir);

    }

  return NULL;

}

static void

peer_connection_up (PeerConnection *data)

{

  GError *error;

  memset (data, '\0', sizeof (PeerConnection));

  data->loop = g_main_loop_new (NULL, FALSE);

  g_mutex_init (&data->service_loop_lock);