// #include <iostream></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) {</this->

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; /* 風の外 */

}