/* PIKA - Photo and Image Kooker Application
 * a rebranding of The GNU Image Manipulation Program (created with heckimp)
 * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
 *
 * Original copyright, applying to most contents (license remains unchanged): 
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 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 General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "config.h"

#include <cairo.h>
#include <gegl.h>
#include <gdk-pixbuf/gdk-pixbuf.h>

#include "libpikabase/pikabase.h"
#include "libpikacolor/pikacolor.h"

#include "core-types.h"

#include "gegl/pika-babl.h"
#include "gegl/pika-gegl-loops.h"
#include "gegl/pika-gegl-utils.h"

#include "pika-memsize.h"
#include "pikabuffer.h"
#include "pikaimage.h"
#include "pikatempbuf.h"


static void          pika_color_managed_iface_init (PikaColorManagedInterface *iface);

static void          pika_buffer_finalize          (GObject           *object);

static gint64        pika_buffer_get_memsize       (PikaObject        *object,
                                                    gint64            *gui_size);

static gboolean      pika_buffer_get_size          (PikaViewable      *viewable,
                                                    gint              *width,
                                                    gint              *height);
static void          pika_buffer_get_preview_size  (PikaViewable      *viewable,
                                                    gint               size,
                                                    gboolean           is_popup,
                                                    gboolean           dot_for_dot,
                                                    gint              *popup_width,
                                                    gint              *popup_height);
static gboolean      pika_buffer_get_popup_size    (PikaViewable      *viewable,
                                                    gint               width,
                                                    gint               height,
                                                    gboolean           dot_for_dot,
                                                    gint              *popup_width,
                                                    gint              *popup_height);
static PikaTempBuf * pika_buffer_get_new_preview   (PikaViewable      *viewable,
                                                    PikaContext       *context,
                                                    gint               width,
                                                    gint               height);
static GdkPixbuf   * pika_buffer_get_new_pixbuf    (PikaViewable      *viewable,
                                                    PikaContext       *context,
                                                    gint               width,
                                                    gint               height);
static gchar       * pika_buffer_get_description   (PikaViewable      *viewable,
                                                    gchar            **tooltip);

static const guint8 *
       pika_buffer_color_managed_get_icc_profile   (PikaColorManaged  *managed,
                                                    gsize             *len);
static PikaColorProfile *
       pika_buffer_color_managed_get_color_profile (PikaColorManaged  *managed);
static void
       pika_buffer_color_managed_profile_changed   (PikaColorManaged  *managed);


G_DEFINE_TYPE_WITH_CODE (PikaBuffer, pika_buffer, PIKA_TYPE_VIEWABLE,
                         G_IMPLEMENT_INTERFACE (PIKA_TYPE_COLOR_MANAGED,
                                                pika_color_managed_iface_init))

#define parent_class pika_buffer_parent_class


static void
pika_buffer_class_init (PikaBufferClass *klass)
{
  GObjectClass      *object_class      = G_OBJECT_CLASS (klass);
  PikaObjectClass   *pika_object_class = PIKA_OBJECT_CLASS (klass);
  PikaViewableClass *viewable_class    = PIKA_VIEWABLE_CLASS (klass);

  object_class->finalize            = pika_buffer_finalize;

  pika_object_class->get_memsize    = pika_buffer_get_memsize;

  viewable_class->default_icon_name = "edit-paste";
  viewable_class->name_editable     = TRUE;
  viewable_class->get_size          = pika_buffer_get_size;
  viewable_class->get_preview_size  = pika_buffer_get_preview_size;
  viewable_class->get_popup_size    = pika_buffer_get_popup_size;
  viewable_class->get_new_preview   = pika_buffer_get_new_preview;
  viewable_class->get_new_pixbuf    = pika_buffer_get_new_pixbuf;
  viewable_class->get_description   = pika_buffer_get_description;
}

static void
pika_color_managed_iface_init (PikaColorManagedInterface *iface)
{
  iface->get_icc_profile   = pika_buffer_color_managed_get_icc_profile;
  iface->get_color_profile = pika_buffer_color_managed_get_color_profile;
  iface->profile_changed   = pika_buffer_color_managed_profile_changed;
}

static void
pika_buffer_init (PikaBuffer *buffer)
{
}

static void
pika_buffer_finalize (GObject *object)
{
  PikaBuffer *buffer = PIKA_BUFFER (object);

  g_clear_object (&buffer->buffer);

  pika_buffer_set_color_profile (buffer, NULL);

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static gint64
pika_buffer_get_memsize (PikaObject *object,
                         gint64     *gui_size)
{
  PikaBuffer *buffer  = PIKA_BUFFER (object);
  gint64      memsize = 0;

  memsize += pika_gegl_buffer_get_memsize (buffer->buffer);
  memsize += pika_g_object_get_memsize (G_OBJECT (buffer->color_profile));
  memsize += pika_g_object_get_memsize (G_OBJECT (buffer->format_profile));

  return memsize + PIKA_OBJECT_CLASS (parent_class)->get_memsize (object,
                                                                  gui_size);
}

static gboolean
pika_buffer_get_size (PikaViewable *viewable,
                      gint         *width,
                      gint         *height)
{
  PikaBuffer *buffer = PIKA_BUFFER (viewable);

  *width  = pika_buffer_get_width (buffer);
  *height = pika_buffer_get_height (buffer);

  return TRUE;
}

static void
pika_buffer_get_preview_size (PikaViewable *viewable,
                              gint          size,
                              gboolean      is_popup,
                              gboolean      dot_for_dot,
                              gint         *width,
                              gint         *height)
{
  PikaBuffer *buffer = PIKA_BUFFER (viewable);

  pika_viewable_calc_preview_size (pika_buffer_get_width (buffer),
                                   pika_buffer_get_height (buffer),
                                   size,
                                   size,
                                   dot_for_dot, 1.0, 1.0,
                                   width,
                                   height,
                                   NULL);
}

static gboolean
pika_buffer_get_popup_size (PikaViewable *viewable,
                            gint          width,
                            gint          height,
                            gboolean      dot_for_dot,
                            gint         *popup_width,
                            gint         *popup_height)
{
  PikaBuffer *buffer;
  gint        buffer_width;
  gint        buffer_height;

  buffer        = PIKA_BUFFER (viewable);
  buffer_width  = pika_buffer_get_width (buffer);
  buffer_height = pika_buffer_get_height (buffer);

  if (buffer_width > width || buffer_height > height)
    {
      gboolean scaling_up;

      pika_viewable_calc_preview_size (buffer_width,
                                       buffer_height,
                                       width  * 2,
                                       height * 2,
                                       dot_for_dot, 1.0, 1.0,
                                       popup_width,
                                       popup_height,
                                       &scaling_up);

      if (scaling_up)
        {
          *popup_width  = buffer_width;
          *popup_height = buffer_height;
        }

      return TRUE;
    }

  return FALSE;
}

static PikaTempBuf *
pika_buffer_get_new_preview (PikaViewable *viewable,
                             PikaContext  *context,
                             gint          width,
                             gint          height)
{
  PikaBuffer  *buffer = PIKA_BUFFER (viewable);
  const Babl  *format = pika_buffer_get_format (buffer);
  PikaTempBuf *preview;

  if (babl_format_is_palette (format))
    format = pika_babl_format (PIKA_RGB,
                               PIKA_PRECISION_U8_NON_LINEAR,
                               babl_format_has_alpha (format),
                               babl_format_get_space (format));
  else
    format = pika_babl_format (pika_babl_format_get_base_type (format),
                               pika_babl_precision (PIKA_COMPONENT_TYPE_U8,
                                                    pika_babl_format_get_trc (format)),
                               babl_format_has_alpha (format),
                               babl_format_get_space (format));

  preview = pika_temp_buf_new (width, height, format);

  gegl_buffer_get (buffer->buffer, GEGL_RECTANGLE (0, 0, width, height),
                   MIN ((gdouble) width  / (gdouble) pika_buffer_get_width (buffer),
                        (gdouble) height / (gdouble) pika_buffer_get_height (buffer)),
                   format,
                   pika_temp_buf_get_data (preview),
                   GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);

  return preview;
}

static GdkPixbuf *
pika_buffer_get_new_pixbuf (PikaViewable *viewable,
                            PikaContext  *context,
                            gint          width,
                            gint          height)
{
  PikaBuffer *buffer = PIKA_BUFFER (viewable);
  GdkPixbuf  *pixbuf;
  gdouble     scale;

  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
                           width, height);

  scale = MIN ((gdouble) width  / (gdouble) pika_buffer_get_width (buffer),
               (gdouble) height / (gdouble) pika_buffer_get_height (buffer));

  if (buffer->color_profile)
    {
      PikaColorProfile *srgb_profile;
      PikaTempBuf      *temp_buf;
      GeglBuffer       *src_buf;
      GeglBuffer       *dest_buf;

      srgb_profile = pika_color_profile_new_rgb_srgb ();

      temp_buf = pika_temp_buf_new (width, height,
                                    pika_buffer_get_format (buffer));

      gegl_buffer_get (buffer->buffer,
                       GEGL_RECTANGLE (0, 0, width, height),
                       scale,
                       pika_temp_buf_get_format (temp_buf),
                       pika_temp_buf_get_data (temp_buf),
                       GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);

      src_buf  = pika_temp_buf_create_buffer (temp_buf);
      dest_buf = pika_pixbuf_create_buffer (pixbuf);

      pika_temp_buf_unref (temp_buf);

      pika_gegl_convert_color_profile (src_buf,
                                       GEGL_RECTANGLE (0, 0, width, height),
                                       buffer->color_profile,
                                       dest_buf,
                                       GEGL_RECTANGLE (0, 0, 0, 0),
                                       srgb_profile,
                                       PIKA_COLOR_RENDERING_INTENT_PERCEPTUAL,
                                       TRUE,
                                       NULL);

      g_object_unref (src_buf);
      g_object_unref (dest_buf);

      g_object_unref (srgb_profile);
    }
  else
    {
      gegl_buffer_get (buffer->buffer,
                       GEGL_RECTANGLE (0, 0, width, height),
                       scale,
                       pika_pixbuf_get_format (pixbuf),
                       gdk_pixbuf_get_pixels (pixbuf),
                       gdk_pixbuf_get_rowstride (pixbuf),
                       GEGL_ABYSS_CLAMP);
    }

  return pixbuf;
}

static gchar *
pika_buffer_get_description (PikaViewable  *viewable,
                             gchar        **tooltip)
{
  PikaBuffer *buffer = PIKA_BUFFER (viewable);

  return g_strdup_printf ("%s (%d × %d)",
                          pika_object_get_name (buffer),
                          pika_buffer_get_width (buffer),
                          pika_buffer_get_height (buffer));
}

static const guint8 *
pika_buffer_color_managed_get_icc_profile (PikaColorManaged *managed,
                                           gsize            *len)
{
  PikaBuffer *buffer = PIKA_BUFFER (managed);

  if (buffer->color_profile)
    return pika_color_profile_get_icc_profile (buffer->color_profile, len);

  /* creates buffer->format_profile */
  pika_color_managed_get_color_profile (managed);

  return pika_color_profile_get_icc_profile (buffer->format_profile, len);
}

static PikaColorProfile *
pika_buffer_color_managed_get_color_profile (PikaColorManaged *managed)
{
  PikaBuffer *buffer = PIKA_BUFFER (managed);

  if (buffer->color_profile)
    return buffer->color_profile;

  if (! buffer->format_profile)
    buffer->format_profile =
      pika_babl_format_get_color_profile (pika_buffer_get_format (buffer));

  return buffer->format_profile;
}

static void
pika_buffer_color_managed_profile_changed (PikaColorManaged *managed)
{
  pika_viewable_invalidate_preview (PIKA_VIEWABLE (managed));
}


/*  public functions  */

PikaBuffer *
pika_buffer_new (GeglBuffer    *buffer,
                 const gchar   *name,
                 gint           offset_x,
                 gint           offset_y,
                 gboolean       copy_pixels)
{
  PikaBuffer *pika_buffer;

  g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);
  g_return_val_if_fail (name != NULL, NULL);

  pika_buffer = g_object_new (PIKA_TYPE_BUFFER,
                              "name", name,
                              NULL);

  if (copy_pixels)
    pika_buffer->buffer = pika_gegl_buffer_dup (buffer);
  else
    pika_buffer->buffer = g_object_ref (buffer);

  pika_buffer->offset_x = offset_x;
  pika_buffer->offset_y = offset_y;

  return pika_buffer;
}

PikaBuffer *
pika_buffer_new_from_pixbuf (GdkPixbuf   *pixbuf,
                             const gchar *name,
                             gint         offset_x,
                             gint         offset_y)
{
  PikaBuffer       *pika_buffer;
  GeglBuffer       *buffer;
  guint8           *icc_data;
  gsize             icc_len;
  PikaColorProfile *profile = NULL;

  g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
  g_return_val_if_fail (name != NULL, NULL);

  buffer = pika_pixbuf_create_buffer (pixbuf);

  pika_buffer = pika_buffer_new (buffer, name,
                                 offset_x, offset_y, FALSE);

  icc_data = pika_pixbuf_get_icc_profile (pixbuf, &icc_len);
  if (icc_data)
    {
      profile = pika_color_profile_new_from_icc_profile (icc_data, icc_len,
                                                         NULL);
      g_free (icc_data);
    }

  if (! profile && gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB)
    {
      profile = pika_color_profile_new_rgb_srgb ();
    }

  if (profile)
    {
      pika_buffer_set_color_profile (pika_buffer, profile);
      g_object_unref (profile);
    }

  g_object_unref (buffer);

  return pika_buffer;
}

gint
pika_buffer_get_width (PikaBuffer *buffer)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), 0);

  return gegl_buffer_get_width (buffer->buffer);
}

gint
pika_buffer_get_height (PikaBuffer *buffer)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), 0);

  return gegl_buffer_get_height (buffer->buffer);
}

const Babl *
pika_buffer_get_format (PikaBuffer *buffer)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), NULL);

  return gegl_buffer_get_format (buffer->buffer);
}

GeglBuffer *
pika_buffer_get_buffer (PikaBuffer *buffer)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), NULL);

  return buffer->buffer;
}

void
pika_buffer_set_resolution (PikaBuffer *buffer,
                            gdouble     resolution_x,
                            gdouble     resolution_y)
{
  g_return_if_fail (PIKA_IS_BUFFER (buffer));
  g_return_if_fail (resolution_x >= 0.0 && resolution_x <= PIKA_MAX_RESOLUTION);
  g_return_if_fail (resolution_y >= 0.0 && resolution_y <= PIKA_MAX_RESOLUTION);

  buffer->resolution_x = resolution_x;
  buffer->resolution_y = resolution_y;
}

gboolean
pika_buffer_get_resolution (PikaBuffer *buffer,
                            gdouble    *resolution_x,
                            gdouble    *resolution_y)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), FALSE);

  if (buffer->resolution_x > 0.0 &&
      buffer->resolution_y > 0.0)
    {
      if (resolution_x) *resolution_x = buffer->resolution_x;
      if (resolution_y) *resolution_y = buffer->resolution_y;

      return TRUE;
    }

  return FALSE;
}

void
pika_buffer_set_unit (PikaBuffer *buffer,
                      PikaUnit    unit)
{
  g_return_if_fail (PIKA_IS_BUFFER (buffer));
  g_return_if_fail (unit > PIKA_UNIT_PIXEL);

  buffer->unit = unit;
}

PikaUnit
pika_buffer_get_unit (PikaBuffer *buffer)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), PIKA_UNIT_PIXEL);

  return buffer->unit;
}

void
pika_buffer_set_color_profile (PikaBuffer       *buffer,
                               PikaColorProfile *profile)
{
  g_return_if_fail (PIKA_IS_BUFFER (buffer));
  g_return_if_fail (profile == NULL || PIKA_IS_COLOR_PROFILE (profile));

  if (profile != buffer->color_profile)
    {
      g_set_object (&buffer->color_profile, profile);
    }

  g_clear_object (&buffer->format_profile);
}

PikaColorProfile *
pika_buffer_get_color_profile (PikaBuffer *buffer)
{
  g_return_val_if_fail (PIKA_IS_BUFFER (buffer), NULL);

  return buffer->color_profile;
}
