/*
 * Copyright (C) 2010 Marco Diego Aurélio Mesquita
 *
 * This program 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 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 Lesser 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.
 *
 * Authors:
 *   Marco Diego Aurélio Mesquita <marcodiegomesquita@gmail.com>
 */

#include <config.h>

/**
 * SECTION:glade-preview
 * @Short_Description: The glade preview launch/kill interface.
 *
 * This object owns all data that is needed to keep a preview. It stores
 * the GIOChannel used for comunnication between glade and glade-previewer,
 * the event source id for a watch  (in the case a watch is used to monitor
 * the communication channel), the previewed widget and the pid of the
 * corresponding glade-previewer.
 * 
 */


#include <string.h>
#include <stdlib.h>
#include <glib.h>
#include <glib/gi18n-lib.h>
#include <glib/gstdio.h>

#include "glade.h"
#include "glade-preview.h"
#include "glade-project.h"
#include "glade-app.h"

#include "glade-preview-tokens.h"

#ifdef G_OS_WIN32
#define GLADE_PREVIEWER "glade-previewer.exe"
#else
#define GLADE_PREVIEWER "glade-previewer"
#endif

/* Private data for glade-preview */
struct _GladePreviewPrivate
{
  GIOChannel *channel;          /* Channel user for communication between glade and glade-previewer */
  guint watch;                  /* Event source id used to monitor the channel */
  GladeWidget *previewed_widget;
  GPid pid;                     /* Pid of the corresponding glade-previewer process */
};

G_DEFINE_TYPE_WITH_PRIVATE (GladePreview, glade_preview, G_TYPE_OBJECT);

enum
{
  PREVIEW_EXITS,
  LAST_SIGNAL
};

static guint glade_preview_signals[LAST_SIGNAL] = { 0 };

/**
 * glade_preview_kill
 * @preview: a #GladePreview that will be killed.
 *
 * Uses the communication channel and protocol to send the "<quit>" token to the
 * glade-previewer telling it to commit suicide.
 *
 */
static void
glade_preview_kill (GladePreview *preview)
{
  const gchar *quit = QUIT_TOKEN;
  GIOChannel *channel;
  GError *error = NULL;
  gsize size;

  channel = preview->priv->channel;
  g_io_channel_write_chars (channel, quit, strlen (quit), &size, &error);

  if (size != strlen (quit) && error != NULL)
    {
      g_warning ("Error passing quit signal trough pipe: %s", error->message);
      g_error_free (error);
    }

  g_io_channel_flush (channel, &error);
  if (error != NULL)
    {
      g_warning ("Error flushing channel: %s", error->message);
      g_error_free (error);
    }

  g_io_channel_shutdown (channel, TRUE, &error);
  if (error != NULL)
    {
      g_warning ("Error shutting down channel: %s", error->message);
      g_error_free (error);
    }
}

static void
glade_preview_dispose (GObject *gobject)
{
  GladePreview *self = GLADE_PREVIEW (gobject);

  if (self->priv->watch)
    {
      g_source_remove (self->priv->watch);
      glade_preview_kill (self);
    }

  if (self->priv->channel)
    {
      g_io_channel_unref (self->priv->channel);
      self->priv->channel = NULL;
    }

  G_OBJECT_CLASS (glade_preview_parent_class)->dispose (gobject);
}

/* We have to use finalize because of the signal that is sent in dispose */
static void
glade_preview_finalize (GObject *gobject)
{
  G_OBJECT_CLASS (glade_preview_parent_class)->finalize (gobject);
}

static void
glade_preview_class_init (GladePreviewClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->dispose  = glade_preview_dispose;
  gobject_class->finalize = glade_preview_finalize;

  /**
   * GladePreview::exits:
   * @gladepreview: the #GladePreview which received the signal.
   * @gladeproject: the #GladeProject associated with the preview.
   *
   * Emitted when @preview exits.
   */
  glade_preview_signals[PREVIEW_EXITS] =
      g_signal_new ("exits",
                    G_TYPE_FROM_CLASS (gobject_class),
                    G_SIGNAL_RUN_FIRST,
                    0, NULL, NULL,
                    g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
}

static void
glade_preview_init (GladePreview *self)
{
  GladePreviewPrivate *priv;

  self->priv = priv = glade_preview_get_instance_private (self);
  priv->channel = NULL;
}

static void
glade_preview_internal_watch (GPid pid, gint status, gpointer data)
{
  GladePreview *preview = GLADE_PREVIEW (data);

  preview->priv->watch = 0;

  /* This means a preview exited. We'll now signal it */
  g_signal_emit (preview, glade_preview_signals[PREVIEW_EXITS], 0);
}

/**
 * glade_preview_launch:
 * @widget: Pointer to a local instance of the widget that will be previewed.
 * @buffer: Contents of an xml definition of the interface which will be previewed
 *
 * Creates a new #GladePreview and launches glade-previewer to preview it.
 *
 * Returns: a new #GladePreview or NULL if launch fails.
 * 
 */
GladePreview *
glade_preview_launch (GladeWidget *widget, const gchar *buffer)
{
  GPid pid;
  GError *error = NULL;
  gchar *argv[10], *executable;
  gint child_stdin;
  gsize bytes_written;
  GIOChannel *output;
  GladePreview *preview = NULL;
  const gchar *css_provider, *filename;
  GladeProject *project;
  gchar *name;
  gint i;

  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);

  executable = g_find_program_in_path (GLADE_PREVIEWER);

  project = glade_widget_get_project (widget);
  filename = glade_project_get_path (project);
  name = (filename) ? NULL : glade_project_get_name (project);
  
  argv[0] = executable;
  argv[1] = "--listen";
  argv[2] = "--toplevel";
  argv[3] = (gchar *) glade_widget_get_name (widget);
  argv[4] = "--filename";
  argv[5] = (filename) ? (gchar *) filename : name;

  i = 5;
  if (glade_project_get_template (project))
    argv[++i] = "--template";
    
  argv[++i] = NULL;

  css_provider = glade_project_get_css_provider_path (glade_widget_get_project (widget));
  if (css_provider)
    {
      argv[i] = "--css";
      argv[++i] = (gchar *) css_provider;
      argv[++i] = NULL;
    }
  
  if (g_spawn_async_with_pipes (NULL,
                                argv,
                                NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL,
                                &pid, &child_stdin, NULL, NULL,
                                &error) == FALSE)
    {
      g_warning (_("Error launching previewer: %s\n"), error->message);
      glade_util_ui_message (glade_app_get_window (),
                             GLADE_UI_ERROR, NULL,
                             _("Failed to launch preview: %s.\n"),
                             error->message);
      g_error_free (error);
      g_free (executable);
      g_free (name);
      return NULL;
    }

#ifdef G_OS_WIN32
  output = g_io_channel_win32_new_fd (child_stdin);
#else
  output = g_io_channel_unix_new (child_stdin);
#endif

  g_io_channel_write_chars (output, buffer, strlen (buffer), &bytes_written,
                            &error);

  if (bytes_written != strlen (buffer) && error != NULL)
    {
      g_warning ("Error passing UI trough pipe: %s", error->message);
      g_error_free (error);
    }

  g_io_channel_flush (output, &error);
  if (error != NULL)
    {
      g_warning ("Error flushing UI trough pipe: %s", error->message);
      g_error_free (error);
    }

  /* Setting up preview data */
  preview                         = g_object_new (GLADE_TYPE_PREVIEW, NULL);
  preview->priv->channel          = output;
  preview->priv->previewed_widget = widget;
  preview->priv->pid              = pid;

  preview->priv->watch = 
    g_child_watch_add (preview->priv->pid,
		       glade_preview_internal_watch,
		       preview);

  g_free (executable);
  g_free (name);

  return preview;
}

void
glade_preview_update (GladePreview *preview, const gchar  *buffer)
{
  const gchar *update_token = UPDATE_TOKEN;
  gchar *update;
  GIOChannel *channel;
  GError *error = NULL;
  gsize size;
  gsize bytes_written;
  GladeWidget *gwidget;

  g_return_if_fail (GLADE_IS_PREVIEW (preview));
  g_return_if_fail (buffer && buffer[0]);

  gwidget = glade_preview_get_widget (preview);

  update = g_strdup_printf ("%s%s\n", update_token,
                            glade_widget_get_name (gwidget));

  channel = preview->priv->channel;
  g_io_channel_write_chars (channel, update, strlen (update), &size, &error);

  if (size != strlen (update) && error != NULL)
    {
      g_warning ("Error passing quit signal trough pipe: %s", error->message);
      g_error_free (error);
    }

  g_io_channel_flush (channel, &error);
  if (error != NULL)
    {
      g_warning ("Error flushing channel: %s", error->message);
      g_error_free (error);
    }

  /* We'll now send the interface: */
  g_io_channel_write_chars (channel, buffer, strlen (buffer), &bytes_written,
                            &error);

  if (bytes_written != strlen (buffer) && error != NULL)
    {
      g_warning ("Error passing UI trough pipe: %s", error->message);
      g_error_free (error);
    }

  g_io_channel_flush (channel, &error);
  if (error != NULL)
    {
      g_warning ("Error flushing UI trough pipe: %s", error->message);
      g_error_free (error);
    }

  g_free (update);
}

GladeWidget *
glade_preview_get_widget (GladePreview *preview)
{
  g_return_val_if_fail (GLADE_IS_PREVIEW (preview), NULL);
  return preview->priv->previewed_widget;
}

GPid
glade_preview_get_pid (GladePreview *preview)
{
  g_return_val_if_fail (GLADE_IS_PREVIEW (preview), 0);
  return preview->priv->pid;
}
