/* 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 2003 Calvin Williamson
 *           2006 Øyvind Kolås
 */

#include "config.h"

#include <string.h>

#include <glib-object.h>
#include <gobject/gvaluecollector.h>

#include "gegl-types-internal.h"

#include "gegl.h"
#include "gegl-apply.h"

#include "graph/gegl-node.h"

#include "operation/gegl-operation.h"
#include "operation/gegl-operations.h"
#include "operation/gegl-operation-meta.h"
#include "operation/gegl-operation-point-filter.h"

#include "process/gegl-eval-mgr.h"
#include "process/gegl-have-visitor.h"
#include "process/gegl-prepare-visitor.h"
#include "process/gegl-finish-visitor.h"
#include "process/gegl-processor.h"


static void
gegl_node_set_props (GeglNode *node,
                     va_list   var_args)
{
  const char *property_name;

  g_object_freeze_notify (G_OBJECT (node));

  property_name = va_arg (var_args, gchar *);
  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 (node->operation)
            {
              pspec = g_object_class_find_property (
                G_OBJECT_GET_CLASS (G_OBJECT (node->operation)), property_name);
            }
          if (!pspec)
            {
              g_warning ("%s:%s has no property named: '%s'",
                         G_STRFUNC,
                         gegl_node_get_debug_name (node), 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 (node->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 (node->operation), property_name, &value);
          g_value_unset (&value);
        }
      property_name = va_arg (var_args, gchar *);
    }
  g_object_thaw_notify (G_OBJECT (node));
}


void
gegl_apply_op (GeglBuffer *buffer,
               const gchar *first_property_name,
               ...)
{
  va_list var_args;

  g_return_if_fail (GEGL_IS_BUFFER (buffer));

  va_start (var_args, first_property_name);
  gegl_apply_op_valist (buffer, first_property_name, var_args);
  va_end (var_args);
}

void
gegl_apply_op_valist (GeglBuffer  *buffer,
                      const gchar *first_property_name,
                      va_list      var_args)
{
  GeglBuffer  *tempbuf = NULL;
  GeglNode    *node;
  GeglNode    *source;
  GeglNode    *sink;

  g_return_if_fail (GEGL_IS_BUFFER (buffer));

  g_object_ref (buffer);

  source  = gegl_node_new_child (NULL, "operation", "gegl:buffer-source",
                                    "buffer", buffer,
                                    NULL);
  node   = gegl_node_new_child (NULL, "operation", first_property_name, NULL);

  if (!GEGL_IS_OPERATION_POINT_FILTER (node->operation))
    {
      tempbuf = gegl_buffer_new (gegl_buffer_get_extent (buffer), gegl_buffer_get_format (buffer));

      sink = gegl_node_new_child (NULL, "operation", "gegl:write-buffer",
                                        "buffer", tempbuf,
                                        NULL);
    }
  else
    {
      sink = gegl_node_new_child (NULL, "operation", "gegl:write-buffer",
                                        "buffer", buffer,
                                        NULL);
    }

  gegl_node_link_many (source, node, sink, NULL);

  gegl_node_set_props (node, var_args);

  gegl_node_process (sink);

  g_object_unref (source);
  g_object_unref (node);
  g_object_unref (sink);

  if (tempbuf)
    {
      gegl_buffer_copy (tempbuf, NULL, buffer, NULL);
      g_object_unref (tempbuf);
    }
  g_object_unref (buffer);
}

GeglBuffer *gegl_filter_op_valist (GeglBuffer    *buffer,
                                   const gchar   *first_property_name,
                                   va_list        var_args)
{
  GeglBuffer  *tempbuf = NULL;
  GeglNode    *node;
  GeglNode    *source;
  GeglNode    *sink;

  //g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);

  if (buffer)
    {
      g_object_ref (buffer);
      source  = gegl_node_new_child (NULL, "operation", "gegl:buffer-source",
                                        "buffer", buffer,
                                        NULL);
    }
  node   = gegl_node_new_child (NULL, "operation", first_property_name, NULL);

  sink = gegl_node_new_child (NULL, "operation", "gegl:buffer-sink",
                                    "buffer", &tempbuf,
                                    NULL);

  if (buffer)
    gegl_node_link_many (source, node, sink, NULL);
  else
    gegl_node_link_many (node, sink, NULL);

  gegl_node_set_props (node, var_args);

  gegl_node_process (sink);

  if (buffer)
    {
      g_object_unref (source);
      g_object_unref (buffer);
    }
  g_object_unref (node);
  g_object_unref (sink);

  return tempbuf;
}

GeglBuffer *gegl_filter_op     (GeglBuffer    *buffer,
                                const gchar   *first_property_name,
                                ...)
{
  GeglBuffer *ret;
  va_list var_args;

  //g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);

  va_start (var_args, first_property_name);
  ret = gegl_filter_op_valist (buffer, first_property_name, var_args);
  va_end (var_args);
  return ret;
}



void
gegl_render_op (GeglBuffer *source_buffer,
                GeglBuffer *target_buffer,
                const gchar *first_property_name,
                ...)
{
  va_list var_args;

  g_return_if_fail (GEGL_IS_BUFFER (source_buffer));
  g_return_if_fail (GEGL_IS_BUFFER (target_buffer));

  va_start (var_args, first_property_name);
  gegl_render_op_valist (source_buffer, target_buffer,
                         first_property_name, var_args);
  va_end (var_args);
}

void
gegl_render_op_valist (GeglBuffer  *source_buffer,
                       GeglBuffer  *target_buffer,
                       const gchar *first_property_name,
                       va_list      var_args)
{
  GeglNode    *node;
  GeglNode    *source;
  GeglNode    *sink;

  g_return_if_fail (GEGL_IS_BUFFER (source_buffer));
  g_return_if_fail (GEGL_IS_BUFFER (target_buffer));

  g_object_ref (source_buffer);
  g_object_ref (target_buffer);

  source  = gegl_node_new_child (NULL, "operation", "gegl:buffer-source",
                                       "buffer", source_buffer,
                                       NULL);
  node   = gegl_node_new_child (NULL, "operation", first_property_name, NULL);

  sink   = gegl_node_new_child (NULL, "operation", "gegl:write-buffer",
                                      "buffer", target_buffer,
                                      NULL);

  gegl_node_link_many (source, node, sink, NULL);
  gegl_node_set_props (node, var_args);
  gegl_node_process (sink);

  g_object_unref (source);
  g_object_unref (node);
  g_object_unref (sink);

  g_object_unref (source_buffer);
  g_object_unref (target_buffer);
}