/*

 * glade-preview-template.c

 *

 * Copyright (C) 2013 Juan Pablo Ugarte

   *

 * Author: Juan Pablo Ugarte <juanpablougarte@gmail.com>

 *

 * 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 program; if not, write to the Free Software

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

 *

 */

#include <config.h>

#include <string.h>

#include "glade-utils.h"

#include "glade-preview-template.h"

typedef struct

{

  GTypeInfo info;

  GString *template_string;

  GBytes *template_data;

  GtkBuilderConnectFunc connect_func;

  gpointer connect_data;

  gint count;

} TypeData;

/* We need to call gtk_widget_init_template() in the instance init for the

* template to work.

*/

static void

template_init (GTypeInstance *instance, gpointer g_class)

{  

  gtk_widget_init_template (GTK_WIDGET (instance));

}

static void

template_connect_function (GtkBuilder   *builder,

                           GObject      *object,

                           const gchar  *signal_name,

                           const gchar  *handler_name,

                           GObject      *connect_object,

                           GConnectFlags flags,

                           gpointer      data)

{

  /* Ignore signal connections */

}

/* Need to associate the class with a template */

static void

template_class_init (gpointer g_class, gpointer user_data)

{

  TypeData *data = user_data;

  gtk_widget_class_set_template (g_class, data->template_data);

  if (data->connect_func && data->connect_data)

    gtk_widget_class_set_connect_func (g_class, data->connect_func, data->connect_data, NULL);

  else

    gtk_widget_class_set_connect_func (g_class, template_connect_function, NULL, NULL);

}

static GQuark type_data_quark = 0;

static GType

template_generate_type (const gchar *name,

                        const gchar *parent_name,

                        GString *template_string,

                        GtkBuilderConnectFunc connect_func,

                        gpointer connect_data)

{

  GType parent_type, retval;

  gchar *real_name = NULL;

  GTypeQuery query;

  TypeData *data;

  g_return_val_if_fail (name != NULL, 0);

  g_return_val_if_fail (parent_name != NULL, 0);

  parent_type = glade_util_get_type_from_name (parent_name, FALSE);

  g_return_val_if_fail (parent_type != 0, 0);

  if ((retval = g_type_from_name (name)) &&

      (data = g_type_get_qdata (retval, type_data_quark)))

    {

      /* Type already registered! reuse TypeData

       * 

       * If the template and parent class are the same there is no need to

       * register a new type

       */

      if (g_type_parent (retval) == parent_type &&

          template_string->len == data->template_string->len && 

          g_strcmp0 (template_string->str, data->template_string->str) == 0)

        return retval;

      real_name = g_strdup_printf ("GladePreviewTemplate_%s_%d", name, data->count);

    }

  else

    {

      /* We only allocate a TypeData struct once for each type class */

      data = g_new0 (TypeData, 1);

    }

  g_type_query (parent_type, &query);

  g_return_val_if_fail (query.type != 0, 0);

  /* Free old template string */

  if (data->template_string)

    g_string_free (data->template_string, TRUE);

  /* And old bytes reference to template string */

  if (data->template_data)

    g_bytes_unref (data->template_data);

  /* Take ownership, will be freed next time we want to create this type */

  data->template_string = template_string;

  data->info.class_size = query.class_size;

  data->info.instance_size = query.instance_size;

  data->info.class_init = template_class_init;

  data->info.instance_init = template_init;

  data->info.class_data = data;

  data->template_data = g_bytes_new_static (template_string->str, template_string->len);

  data->connect_func = connect_func;

  data->connect_data = connect_data;

  retval = g_type_register_static (parent_type, real_name ? real_name : name, &data->info, 0);

  /* bind TypeData struct with GType */

  if (!data->count)

    g_type_set_qdata (retval, type_data_quark, data);

  data->count++;

  g_free (real_name);

  return retval;

}

typedef struct

{

  gboolean is_template;

  GString *xml;

  gchar *klass, *parent;

  gint indent;

} ParseData;

static void

start_element (GMarkupParseContext  *context,

               const gchar          *element_name,

               const gchar         **attribute_names,

               const gchar         **attribute_values,

               gpointer              user_data,

               GError              **error)

{

  ParseData *state = user_data;

  gboolean is_template = FALSE;

  gint i;

  g_string_append_printf (state->xml, "<%s", element_name);

  if (g_strcmp0 (element_name, "template") == 0)

    state->is_template = is_template = TRUE;

  for (i = 0; attribute_names[i]; i++)

    {

      gchar *escaped_value = g_markup_escape_text (attribute_values[i], -1);

      if (is_template)

        {

          if (!g_strcmp0 (attribute_names[i], "class"))

            {

              TypeData *data;

              GType type;

              state->klass = g_strdup (attribute_values[i]);

              /* If we are in a template then we need to replace the class with

               * the fake name template_generate_type() will use to register

                 * a new class

               */

              if ((type = g_type_from_name (state->klass)) &&

                  (data = g_type_get_qdata (type, type_data_quark)))

                {

                  g_free (escaped_value);

                  escaped_value = g_strdup_printf ("GladePreviewTemplate_%s_%d", state->klass, data->count);

                }

            }

          else if (!g_strcmp0 (attribute_names[i], "parent"))

            state->parent = g_strdup (attribute_values[i]);

        }

      g_string_append_printf (state->xml, " %s=\"%s\"",

                              attribute_names[i], escaped_value);

      g_free (escaped_value);

    }

  g_string_append (state->xml, ">");

}

static void

end_element (GMarkupParseContext *context,

             const gchar         *element_name,

             gpointer             user_data,

             GError             **error)

{

  ParseData *state = user_data;

  g_string_append_printf (state->xml, "</%s>", element_name);

}

static void

text (GMarkupParseContext *context,

      const gchar         *text,

      gsize                text_len,

      gpointer             user_data,

      GError             **error)

{

  gchar *escaped_text = g_markup_escape_text (text, text_len);

  ParseData *state = user_data;

  g_string_append_len (state->xml, escaped_text, -1);

  g_free (escaped_text);

}

static void

passthrough (GMarkupParseContext *context,

             const gchar         *text,

             gsize                text_len,

             gpointer             user_data,

             GError             **error)

{

  ParseData *state = user_data;

  g_string_append_len (state->xml, text, text_len);

  g_string_append_c (state->xml, '\n');

}

GObject *

glade_preview_template_object_new (const gchar          *template_data,

                                   gsize                 len,

                                   GtkBuilderConnectFunc connect_func,

                                   gpointer              connect_data)

{

  GMarkupParser parser = { start_element, end_element, text, passthrough};

  ParseData state = { FALSE, NULL};

  GMarkupParseContext *context;

  GObject *object = NULL;

  if (type_data_quark == 0)

    type_data_quark = g_quark_from_string ("glade-preview-type-data");

  if (len == -1)

    len = strlen (template_data);

  /* Preallocate enough for the string plus the new fake template name */

  state.xml = g_string_sized_new (len + 32);

  context = g_markup_parse_context_new (&parser,

                                        G_MARKUP_TREAT_CDATA_AS_TEXT |

                                        G_MARKUP_PREFIX_ERROR_POSITION,

                                        &state, NULL);

  if (g_markup_parse_context_parse (context, template_data, len, NULL) &&

      g_markup_parse_context_end_parse (context, NULL) && 

      state.is_template)

    {

      GType template_type = template_generate_type (state.klass,

                                                    state.parent,

                                                    state.xml,

                                                    connect_func,

                                                    connect_data);

      if (template_type)

        object = g_object_new (template_type, NULL);

      else

        {

          /* on success template_generate_type() takes ownership of xml */

          g_string_free (state.xml, TRUE);

        }

    }

  else

    g_string_free (state.xml, TRUE);

  g_free (state.klass);

  g_free (state.parent);

  g_markup_parse_context_free (context);

  return object ? g_object_ref_sink (object) : NULL;

}