/*
    This file is part of darktable,
    Copyright (C) 2011-2026 darktable developers.

    darktable 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.

    darktable 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 darktable.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "bauhaus/bauhaus.h"
#include "common/imagebuf.h"
#include "control/control.h"
#include "develop/imageop.h"
#include "develop/imageop_math.h"
#include "develop/imageop_gui.h"
#include "dtgtk/resetlabel.h"
#include "gui/accelerators.h"
#include "gui/gtk.h"
#include "iop/iop_api.h"
#include "common/opencl.h"

#include <gtk/gtk.h>
#include <stdlib.h>

DT_MODULE_INTROSPECTION(1, dt_iop_hotpixels_params_t)

typedef struct dt_iop_hotpixels_params_t
{
  float strength;  // $MIN: 0.0 $MAX: 1.0 $DEFAULT: 0.25
  float threshold; // $MIN: 0.0 $MAX: 1.0 $DEFAULT: 0.05
  gboolean markfixed;  // $DEFAULT: FALSE $DESCRIPTION: "mark fixed pixels"
  gboolean permissive; // $DEFAULT: FALSE $DESCRIPTION: "detect by 3 neighbors"
} dt_iop_hotpixels_params_t;

typedef struct dt_iop_hotpixels_gui_data_t
{
  GtkWidget *threshold, *strength;
  GtkWidget *markfixed;
  GtkWidget *permissive;
  GtkLabel *message;
  int pixels_fixed;
} dt_iop_hotpixels_gui_data_t;

typedef struct dt_iop_hotpixels_data_t
{
  uint32_t filters;
  float threshold;
  float multiplier;
  gboolean permissive;
  gboolean markfixed;
  gboolean monochrome;
  gboolean pure_monochrome;
} dt_iop_hotpixels_data_t;

typedef struct dt_iop_hotpixels_global_data_t
{
  int kernel_hotpixels;
} dt_iop_hotpixels_global_data_t;


const char *name()
{
  return _("hot pixels");
}

const char **description(dt_iop_module_t *self)
{
  return dt_iop_set_description(self, _("remove abnormally bright pixels\n"
                                        "by dampening them with neighbors"),
                                      _("corrective"),
                                      _("linear, raw, scene-referred"),
                                      _("reconstruction, raw"),
                                      _("linear, raw, scene-referred"));
}


int default_group()
{
  return IOP_GROUP_CORRECT | IOP_GROUP_TECHNICAL;
}

int flags()
{
  return IOP_FLAGS_SUPPORTS_BLENDING | IOP_FLAGS_ONE_INSTANCE;
}

dt_iop_colorspace_type_t default_colorspace(dt_iop_module_t *self,
                                            dt_dev_pixelpipe_t *pipe,
                                            dt_dev_pixelpipe_iop_t *piece)
{
  return IOP_CS_RAW;
}

/* Detect hot sensor pixels based on the 4 surrounding sites. Pixels
 * having 3 or 4 (depending on permissive setting) surrounding pixels that
 * than value*multiplier are considered "hot", and are replaced by the maximum of
 * the neighbour pixels. The permissive variant allows for
 * correcting pairs of hot pixels in adjacent sites. Replacement using
 * the maximum produces fewer artifacts when inadvertently replacing
 * non-hot pixels.
 * This is the Bayer sensor variant. */
static int _process_bayer(const dt_iop_hotpixels_data_t *data,
                          const void *const ivoid,
                          void *const ovoid,
                          const dt_iop_roi_t *const roi_out)
{
  const float threshold = data->threshold;
  const float multiplier = data->multiplier;
  const gboolean markfixed = data->markfixed;
  const int min_neighbours = data->permissive ? 3 : 4;
  const int width = roi_out->width;
  const int widthx2 = width * 2;
  int fixed = 0;

  DT_OMP_FOR(reduction(+ : fixed))
  for(int row = 2; row < roi_out->height - 2; row++)
  {
    const float *in = (float *)ivoid + (size_t)width * row + 2;
    float *out = (float *)ovoid + (size_t)width * row + 2;
    for(int col = 2; col < width - 2; col++, in++, out++)
    {
      float mid = *in * multiplier;
      if(*in > threshold)
      {
        int count = 0;
        float maxin = 0.0;
        float other;
#define TESTONE(OFFSET)                                                                                      \
  other = in[OFFSET];                                                                                        \
  if(mid > other)                                                                                            \
  {                                                                                                          \
    count++;                                                                                                 \
    if(other > maxin) maxin = other;                                                                         \
  }
        TESTONE(-2);
        TESTONE(-widthx2);
        TESTONE(+2);
        TESTONE(+widthx2);
#undef TESTONE
        if(count >= min_neighbours)
        {
          *out = maxin;
          fixed++;
          if(markfixed)
          {
            for(int i = -2; i >= -10 && i >= -col; i -= 2) out[i] = *in;
            for(int i = 2; i <= 10 && i < width - col; i += 2) out[i] = *in;
          }
        }
      }
    }
  }

  return fixed;
}

/* This is the monochrome sensor variant. */
static int _process_monochrome(const dt_iop_hotpixels_data_t *data,
                              const void *const ivoid,
                              void *const ovoid,
                              const dt_iop_roi_t *const roi_out,
                              const int planes)
{
  const float threshold = data->threshold;
  const float multiplier = data->multiplier;
  const gboolean markfixed = data->markfixed;
  const int min_neighbours = data->permissive ? 3 : 4;
  const int width = roi_out->width;
  int fixed = 0;

  DT_OMP_FOR(reduction(+ : fixed))
  for(int row = 1; row < roi_out->height - 1; row++)
  {
    const float *in = (float *)ivoid + (size_t)planes * (width * row + 1);
    float *out = (float *)ovoid + (size_t)planes * (width * row + 1);
    for(int col = 1; col < width - 1; col++, in += planes, out += planes)
    {
      float mid = *in * multiplier;
      if(*in > threshold)
      {
        int count = 0;
        float maxin = 0.0f;
        float other;
#define TESTONE(OFFSET)                                                                                      \
  other = in[OFFSET];                                                                                        \
  if(mid > other)                                                                                            \
  {                                                                                                          \
    count++;                                                                                                 \
    if(other > maxin) maxin = other;                                                                         \
  }
        TESTONE(-planes);
        TESTONE(-planes*width);
        TESTONE(planes);
        TESTONE(planes*width);
#undef TESTONE
        if(count >= min_neighbours)
        {
          for(int c=0; c < planes; c++)
            out[c] = maxin;
          fixed++;
          if(markfixed)
          {
            for(int i = -1; i >= -10 && i >= -col; i -= 1)
              for(int c = 0; c < planes; c++) out[4*i + c] = *in;
            for(int i = 1; i <= 10 && i < width - col; i++)
              for(int c = 0; c < planes; c++) out[4*i + c] = *in;
          }
        }
      }
    }
  }
  return fixed;
}

/* X-Trans sensor equivalent of _process_bayer(). */
static int _process_xtrans(const dt_iop_hotpixels_data_t *data,
                           const void *const ivoid,
                           void *const ovoid,
                           const dt_iop_roi_t *const roi_out,
                           const uint8_t (*const xtrans)[6])
{
  // for each cell of sensor array, pre-calculate, a list of the x/y
  // offsets of the four radially nearest pixels of the same color
  int offsets[6][6][4][2];
  // increasing offsets from pixel to find nearest like-colored pixels
  const int search[20][2] = { { -1, 0 },
                              { 1, 0 },
                              { 0, -1 },
                              { 0, 1 },
                              { -1, -1 },
                              { -1, 1 },
                              { 1, -1 },
                              { 1, 1 },
                              { -2, 0 },
                              { 2, 0 },
                              { 0, -2 },
                              { 0, 2 },
                              { -2, -1 },
                              { -2, 1 },
                              { 2, -1 },
                              { 2, 1 },
                              { -1, -2 },
                              { 1, -2 },
                              { -1, 2 },
                              { 1, 2 } };
  for(int j = 0; j < 6; ++j)
  {
    for(int i = 0; i < 6; ++i)
    {
      const uint8_t c = FCNxtrans(j, i, xtrans);
      for(int s = 0, found = 0; s < 20 && found < 4; ++s)
      {
        if(c == FCNxtrans(j + search[s][1], i + search[s][0], xtrans))
        {
          offsets[j][i][found][0] = search[s][0];
          offsets[j][i][found][1] = search[s][1];
          ++found;
        }
      }
    }
  }

  const float threshold = data->threshold;
  const float multiplier = data->multiplier;
  const gboolean markfixed = data->markfixed;
  const int min_neighbours = data->permissive ? 3 : 4;
  const int width = roi_out->width;
  int fixed = 0;

  DT_OMP_FOR(reduction(+ : fixed))
  for(int row = 2; row < roi_out->height - 2; row++)
  {
    const float *in = (float *)ivoid + (size_t)width * row + 2;
    float *out = (float *)ovoid + (size_t)width * row + 2;
    for(int col = 2; col < width - 2; col++, in++, out++)
    {
      float mid = *in * multiplier;
      if(*in > threshold)
      {
        int count = 0;
        float maxin = 0.0;
        for(int n = 0; n < 4; ++n)
        {
          int xx = offsets[row % 6][col % 6][n][0];
          int yy = offsets[row % 6][col % 6][n][1];
          float other = *(in + xx + yy * (size_t)width);
          if(mid > other)
          {
            count++;
            if(other > maxin) maxin = other;
          }
        }
        // NOTE: it seems that detecting by 2 neighbors would help for extreme cases
        if(count >= min_neighbours)
        {
          *out = maxin;
          fixed++;
          if(markfixed)
          {
            const uint8_t c = FCNxtrans(row, col, xtrans);
            for(int i = -2; i >= -10 && i >= -col; --i)
            {
              if(c == FCNxtrans(row, col+i, xtrans))
              {
                out[i] = *in;
              }
            }
            for(int i = 2; i <= 10 && i < width - col; ++i)
            {
              if(c == FCNxtrans(row, col+i, xtrans))
              {
                out[i] = *in;
              }
            }
          }
        }
      }
    }
  }

  return fixed;
}

void process(dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
             void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
  dt_iop_hotpixels_gui_data_t *g = self->gui_data;
  const dt_iop_hotpixels_data_t *data = piece->data;

  // The processing loop should output only a few pixels, so just copy everything first
  const int planes = data->pure_monochrome ? 4 : 1;
  dt_iop_image_copy_by_size(ovoid, ivoid, roi_out->width, roi_out->height, planes);

  int fixed = 0;

  if(data->monochrome || data->pure_monochrome)
  {
    fixed = _process_monochrome(data, ivoid, ovoid, roi_out, planes);
  }
  else if(piece->pipe->dsc.filters == 9u)
  {
    fixed = _process_xtrans(data, ivoid, ovoid, roi_out, piece->xtrans);
  }
  else
  {
    fixed = _process_bayer(data, ivoid, ovoid, roi_out);
  }

  if(g && self->dev->gui_attached && dt_pipe_is_full(piece->pipe))
  {
    dt_iop_gui_enter_critical_section(self);
    g->pixels_fixed = fixed;
    dt_iop_gui_leave_critical_section(self);
  }
}

#ifdef HAVE_OPENCL
int process_cl(dt_iop_module_t *self,
               dt_dev_pixelpipe_iop_t *piece,
               cl_mem dev_in,
               cl_mem dev_out,
               const dt_iop_roi_t *const roi_in,
               const dt_iop_roi_t *const roi_out)
{
  dt_iop_hotpixels_gui_data_t *g = self->gui_data;
  const dt_iop_hotpixels_data_t *data = piece->data;
  const dt_iop_hotpixels_global_data_t *gd = self->global_data;
  const int devid = piece->pipe->devid;

  // marking the fixed pixels writes the neighbors of each hot pixel, and a
  // monochrome raw comes as 4 channels: both stay on the CPU
  if(data->markfixed || data->pure_monochrome) return DT_OPENCL_PROCESS_CL;

  const gboolean xtrans = !data->monochrome && piece->pipe->dsc.filters == 9u;
  const int mode = data->monochrome ? 1 : xtrans ? 2 : 0;

  // the four nearest like-colored sensels for each cell of the X-Trans
  // pattern, found as _process_xtrans() does
  int offsets[6][6][4][2] = { { { { 0 } } } };
  if(xtrans)
  {
    const int search[20][2] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 }, { -1, -1 },
                                { -1, 1 }, { 1, -1 }, { 1, 1 }, { -2, 0 }, { 2, 0 },
                                { 0, -2 }, { 0, 2 }, { -2, -1 }, { -2, 1 }, { 2, -1 },
                                { 2, 1 }, { -1, -2 }, { 1, -2 }, { -1, 2 }, { 1, 2 } };
    for(int j = 0; j < 6; ++j)
      for(int i = 0; i < 6; ++i)
      {
        const uint8_t c = FCNxtrans(j, i, piece->xtrans);
        for(int s = 0, found = 0; s < 20 && found < 4; ++s)
        {
          if(c == FCNxtrans(j + search[s][1], i + search[s][0], piece->xtrans))
          {
            offsets[j][i][found][0] = search[s][0];
            offsets[j][i][found][1] = search[s][1];
            ++found;
          }
        }
      }
  }

  const int width = roi_out->width;
  const int height = roi_out->height;
  const int min_neighbours = data->permissive ? 3 : 4;
  const uint32_t zero = 0;

  cl_int err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
  cl_mem dev_offsets = dt_opencl_copy_host_to_device_constant(devid, sizeof(offsets), offsets);
  cl_mem dev_fixed = dt_opencl_alloc_device_buffer(devid, sizeof(uint32_t));
  if(!dev_offsets || !dev_fixed) goto error;

  err = dt_opencl_write_buffer_to_device(devid, (void *)&zero, dev_fixed, 0, sizeof(uint32_t), TRUE);
  if(err != CL_SUCCESS) goto error;

  err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_hotpixels, width, height,
          CLARG(dev_in), CLARG(dev_out), CLARG(width), CLARG(height),
          CLARG(data->threshold), CLARG(data->multiplier), CLARG(min_neighbours),
          CLARG(mode), CLARG(dev_offsets), CLARG(dev_fixed));
  if(err != CL_SUCCESS) goto error;

  // reading the count waits for the kernel, so only the darkroom does it
  if(g && self->dev->gui_attached && dt_pipe_is_full(piece->pipe))
  {
    uint32_t count = 0;
    err = dt_opencl_read_buffer_from_device(devid, &count, dev_fixed, 0, sizeof(count), TRUE);
    if(err != CL_SUCCESS) goto error;
    dt_iop_gui_enter_critical_section(self);
    g->pixels_fixed = count;
    dt_iop_gui_leave_critical_section(self);
  }

error:
  dt_opencl_release_mem_object(dev_offsets);
  dt_opencl_release_mem_object(dev_fixed);
  return err;
}
#endif

void init_global(dt_iop_module_so_t *self)
{
  const int program = 2; // basic.cl, from programs.conf
  dt_iop_hotpixels_global_data_t *gd = malloc(sizeof(dt_iop_hotpixels_global_data_t));
  self->data = gd;
  gd->kernel_hotpixels = dt_opencl_create_kernel(program, "hotpixels");
}

void cleanup_global(dt_iop_module_so_t *self)
{
  dt_iop_hotpixels_global_data_t *gd = self->data;
  if(gd) dt_opencl_free_kernel(gd->kernel_hotpixels);
  free(self->data);
  self->data = NULL;
}

void reload_defaults(dt_iop_module_t *self)
{
  const dt_image_t *img = &self->dev->image_storage;

  const gboolean monoraw = (img->flags & DT_IMAGE_S_RAW) && (img->flags & DT_IMAGE_MONOCHROME);
  const gboolean supported = dt_image_is_raw(img) || monoraw;
  // can't be switched on for non-raw images:
  self->hide_enable_button = !supported;
}

void commit_params(dt_iop_module_t *self, dt_iop_params_t *params, dt_dev_pixelpipe_t *pipe,
                   dt_dev_pixelpipe_iop_t *piece)
{
  dt_iop_hotpixels_params_t *p = (dt_iop_hotpixels_params_t *)params;
  dt_iop_hotpixels_data_t *d = piece->data;
  d->filters = piece->pipe->dsc.filters;
  d->multiplier = p->strength / 2.0;
  d->threshold = p->threshold;
  d->permissive = p->permissive;
  d->markfixed = p->markfixed && (!(dt_pipe_is_thumb(pipe) || dt_pipe_is_export(pipe)));

  const dt_image_t *img = &pipe->image;
  const gboolean monoraw = (img->flags & DT_IMAGE_S_RAW) && (img->flags & DT_IMAGE_MONOCHROME);
  const gboolean supported = dt_image_is_raw(img) || monoraw;
  d->monochrome = img->flags & DT_IMAGE_MONOCHROME_BAYER;
  d->pure_monochrome = monoraw;
  if(!supported || p->strength == 0.0) piece->enabled = FALSE;
}

void init_pipe(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  piece->data = malloc(sizeof(dt_iop_hotpixels_data_t));
}

void cleanup_pipe(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  free(piece->data);
  piece->data = NULL;
}


void gui_update(dt_iop_module_t *self)
{
  dt_iop_hotpixels_gui_data_t *g = self->gui_data;
  dt_iop_hotpixels_params_t *p = self->params;
  dt_bauhaus_toggle_set(g->markfixed, p->markfixed);
  dt_bauhaus_toggle_set(g->permissive, p->permissive);
  g->pixels_fixed = -1;
  gtk_label_set_text(g->message, "");

  const dt_image_t *img = &self->dev->image_storage;
  const gboolean monoraw = (img->flags & DT_IMAGE_S_RAW) && (img->flags & DT_IMAGE_MONOCHROME);
  const gboolean supported = dt_image_is_raw(img) || monoraw;
  // can't be switched on for non-raw images:
  self->hide_enable_button = !supported;

  gtk_stack_set_visible_child_name(GTK_STACK(self->widget), self->hide_enable_button ? "non_raw" : "raw");
}

static gboolean draw(GtkWidget *widget, cairo_t *cr, dt_iop_module_t *self)
{
  dt_iop_hotpixels_gui_data_t *g = self->gui_data;
  DT_GUARD_GUI_UPDATE(FALSE);

  dt_iop_gui_enter_critical_section(self);
  const int pixels_fixed = g->pixels_fixed;
  g->pixels_fixed = -1;
  dt_iop_gui_leave_critical_section(self);

  if(pixels_fixed < 0) return FALSE;

  char *str = g_strdup_printf(ngettext("fixed %d pixel", "fixed %d pixels", g->pixels_fixed), g->pixels_fixed);

  DT_ENTER_GUI_UPDATE();
  gtk_label_set_text(g->message, str);
  DT_LEAVE_GUI_UPDATE();

  g_free(str);

  return FALSE;
}

void gui_init(dt_iop_module_t *self)
{
  dt_iop_hotpixels_gui_data_t *g = IOP_GUI_ALLOC(hotpixels);

  g->pixels_fixed = -1;

  GtkWidget *box_raw = self->widget = dt_gui_vbox();
  g_signal_connect(G_OBJECT(box_raw), "draw", G_CALLBACK(draw), self);

  g->threshold = dt_bauhaus_slider_from_params(self, N_("threshold"));
  dt_bauhaus_slider_set_digits(g->threshold, 4);
  gtk_widget_set_tooltip_text(g->threshold, _("lower threshold for hot pixel"));

  g->strength = dt_bauhaus_slider_from_params(self, N_("strength"));
  dt_bauhaus_slider_set_digits(g->strength, 4);
  gtk_widget_set_tooltip_text(g->strength, _("strength of hot pixel correction"));

  // 3 neighbours
  g->permissive = dt_bauhaus_toggle_from_params(self, "permissive");

  // mark fixed pixels
  GtkWidget *hbox = self->widget = dt_gui_hbox();
  g->markfixed = dt_bauhaus_toggle_from_params(self, "markfixed");
  g->message = GTK_LABEL(gtk_label_new("")); // This gets filled in by process
  dt_gui_box_add(hbox, g->message);
  dt_gui_box_add(box_raw, hbox);

  // start building top level widget
  self->widget = gtk_stack_new();
  gtk_stack_set_homogeneous(GTK_STACK(self->widget), FALSE);

  GtkWidget *label_non_raw = dt_ui_label_new(_("hot pixel correction\nonly works for raw images."));

  gtk_stack_add_named(GTK_STACK(self->widget), label_non_raw, "non_raw");
  gtk_stack_add_named(GTK_STACK(self->widget), box_raw, "raw");
}

// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on