// #include <iostream>
#include "igs_motion_wind_table.h"
#include "igs_motion_wind_pixel.h"

igs::motion_wind::pixel::pixel(
	const bool blow_dark_sw, const bool blow_alpha_sw

	,
	const unsigned long length_random_seed, const double length_min, const double length_max, const double length_bias, const bool length_ref_sw

	,
	const unsigned long force_random_seed, const double force_min, const double force_max, const double force_bias, const bool force_ref_sw

	,
	const unsigned long density_random_seed, const double density_min, const double density_max, const double density_bias, const bool density_ref_sw)
	: blow_dark_sw_(blow_dark_sw), blow_alpha_sw_(blow_alpha_sw)

	  ,
	  length_min_(length_min), length_max_(length_max), length_bias_(length_bias), length_ref_sw_(length_ref_sw)

	  ,
	  force_min_(force_min), force_max_(force_max), force_bias_(force_bias), force_ref_sw_(force_ref_sw)

	  ,
	  density_min_(density_min), density_max_(density_max), density_bias_(density_bias), density_ref_sw_(density_ref_sw)

	  ,
	  key_lightness_(0), table_len_(0), table_pos_(0), table_array_(0)
{
	this->table_.resize(
		igs::motion_wind::table_size(length_min, length_max));
	this->length_random_.seed(length_random_seed);
	this->force_random_.seed(force_random_seed);
	this->density_random_.seed(density_random_seed);
}
void igs::motion_wind::pixel::clear(void)
{
	this->table_.clear();
}
//----------------------------------------------------------------------
namespace
{
void wind_rgba_(
	const double key, const double alp, const double ratio, bool &sw, double &tgt)
{
	if (tgt < key) {
		tgt += ratio * (key - tgt) * alp;
		tgt = (tgt < 0.0) ? 0.0 : ((1.0 < tgt) ? 1.0 : tgt); //limit
		sw = true;
	}
}
void wind_rgb_(
	const double key, const double ratio, bool &sw, double &tgt)
{
	if (tgt < key) {
		// std::cout << "(R" << ratio << ",K" << key << ",T" << tgt;
		tgt += ratio * (key - tgt);
		// std::cout << ">" << tgt << ")\n";
		tgt = (tgt < 0.0) ? 0.0 : ((1.0 < tgt) ? 1.0 : tgt); //limit
		sw = true;
	}
}
void wind_a_(
	const double key /* alpha値 */
	,
	const double ratio, const bool sw, double &tgt /* alpha値 */
	)
{
	if ((tgt < key) || sw) {
		double val = tgt + (ratio * (key - tgt));
		if (tgt < val) { /* 元より明るいときのみ変化 */
			tgt = val;
			tgt = (tgt < 0.0) ? 0.0 : ((1.0 < tgt) ? 1.0 : tgt); //limit
		}
	}
}
//-----------------------------------------------------------
void blow_wind_(/* 風の影響による値の変化 */
				const int channels, const double *key, const double *tbl_a, const int tbl_p, const bool blow_alpha_sw, double *tgt)
{
	bool sw = false; /* rgb風を実行したか否かを示す */

	if (igs::image::rgba::siz == channels) { /* Alphaがある */
		using namespace igs::image::rgba;
		if (blow_alpha_sw) { /* Alpha風を実行する */
							 /* RGB風 */
			wind_rgb_(key[red], tbl_a[tbl_p], sw, tgt[red]);
			wind_rgb_(key[gre], tbl_a[tbl_p], sw, tgt[gre]);
			wind_rgb_(key[blu], tbl_a[tbl_p], sw, tgt[blu]);
			/* Alpha風 */
			/* Alpha独自の風と、RGB風の、両方の影響による値の変化 */
			wind_a_(key[alp], tbl_a[tbl_p], sw, tgt[alp]);
		} else { /* Alpha風を実行せず、マスク抜きのRGB風を生成 */
			wind_rgba_(key[red], tgt[alp], tbl_a[tbl_p], sw, tgt[red]);
			wind_rgba_(key[gre], tgt[alp], tbl_a[tbl_p], sw, tgt[gre]);
			wind_rgba_(key[blu], tgt[alp], tbl_a[tbl_p], sw, tgt[blu]);
		}
	} else { /* channel毎に風を生成する */
		for (int zz = 0; zz < channels; ++zz) {
			wind_rgb_(key[zz], tbl_a[tbl_p], sw, tgt[zz]);
		}
	}
}
void invert_pixel_(
	const int channels, double *pixel)
{
	if (igs::image::rgba::siz == channels) { /* Alphaがある */
		using namespace igs::image::rgba;
		pixel[red] = (1.0 - pixel[red]) * pixel[alp];
		pixel[gre] = (1.0 - pixel[gre]) * pixel[alp];
		pixel[blu] = (1.0 - pixel[blu]) * pixel[alp];
	} else /* Alphaがないなら、ただ白黒反転 */
		if (igs::image::rgb::siz == channels) {
		using namespace igs::image::rgb;
		pixel[red] = 1.0 - pixel[red];
		pixel[gre] = 1.0 - pixel[gre];
		pixel[blu] = 1.0 - pixel[blu];
	} else {
		for (int zz = 0; zz < channels; ++zz) {
			pixel[zz] = 1.0 - pixel[zz];
		}
	}
}
void rgb_to_lightness_(
	const double re, const double gr, const double bl, double &li)
{
	li = ((re < gr) ? ((gr < bl) ? bl : gr) : ((re < bl) ? bl : re) +
													  (gr < re)
												  ? ((bl < gr) ? bl : gr)
												  : ((bl < re) ? bl : re)) /
		 2.0;
}
double get_lightness_(
	const int channels, const double *pixel
	// , const bool blow_dark_sw
	)
{
	double lightness;

	if (igs::image::rgba::siz == channels) {
		using namespace igs::image::rgba;
		rgb_to_lightness_(
			pixel[red], pixel[gre], pixel[blu], lightness);
	} else if (igs::image::rgb::siz == channels) {
		using namespace igs::image::rgb;
		rgb_to_lightness_(
			pixel[red], pixel[gre], pixel[blu], lightness);
	} else {
		lightness = pixel[0];
	}
	/* 指定があるなら白黒反転 */
	// if (blow_dark_sw) { lightness = 1.0 - lightness; }
	return lightness;
}
}
//------------------------------------------------------------
int igs::motion_wind::pixel::change(
	const bool key_reset_sw

	/***, const int ref_channel
	, const double *ref_pixel***/

	,
	const double ref_val /* ゼロ以上なら有効値、マイナスなら無効 */
	,
	const int channels, double *pixel_tgt)
{
	/* 指定があるなら白黒反転、
	このプログラム内ではすべて明るさで処理する */
	if (this->blow_dark_sw_) {
		invert_pixel_(channels, pixel_tgt);
	}

	/* 現位置の明るさを求める */
	const double crnt_lightness = get_lightness_(
		channels, pixel_tgt // , this->blow_dark_sw_
		);

	/* スキャンラインの始点のではkey pixel値のreset */
	if (key_reset_sw) {
		this->key_lightness_ = crnt_lightness;
		for (int ii = 0; ii < channels; ++ii) {
			this->pixel_key_[ii] = pixel_tgt[ii];
		}
	}

	/* 値がkeyより小さい(山の頂上より小さい)時 */
	if (crnt_lightness < this->key_lightness_) {
		/* 風テーブルがゼロなら
		風データを設定し、風テーブルを設定する */
		if (0 == this->table_array_) {
			double length_min = this->length_min_;
			double length_max = this->length_max_;
			double length_bias = this->length_bias_;
			double force_min = this->force_min_;
			double force_max = this->force_max_;
			double force_bias = this->force_bias_;
			double density_min = this->density_min_;
			double density_max = this->density_max_;
			double density_bias = this->density_bias_;
#if 0
			double ref_value;
			/* 画像から強弱を得る */
			if (0 != ref_pixel) {/* 参照画像のRGBAから */
				ref_value = ref_pixel[ref_channel];
			} else { /* 自画像から強弱を得る */
				ref_value = get_lightness_(
					channels, pixel_tgt);
			}
#endif
			double ref_value = ref_val;
			/* 参照画像から取らないときは自画像から強弱を得る */
			if (ref_value < 0.0) {
				ref_value = get_lightness_(
					channels, pixel_tgt);
			}

			if (this->length_ref_sw_) {
				length_min *= ref_value;
				length_max *= ref_value;
			}
			if (this->force_ref_sw_) {
				force_min *= ref_value;
				force_max *= ref_value;
			}
			if (this->density_ref_sw_) {
				density_min *= ref_value;
				density_max *= ref_value;
			}

			/* 風データを得る(流れのパターンの更新) */
			/***std::cout
	<< "lmin " << length_min << "  lmax " << length_max
	<< "\ncmin " << force_min  << "  cmax " << force_max
	<< "\nhmin " << density_min << "  hmax " << density_max
	<< "\n"
;***/
			/* 更新した、風データを、カレントにセットする */
			this->table_len_ = igs::motion_wind::make_table(
				this->table_, this->length_random_, this->force_random_, this->density_random_, length_min, length_max, length_bias, force_min, force_max, force_bias, density_min, density_max, density_bias);
			this->table_array_ = &this->table_.at(0);
			this->table_pos_ = 1;
			/***for (int ii=0;ii<this->table_len_;++ii) {
std::cout << this->table_array_[ii] << "\n";
}***/

			/* 風の中である。
			風の長さは１かもしれない... */
		}

		/* 風に影響された値を出力値にいれる */
		if (this->table_pos_ < this->table_len_) {
			/* 風の計算 */
			blow_wind_(
				channels, this->pixel_key_, this->table_array_, this->table_pos_, this->blow_alpha_sw_, pixel_tgt);
			++this->table_pos_;

			/* 保存すべき値となったので白黒反転を戻す */
			if (this->blow_dark_sw_) {
				invert_pixel_(channels, pixel_tgt);
			}

			return true; /* 風ん中 */
		}
	}

	/*	ここに来たということは、
		風の外である、
			つまり風の影響範囲からはずれたとき、
			つまりtable_pos_がtable_len_から外れた、
		あるいは、
		値が等しいかkeyより大きい値のとき、
			つまりcrnt_lightnessがkey_lightness_以上、
		なので、現在値をメモリする(keyにいれる)
	*/

	this->key_lightness_ = crnt_lightness;
	for (int ii = 0L; ii < channels; ++ii) {
		this->pixel_key_[ii] = pixel_tgt[ii];
	}

	/* 風が途切れたので風テーブルをゼロとする */
	this->table_array_ = 0;

	return false; /* 風の外 */
}