/*

 * Clutter.

 *

 * An OpenGL based 'interactive canvas' library.

 *

 * Copyright (C) 2006, 2007, 2008 OpenedHand Ltd

 * Copyright (C) 2009 Intel Corportation

 *

 * 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 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see <http://www.gnu.org/licenses/>.

 *

 * Original author:

 *

 *      Emmanuele Bassi <ebassi@linux.intel.com>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <stdlib.h>

#include <glib.h>

#include <gmodule.h>

#define CLUTTER_DISABLE_DEPRECATION_WARNINGS

#include "deprecated/clutter-container.h"

#include "deprecated/clutter-alpha.h"

#include "clutter-actor.h"

#include "clutter-debug.h"

#include "clutter-enum-types.h"

#include "clutter-script.h"

#include "clutter-script-private.h"

#include "clutter-scriptable.h"

#include "clutter-stage-manager.h"

#include "clutter-private.h"

static void clutter_script_parser_object_end (JsonParser *parser,

                                              JsonObject *object);

static void clutter_script_parser_parse_end  (JsonParser *parser);

#define clutter_script_parser_get_type  _clutter_script_parser_get_type

G_DEFINE_TYPE (ClutterScriptParser, clutter_script_parser, JSON_TYPE_PARSER);

static void

clutter_script_parser_class_init (ClutterScriptParserClass *klass)

{

  JsonParserClass *parser_class = JSON_PARSER_CLASS (klass);

  parser_class->object_end = clutter_script_parser_object_end;

  parser_class->parse_end = clutter_script_parser_parse_end;

}

static void

clutter_script_parser_init (ClutterScriptParser *parser)

{

}

GType

_clutter_script_get_type_from_symbol (const gchar *symbol)

{

  static GModule *module = NULL;

  GTypeGetFunc func;

  GType gtype = G_TYPE_INVALID;

  if (!module)

    module = g_module_open (NULL, 0);

  if (g_module_symbol (module, symbol, (gpointer)&func))

    gtype = func ();

  return gtype;

}

GType

_clutter_script_get_type_from_class (const gchar *name)

{

  static GModule *module = NULL;

  GString *symbol_name = g_string_sized_new (64);

  GType gtype = G_TYPE_INVALID;

  GTypeGetFunc func;

  gchar *symbol;

  gint i;

  if (G_UNLIKELY (!module))

    module = g_module_open (NULL, 0);

  for (i = 0; name[i] != '\0'; i++)

    {

      gchar c = name[i];

      /* the standard naming policy for GObject-based libraries

       * is:

       *

       *   NAME := INITIAL_WORD WORD+

       *   INITIAL_WORD := [A-Z][a-z0-9]*

       *   WORD := [A-Z]{1,2}[a-z0-9]+ | [A-Z]{2,}

       *

       * for instance:

       *

       *   GString -> g_string

       *   GtkCTree -> gtk_ctree

       *   ClutterX11TexturePixmap -> clutter_x11_texture_pixmap

       *

       * see:

       *

       * http://mail.gnome.org/archives/gtk-devel-list/2007-June/msg00022.html

       *

       * and:

       *

       * http://git.gnome.org/cgit/gtk+/plain/gtk/gtkbuilderparser.c

       */

      if ((c == g_ascii_toupper (c) &&

           i > 0 && name[i - 1] != g_ascii_toupper (name[i - 1])) ||

          (i > 2 && name[i] == g_ascii_toupper (name[i]) &&

           name[i - 1] == g_ascii_toupper (name[i - 1]) &&

           name[i - 2] == g_ascii_toupper (name[i - 2])))

        g_string_append_c (symbol_name, '_');

      g_string_append_c (symbol_name, g_ascii_tolower (c));

    }

  g_string_append (symbol_name, "_get_type");

  symbol = g_string_free (symbol_name, FALSE);

  if (g_module_symbol (module, symbol, (gpointer)&func))

    {

      CLUTTER_NOTE (SCRIPT, "Type function: %s", symbol);

      gtype = func ();

    }

  g_free (symbol);

  return gtype;

}

/*

 * clutter_script_enum_from_string:

 * @type: a #GType for an enumeration type

 * @string: the enumeration value as a string

 * @enum_value: (out): return location for the enumeration value as an integer

 *

 * Converts an enumeration value inside @string into a numeric

 * value and places it into @enum_value.

 *

 * The enumeration value can be an integer, the enumeration nick

 * or the enumeration name, as part of the #GEnumValue structure.

 *

 * Return value: %TRUE if the conversion was successfull.

 */

gboolean

_clutter_script_enum_from_string (GType        type,

                                  const gchar *string,

                                  gint        *enum_value)

{

  GEnumClass *eclass;

  GEnumValue *ev;

  gchar *endptr;

  gint value;

  gboolean retval = TRUE;

  g_return_val_if_fail (G_TYPE_IS_ENUM (type), 0);

  g_return_val_if_fail (string != NULL, 0);

  value = strtoul (string, &endptr, 0);

  if (endptr != string) /* parsed a number */

    *enum_value = value;

  else

    {

      eclass = g_type_class_ref (type);

      ev = g_enum_get_value_by_name (eclass, string);

      if (!ev)

	ev = g_enum_get_value_by_nick (eclass, string);

      if (ev)

	*enum_value = ev->value;

      else

        retval = FALSE;

      g_type_class_unref (eclass);

    }

  return retval;

}

gboolean

_clutter_script_flags_from_string (GType        type,

                                   const gchar *string,

                                   gint        *flags_value)

{

  gchar *endptr, *prevptr;

  guint i, j, ret, value;

  gchar *flagstr;

  GFlagsValue *fv;

  const gchar *flag;

  g_return_val_if_fail (G_TYPE_IS_FLAGS (type), 0);

  g_return_val_if_fail (string != NULL, 0);

  ret = TRUE;

  value = strtoul (string, &endptr, 0);

  if (endptr != string) /* parsed a number */

    *flags_value = value;

  else

    {

      GFlagsClass *fclass;

      fclass = g_type_class_ref (type);

      flagstr = g_strdup (string);

      for (value = i = j = 0; ; i++)

	{

          gboolean eos = (flagstr[i] == '\0') ? TRUE : FALSE;

	  if (!eos && flagstr[i] != '|')

	    continue;

	  flag = &flagstr[j];

	  endptr = &flagstr[i];

	  if (!eos)

	    {

	      flagstr[i++] = '\0';

	      j = i;

	    }

	  /* trim spaces */

	  for (;;)

	    {

	      gunichar ch = g_utf8_get_char (flag);

	      if (!g_unichar_isspace (ch))

		break;

	      flag = g_utf8_next_char (flag);

	    }

	  while (endptr > flag)

	    {

              gunichar ch;

	      prevptr = g_utf8_prev_char (endptr);

	      ch = g_utf8_get_char (prevptr);

	      if (!g_unichar_isspace (ch))

		break;

	      endptr = prevptr;

	    }

	  if (endptr > flag)

	    {

	      *endptr = '\0';

	      fv = g_flags_get_value_by_name (fclass, flag);

	      if (!fv)

		fv = g_flags_get_value_by_nick (fclass, flag);

	      if (fv)

		value |= fv->value;

	      else

		{

		  ret = FALSE;

		  break;

		}

	    }

	  if (eos)

	    {

	      *flags_value = value;

	      break;

	    }

	}

      g_free (flagstr);

      g_type_class_unref (fclass);

    }

  return ret;

}

static gboolean

parse_knot_from_array (JsonArray   *array,

                       ClutterKnot *knot)

{

  if (json_array_get_length (array) != 2)

    return FALSE;

  knot->x = json_array_get_int_element (array, 0);

  knot->y = json_array_get_int_element (array, 1);

  return TRUE;

}

static gboolean

parse_knot_from_object (JsonObject  *object,

                        ClutterKnot *knot)

{

  if (json_object_has_member (object, "x"))

    knot->x = json_object_get_int_member (object, "x");

  else

    knot->x = 0;

  if (json_object_has_member (object, "y"))

    knot->y = json_object_get_int_member (object, "y");

  else

    knot->y = 0;

  return TRUE;

}

gboolean

_clutter_script_parse_knot (ClutterScript *script,

                            JsonNode      *node,

                            ClutterKnot   *knot)

{

  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);

  g_return_val_if_fail (node != NULL, FALSE);

  g_return_val_if_fail (knot != NULL, FALSE);

  switch (JSON_NODE_TYPE (node))

    {

    case JSON_NODE_ARRAY:

      return parse_knot_from_array (json_node_get_array (node), knot);

    case JSON_NODE_OBJECT:

      return parse_knot_from_object (json_node_get_object (node), knot);

    default:

      break;

    }

  return FALSE;

}

static gboolean

parse_geometry_from_array (JsonArray       *array,

                           ClutterGeometry *geometry)

{

  if (json_array_get_length (array) != 4)

    return FALSE;

  geometry->x = json_array_get_int_element (array, 0);

  geometry->y = json_array_get_int_element (array, 1);

  geometry->width = json_array_get_int_element (array, 2);

  geometry->height = json_array_get_int_element (array, 3);

  return TRUE;

}

static gboolean

parse_geometry_from_object (JsonObject      *object,

                            ClutterGeometry *geometry)

{

  if (json_object_has_member (object, "x"))

    geometry->x = json_object_get_int_member (object, "x");

  else

    geometry->x = 0;

  if (json_object_has_member (object, "y"))

    geometry->y = json_object_get_int_member (object, "y");

  else

    geometry->y = 0;

  if (json_object_has_member (object, "width"))

    geometry->width = json_object_get_int_member (object, "width");

  else

    geometry->width = 0;

  if (json_object_has_member (object, "height"))

    geometry->height = json_object_get_int_member (object, "height");

  else

    geometry->height = 0;

  return TRUE;

}

gboolean

_clutter_script_parse_geometry (ClutterScript   *script,

                                JsonNode        *node,

                                ClutterGeometry *geometry)

{

  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);

  g_return_val_if_fail (node != NULL, FALSE);

  g_return_val_if_fail (geometry != NULL, FALSE);

  switch (JSON_NODE_TYPE (node))

    {

    case JSON_NODE_ARRAY:

      return parse_geometry_from_array (json_node_get_array (node), geometry);

    case JSON_NODE_OBJECT:

      return parse_geometry_from_object (json_node_get_object (node), geometry);

    default:

      break;

    }

  return FALSE;

}

static gboolean

parse_color_from_array (JsonArray    *array,

                        ClutterColor *color)

{

  if (json_array_get_length (array) != 3 ||

      json_array_get_length (array) != 4)

    return FALSE;

  color->red   = CLAMP (json_array_get_int_element (array, 0), 0, 255);

  color->green = CLAMP (json_array_get_int_element (array, 1), 0, 255);

  color->blue  = CLAMP (json_array_get_int_element (array, 2), 0, 255);

  if (json_array_get_length (array) == 4)

    color->alpha = CLAMP (json_array_get_int_element (array, 3), 0, 255);

  else

    color->alpha = 255;

  return TRUE;

}

static gboolean

parse_color_from_object (JsonObject   *object,

                         ClutterColor *color)

{

  if (json_object_has_member (object, "red"))

    color->red = CLAMP (json_object_get_int_member (object, "red"), 0, 255);

  else

    color->red = 0;

  if (json_object_has_member (object, "green"))

    color->green = CLAMP (json_object_get_int_member (object, "green"), 0, 255);

  else

    color->green = 0;

  if (json_object_has_member (object, "blue"))

    color->blue = CLAMP (json_object_get_int_member (object, "blue"), 0, 255);

  else

    color->blue = 0;

  if (json_object_has_member (object, "alpha"))

    color->alpha = CLAMP (json_object_get_int_member (object, "alpha"), 0, 255);

  else

    color->alpha = 255;

  return TRUE;

}

gboolean

_clutter_script_parse_color (ClutterScript *script,

                             JsonNode      *node,

                             ClutterColor  *color)

{

  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);

  g_return_val_if_fail (node != NULL, FALSE);

  g_return_val_if_fail (color != NULL, FALSE);

  switch (JSON_NODE_TYPE (node))

    {

    case JSON_NODE_ARRAY:

      return parse_color_from_array (json_node_get_array (node), color);

    case JSON_NODE_OBJECT:

      return parse_color_from_object (json_node_get_object (node), color);

    case JSON_NODE_VALUE:

      return clutter_color_from_string (color, json_node_get_string (node));

    default:

      break;

    }

  return FALSE;

}

static gboolean

parse_point_from_array (JsonArray    *array,

                        ClutterPoint *point)

{

  if (json_array_get_length (array) != 2)

    return FALSE;

  point->x = json_array_get_double_element (array, 0);

  point->y = json_array_get_double_element (array, 1);

  return TRUE;

}

static gboolean

parse_point_from_object (JsonObject   *object,

                         ClutterPoint *point)

{

  if (json_object_has_member (object, "x"))

    point->x = json_object_get_double_member (object, "x");

  else

    point->x = 0.f;

  if (json_object_has_member (object, "y"))

    point->y = json_object_get_double_member (object, "y");

  else

    point->y = 0.f;

  return TRUE;

}

gboolean

_clutter_script_parse_point (ClutterScript *script,

                             JsonNode      *node,

                             ClutterPoint  *point)

{

  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);

  g_return_val_if_fail (node != NULL, FALSE);

  g_return_val_if_fail (point != NULL, FALSE);

  switch (JSON_NODE_TYPE (node))

    {

    case JSON_NODE_ARRAY:

      return parse_point_from_array (json_node_get_array (node), point);

    case JSON_NODE_OBJECT:

      return parse_point_from_object (json_node_get_object (node), point);

    default:

      break;

    }

  return FALSE;

}

static gboolean

parse_size_from_array (JsonArray   *array,

                       ClutterSize *size)

{

  if (json_array_get_length (array) != 2)

    return FALSE;

  size->width = json_array_get_double_element (array, 0);

  size->height = json_array_get_double_element (array, 1);

  return TRUE;

}

static gboolean

parse_size_from_object (JsonObject  *object,

                        ClutterSize *size)

{

  if (json_object_has_member (object, "width"))

    size->width = json_object_get_double_member (object, "width");

  else

    size->width = 0.f;

  if (json_object_has_member (object, "height"))

    size->height = json_object_get_double_member (object, "height");

  else

    size->height = 0.f;

  return TRUE;

}

gboolean

_clutter_script_parse_size (ClutterScript *script,

                            JsonNode      *node,

                            ClutterSize   *size)

{

  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);

  g_return_val_if_fail (node != NULL, FALSE);

  g_return_val_if_fail (size != NULL, FALSE);

  switch (JSON_NODE_TYPE (node))

    {

    case JSON_NODE_ARRAY:

      return parse_size_from_array (json_node_get_array (node), size);

    case JSON_NODE_OBJECT:

      return parse_size_from_object (json_node_get_object (node), size);

    default:

      break;

    }

  return FALSE;

}

const gchar *

_clutter_script_get_id_from_node (JsonNode *node)

{

  JsonObject *object;

  switch (JSON_NODE_TYPE (node))

    {

    case JSON_NODE_OBJECT:

      object = json_node_get_object (node);

      if (json_object_has_member (object, "id"))

        return json_object_get_string_member (object, "id");

      break;

    case JSON_NODE_VALUE:

      return json_node_get_string (node);

    default:

      break;

    }

  return NULL;

}

static GList *

parse_children (ObjectInfo *oinfo,

                JsonNode   *node)

{

  JsonArray *array;

  GList *retval;

  guint array_len, i;

  if (JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)

    return NULL;

  retval = oinfo->children;

  array = json_node_get_array (node);

  array_len = json_array_get_length (array);

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

    {

      JsonNode *child = json_array_get_element (array, i);

      const gchar *id_;

      id_ = _clutter_script_get_id_from_node (child);

      if (id_ != NULL)

        retval = g_list_prepend (retval, g_strdup (id_));

    }

  return g_list_reverse (retval);

}

static GList *

parse_signals (ClutterScript *script,

               ObjectInfo    *oinfo,

               JsonNode      *node)

{

  JsonArray *array;

  GList *retval;

  guint array_len, i;

  if (JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)

    {

      _clutter_script_warn_invalid_value (script, "signals", "Array", node);

      return NULL;

    }

  retval = oinfo->signals;

  array = json_node_get_array (node);

  array_len = json_array_get_length (array);

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

    {

      JsonNode *val = json_array_get_element (array, i);

      SignalInfo *sinfo = NULL;

      JsonObject *object;

      const gchar *name;

      if (JSON_NODE_TYPE (val) != JSON_NODE_OBJECT)

        {

          _clutter_script_warn_invalid_value (script,

                                              "signals array", "Object",

                                              node);

          continue;

        }

      object = json_node_get_object (val);

      /* mandatory: "name" */

      if (!json_object_has_member (object, "name"))

        {

          _clutter_script_warn_missing_attribute (script, NULL, "name");

          continue;

        }

      else

        {

          name = json_object_get_string_member (object, "name");

          if (!name)

            {

              _clutter_script_warn_invalid_value (script,

                                                  "name", "string",

                                                  val);

              continue;

            }

        }

      /* mandatory: "target-state" or "handler" */

      if (json_object_has_member (object, "target-state"))

        {

          const gchar *state = NULL;

          const gchar *target = NULL;

          gboolean warp_to = FALSE;

          target = json_object_get_string_member (object, "target-state");

          if (target == NULL)

            {

              _clutter_script_warn_invalid_value (script,

                                                  "target-state", "string",

                                                  val);

              continue;

            }

          if (json_object_has_member (object, "states"))

            state = json_object_get_string_member (object, "states");

          if (json_object_has_member (object, "warp"))

            warp_to = json_object_get_boolean_member (object, "warp");

          CLUTTER_NOTE (SCRIPT,

                        "Added signal '%s' (states:%s, target-state:%s, warp:%s)",

                        name,

                        state != NULL ? state : "<default>", target,

                        warp_to ? "true" : "false");

          sinfo = g_slice_new0 (SignalInfo);

          sinfo->is_handler = FALSE;

          sinfo->name = g_strdup (name);

          sinfo->state = g_strdup (state);

          sinfo->target = g_strdup (target);

          sinfo->warp_to = warp_to;

        }

      else if (json_object_has_member (object, "handler"))

        {

          const gchar *handler;

          const gchar *connect;

          GConnectFlags flags = 0;

          handler = json_object_get_string_member (object, "handler");

          if (handler == NULL)

            {

              _clutter_script_warn_invalid_value (script,

                                                  "handler", "string",

                                                  val);

              continue;

            }

          /* optional: "object" */

          if (json_object_has_member (object, "object"))

            connect = json_object_get_string_member (object, "object");

          else

            connect = NULL;

          /* optional: "after" */

          if (json_object_has_member (object, "after"))

            {

              if (json_object_get_boolean_member (object, "after"))

                flags |= G_CONNECT_AFTER;

            }

          /* optional: "swapped" */

          if (json_object_has_member (object, "swapped"))

            {

              if (json_object_get_boolean_member (object, "swapped"))

                flags |= G_CONNECT_SWAPPED;

            }

          CLUTTER_NOTE (SCRIPT,

                        "Added signal '%s' (handler:%s, object:%s, flags:%d)",

                        name,

                        handler, connect, flags);

          sinfo = g_slice_new0 (SignalInfo);

          sinfo->is_handler = TRUE;

          sinfo->name = g_strdup (name);

          sinfo->handler = g_strdup (handler);

          sinfo->object = g_strdup (connect);

          sinfo->flags = flags;

        }

      else

        _clutter_script_warn_missing_attribute (script,

                                                NULL,

                                                "handler or state");

      if (sinfo != NULL)

        retval = g_list_prepend (retval, sinfo);

    }

  return retval;

}

static ClutterTimeline *

construct_timeline (ClutterScript *script,

                    JsonObject    *object)

{

  ClutterTimeline *retval = NULL;

  ObjectInfo *oinfo;

  GList *members, *l;

  /* we fake an ObjectInfo so we can reuse clutter_script_construct_object()

   * here; we do not save it inside the hash table, because if this had

   * been a named object then we wouldn't have ended up here in the first

   * place

   */

  oinfo = g_slice_new0 (ObjectInfo);

  oinfo->gtype = CLUTTER_TYPE_TIMELINE;

  oinfo->id = g_strdup ("dummy");

  members = json_object_get_members (object);

  for (l = members; l != NULL; l = l->next)

    {

      const gchar *name = l->data;

      JsonNode *node = json_object_get_member (object, name);

      PropertyInfo *pinfo = g_slice_new0 (PropertyInfo);

      pinfo->name = g_strdelimit (g_strdup (name), G_STR_DELIMITERS, '-');

      pinfo->node = json_node_copy (node);

      oinfo->properties = g_list_prepend (oinfo->properties, pinfo);

    }

  g_list_free (members);

  _clutter_script_construct_object (script, oinfo);

  _clutter_script_apply_properties (script, oinfo);

  retval = CLUTTER_TIMELINE (oinfo->object);

  /* we transfer ownership to the alpha function, so we ref before

   * destroying the ObjectInfo to avoid the timeline going away

   */

  g_object_ref (retval);

  object_info_free (oinfo);

  return retval;

}

/* define the names of the animation modes to match the ones

 * that developers might be more accustomed to

 */

static const struct

{

  const gchar *name;

  ClutterAnimationMode mode;

} animation_modes[] = {

  { "linear", CLUTTER_LINEAR },

  { "easeInQuad", CLUTTER_EASE_IN_QUAD },

  { "easeOutQuad", CLUTTER_EASE_OUT_QUAD },

  { "easeInOutQuad", CLUTTER_EASE_IN_OUT_QUAD },

  { "easeInCubic", CLUTTER_EASE_IN_CUBIC },

  { "easeOutCubic", CLUTTER_EASE_OUT_CUBIC },

  { "easeInOutCubic", CLUTTER_EASE_IN_OUT_CUBIC },

  { "easeInQuart", CLUTTER_EASE_IN_QUART },

  { "easeOutQuart", CLUTTER_EASE_OUT_QUART },

  { "easeInOutQuart", CLUTTER_EASE_IN_OUT_QUART },

  { "easeInQuint", CLUTTER_EASE_IN_QUINT },

  { "easeOutQuint", CLUTTER_EASE_OUT_QUINT },

  { "easeInOutQuint", CLUTTER_EASE_IN_OUT_QUINT },

  { "easeInSine", CLUTTER_EASE_IN_SINE },

  { "easeOutSine", CLUTTER_EASE_OUT_SINE },

  { "easeInOutSine", CLUTTER_EASE_IN_OUT_SINE },

  { "easeInExpo", CLUTTER_EASE_IN_EXPO },

  { "easeOutExpo", CLUTTER_EASE_OUT_EXPO },

  { "easeInOutExpo", CLUTTER_EASE_IN_OUT_EXPO },

  { "easeInCirc", CLUTTER_EASE_IN_CIRC },

  { "easeOutCirc", CLUTTER_EASE_OUT_CIRC },

  { "easeInOutCirc", CLUTTER_EASE_IN_OUT_CIRC },

  { "easeInElastic", CLUTTER_EASE_IN_ELASTIC },

  { "easeOutElastic", CLUTTER_EASE_OUT_ELASTIC },

  { "easeInOutElastic", CLUTTER_EASE_IN_OUT_ELASTIC },