#include "texception.h"
#include "tfxparam.h"
#include "stdfx.h"
 
#include "tparamset.h"
 
static void OLDRGB2HSV(double r, double g, double b, double *h, double *s,
                       double *v) {
  double max, min;
  double delta;
 
  max = std::max({r, g, b});
  min = std::min({r, g, b});
 
  *v = max;
 
  if (max != 0)
    *s = (max - min) / max;
  else
    *s = 0;
 
  if (*s == 0)
    *h = 0;
  else {
    delta = max - min;
 
    if (r == max)
      *h = (g - b) / delta;
    else if (g == max)
      *h = 2 + (b - r) / delta;
    else if (b == max)
      *h = 4 + (r - g) / delta;
    *h   = *h * 60;
    if (*h < 0) *h += 360;
  }
}
 
static void OLDHSV2RGB(double hue, double sat, double value, double *red,
                       double *green, double *blue) {
  int i;
  double p, q, t, f;
 
  //  if (hue > 360 || hue < 0)
  //    hue=0;
  if (hue > 360) hue -= 360;
  if (hue < 0) hue += 360;
  if (sat < 0) sat     = 0;
  if (sat > 1) sat     = 1;
  if (value < 0) value = 0;
  if (value > 1) value = 1;
  if (sat == 0) {
    *red   = value;
    *green = value;
    *blue  = value;
  } else {
    if (hue == 360) hue = 0;
 
    hue = hue / 60;
    i   = (int)hue;
    f   = hue - i;
    p   = value * (1 - sat);
    q   = value * (1 - (sat * f));
    t   = value * (1 - (sat * (1 - f)));
 
    switch (i) {
    case 0:
      *red   = value;
      *green = t;
      *blue  = p;
      break;
    case 1:
      *red   = q;
      *green = value;
      *blue  = p;
      break;
    case 2:
      *red   = p;
      *green = value;
      *blue  = t;
      break;
    case 3:
      *red   = p;
      *green = q;
      *blue  = value;
      break;
    case 4:
      *red   = t;
      *green = p;
      *blue  = value;
      break;
    case 5:
      *red   = value;
      *green = p;
      *blue  = q;
      break;
    }
  }
}
 
class ChangeColorFx final : public TStandardRasterFx {
  FX_PLUGIN_DECLARATION(ChangeColorFx)
  TRasterFxPort m_input;
  TPixelParamP m_from_color;
  TPixelParamP m_to_color;
  TDoubleParamP m_range;
  TDoubleParamP m_falloff;
 
public:
  ChangeColorFx()
      : m_from_color(TPixel32::Red)
      , m_to_color(TPixel32::Blue)
      , m_range(0.0)
      , m_falloff(0.0) {
    addInputPort("Source", m_input);
    bindParam(this, "range", m_range);
    bindParam(this, "falloff", m_falloff);
    bindParam(this, "from_color", m_from_color);
    bindParam(this, "to_color", m_to_color);
    m_range->setValueRange(0, 100);
    m_falloff->setValueRange(0, 100);
  }
  ~ChangeColorFx(){};
 
  bool doGetBBox(double frame, TRectD &bBox,
                 const TRenderSettings &info) override {
    if (m_input.isConnected()) return m_input->doGetBBox(frame, bBox, info);
    {
      bBox = TRectD();
      return false;
    }
  };
 
  void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;
};
 
static double normalize_h(double h) {
  if (h < 0) h += 360;
  if (h > 360) h -= 360;
  return h;
}
//------------------------------------------------------------------------------
 
void ChangeColorFx::doCompute(TTile &tile, double frame,
                              const TRenderSettings &ri) {
  if (!m_input.isConnected()) return;
 
  m_input->compute(tile, frame, ri);
 
  double from_h, from_s, from_v, to_h, to_s, to_v;
  bool swaprange = false, swapfallmin = false, swapfallmax;
  TPixel32 from_color = m_from_color->getPremultipliedValue(frame);
  TPixel32 to_color   = m_to_color->getPremultipliedValue(frame);
  double range        = m_range->getValue(frame) / 100;
  double falloff      = m_falloff->getValue(frame) / 100;
 
  OLDRGB2HSV(from_color.r / 255.0, from_color.g / 255.0, from_color.b / 255.0,
             &from_h, &from_s, &from_v);
  OLDRGB2HSV(to_color.r / 255.0, to_color.g / 255.0, to_color.b / 255.0, &to_h,
             &to_s, &to_v);
  /*
int from_hsv[3];
int to_hsv[3];
rgb2hsv(from_hsv, from_color);
rgb2hsv(to_hsv, to_color);
 
///////////////  verificare   ///////
from_h =((double)from_hsv[0]/255.)*360.;
from_s =from_hsv[1]/255.;
from_v =from_hsv[2]/255.;
to_h =((double)to_hsv[0]/255.)*360.;
to_s =to_hsv[1]/255.;
to_v =to_hsv[2]/255.;
*/
  ////////////////////////
  TRaster32P raster32 = tile.getRaster();
  assert(raster32);  // per ora gestisco solo i Raster32
 
  double hmin = from_h - range * 180;
  hmin        = normalize_h(hmin);
  double hmax = from_h + range * 180;
  hmax        = normalize_h(hmax);
  if (hmax <= hmin) {
    std::swap(hmin, hmax);
    swaprange = true;
  }
  double smin     = from_s - range;
  double smax     = from_s + range;
  double vmin     = from_v - range;
  double vmax     = from_v + range;
  double hfallmin = hmin - falloff * 180;
  double hfallmax = hmax + falloff * 180;
  hfallmin        = normalize_h(hfallmin);
  hfallmax        = normalize_h(hfallmax);
  if (hfallmin > hmin) {
    swapfallmin = true;
  }
  if (hfallmax < hmax) {
    swapfallmax = true;
  }
  double sfallmin = smin - falloff;
  double sfallmax = smax + falloff;
  double vfallmin = vmin - falloff;
  double vfallmax = vmax + falloff;
 
  int j;
  raster32->lock();
  for (j = 0; j < raster32->getLy(); j++) {
    TPixel32 *pix    = raster32->pixels(j);
    TPixel32 *endPix = pix + raster32->getLx();
    while (pix < endPix) {
      double r, g, b, h, s, v;
      r = pix->r / 255.0;
      g = pix->g / 255.0;
      b = pix->b / 255.0;
      // int hsv[3];
      OLDRGB2HSV(r, g, b, &h, &s, &v);
      int hflag            = (h <= hmax && h >= hmin);
      if (swaprange) hflag = !hflag;
      if (hflag && s <= smax && s >= smin && v <= vmax && v >= vmin)
        *pix = to_color;
      else {
        double hcorr            = 0;
        double scorr            = 0;
        double vcorr            = 0;
        int hfallminflag        = (h <= hmin && h >= hfallmin);
        if (hfallminflag) hcorr = h - hmin;
        int hfallmaxflag        = (h >= hmax && h <= hfallmax);
        if (hfallmaxflag) hcorr = h - hmax;
        if (hcorr) {
          if (s <= smin && s >= sfallmin) scorr = s - smin;
          if (s >= smax && s <= sfallmax) scorr = s - smax;
          if (v <= vmin && v >= vfallmin) vcorr = v - vmin;
          if (v >= vmax && v <= vfallmax) vcorr = v - vmax;
          if (s < smin && s > sfallmin) scorr   = s - smin;
          if (s > smax && s < sfallmax) scorr   = s - smax;
          h                                     = to_h + hcorr;
          if (h < 0) h += 360;
          if (h > 360) h -= 360;
          OLDHSV2RGB(h, s, v, &r, &g, &b);
 
          pix->r = (UCHAR)(r * 255);
          pix->g = (UCHAR)(g * 255);
          pix->b = (UCHAR)(b * 255);
        }
      }
      // premultiply(*pix);
      *pix++;
    }
  }
  raster32->unlock();
}
 
// FX_PLUGIN_IDENTIFIER(ChangeColorFx    , "changeColorFx")