/* This file is part of GEGL
 *
 * GEGL 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 3 of the License, or (at your option) any later version.
 *
 * GEGL 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 GEGL; if not, see <http://www.gnu.org/licenses/>.
 *
 * Copyright 2009 Øyvind Kolås
 */

#include "config.h"
#include <gegl.h>
#include <gegl-plugin.h>
#undef gegl_sampler_get
#include <glib/gprintf.h>
#include <gobject/gvaluecollector.h>
#include <stdarg.h>
#include <unistd.h>

#include "graph/gegl-node.h"
#include "graph/gegl-pad.h"

static void
gegl_graph_adopt (GeglNode *graph, GeglNode *node)
{
  GeglNode *input, *aux;

  gegl_node_add_child (graph, node);
  g_object_unref (node);

  if ((input = gegl_node_get_producer (node, "input", NULL)))
    gegl_graph_adopt (graph, input);
  if ((aux = gegl_node_get_producer (node, "aux", NULL)))
    gegl_graph_adopt (graph, aux);
}

GeglNode *
gegl_graph (GeglNode *node)
{
  GeglNode *graph;

  graph = g_object_new (GEGL_TYPE_NODE, NULL);
  if (gegl_node_get_pad (node, "output"))
    {
      GeglNode *outproxynop = gegl_node_get_output_proxy (graph, "output");
      gegl_node_connect_to (node, "output", outproxynop, "input");
    }
  gegl_graph_adopt (graph, node);
  return graph;
}

GeglNode *
gegl_node (const gchar *type,
           const gchar *firstname,
           ...)
{
  GeglNode      *node;
  GeglOperation *operation;
  va_list        var_args;
  const gchar   *property_name;

  node = g_object_new (GEGL_TYPE_NODE, "operation", type, NULL);
  g_object_get (G_OBJECT (node), "gegl-operation", &operation, NULL);

  g_object_freeze_notify (G_OBJECT (node));
  va_start (var_args, firstname);
  property_name = firstname;
  while (property_name)
    {
      GValue      value = { 0, };
      GParamSpec *pspec = NULL;
      gchar      *error = NULL;

      if (!strcmp (property_name, "name"))
        {
          pspec = g_object_class_find_property (
            G_OBJECT_GET_CLASS (G_OBJECT (node)), property_name);

          g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
          G_VALUE_COLLECT (&value, var_args, 0, &error);
          if (error)
            {
              g_warning ("%s: %s", G_STRFUNC, error);
              g_free (error);
              g_value_unset (&value);
              break;
            }
          g_object_set_property (G_OBJECT (node), property_name, &value);
          g_value_unset (&value);
        }
      else
        {
          if (operation)
            {
              pspec = g_object_class_find_property (
                G_OBJECT_GET_CLASS (G_OBJECT (operation)), property_name);
            }
          if (!pspec)
            {
              g_warning ("%s:%s has no property named: '%s'",
                         G_STRFUNC,
                         G_OBJECT_TYPE_NAME (operation), property_name);
              break;
            }
          if (!(pspec->flags & G_PARAM_WRITABLE))
            {
              g_warning ("%s: property (%s of operation class '%s' is not writable",
                         G_STRFUNC,
                         pspec->name,
                         G_OBJECT_TYPE_NAME (operation));
              break;
            }

          g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
          G_VALUE_COLLECT (&value, var_args, 0, &error);
          if (error)
            {
              g_warning ("%s: %s", G_STRFUNC, error);
              g_free (error);
              g_value_unset (&value);
              break;
            }
          g_object_set_property (G_OBJECT (operation), property_name, &value);
          g_value_unset (&value);
        }

      property_name = va_arg (var_args, gchar *);
    }
  g_object_thaw_notify (G_OBJECT (node));

  /* The input pads checked for are hard-coded, if no output is connected
   * pass NULL to indicate no connected node.
   */
  if (gegl_node_get_pad (node, "input"))
    {
      GeglNode *input = va_arg (var_args, GeglNode*);

      if (input)
        gegl_node_connect_from (node, "input", input, "output");
    }

  if (gegl_node_get_pad (node, "aux"))
    {
      GeglNode *aux = va_arg (var_args, GeglNode*);

      if (aux)
        gegl_node_connect_from (node, "aux", aux, "output");
    }
  va_end (var_args);
  return node;
}