#include <sstream> /* std::ostringstream */</sstream>

/* Not use boost at toonz-6.1 */

// #include <boost shared_array.hpp=""> /* boost::shared_array<> */</boost>

#include "tfxparam.h"

#include "stdfx.h"

#include "ino_common.h"

//------------------------------------------------------------

class ino_channel_selector : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(ino_channel_selector)

	TRasterFxPort m_source1;

	TRasterFxPort m_source2;

	TRasterFxPort m_source3;

	TRasterFxPort m_source4;

	TIntParamP m_red_source;

	TIntParamP m_gre_source;

	TIntParamP m_blu_source;

	TIntParamP m_alp_source;

	TIntEnumParamP m_red_channel;

	TIntEnumParamP m_gre_channel;

	TIntEnumParamP m_blu_channel;

	TIntEnumParamP m_alp_channel;

public:

	ino_channel_selector()

		: m_red_source(1), m_gre_source(1), m_blu_source(1), m_alp_source(1)

		  ,

		  m_red_channel(new TIntEnumParam(0, "Red")), m_gre_channel(new TIntEnumParam(1, "Green")), m_blu_channel(new TIntEnumParam(2, "Blue")), m_alp_channel(new TIntEnumParam(3, "Alpha"))

	{

		addInputPort("Source1", this->m_source1);

		addInputPort("Source2", this->m_source2);

		addInputPort("Source3", this->m_source3);

		addInputPort("Source4", this->m_source4);

		bindParam(this, "red_source", this->m_red_source);

		bindParam(this, "green_source", this->m_gre_source);

		bindParam(this, "blue_source", this->m_blu_source);

		bindParam(this, "alpha_source", this->m_alp_source);

		bindParam(this, "red_channel", this->m_red_channel);

		bindParam(this, "green_channel", this->m_gre_channel);

		bindParam(this, "blue_channel", this->m_blu_channel);

		bindParam(this, "alpha_channel", this->m_alp_channel);

		this->m_red_channel->addItem(1, "Green");

		this->m_red_channel->addItem(2, "Blue");

		this->m_red_channel->addItem(3, "Alpha");

		this->m_gre_channel->addItem(0, "Red");

		this->m_gre_channel->addItem(2, "Blue");

		this->m_gre_channel->addItem(3, "Alpha");

		this->m_blu_channel->addItem(0, "Red");

		this->m_blu_channel->addItem(1, "Green");

		this->m_blu_channel->addItem(3, "Alpha");

		this->m_alp_channel->addItem(0, "Red");

		this->m_alp_channel->addItem(1, "Green");

		this->m_alp_channel->addItem(2, "Blue");

	}

	bool doGetBBox(

		double frame, TRectD &bBox, const TRenderSettings &info)

	{

		for (int ii = 0; ii < this->getInputPortCount(); ++ii) {

			std::string nm = this->getInputPortName(ii);

			TRasterFxPort *

				tmp_port = (TRasterFxPort *)this->getInputPort(nm);

			if (tmp_port->isConnected()) {

				return (*tmp_port)->doGetBBox(frame, bBox, info);

			}

		}

		bBox = TRectD();

		return false;

	}

	bool canHandle(const TRenderSettings &info, double frame)

	{

		return true;

	}

	void doCompute(

		TTile &tile, double frame, const TRenderSettings &ri);

};

FX_PLUGIN_IDENTIFIER(ino_channel_selector, "inoChannelSelectorFx");

//--------------------------------------------------------------------

// #include "igs_channel_selector.h"

namespace

{

template <typename in_pixel,="" out_pixel="" typename=""></typename>

void fx_template(

	const TRasterPT<in_pixel> in_ras, const int in_sel, const TRasterPT<out_pixel> out_ras, const int out_sel)</out_pixel></in_pixel>

{

	for (int yy = 0; yy < out_ras->getLy(); ++yy) {

		IN_PIXEL *sl_in = in_ras->pixels(yy);

		OUT_PIXEL *sl_out = out_ras->pixels(yy);

		for (int xx = 0; xx < out_ras->getLx(); ++xx, ++sl_in, ++sl_out) {

			int val = 0;

			switch (in_sel) {

			case 0:

				val = sl_in->r;

				break;

			case 1:

				val = sl_in->g;

				break;

			case 2:

				val = sl_in->b;

				break;

			case 3:

				val = sl_in->m;

				break;

			}

			switch (out_sel) {

			case 0:

				sl_out->r = val;

				break;

			case 1:

				sl_out->g = val;

				break;

			case 2:

				sl_out->b = val;

				break;

			case 3:

				sl_out->m = val;

				break;

			}

		}

	}

}

void fx_(

	const TRasterP in_ras, const int in_sel, TRasterP out_ras, const int out_sel)

{

	if ((TRaster32P)in_ras && (TRaster32P)out_ras) {

		fx_template<tpixel32, tpixel32="">(in_ras, in_sel, out_ras, out_sel);</tpixel32,>

	} else if ((TRaster64P)in_ras && (TRaster64P)out_ras) {

		fx_template<tpixel64, tpixel64="">(in_ras, in_sel, out_ras, out_sel);</tpixel64,>

	}

}

}

//------------------------------------------------------------

void ino_channel_selector::doCompute(

	TTile &tile, double frame, const TRenderSettings &ri)

{

	/* ------ サポートしていないPixelタイプはエラーを投げる --- */

	if (!((TRaster32P)tile.getRaster()) &&

		!((TRaster64P)tile.getRaster())) {

		throw TRopException("unsupported input pixel type");

	}

	/* ------ 動作パラメータを得る ---------------------------- */

	const int red_source = this->m_red_source->getValue() - 1;

	const int gre_source = this->m_gre_source->getValue() - 1;

	const int blu_source = this->m_blu_source->getValue() - 1;

	const int alp_source = this->m_alp_source->getValue() - 1;

	const int red_channel = this->m_red_channel->getValue();

	const int gre_channel = this->m_gre_channel->getValue();

	const int blu_channel = this->m_blu_channel->getValue();

	const int alp_channel = this->m_alp_channel->getValue();

	/* ------ 画像位置とサイズ -------------------------------- */

	/***const TRectD rect = TRectD( tile.m_pos, TDimensionD(

		  tile.getRaster()->getLx()

		, tile.getRaster()->getLy()

	));

	const TPointD poin = TPointD(rect.getP00());

	const TDimension dime = TDimension(

		 (int)(rect.getLx()+0.5)

		,(int)(rect.getLy()+0.5)

	);***/

	/* ------ 塗りつぶしクリア -------------------------------- */

	tile.getRaster()->clear();

	/* ------ 入力画像を接続していなければ処理しない ---------- */

	if (this->getInputPortCount() <= 0) {

		return;

	}

	/* ------ 入力画像の参照を確保 ---------------------------- */

	//TTile *source_tiles = new TTile[this->getInputPortCount()];

	//int   *source_sw    = new int[this->getInputPortCount()];

	//TRasterP *ras_a     = new TRasterP[this->getInputPortCount()];

	/* Not use boost at toonz-6.1 */

	/******

	boost::shared_array<ttile></ttile>

		source_tiles(new TTile[this->getInputPortCount()]);

	boost::shared_array<int></int>

		source_sw(new int[this->getInputPortCount()]);

	boost::shared_array<trasterp></trasterp>

		ras_a(new TRasterP[this->getInputPortCount()]);

******/

	/* Array item(TRasterFxPort) number is 4(fix) in this code */

	TTile source_tiles[4];

	int source_sw[4];

	TRasterP ras_a[4];

	int ras_s = 0;

	/* ------ 画像生成 ---------------------------------------- */

	for (int ii = 0; ii < this->getInputPortCount(); ++ii) {

		std::string nm = this->getInputPortName(ii);

		TRasterFxPort *

			tmp_port = (TRasterFxPort *)this->getInputPort(nm);

		if (tmp_port->isConnected() && ((ii == red_source) || (ii == gre_source) ||

										(ii == blu_source) || (ii == alp_source))) {

			(*tmp_port)->allocateAndCompute(

				source_tiles[ii]

				//,poin,dime

				,

				tile.m_pos /* 位置 */

				,

				TDimension(/* サイズ */

						   tile.getRaster()->getLx(), tile.getRaster()->getLy()),

				tile.getRaster() /* sampling */

				,

				frame, ri);

			source_sw[ii] = 1;

			ras_a[ras_s++] = source_tiles[ii].getRaster();

		} else

			source_sw[ii] = 0;

	}

	TRasterP red_ras = 0;

	TRasterP gre_ras = 0;

	TRasterP blu_ras = 0;

	TRasterP alp_ras = 0;

	if ((0 <= red_source) && (red_source < this->getInputPortCount()) && source_sw[red_source]) {

		red_ras = source_tiles[red_source].getRaster();

	}

	if ((0 <= gre_source) && (gre_source < this->getInputPortCount()) && source_sw[gre_source]) {

		gre_ras = source_tiles[gre_source].getRaster();

	}

	if ((0 <= blu_source) && (blu_source < this->getInputPortCount()) && source_sw[blu_source]) {

		blu_ras = source_tiles[blu_source].getRaster();

	}

	if ((0 <= alp_source) && (alp_source < this->getInputPortCount()) && source_sw[alp_source]) {

		alp_ras = source_tiles[alp_source].getRaster();

	}

	/* ------ (app_begin)log記憶 ------------------------------ */

	const bool log_sw = ino::log_enable_sw();

	if (log_sw) {

		std::ostringstream os;

		os

			<< "red"

			<< "  s " << red_source << "  c " << red_channel

			<< "   green"

			<< "  s " << gre_source << "  c " << gre_channel

			<< "   blue"

			<< "  s " << blu_source << "  c " << blu_channel

			<< "   alpha"

			<< "  s " << alp_source << "  c " << alp_channel

			<< "   tile w " << tile.getRaster()->getLx()

			<< "  h " << tile.getRaster()->getLy()

			<< "  b " << ino::pixel_bits(tile.getRaster());

		os

			<< "   s_count " << this->getInputPortCount();

		for (int ii = 0; ii < this->getInputPortCount(); ++ii) {

			if (source_sw[ii]) {

				os

					<< "   tile" << ii

					<< "  w " << source_tiles[ii].getRaster()->getLx()

					<< "  h " << source_tiles[ii].getRaster()->getLy()

					<< "  b " << ino::pixel_bits(source_tiles[ii].getRaster());

			}

		}

		os

			<< "   frame " << frame;

	}

	/* ------ 入力画像の参照開放 ------------------------------ */

	//delete [] source_sw;

	//delete [] source_tiles;

	/* ------ fx処理 ------------------------------------------ */

	try {

		tile.getRaster()->lock();

		for (int ii = 0; ii < ras_s; ++ii) {

			ras_a[ii]->lock();

		}

		if (red_ras) {

			fx_(red_ras, red_channel, tile.getRaster(), 0);

		}

		if (gre_ras) {

			fx_(gre_ras, gre_channel, tile.getRaster(), 1);

		}

		if (blu_ras) {

			fx_(blu_ras, blu_channel, tile.getRaster(), 2);

		}

		if (alp_ras) {

			fx_(alp_ras, alp_channel, tile.getRaster(), 3);

		}

		for (int ii = ras_s - 1; 0 <= ii; --ii) {

			ras_a[ii]->unlock();

		}

		tile.getRaster()->unlock();

	}

	/* ------ error処理 --------------------------------------- */

	catch (std::bad_alloc &e) {

		for (int ii = ras_s - 1; 0 <= ii; --ii) {

			ras_a[ii]->unlock();

		}

		tile.getRaster()->unlock();

		if (log_sw) {

			std::string str("std::bad_alloc <");

			str += e.what();

			str += '>';

		}

		//delete [] ras_a;

		throw;

	} catch (std::exception &e) {

		for (int ii = ras_s - 1; 0 <= ii; --ii) {

			ras_a[ii]->unlock();

		}

		tile.getRaster()->unlock();

		if (log_sw) {

			std::string str("exception <");

			str += e.what();

			str += '>';

		}

		//delete [] ras_a;

		throw;

	} catch (...) {

		for (int ii = ras_s - 1; 0 <= ii; --ii) {

			ras_a[ii]->unlock();

		}

		tile.getRaster()->unlock();

		if (log_sw) {

			std::string str("other exception");

		}

		//delete [] ras_a;

		throw;

	}

	//delete [] ras_a;

}