#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 = tmax(r, g, b);
	min = tmin(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;
			CASE 1 :
				*red = q;
			*green = value;
			*blue = p;
			CASE 2 :
				*red = p;
			*green = value;
			*blue = t;
			CASE 3 :
				*red = p;
			*green = q;
			*blue = value;
			CASE 4 :
				*red = t;
			*green = p;
			*blue = value;
			CASE 5 :
				*red = value;
			*green = p;
			*blue = q;
		}
	}
}

class ChangeColorFx : 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)
	{
		if (m_input.isConnected())
			return m_input->doGetBBox(frame, bBox, info);
		{
			bBox = TRectD();
			return false;
		}
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
};

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) {
		tswap(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")