/* 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 <gegl.h>
#include <gtk/gtk.h>

#include "libpikacolor/pikacolor.h"
#include "libpikawidgets/pikawidgets.h"

#include "widgets-types.h"

#include "config/pikacoreconfig.h"

#include "core/pika.h"
#include "core/pikacontext.h"

#include "pikaaction.h"
#include "pikaactiongroup.h"
#include "pikaactionimpl.h"
#include "pikacolordialog.h"
#include "pikacolorpanel.h"


#define RGBA_EPSILON 1e-6

enum
{
  RESPONSE,
  LAST_SIGNAL
};


/*  local function prototypes  */

static void       pika_color_panel_dispose         (GObject            *object);

static gboolean   pika_color_panel_button_press    (GtkWidget          *widget,
                                                    GdkEventButton     *bevent);

static void       pika_color_panel_clicked         (GtkButton          *button);

static void       pika_color_panel_color_changed   (PikaColorButton    *button);
static GType      pika_color_panel_get_action_type (PikaColorButton    *button);

static void       pika_color_panel_dialog_update   (PikaColorDialog    *dialog,
                                                    const PikaRGB      *color,
                                                    PikaColorDialogState state,
                                                    PikaColorPanel     *panel);


G_DEFINE_TYPE (PikaColorPanel, pika_color_panel, PIKA_TYPE_COLOR_BUTTON)

#define parent_class pika_color_panel_parent_class

static guint color_panel_signals[LAST_SIGNAL] = { 0, };


static void
pika_color_panel_class_init (PikaColorPanelClass *klass)
{
  GObjectClass         *object_class       = G_OBJECT_CLASS (klass);
  GtkWidgetClass       *widget_class       = GTK_WIDGET_CLASS (klass);
  GtkButtonClass       *button_class       = GTK_BUTTON_CLASS (klass);
  PikaColorButtonClass *color_button_class = PIKA_COLOR_BUTTON_CLASS (klass);

  object_class->dispose               = pika_color_panel_dispose;

  widget_class->button_press_event    = pika_color_panel_button_press;

  button_class->clicked               = pika_color_panel_clicked;

  color_button_class->color_changed   = pika_color_panel_color_changed;
  color_button_class->get_action_type = pika_color_panel_get_action_type;

  color_panel_signals[RESPONSE] =
    g_signal_new ("response",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (PikaColorPanelClass, response),
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 1,
                  PIKA_TYPE_COLOR_DIALOG_STATE);
}

static void
pika_color_panel_init (PikaColorPanel *panel)
{
  panel->context      = NULL;
  panel->color_dialog = NULL;
}

static void
pika_color_panel_dispose (GObject *object)
{
  PikaColorPanel *panel = PIKA_COLOR_PANEL (object);

  if (panel->color_dialog)
    {
      gtk_widget_destroy (panel->color_dialog);
      panel->color_dialog = NULL;
    }

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

static gboolean
pika_color_panel_button_press (GtkWidget      *widget,
                               GdkEventButton *bevent)
{
  if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
    {
      PikaColorButton    *color_button;
      PikaColorPanel     *color_panel;
      GSimpleActionGroup *group;
      PikaAction         *action;
      PikaRGB             color;

      color_button = PIKA_COLOR_BUTTON (widget);
      color_panel  = PIKA_COLOR_PANEL (widget);

      group = pika_color_button_get_action_group (color_button);

      action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (group), "use-foreground"));
      pika_action_set_visible (action, color_panel->context != NULL);

      action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (group), "use-background"));
      pika_action_set_visible (action, color_panel->context != NULL);

      if (color_panel->context)
        {
          action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (group), "use-foreground"));
          pika_context_get_foreground (color_panel->context, &color);
          g_object_set (action, "color", &color, NULL);

          action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (group), "use-background"));
          pika_context_get_background (color_panel->context, &color);
          g_object_set (action, "color", &color, NULL);
        }

      action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (group), "use-black"));
      pika_rgba_set (&color, 0.0, 0.0, 0.0, PIKA_OPACITY_OPAQUE);
      g_object_set (action, "color", &color, NULL);

      action = PIKA_ACTION (g_action_map_lookup_action (G_ACTION_MAP (group), "use-white"));
      pika_rgba_set (&color, 1.0, 1.0, 1.0, PIKA_OPACITY_OPAQUE);
      g_object_set (action, "color", &color, NULL);
    }

  if (GTK_WIDGET_CLASS (parent_class)->button_press_event)
    return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, bevent);

  return FALSE;
}

static void
pika_color_panel_clicked (GtkButton *button)
{
  PikaColorPanel *panel = PIKA_COLOR_PANEL (button);
  PikaRGB         color;

  pika_color_button_get_color (PIKA_COLOR_BUTTON (button), &color);

  if (! panel->color_dialog)
    {
      PikaColorButton *color_button = PIKA_COLOR_BUTTON (button);

      panel->color_dialog =
        pika_color_dialog_new (NULL, panel->context, TRUE,
                               pika_color_button_get_title (color_button),
                               NULL, NULL,
                               GTK_WIDGET (button),
                               NULL, NULL,
                               &color,
                               pika_color_button_get_update (color_button),
                               pika_color_button_has_alpha (color_button));

      g_signal_connect (panel->color_dialog, "destroy",
                        G_CALLBACK (gtk_widget_destroyed),
                        &panel->color_dialog);

      g_signal_connect (panel->color_dialog, "update",
                        G_CALLBACK (pika_color_panel_dialog_update),
                        panel);
    }
  else
    {
      pika_color_dialog_set_color (PIKA_COLOR_DIALOG (panel->color_dialog),
                                   &color);
    }

  gtk_window_present (GTK_WINDOW (panel->color_dialog));
}

static GType
pika_color_panel_get_action_type (PikaColorButton *button)
{
  return PIKA_TYPE_ACTION_IMPL;
}


/*  public functions  */

GtkWidget *
pika_color_panel_new (const gchar       *title,
                      const PikaRGB     *color,
                      PikaColorAreaType  type,
                      gint               width,
                      gint               height)
{
  g_return_val_if_fail (title != NULL, NULL);
  g_return_val_if_fail (color != NULL, NULL);
  g_return_val_if_fail (width > 0, NULL);
  g_return_val_if_fail (height > 0, NULL);

  return g_object_new (PIKA_TYPE_COLOR_PANEL,
                       "title",       title,
                       "type",        type,
                       "color",       color,
                       "area-width",  width,
                       "area-height", height,
                       NULL);
}

static void
pika_color_panel_color_changed (PikaColorButton *button)
{
  PikaColorPanel *panel = PIKA_COLOR_PANEL (button);
  PikaRGB         color;

  if (panel->color_dialog)
    {
      PikaRGB dialog_color;

      pika_color_button_get_color (PIKA_COLOR_BUTTON (button), &color);
      pika_color_dialog_get_color (PIKA_COLOR_DIALOG (panel->color_dialog),
                                   &dialog_color);

      if (pika_rgba_distance (&color, &dialog_color) > RGBA_EPSILON ||
          color.a != dialog_color.a)
        {
          pika_color_dialog_set_color (PIKA_COLOR_DIALOG (panel->color_dialog),
                                       &color);
        }
    }
}

void
pika_color_panel_set_context (PikaColorPanel *panel,
                              PikaContext    *context)
{
  g_return_if_fail (PIKA_IS_COLOR_PANEL (panel));
  g_return_if_fail (context == NULL || PIKA_IS_CONTEXT (context));

  panel->context = context;

  if (context)
    pika_color_button_set_color_config (PIKA_COLOR_BUTTON (panel),
                                        context->pika->config->color_management);
}

void
pika_color_panel_dialog_response (PikaColorPanel       *panel,
                                  PikaColorDialogState  state)
{
  g_return_if_fail (PIKA_IS_COLOR_PANEL (panel));
  g_return_if_fail (state == PIKA_COLOR_DIALOG_OK ||
                    state == PIKA_COLOR_DIALOG_CANCEL);

  if (panel->color_dialog && gtk_widget_get_visible (panel->color_dialog))
    pika_color_panel_dialog_update (NULL, NULL, state, panel);
}


/*  private functions  */

static void
pika_color_panel_dialog_update (PikaColorDialog      *dialog,
                                const PikaRGB        *color,
                                PikaColorDialogState  state,
                                PikaColorPanel       *panel)
{
  switch (state)
    {
    case PIKA_COLOR_DIALOG_UPDATE:
      if (pika_color_button_get_update (PIKA_COLOR_BUTTON (panel)))
        pika_color_button_set_color (PIKA_COLOR_BUTTON (panel), color);
      break;

    case PIKA_COLOR_DIALOG_OK:
    case PIKA_COLOR_DIALOG_CANCEL:
      /* PikaColorDialog returns the appropriate color (new one or
       * original one if process cancelled.
       */
      pika_color_button_set_color (PIKA_COLOR_BUTTON (panel), color);
      gtk_widget_hide (panel->color_dialog);

      g_signal_emit (panel, color_panel_signals[RESPONSE], 0,
                     state);
      break;
    }
}
