#include "stdfx.h"
#include "tfxparam.h"
#include "tspectrumparam.h"

class Test_BoxFx : public TStandardRasterFx
{
	FX_PLUGIN_DECLARATION(Test_BoxFx)

	TRasterFxPort m_input;
	TDoubleParamP m_h;
	TDoubleParamP m_v;
	TPixelParamP m_color;
	TPointParamP m_point;
	TSpectrumParamP m_colors;
	TIntParamP m_int;
	TIntEnumParamP m_enum;
	TRangeParamP m_range;
	TBoolParamP m_bool;
	TStringParamP m_string;

public:
	Test_BoxFx()
		: m_h(30.0), m_v(30.0), m_color(TPixel32::Blue), m_range(DoublePair(100., 100.)), m_int(12), m_enum(new TIntEnumParam(0, "Color")), m_point(TPointD(0.0, 0.0)), m_bool(true), m_string(L"urka")
	{
		m_h->setValueRange(0, 100);
		m_enum->addItem(1, "Uno");
		m_enum->addItem(2, "Due");
		m_enum->addItem(3, "Tre");
		bindParam(this, "h", m_h);
		bindParam(this, "v", m_v);
		bindParam(this, "color", m_color);
		bindParam(this, "Point", m_point);
		bindParam(this, "enum", m_enum);
		m_enum->addItem(1, "Spectrum");
		bindParam(this, "int", m_int);
		bindParam(this, "range", m_range);
		bindParam(this, "bool", m_bool);
		TSpectrum::ColorKey colors[] = {
			TSpectrum::ColorKey(0, TPixel32::White),
			TSpectrum::ColorKey(0.5, TPixel32::Yellow),
			TSpectrum::ColorKey(1, TPixel32::Red)};
		m_colors = TSpectrumParamP(tArrayCount(colors), colors);
		bindParam(this, "spectrum", m_colors);
		bindParam(this, "string", m_string);
		addInputPort("Source", m_input);
	}

	~Test_BoxFx(){};

	bool canHandle(const TRenderSettings &info, double frame) { return false; }

	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
	{
		if (!m_input.isConnected()) {
			bBox = TRectD();
			return false;
		}
		return m_input->doGetBBox(frame, bBox, info);
	};

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

//===================================================================

template <class PIX, class RAS>
void doTest_Box(
	RAS ras,
	double h, double v,
	TPointD pos,
	TPixel32 &color32,
	int my_enum, int my_int,
	const TSpectrumT<PIX> spectrum,
	TPointD point,
	DoublePair range,
	bool my_bool)
{
	int lx = ras->getLx();
	int ly = ras->getLy();

	TPointD tmp = pos;

	const PIX color = PixelConverter<RAS::Pixel>::from(color32);
	int j, i;
	for (j = 0; j < ly; j++) {
		PIX *pix = ras->pixels(j);
		tmp.y++;
		tmp.x = pos.x;
		for (i = 0; i < lx; i++) {
			if (tmp.x > 0 && tmp.x < h && tmp.y > 0 && tmp.y < v) {
				if (my_enum && my_bool) {
					if (tmp.x > range.first && tmp.x < range.second)
						*pix = spectrum.getPremultipliedValue(sqrt((tmp.x - point.x) * (tmp.x - point.x) / (h * h) + (tmp.y - point.y) * (tmp.y - point.y) / (v * v)));
					else
						*pix = color;
				} else
					*pix = color;
			}
			tmp.x++;
			pix++;
		}
	}
}

void Test_BoxFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	if (!m_input.isConnected())
		return;
	wstring text = m_string->getValue();

	m_input->compute(tile, frame, ri);
	TPixel32 color = m_color->getValue(frame);
	double h = m_h->getValue(frame);
	double v = m_v->getValue(frame);
	int my_enum = m_enum->getValue();
	// TSpectrum spectrum = m_colors->getValue(frame);
	int my_int = m_int->getValue();
	TPointD point = m_point->getValue(frame);
	DoublePair range = m_range->getValue(frame);
	bool my_bool = m_bool->getValue();
	if (TRaster32P raster32 = tile.getRaster())
		doTest_Box<TPixel32, TRaster32P>(
			raster32, h, v, tile.m_pos, color, my_enum, my_int,
			m_colors->getValue(frame), point, range, my_bool);
	else if (TRaster64P raster64 = tile.getRaster())
		doTest_Box<TPixel64, TRaster64P>(
			raster64, h, v, tile.m_pos, color, my_enum, my_int,
			m_colors->getValue64(frame), point, range, my_bool);
	else
		throw TException("Test_BoxFx: unsupported Pixel Type");
}

#ifdef _DEBUG
FX_PLUGIN_IDENTIFIER(Test_BoxFx, "test_BoxFx")
#endif