/*
 * Copyright (C) 2013 Intel, Inc
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Author: Thomas Wood <thomas.wood@intel.com>
 *
 */

#include "cc-sharing-panel.h"
#include "cc-hostname-entry.h"
#include "cc-list-row.h"

#include "cc-sharing-resources.h"
#include "cc-remote-login.h"
#include "file-share-properties.h"
#include "cc-media-sharing.h"
#include "cc-sharing-networks.h"
#include "cc-gnome-remote-desktop.h"
#include "cc-tls-certificate.h"
#include "cc-systemd-service.h"
#include "org.gnome.SettingsDaemon.Sharing.h"

#ifdef GDK_WINDOWING_WAYLAND
#include <gdk/wayland/gdkwayland.h>
#endif
#include <glib/gi18n.h>

#define GCR_API_SUBJECT_TO_CHANGE
#include <gcr/gcr-base.h>

#include <pwquality.h>

#include <config.h>

static void cc_sharing_panel_setup_label_with_hostname (CcSharingPanel *self, GtkWidget *label);
static GtkWidget *cc_sharing_panel_new_media_sharing_row (const char     *uri_or_path,
                                                          CcSharingPanel *self);

#define FILE_SHARING_SCHEMA_ID "org.gnome.desktop.file-sharing"
#define GNOME_REMOTE_DESKTOP_SCHEMA_ID "org.gnome.desktop.remote-desktop"
#define GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID "org.gnome.desktop.remote-desktop.rdp"

#define REMOTE_DESKTOP_STORE_CREDENTIALS_TIMEOUT_S 1

#define REMOTE_DESKTOP_SERVICE "gnome-remote-desktop.service"

struct _CcSharingPanel
{
  CcPanel parent_instance;

  GtkWidget *hostname_entry;
  GtkWidget *main_list_box;
  GtkWidget *master_switch;
  GtkWidget *media_sharing_dialog;
  GtkWidget *media_sharing_headerbar;
  GtkWidget *media_sharing_row;
  GtkWidget *media_sharing_switch;
  GtkWidget *personal_file_sharing_dialog;
  GtkWidget *personal_file_sharing_grid;
  GtkWidget *personal_file_sharing_headerbar;
  GtkWidget *personal_file_sharing_label;
  GtkWidget *personal_file_sharing_password_entry;
  GtkWidget *personal_file_sharing_password_label;
  GtkWidget *personal_file_sharing_require_password_switch;
  GtkWidget *personal_file_sharing_row;
  GtkWidget *personal_file_sharing_switch;
  GtkWidget *remote_login_dialog;
  GtkWidget *remote_login_label;
  GtkWidget *remote_login_row;
  GtkWidget *remote_login_switch;

  GtkWidget *remote_control_checkbutton;
  GtkWidget *remote_desktop_password_entry;
  GtkWidget *remote_desktop_password_copy;
  GtkWidget *remote_desktop_username_entry;
  GtkWidget *remote_desktop_username_copy;
  GtkWidget *remote_desktop_dialog;
  GtkWidget *remote_desktop_device_name_label;
  GtkWidget *remote_desktop_device_name_copy;
  GtkWidget *remote_desktop_address_label;
  GtkWidget *remote_desktop_address_copy;
  GtkWidget *remote_desktop_row;
  GtkWidget *remote_desktop_switch;
  GtkWidget *remote_desktop_verify_encryption;
  GtkWidget *remote_desktop_fingerprint_dialog;
  GtkWidget *remote_desktop_fingerprint_left;
  GtkWidget *remote_desktop_fingerprint_right;

  GtkWidget *shared_folders_grid;
  GtkWidget *shared_folders_listbox;

  GDBusProxy *sharing_proxy;

  guint remote_desktop_name_watch;
  guint remote_desktop_store_credentials_id;
  GTlsCertificate *remote_desktop_certificate;
};

CC_PANEL_REGISTER (CcSharingPanel, cc_sharing_panel)

#define OFF_IF_VISIBLE(x, y) { if (gtk_widget_is_visible(x) && (y) != NULL && gtk_widget_is_sensitive(y)) gtk_switch_set_active (GTK_SWITCH(y), FALSE); }

static gboolean store_remote_desktop_credentials_timeout (gpointer user_data);

static void
cc_sharing_panel_master_switch_notify (CcSharingPanel *self)
{
  gboolean active;

  active = gtk_switch_get_active (GTK_SWITCH (self->master_switch));

  if (!active)
    {
      /* disable all services if the master switch is not active */
      OFF_IF_VISIBLE(self->media_sharing_row, self->media_sharing_switch);
      OFF_IF_VISIBLE(self->personal_file_sharing_row, self->personal_file_sharing_switch);
      OFF_IF_VISIBLE(self->remote_desktop_row, self->remote_desktop_switch);

      gtk_switch_set_active (GTK_SWITCH (self->remote_login_switch), FALSE);
    }

  gtk_widget_set_sensitive (self->main_list_box, active);
}

static void
cc_sharing_panel_dispose (GObject *object)
{
  CcSharingPanel *self = CC_SHARING_PANEL (object);

  if (self->remote_desktop_name_watch)
    g_bus_unwatch_name (self->remote_desktop_name_watch);
  self->remote_desktop_name_watch = 0;

  if (self->media_sharing_dialog)
    {
      gtk_window_destroy (GTK_WINDOW (self->media_sharing_dialog));
      self->media_sharing_dialog = NULL;
    }

  if (self->personal_file_sharing_dialog)
    {
      gtk_window_destroy (GTK_WINDOW (self->personal_file_sharing_dialog));
      self->personal_file_sharing_dialog = NULL;
    }

  if (self->remote_login_dialog)
    {
      gtk_window_destroy (GTK_WINDOW (self->remote_login_dialog));
      self->remote_login_dialog = NULL;
    }

  if (self->remote_desktop_dialog)
    {
      gtk_window_destroy (GTK_WINDOW (self->remote_desktop_dialog));
      self->remote_desktop_dialog = NULL;
    }

  g_clear_object (&self->sharing_proxy);

  if (self->remote_desktop_store_credentials_id)
    {
      g_clear_handle_id (&self->remote_desktop_store_credentials_id,
                         g_source_remove);
      store_remote_desktop_credentials_timeout (self);
    }

  G_OBJECT_CLASS (cc_sharing_panel_parent_class)->dispose (object);
}

static const char *
cc_sharing_panel_get_help_uri (CcPanel *panel)
{
  return "help:gnome-help/prefs-sharing";
}

static void
remote_desktop_show_encryption_fingerprint (CcSharingPanel *self)
{
  g_autoptr(GByteArray) der = NULL;
  g_autoptr(GcrCertificate) gcr_cert = NULL;
  g_autofree char *fingerprint = NULL;
  g_auto(GStrv) fingerprintv = NULL;
  g_autofree char *left_string = NULL;
  g_autofree char *right_string = NULL;

  g_return_if_fail (self->remote_desktop_certificate);

  g_object_get (self->remote_desktop_certificate,
                "certificate", &der, NULL);
  gcr_cert = gcr_simple_certificate_new (der->data, der->len);
  if (!gcr_cert)
    {
      g_warning ("Failed to load GCR TLS certificate representation");
      return;
    }

  fingerprint = gcr_certificate_get_fingerprint_hex (gcr_cert, G_CHECKSUM_SHA256);

  fingerprintv = g_strsplit (fingerprint, " ", -1);
  g_return_if_fail (g_strv_length (fingerprintv) == 32);

  left_string = g_strdup_printf (
    "%s:%s:%s:%s\n"
    "%s:%s:%s:%s\n"
    "%s:%s:%s:%s\n"
    "%s:%s:%s:%s\n",
    fingerprintv[0], fingerprintv[1], fingerprintv[2], fingerprintv[3],
    fingerprintv[8], fingerprintv[9], fingerprintv[10], fingerprintv[11],
    fingerprintv[16], fingerprintv[17], fingerprintv[18], fingerprintv[19],
    fingerprintv[24], fingerprintv[25], fingerprintv[26], fingerprintv[27]);

 right_string = g_strdup_printf (
   "%s:%s:%s:%s\n"
   "%s:%s:%s:%s\n"
   "%s:%s:%s:%s\n"
   "%s:%s:%s:%s\n",
   fingerprintv[4], fingerprintv[5], fingerprintv[6], fingerprintv[7],
   fingerprintv[12], fingerprintv[13], fingerprintv[14], fingerprintv[15],
   fingerprintv[20], fingerprintv[21], fingerprintv[22], fingerprintv[23],
   fingerprintv[28], fingerprintv[29], fingerprintv[30], fingerprintv[31]);

  gtk_label_set_label (GTK_LABEL (self->remote_desktop_fingerprint_left),
                       left_string);
  gtk_label_set_label (GTK_LABEL (self->remote_desktop_fingerprint_right),
                       right_string);

  gtk_window_set_transient_for (GTK_WINDOW (self->remote_desktop_fingerprint_dialog),
                                GTK_WINDOW (self->remote_desktop_dialog));
  gtk_window_present (GTK_WINDOW (self->remote_desktop_fingerprint_dialog));
}

static void
remote_desktop_hide_encryption_fingerprint (CcSharingPanel *self)
{
  gtk_widget_hide (self->remote_desktop_fingerprint_dialog);
}

static void
cc_sharing_panel_class_init (CcSharingPanelClass *klass)
{
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  CcPanelClass *panel_class = CC_PANEL_CLASS (klass);

  object_class->dispose = cc_sharing_panel_dispose;

  panel_class->get_help_uri = cc_sharing_panel_get_help_uri;

  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/sharing/cc-sharing-panel.ui");

  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, hostname_entry);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, shared_folders_grid);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, master_switch);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, main_list_box);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, media_sharing_dialog);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, media_sharing_headerbar);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, media_sharing_row);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_dialog);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_grid);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_headerbar);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_label);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_password_entry);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_password_label);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_require_password_switch);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_row);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_dialog);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_label);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_row);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_switch);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_dialog);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_switch);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_control_checkbutton);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_username_entry);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_username_copy);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_password_entry);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_password_copy);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_device_name_label);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_device_name_copy);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_address_label);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_address_copy);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_verify_encryption);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_fingerprint_dialog);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_row);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_fingerprint_left);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_fingerprint_right);
  gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, shared_folders_listbox);

  gtk_widget_class_bind_template_callback (widget_class, remote_desktop_show_encryption_fingerprint);
  gtk_widget_class_bind_template_callback (widget_class, remote_desktop_hide_encryption_fingerprint);

  g_type_ensure (CC_TYPE_LIST_ROW);
  g_type_ensure (CC_TYPE_HOSTNAME_ENTRY);
}

static void
cc_sharing_panel_run_dialog (CcSharingPanel *self,
                             GtkWidget      *dialog)
{
  GtkWidget *parent;

  /* ensure labels with the hostname are updated if the hostname has changed */
  cc_sharing_panel_setup_label_with_hostname (self,
                                              self->remote_desktop_address_label);
  cc_sharing_panel_setup_label_with_hostname (self, self->remote_login_label);
  cc_sharing_panel_setup_label_with_hostname (self,
                                              self->personal_file_sharing_label);


  parent = cc_shell_get_toplevel (cc_panel_get_shell (CC_PANEL (self)));

  gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
  gtk_window_present (GTK_WINDOW (dialog));
}

static void
cc_sharing_panel_main_list_box_row_activated (CcSharingPanel *self,
                                              GtkListBoxRow  *row)
{
  GtkWidget *dialog;

  if (row == GTK_LIST_BOX_ROW (self->media_sharing_row))
    dialog = self->media_sharing_dialog;
  else if (row == GTK_LIST_BOX_ROW (self->personal_file_sharing_row))
    dialog = self->personal_file_sharing_dialog;
  else if (row == GTK_LIST_BOX_ROW (self->remote_login_row))
    dialog = self->remote_login_dialog;
  else if (row == GTK_LIST_BOX_ROW (self->remote_desktop_row))
    dialog = self->remote_desktop_dialog;
  else
    return;

  gtk_list_box_select_row (GTK_LIST_BOX (self->main_list_box), NULL);

  cc_sharing_panel_run_dialog (self, dialog);
}

static gboolean
cc_sharing_panel_switch_to_label_transform_func (GBinding       *binding,
                                                 const GValue   *source_value,
                                                 GValue         *target_value,
                                                 CcSharingPanel *self)
{
  gboolean active;

  if (!G_VALUE_HOLDS_BOOLEAN (source_value))
    return FALSE;

  if (!G_VALUE_HOLDS_STRING (target_value))
    return FALSE;

  active = g_value_get_boolean (source_value);

  if (active)
    g_value_set_string (target_value, C_("service is enabled", "On"));
  else
    g_value_set_string (target_value, C_("service is disabled", "Off"));

  /* ensure the master switch is active if one of the services is active */
  if (active)
    gtk_switch_set_active (GTK_SWITCH (self->master_switch), TRUE);

  return TRUE;
}

static gboolean
cc_sharing_panel_networks_to_label_transform_func (GBinding       *binding,
                                                   const GValue   *source_value,
                                                   GValue         *target_value,
                                                   CcSharingPanel *self)
{
  CcSharingStatus status;

  if (!G_VALUE_HOLDS_UINT (source_value))
    return FALSE;

  if (!G_VALUE_HOLDS_STRING (target_value))
    return FALSE;

  status = g_value_get_uint (source_value);

  switch (status) {
  case CC_SHARING_STATUS_OFF:
    g_value_set_string (target_value, C_("service is disabled", "Off"));
    break;
  case CC_SHARING_STATUS_ENABLED:
    g_value_set_string (target_value, C_("service is enabled", "Enabled"));
    break;
  case CC_SHARING_STATUS_ACTIVE:
    g_value_set_string (target_value, C_("service is active", "Active"));
    break;
  default:
    return FALSE;
  }

  /* ensure the master switch is active if one of the services is active */
  if (status != CC_SHARING_STATUS_OFF)
    gtk_switch_set_active (GTK_SWITCH (self->master_switch), TRUE);

  return TRUE;
}

static void
cc_sharing_panel_bind_switch_to_label (CcSharingPanel *self,
                                       GtkWidget      *gtkswitch,
                                       GtkWidget      *row)
{
  g_object_bind_property_full (gtkswitch, "active", row, "secondary-label",
                               G_BINDING_SYNC_CREATE,
                               (GBindingTransformFunc) cc_sharing_panel_switch_to_label_transform_func,
                               NULL, self, NULL);
}

static void
cc_sharing_panel_bind_networks_to_label (CcSharingPanel *self,
					 GtkWidget      *networks,
					 GtkWidget      *list_row)
{
  g_object_bind_property_full (networks, "status", list_row, "secondary-label",
                               G_BINDING_SYNC_CREATE,
                               (GBindingTransformFunc) cc_sharing_panel_networks_to_label_transform_func,
                               NULL, self, NULL);
}

static void
cc_sharing_panel_bind_switch_to_widgets (GtkWidget *gtkswitch,
                                         GtkWidget *first_widget,
                                         ...)
{
  va_list w;
  GtkWidget *widget;

  va_start (w, first_widget);

  g_object_bind_property (gtkswitch, "active", first_widget,
                          "sensitive", G_BINDING_SYNC_CREATE);

  while ((widget = va_arg (w, GtkWidget*)))
    {
      g_object_bind_property (gtkswitch, "active", widget,
                              "sensitive", G_BINDING_SYNC_CREATE);
    }

  va_end (w);
}

static void
on_add_folder_dialog_response_cb (GtkDialog      *dialog,
                                  gint            response,
                                  CcSharingPanel *self)
{
  g_autofree gchar *folder = NULL;
  g_autoptr(GFile) file = NULL;
  GtkWidget *child;
  gboolean matching = FALSE;
  gint n_rows = 0;

  if (response != GTK_RESPONSE_ACCEPT)
    goto bail;

  file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
  folder = g_file_get_uri (file);
  if (!folder || g_str_equal (folder, ""))
    goto bail;

  g_debug ("Trying to add %s", folder);

  for (child = gtk_widget_get_first_child (self->shared_folders_listbox);
       child;
       child = gtk_widget_get_next_sibling (child))
    {
      const char *string;

      string = g_object_get_data (G_OBJECT (child), "path");
      matching = (g_strcmp0 (string, folder) == 0);

      if (matching)
        {
          g_debug ("Found a duplicate for %s", folder);
          break;
        }

      n_rows++;
    }

  if (!matching)
    {
      GtkWidget *row = cc_sharing_panel_new_media_sharing_row (folder, self);

      gtk_list_box_insert (GTK_LIST_BOX (self->shared_folders_listbox),
                           row,
                           n_rows - 1);
    }

bail:
  gtk_window_destroy (GTK_WINDOW (dialog));
}

static void
cc_sharing_panel_add_folder (CcSharingPanel *self,
                             GtkListBoxRow  *row)
{
  GtkWidget *dialog;

  if (!GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "is-add")))
    return;

  dialog = gtk_file_chooser_dialog_new (_("Choose a Folder"),
                                        GTK_WINDOW (self->media_sharing_dialog),
                                        GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                                        _("_Cancel"), GTK_RESPONSE_CANCEL,
                                        _("_Open"), GTK_RESPONSE_ACCEPT,
                                        NULL);

  g_signal_connect_object (dialog,
                           "response",
                           G_CALLBACK (on_add_folder_dialog_response_cb),
                           self,
                           0);
  gtk_window_present (GTK_WINDOW (dialog));
}

static void
cc_sharing_panel_remove_folder (CcSharingPanel *self,
                                GtkButton      *button)
{
  GtkWidget *row;

  row = g_object_get_data (G_OBJECT (button), "row");
  gtk_list_box_remove (GTK_LIST_BOX (self->shared_folders_listbox), row);
}

static void
cc_sharing_panel_media_sharing_dialog_response (CcSharingPanel *self,
                                                gint            reponse_id)
{
  g_autoptr(GPtrArray) folders = NULL;
  GtkWidget *child;

  folders = g_ptr_array_new_with_free_func (g_free);

  for (child = gtk_widget_get_first_child (self->shared_folders_listbox);
       child;
       child = gtk_widget_get_next_sibling (child))
    {
      const char *folder;

      folder = g_object_get_data (G_OBJECT (child), "path");
      if (folder == NULL)
        continue;
      g_ptr_array_add (folders, g_strdup (folder));
    }

  g_ptr_array_add (folders, NULL);

  cc_media_sharing_set_preferences ((gchar **) folders->pdata);
}

#define ICON_NAME_FOLDER                "folder-symbolic"
#define ICON_NAME_FOLDER_DESKTOP        "user-desktop-symbolic"
#define ICON_NAME_FOLDER_DOCUMENTS      "folder-documents-symbolic"
#define ICON_NAME_FOLDER_DOWNLOAD       "folder-download-symbolic"
#define ICON_NAME_FOLDER_MUSIC          "folder-music-symbolic"
#define ICON_NAME_FOLDER_PICTURES       "folder-pictures-symbolic"
#define ICON_NAME_FOLDER_PUBLIC_SHARE   "folder-publicshare-symbolic"
#define ICON_NAME_FOLDER_TEMPLATES      "folder-templates-symbolic"
#define ICON_NAME_FOLDER_VIDEOS         "folder-videos-symbolic"
#define ICON_NAME_FOLDER_SAVED_SEARCH   "folder-saved-search-symbolic"

static GIcon *
special_directory_get_gicon (GUserDirectory directory)
{
#define ICON_CASE(x)                      \
  case G_USER_DIRECTORY_ ## x:            \
          return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER_ ## x);

  switch (directory)
    {
      ICON_CASE (DESKTOP);
      ICON_CASE (DOCUMENTS);
      ICON_CASE (DOWNLOAD);
      ICON_CASE (MUSIC);
      ICON_CASE (PICTURES);
      ICON_CASE (PUBLIC_SHARE);
      ICON_CASE (TEMPLATES);
      ICON_CASE (VIDEOS);

    default:
      return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER);
    }

#undef ICON_CASE
}

static GtkWidget *
cc_sharing_panel_new_media_sharing_row (const char     *uri_or_path,
                                        CcSharingPanel *self)
{
  GtkWidget *row, *w;
  GUserDirectory dir = G_USER_N_DIRECTORIES;
  g_autoptr(GIcon) icon = NULL;
  guint i;
  g_autofree gchar *basename = NULL;
  g_autofree gchar *path = NULL;
  g_autoptr(GFile) file = NULL;

  file = g_file_new_for_commandline_arg (uri_or_path);
  path = g_file_get_path (file);

  row = adw_action_row_new ();

  /* Find the icon and create it */
  for (i = 0; i < G_USER_N_DIRECTORIES; i++)
    {
      if (g_strcmp0 (path, g_get_user_special_dir (i)) == 0)
        {
          dir = i;
          break;
        }
    }

  icon = special_directory_get_gicon (dir);
  adw_action_row_add_prefix (ADW_ACTION_ROW (row),
                             gtk_image_new_from_gicon (icon));

  /* Label */
  basename = g_filename_display_basename (path);
  adw_preferences_row_set_title (ADW_PREFERENCES_ROW (row), basename);

  /* Remove button */
  w = gtk_button_new_from_icon_name ("window-close-symbolic");
  gtk_widget_add_css_class (w, "flat");
  gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
  adw_action_row_add_suffix (ADW_ACTION_ROW (row), w);
  g_signal_connect_object (G_OBJECT (w), "clicked",
                           G_CALLBACK (cc_sharing_panel_remove_folder), self, G_CONNECT_SWAPPED);
  g_object_set_data (G_OBJECT (w), "row", row);

  g_object_set_data_full (G_OBJECT (row), "path", g_steal_pointer (&path), g_free);

  return row;
}

static GtkWidget *
cc_sharing_panel_new_add_media_sharing_row (CcSharingPanel *self)
{
  GtkWidget *row, *box, *w;

  row = gtk_list_box_row_new ();
  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);

  w = gtk_image_new_from_icon_name ("list-add-symbolic");
  gtk_widget_set_hexpand (w, TRUE);
  gtk_widget_set_margin_top (w, 12);
  gtk_widget_set_margin_bottom (w, 12);
  gtk_box_append (GTK_BOX (box), w);

  g_object_set_data (G_OBJECT (w), "row", row);

  g_object_set_data (G_OBJECT (row), "is-add", GINT_TO_POINTER (1));

  return row;
}

static GtkWidget *
create_switch_with_bindings (GtkSwitch *from)
{
  GtkWidget *new_switch = gtk_switch_new ();

  g_object_bind_property (from, "visible", new_switch, "visible", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
  g_object_bind_property (from, "state", new_switch, "state", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
  g_object_bind_property (from, "active", new_switch, "active", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
  g_object_bind_property (from, "sensitive", new_switch, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);

  return new_switch;
}

static void
cc_sharing_panel_setup_media_sharing_dialog (CcSharingPanel *self)
{
  g_auto(GStrv) folders = NULL;
  GStrv list;
  GtkWidget *row, *networks, *w;
  g_autofree gchar *path = NULL;

  path = g_find_program_in_path ("rygel");
  if (path == NULL)
    {
      gtk_widget_hide (self->media_sharing_row);
      return;
    }

  g_signal_connect_object (self->media_sharing_dialog, "response",
                           G_CALLBACK (cc_sharing_panel_media_sharing_dialog_response),
                           self, G_CONNECT_SWAPPED);

  cc_media_sharing_get_preferences (&folders);

  list = folders;
  while (list && *list)
    {
      row = cc_sharing_panel_new_media_sharing_row (*list, self);
      gtk_list_box_insert (GTK_LIST_BOX (self->shared_folders_listbox), row, -1);
      list++;
    }

  row = cc_sharing_panel_new_add_media_sharing_row (self);
  gtk_list_box_append (GTK_LIST_BOX (self->shared_folders_listbox), row);

  g_signal_connect_object (self->shared_folders_listbox, "row-activated",
                           G_CALLBACK (cc_sharing_panel_add_folder), self, G_CONNECT_SWAPPED);

  networks = cc_sharing_networks_new (self->sharing_proxy, "rygel");
  gtk_grid_attach (GTK_GRID (self->shared_folders_grid), networks, 0, 4, 2, 1);

  w = create_switch_with_bindings (GTK_SWITCH (g_object_get_data (G_OBJECT (networks), "switch")));
  gtk_header_bar_pack_start (GTK_HEADER_BAR (self->media_sharing_headerbar), w);
  self->media_sharing_switch = w;

  cc_sharing_panel_bind_networks_to_label (self, networks,
                                           self->media_sharing_row);
}

static void
cc_sharing_panel_setup_label (CcSharingPanel *self,
                              GtkWidget      *label,
                              const gchar    *hostname)
{
  g_autofree gchar *text = NULL;

  if (label == self->personal_file_sharing_label)
    {
      g_autofree gchar *url = g_strdup_printf ("<a href=\"dav://%s\">dav://%s</a>", hostname, hostname);
      /* TRANSLATORS: %s is replaced with a link to a dav://<hostname> URL */
      text = g_strdup_printf (_("File Sharing allows you to share your Public folder with others on your current network using: %s"), url);
    }
  else if (label == self->remote_login_label)
    {
      g_autofree gchar *command = g_strdup_printf ("<a href=\"ssh %s\">ssh %s</a>", hostname, hostname);
      /* TRANSLATORS: %s is replaced with a link to a "ssh <hostname>" command to run */
      text = g_strdup_printf (_("When remote login is enabled, remote users can connect using the Secure Shell command:\n%s"), command);
    }
  else if (label == self->remote_desktop_address_label)
    {
      text = g_strdup_printf ("ms-rd://%s", hostname);
    }
  else
    g_assert_not_reached ();

  gtk_label_set_label (GTK_LABEL (label), text);
}

typedef struct
{
  CcSharingPanel *panel;
  GtkWidget *label;
} GetHostNameData;

G_DEFINE_AUTOPTR_CLEANUP_FUNC (GetHostNameData, g_free);

static void
cc_sharing_panel_get_host_name_fqdn_done (GObject         *object,
                                          GAsyncResult    *res,
                                          gpointer         user_data)
{
  GDBusConnection *connection = G_DBUS_CONNECTION (object);
  g_autoptr(GetHostNameData) data = user_data;
  g_autoptr(GError) error = NULL;
  g_autoptr(GVariant) variant = NULL;
  const gchar *fqdn;

  variant = g_dbus_connection_call_finish (connection, res, &error);

  if (variant == NULL)
    {
      /* Avahi service may not be available */
      g_debug ("Error calling GetHostNameFqdn: %s", error->message);

      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        {
          g_autofree gchar *hostname = NULL;

          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->hostname_entry));

          cc_sharing_panel_setup_label (data->panel, data->label, hostname);
        }

      return;
    }

  g_variant_get (variant, "(&s)", &fqdn);

  cc_sharing_panel_setup_label (data->panel, data->label, fqdn);
}

static void
cc_sharing_panel_bus_ready (GObject         *object,
                            GAsyncResult    *res,
                            gpointer         user_data)
{
  g_autoptr(GDBusConnection) connection = NULL;
  g_autoptr(GetHostNameData) data = user_data;
  g_autoptr(GError) error = NULL;

  connection = g_bus_get_finish (res, &error);

  if (connection == NULL)
    {
      g_warning ("Could not connect to system bus: %s", error->message);

      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        {
          g_autofree gchar *hostname = NULL;

          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->hostname_entry));

          cc_sharing_panel_setup_label (data->panel, data->label, hostname);
        }

      return;
    }

  g_dbus_connection_call (connection,
                          "org.freedesktop.Avahi",
                          "/",
                          "org.freedesktop.Avahi.Server",
                          "GetHostNameFqdn",
                          NULL,
                          (GVariantType*)"(s)",
                          G_DBUS_CALL_FLAGS_NONE,
                          -1,
                          cc_panel_get_cancellable (CC_PANEL (data->panel)),
                          cc_sharing_panel_get_host_name_fqdn_done,
                          data);
  g_steal_pointer (&data);
}


static void
cc_sharing_panel_setup_label_with_hostname (CcSharingPanel *self,
                                            GtkWidget      *label)

{
  GetHostNameData *get_hostname_data;

  /* set the hostname */
  get_hostname_data = g_new (GetHostNameData, 1);
  get_hostname_data->panel = self;
  get_hostname_data->label = label;
  g_bus_get (G_BUS_TYPE_SYSTEM,
             cc_panel_get_cancellable (CC_PANEL (self)),
             cc_sharing_panel_bus_ready,
             get_hostname_data);
}

static gboolean
file_sharing_get_require_password (GValue   *value,
                                   GVariant *variant,
                                   gpointer  user_data)
{
  if (g_str_equal (g_variant_get_string (variant, NULL), "always"))
    g_value_set_boolean (value, TRUE);
  else
    g_value_set_boolean (value, FALSE);

  return TRUE;
}

static GVariant *
file_sharing_set_require_password (const GValue       *value,
                                   const GVariantType *type,
                                   gpointer            user_data)
{
  if (g_value_get_boolean (value))
    return g_variant_new_string ("always");
  else
    return g_variant_new_string ("never");
}

static void
file_sharing_password_changed (GtkEntry *entry)
{
  file_share_write_out_password (gtk_editable_get_text (GTK_EDITABLE (entry)));
}

static void
cc_sharing_panel_setup_personal_file_sharing_dialog (CcSharingPanel *self)
{
  GSettings *settings;
  GtkWidget *networks, *w;

  cc_sharing_panel_bind_switch_to_widgets (self->personal_file_sharing_require_password_switch,
                                           self->personal_file_sharing_password_entry,
                                           self->personal_file_sharing_password_label,
                                           NULL);

  cc_sharing_panel_setup_label_with_hostname (self,
                                              self->personal_file_sharing_label);

  /* the password cannot be read, so just make sure the entry is not empty */
  gtk_editable_set_text (GTK_EDITABLE (self->personal_file_sharing_password_entry),
                         "password");

  settings = g_settings_new (FILE_SHARING_SCHEMA_ID);
  g_settings_bind_with_mapping (settings, "require-password",
                                self->personal_file_sharing_require_password_switch,
                                "active",
                                G_SETTINGS_BIND_DEFAULT,
                                file_sharing_get_require_password,
                                file_sharing_set_require_password, NULL, NULL);

  g_signal_connect (self->personal_file_sharing_password_entry,
                    "notify::text", G_CALLBACK (file_sharing_password_changed),
                    NULL);

  networks = cc_sharing_networks_new (self->sharing_proxy, "gnome-user-share-webdav");
  gtk_grid_attach (GTK_GRID (self->personal_file_sharing_grid), networks, 0, 3, 2, 1);

  w = create_switch_with_bindings (GTK_SWITCH (g_object_get_data (G_OBJECT (networks), "switch")));
  gtk_header_bar_pack_start (GTK_HEADER_BAR (self->personal_file_sharing_headerbar), w);
  self->personal_file_sharing_switch = w;

  cc_sharing_panel_bind_networks_to_label (self,
                                           networks,
                                           self->personal_file_sharing_row);
}

static void
remote_login_switch_activate (CcSharingPanel *self)
{
  cc_remote_login_set_enabled (cc_panel_get_cancellable (CC_PANEL (self)), GTK_SWITCH (self->remote_login_switch));
}

static void
cc_sharing_panel_setup_remote_login_dialog (CcSharingPanel *self)
{
  cc_sharing_panel_bind_switch_to_label (self, self->remote_login_switch,
                                         self->remote_login_row);

  cc_sharing_panel_setup_label_with_hostname (self, self->remote_login_label);

  g_signal_connect_object (self->remote_login_switch, "notify::active",
                           G_CALLBACK (remote_login_switch_activate), self, G_CONNECT_SWAPPED);
  gtk_widget_set_sensitive (self->remote_login_switch, FALSE);

  cc_remote_login_get_enabled (cc_panel_get_cancellable (CC_PANEL (self)),
                               GTK_SWITCH (self->remote_login_switch),
                               self->remote_login_row);
}

static gboolean
cc_sharing_panel_check_schema_available (CcSharingPanel *self,
                                         const gchar *schema_id)
{
  GSettingsSchemaSource *source;
  g_autoptr(GSettingsSchema) schema = NULL;

  source = g_settings_schema_source_get_default ();
  if (!source)
    return FALSE;

  schema = g_settings_schema_source_lookup (source, schema_id, TRUE);
  if (!schema)
    return FALSE;

  return TRUE;
}

#define MAX_PASSWORD_SIZE 8
static void
remote_desktop_password_insert_text_cb (CcSharingPanel *self,
                                        gchar          *new_text,
                                        gint            new_text_length,
                                        gpointer        position)
{
  int l, available_size;

  l = gtk_entry_buffer_get_bytes (gtk_entry_get_buffer (GTK_ENTRY (self->remote_desktop_password_entry)));

  if (l + new_text_length <= MAX_PASSWORD_SIZE)
    return;

  g_signal_stop_emission_by_name (self->remote_desktop_password_entry, "insert-text");
  gtk_widget_error_bell (GTK_WIDGET (self->remote_desktop_password_entry));

  available_size = g_utf8_strlen (new_text, MAX_PASSWORD_SIZE - l);
  if (available_size == 0)
    return;

  g_signal_handlers_block_by_func (self->remote_desktop_password_entry,
                                   (gpointer) remote_desktop_password_insert_text_cb,
                                   self);
  gtk_editable_insert_text (GTK_EDITABLE (self->remote_desktop_password_entry), new_text, available_size, position);
  g_signal_handlers_unblock_by_func (self->remote_desktop_password_entry,
                                     (gpointer) remote_desktop_password_insert_text_cb,
                                     self);
}
#undef MAX_PASSWORD_SIZE

static gboolean
store_remote_desktop_credentials_timeout (gpointer user_data)
{
  CcSharingPanel *self = CC_SHARING_PANEL (user_data);
  const char *username, *password;

  username = gtk_editable_get_text (GTK_EDITABLE (self->remote_desktop_username_entry));
  password = gtk_editable_get_text (GTK_EDITABLE (self->remote_desktop_password_entry));

  if (username && password)
    {
      cc_grd_store_rdp_credentials (username, password,
                                    cc_panel_get_cancellable (CC_PANEL (self)));
    }

  self->remote_desktop_store_credentials_id = 0;

  return G_SOURCE_REMOVE;
}

static void
remote_desktop_credentials_changed (CcSharingPanel *self)
{
  g_clear_handle_id (&self->remote_desktop_store_credentials_id,
                     g_source_remove);

  self->remote_desktop_store_credentials_id =
    g_timeout_add_seconds (REMOTE_DESKTOP_STORE_CREDENTIALS_TIMEOUT_S,
                           store_remote_desktop_credentials_timeout,
                           self);
}

static gboolean
is_remote_desktop_enabled (CcSharingPanel *self)
{
  return cc_is_service_active (REMOTE_DESKTOP_SERVICE, G_BUS_TYPE_SESSION);
}

static void
enable_gnome_remote_desktop_service (CcSharingPanel *self)
{
  g_autoptr(GError) error = NULL;

  if (is_remote_desktop_enabled (self))
    return;

  if (!cc_enable_service (REMOTE_DESKTOP_SERVICE,
                          G_BUS_TYPE_SESSION,
                          &error))
    g_warning ("Failed to enable remote desktop service: %s", error->message);
}

static void
disable_gnome_remote_desktop_service (CcSharingPanel *self)
{
  g_autoptr(GError) error = NULL;

  if (!cc_disable_service (REMOTE_DESKTOP_SERVICE,
                           G_BUS_TYPE_SESSION,
                           &error))
    g_warning ("Failed to enable remote desktop service: %s", error->message);
}

static void
calc_default_tls_paths (char **out_dir_path,
                        char **out_cert_path,
                        char **out_key_path)
{
  g_autofree char *dir_path = NULL;

  dir_path = g_strdup_printf ("%s/gnome-remote-desktop",
                              g_get_user_data_dir ());

  if (out_cert_path)
    *out_cert_path = g_strdup_printf ("%s/rdp-tls.crt", dir_path);
  if (out_key_path)
    *out_key_path = g_strdup_printf ("%s/rdp-tls.key", dir_path);

  if (out_dir_path)
    *out_dir_path = g_steal_pointer (&dir_path);
}

static void
set_tls_certificate (CcSharingPanel  *self,
                     GTlsCertificate *tls_certificate)
{
  g_set_object (&self->remote_desktop_certificate,
                tls_certificate);
  gtk_widget_set_sensitive (self->remote_desktop_verify_encryption, TRUE);
}

static void
on_certificate_generated (GObject      *source_object,
                          GAsyncResult *res,
                          gpointer      user_data)
{
  CcSharingPanel *self;
  g_autoptr(GTlsCertificate) tls_certificate = NULL;
  g_autoptr(GError) error = NULL;
  g_autofree char *cert_path = NULL;
  g_autofree char *key_path = NULL;
  g_autoptr(GSettings) rdp_settings = NULL;

  tls_certificate = bonsai_tls_certificate_new_generate_finish (res, &error);
  if (!tls_certificate)
    {
      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

      g_warning ("Failed to generate TLS certificate: %s", error->message);
      return;
    }

  self = CC_SHARING_PANEL (user_data);

  calc_default_tls_paths (NULL, &cert_path, &key_path);

  rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID);

  g_settings_set_string (rdp_settings, "tls-cert", cert_path);
  g_settings_set_string (rdp_settings, "tls-key", key_path);

  set_tls_certificate (self, tls_certificate);

  enable_gnome_remote_desktop_service (self);
}

static void
enable_gnome_remote_desktop (CcSharingPanel *self)
{
  g_autofree char *dir_path = NULL;
  g_autofree char *cert_path = NULL;
  g_autofree char *key_path = NULL;
  g_autoptr(GFile) dir = NULL;
  g_autoptr(GFile) cert_file = NULL;
  g_autoptr(GFile) key_file = NULL;
  g_autoptr(GError) error = NULL;
  g_autoptr(GSettings) rdp_settings = NULL;

  rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID);

  g_settings_set_boolean (rdp_settings, "enable", TRUE);

  cert_path = g_settings_get_string (rdp_settings, "tls-cert");
  key_path = g_settings_get_string (rdp_settings, "tls-key");
  if (strlen (cert_path) > 0 &&
      strlen (key_path) > 0)
    {
      g_autoptr(GTlsCertificate) tls_certificate = NULL;

      tls_certificate = g_tls_certificate_new_from_file (cert_path, &error);
      if (tls_certificate)
        {
          set_tls_certificate (self, tls_certificate);

          enable_gnome_remote_desktop_service (self);
          return;
        }

      g_warning ("Configured TLS certificate invalid: %s", error->message);
      return;
    }

  calc_default_tls_paths (&dir_path, &cert_path, &key_path);

  dir = g_file_new_for_path (dir_path);
  if (!g_file_query_exists (dir, NULL))
    {
      if (!g_file_make_directory_with_parents (dir, NULL, &error))
        {
          g_warning ("Failed to create remote desktop certificate directory: %s",
                     error->message);
          return;
        }
    }

  cert_file = g_file_new_for_path (cert_path);
  key_file = g_file_new_for_path (key_path);

  if (g_file_query_exists (cert_file, NULL) &&
      g_file_query_exists (key_file, NULL))
    {
      g_autoptr(GTlsCertificate) tls_certificate = NULL;

      tls_certificate = g_tls_certificate_new_from_file (cert_path, &error);
      if (tls_certificate)
        {
          g_settings_set_string (rdp_settings, "tls-cert", cert_path);
          g_settings_set_string (rdp_settings, "tls-key", key_path);

          set_tls_certificate (self, tls_certificate);

          enable_gnome_remote_desktop_service (self);
          return;
        }

      g_warning ("Existing TLS certificate invalid: %s", error->message);
      return;
    }

  bonsai_tls_certificate_new_generate_async (cert_path,
                                             key_path,
                                             "US",
                                             "GNOME",
                                             cc_panel_get_cancellable (CC_PANEL (self)),
                                             on_certificate_generated,
                                             self);
}

static void
on_remote_desktop_state_changed (GtkWidget      *widget,
                                 GParamSpec     *pspec,
                                 CcSharingPanel *self)
{
  if (gtk_switch_get_active (GTK_SWITCH (widget)))
    enable_gnome_remote_desktop (self);
  else
    disable_gnome_remote_desktop_service (self);
}

static char *
get_hostname (void)
{
  g_autoptr(GDBusConnection) bus = NULL;
  g_autoptr(GVariant) res = NULL;
  g_autoptr(GVariant) inner = NULL;
  g_autoptr(GError) error = NULL;
  const char *hostname;

  bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
  if (bus == NULL)
    {
      g_warning ("Failed to get system bus connection: %s", error->message);
      return NULL;
    }
  res = g_dbus_connection_call_sync (bus,
                                     "org.freedesktop.hostname1",
                                     "/org/freedesktop/hostname1",
                                     "org.freedesktop.DBus.Properties",
                                     "Get",
                                     g_variant_new ("(ss)",
                                                    "org.freedesktop.hostname1",
                                                    "PrettyHostname"),
                                     (GVariantType*)"(v)",
                                     G_DBUS_CALL_FLAGS_NONE,
                                     -1,
                                     NULL,
                                     &error);

  if (res == NULL)
    {
      g_warning ("Getting pretty hostname failed: %s", error->message);
      return NULL;
    }

  g_variant_get (res, "(v)", &inner);
  hostname = g_variant_get_string (inner, NULL);
  if (g_strcmp0 (hostname, "") != 0)
    return g_strdup (hostname);

  g_clear_pointer (&inner, g_variant_unref);
  g_clear_pointer (&res, g_variant_unref);

  res = g_dbus_connection_call_sync (bus,
                                     "org.freedesktop.hostname1",
                                     "/org/freedesktop/hostname1",
                                     "org.freedesktop.DBus.Properties",
                                     "Get",
                                     g_variant_new ("(ss)",
                                                    "org.freedesktop.hostname1",
                                                    "Hostname"),
                                     (GVariantType*)"(v)",
                                     G_DBUS_CALL_FLAGS_NONE,
                                     -1,
                                     NULL,
                                     &error);

  if (res == NULL)
    {
      g_warning ("Getting hostname failed: %s", error->message);
      return NULL;
    }

  g_variant_get (res, "(v)", &inner);
  return g_variant_dup_string (inner, NULL);
}

static void
on_copy_clicked_label (GtkButton *button,
                       GtkLabel  *label)
{
  gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (button)),
                          gtk_label_get_text (label));
}

static void
on_copy_clicked_editable (GtkButton   *button,
                          GtkEditable *editable)
{
  gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (button)),
                          gtk_editable_get_text (editable));
}

static pwquality_settings_t *
get_pwq (void)
{
  static pwquality_settings_t *settings;

  if (settings == NULL)
    {
      gchar *err = NULL;
      gint rv = 0;

      settings = pwquality_default_settings ();
      pwquality_set_int_value (settings, PWQ_SETTING_MAX_SEQUENCE, 4);

      rv = pwquality_read_config (settings, NULL, (gpointer)&err);
      if (rv < 0)
        {
          g_warning ("Failed to read pwquality configuration: %s\n",
                     pwquality_strerror (NULL, 0, rv, err));
          pwquality_free_settings (settings);

          /* Load just default settings in case of failure. */
          settings = pwquality_default_settings ();
          pwquality_set_int_value (settings, PWQ_SETTING_MAX_SEQUENCE, 4);
        }
    }

  return settings;
}

static char *
pw_generate (void)
{
  char *res;
  int rv;

  rv = pwquality_generate (get_pwq (), 0, &res);

  if (rv < 0) {
      g_warning ("Password generation failed: %s\n",
                 pwquality_strerror (NULL, 0, rv, NULL));
      return NULL;
  }

  return res;
}

static void
cc_sharing_panel_setup_remote_desktop_dialog (CcSharingPanel *self)
{
  const gchar *username = NULL;
  const gchar *password = NULL;
  g_autoptr(GSettings) rdp_settings = NULL;
  g_autofree char *hostname = NULL;

  cc_sharing_panel_bind_switch_to_label (self, self->remote_desktop_switch,
                                         self->remote_desktop_row);

  cc_sharing_panel_setup_label_with_hostname (self, self->remote_desktop_address_label);

  rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID);

  g_settings_bind (rdp_settings,
                   "view-only",
                   self->remote_control_checkbutton,
                   "active",
                   G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_INVERT_BOOLEAN);
  g_object_bind_property (self->remote_desktop_switch, "state",
                          self->remote_control_checkbutton, "sensitive",
                          G_BINDING_SYNC_CREATE);

  hostname = get_hostname ();
  gtk_label_set_label (GTK_LABEL (self->remote_desktop_device_name_label),
                       hostname);

  username = cc_grd_lookup_rdp_username (cc_panel_get_cancellable (CC_PANEL (self)));
  password = cc_grd_lookup_rdp_password (cc_panel_get_cancellable (CC_PANEL (self)));
  if (username != NULL)
    gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_username_entry), username);
  if (password != NULL)
    gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_password_entry), password);

  g_signal_connect_swapped (self->remote_desktop_username_entry,
                            "notify::text",
                            G_CALLBACK (remote_desktop_credentials_changed),
                            self);
  g_signal_connect_swapped (self->remote_desktop_password_entry,
                            "notify::text",
                            G_CALLBACK (remote_desktop_credentials_changed),
                            self);

  if (username == NULL)
    gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_username_entry),
                           getlogin ());
  if (password == NULL)
    gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_password_entry),
                           pw_generate ());

  g_signal_connect (self->remote_desktop_device_name_copy,
                    "clicked", G_CALLBACK (on_copy_clicked_label),
                    self->remote_desktop_device_name_label);
  g_signal_connect (self->remote_desktop_address_copy,
                    "clicked", G_CALLBACK (on_copy_clicked_label),
                    self->remote_desktop_address_label);
  g_signal_connect (self->remote_desktop_username_copy,
                    "clicked", G_CALLBACK (on_copy_clicked_editable),
                    self->remote_desktop_username_entry);
  g_signal_connect (self->remote_desktop_password_copy,
                    "clicked", G_CALLBACK (on_copy_clicked_editable),
                    self->remote_desktop_password_entry);

  g_signal_connect (self->remote_desktop_switch, "notify::state",
                    G_CALLBACK (on_remote_desktop_state_changed), self);

  if (is_remote_desktop_enabled (self))
    {
      gtk_switch_set_active (GTK_SWITCH (self->remote_desktop_switch),
                             TRUE);
    }
}

static void
remote_desktop_name_appeared (GDBusConnection *connection,
                              const gchar     *name,
                              const gchar     *name_owner,
                              gpointer         user_data)
{
  CcSharingPanel *self = CC_SHARING_PANEL (user_data);

  g_bus_unwatch_name (self->remote_desktop_name_watch);
  self->remote_desktop_name_watch = 0;

  cc_sharing_panel_setup_remote_desktop_dialog (self);
  gtk_widget_show (self->remote_desktop_row);
}

static void
check_remote_desktop_available (CcSharingPanel *self)
{
  if (!cc_sharing_panel_check_schema_available (self, GNOME_REMOTE_DESKTOP_SCHEMA_ID))
    return;

  if (!cc_sharing_panel_check_schema_available (self, GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID))
    return;

  self->remote_desktop_name_watch = g_bus_watch_name (G_BUS_TYPE_SESSION,
                                                      "org.gnome.Mutter.RemoteDesktop",
                                                      G_BUS_NAME_WATCHER_FLAGS_NONE,
                                                      remote_desktop_name_appeared,
                                                      NULL,
                                                      self,
                                                      NULL);
}

static void
sharing_proxy_ready (GObject      *source,
                     GAsyncResult *res,
                     gpointer      user_data)
{
  CcSharingPanel *self;
  GDBusProxy *proxy;
  g_autoptr(GError) error = NULL;

  proxy = G_DBUS_PROXY (gsd_sharing_proxy_new_for_bus_finish (res, &error));
  if (!proxy) {
    if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
      g_warning ("Failed to get sharing proxy: %s", error->message);
    return;
  }

  self = CC_SHARING_PANEL (user_data);
  self->sharing_proxy = proxy;

  /* media sharing */
  cc_sharing_panel_setup_media_sharing_dialog (self);

  /* personal file sharing */
  if (cc_sharing_panel_check_schema_available (self, FILE_SHARING_SCHEMA_ID))
    cc_sharing_panel_setup_personal_file_sharing_dialog (self);
  else
    gtk_widget_hide (self->personal_file_sharing_row);

  /* remote login */
  cc_sharing_panel_setup_remote_login_dialog (self);

  /* screen sharing */
  check_remote_desktop_available (self);
  gtk_widget_hide (self->remote_desktop_row);
}

static void
cc_sharing_panel_init (CcSharingPanel *self)
{
  g_autoptr(GtkCssProvider) provider = NULL;

  g_resources_register (cc_sharing_get_resource ());

  gtk_widget_init_template (GTK_WIDGET (self));

  g_signal_connect_object (self->main_list_box, "row-activated",
                           G_CALLBACK (cc_sharing_panel_main_list_box_row_activated), self, G_CONNECT_SWAPPED);

  g_signal_connect (self->media_sharing_dialog, "response",
                    G_CALLBACK (gtk_widget_hide), NULL);
  g_signal_connect (self->personal_file_sharing_dialog, "response",
                    G_CALLBACK (gtk_widget_hide), NULL);
  g_signal_connect (self->remote_login_dialog, "response",
                    G_CALLBACK (gtk_widget_hide), NULL);
  g_signal_connect (self->remote_desktop_dialog, "response",
                    G_CALLBACK (gtk_widget_hide), NULL);

  gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (self->main_list_box),
                                             TRUE);

  /* start the panel in the disabled state */
  gtk_switch_set_active (GTK_SWITCH (self->master_switch), FALSE);
  gtk_widget_set_sensitive (self->main_list_box, FALSE);
  g_signal_connect_object (self->master_switch, "notify::active",
                           G_CALLBACK (cc_sharing_panel_master_switch_notify), self, G_CONNECT_SWAPPED);

  gsd_sharing_proxy_new_for_bus (G_BUS_TYPE_SESSION,
                                 G_DBUS_PROXY_FLAGS_NONE,
                                 "org.gnome.SettingsDaemon.Sharing",
                                 "/org/gnome/SettingsDaemon/Sharing",
                                 cc_panel_get_cancellable (CC_PANEL (self)),
                                 sharing_proxy_ready,
                                 self);

  /* make sure the hostname entry isn't focused by default */
  g_signal_connect_swapped (self, "map", G_CALLBACK (gtk_widget_grab_focus),
                            self->main_list_box);

  provider = gtk_css_provider_new ();
  gtk_css_provider_load_from_resource (provider,
                                       "/org/gnome/control-center/sharing/sharing.css");
  gtk_style_context_add_provider_for_display (gdk_display_get_default (),
                                              GTK_STYLE_PROVIDER (provider),
                                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}

CcSharingPanel *
cc_sharing_panel_new (void)
{
  return g_object_new (CC_TYPE_SHARING_PANEL, NULL);
}
