#include <iostream>
#include <iomanip>
#include <algorithm> /* std::copy() */
#include "igs_maxmin_slrender.h"
#include "igs_maxmin_lens_matrix.h"
 
void igs::maxmin::slrender::resize(const int odd_diameter, const int width,
                                   const bool alpha_ref_sw,
                                   std::vector<std::vector<double>> &tracks,
                                   std::vector<double> &alpha_ref,
                                   std::vector<double> &result) {
  tracks.resize(odd_diameter);
  for (int yy = 0; yy < odd_diameter; ++yy) {
    tracks.at(yy).resize(width + odd_diameter - 1);
  }
  if (alpha_ref_sw) {
    alpha_ref.resize(width);
  }
  result.resize(width);
}
void igs::maxmin::slrender::clear(std::vector<std::vector<double>> &tracks,
                                  std::vector<double> &alpha_ref,
                                  std::vector<double> &result) {
  result.clear();
  alpha_ref.clear();
  tracks.clear();
}
void igs::maxmin::slrender::shift(std::vector<std::vector<double>> &tracks) {
  /* 先頭からtracks.end()-1番目の要素が先頭にくるように回転 */
  std::rotate(tracks.begin(), tracks.end() - 1, tracks.end());
}
 
namespace {
double maxmin_(const double src, const bool min_sw,
               const std::vector<const double *> &begin_ptr,
               const std::vector<int> &lens_sizes,
               const std::vector<std::vector<double>> &lens_ratio) {
  if (min_sw) {
    /* 暗を広げる場合、反転して判断し、結果は反転して戻す */
    double val           = 1.0 - src; /* 反転して判断 */
    const double rev_src = 1.0 - src; /* 反転して判断 */
    for (unsigned yy = 0; yy < begin_ptr.size(); ++yy) {
      const int sz = lens_sizes.at(yy);
      if (sz <= 0) {
        continue;
      }
 
      const double *xptr = begin_ptr.at(yy);
      const double *rptr = &lens_ratio.at(yy).at(0);
      for (int xx = 0; xx < sz; ++xx, ++xptr, ++rptr) {
        double crnt = 1.0 - (*xptr); /* 反転して判断 */
 
        /* 元値と同じか(反転してるので)小さい値は不要 */
        if (crnt <= rev_src) {
          continue;
        }
 
        /* 元値との差に比率を掛けて結果値を出す */
        crnt = rev_src + (crnt - rev_src) * (*rptr);
        /* 今までの中で(反転してるので)より大きいなら代入 */
        if (val < crnt) {
          val = crnt;
        }
      }
    }
    return 1.0 - val; /* 結果は反転して戻す */
  }
  /* Max */
  double val = src;
  for (unsigned yy = 0; yy < begin_ptr.size(); ++yy) {
    const int sz = lens_sizes.at(yy);
    if (sz <= 0) {
      continue;
    }
 
    const double *xptr = begin_ptr.at(yy);
    const double *rptr = &lens_ratio.at(yy).at(0);
    for (int xx = 0; xx < sz; ++xx, ++xptr, ++rptr) {
      /* 元値と同じか小さい値は不要 */
      if ((*xptr) <= src) {
        continue;
      }
 
      /* 元値との差に比率を掛けて結果値を出す */
      const double crnt = src + ((*xptr) - src) * (*rptr);
      /* 今までの中でより大きいなら代入 */
      if (val < crnt) {
        val = crnt;
      }
    }
  }
  return val;
}
void set_begin_ptr_(const std::vector<std::vector<double>> &tracks,
                    const std::vector<int> &lens_offsets, const int offset,
                    std::vector<const double *> &begin_ptr) {
  for (unsigned ii = 0; ii < lens_offsets.size(); ++ii) {
    begin_ptr.at(ii) = (0 <= lens_offsets.at(ii))
                           ? &tracks.at(ii).at(offset + lens_offsets.at(ii))
                           : 0;
  }
}
}
/* --- tracksをレンダリングする --------------------------------------*/
void igs::maxmin::slrender::render(
    const double radius, const double smooth_outer_range,
    const int polygon_number, const double roll_degree
 
    ,
    const bool min_sw
 
    ,
    std::vector<int> &lens_offsets, std::vector<int> &lens_sizes,
    std::vector<std::vector<double>> &lens_ratio
 
    ,
    const std::vector<std::vector<double>> &tracks /* RGBのどれか */
    ,
    const std::vector<double> &alpha_ref /* alpha値で影響度合を決める */
    ,
    std::vector<double> &result /* 計算結果 */
    ) {
  /* 初期位置 */
  std::vector<const double *> begin_ptr(lens_offsets.size());
  set_begin_ptr_(tracks, lens_offsets, 0, begin_ptr);
 
  /* 効果半径に変化がある場合 */
  if (0 < alpha_ref.size()) {
    double before_radius = 0.0;
    for (unsigned xx = 0; xx < result.size(); ++xx) {
      /* 次の処理の半径 */
      const double radius2 = alpha_ref.at(xx) * radius;
 
      /* ゼロ以上なら処理する */
      if (0.0 < alpha_ref.at(xx)) {
        /* 前のPixelと違う大きさならreshapeする */
        if (radius2 != before_radius) {
          igs::maxmin::reshape_lens_matrix(
              radius2, igs::maxmin::outer_radius_from_radius(
                           radius2, smooth_outer_range),
              igs::maxmin::diameter_from_outer_radius(radius +
                                                      smooth_outer_range),
              polygon_number, roll_degree, lens_offsets, lens_sizes,
              lens_ratio);
          set_begin_ptr_(tracks, lens_offsets, xx, begin_ptr);
        }
        /* 各ピクセルの処理 */
        result.at(xx) =
            maxmin_(result.at(xx), min_sw, begin_ptr, lens_sizes, lens_ratio);
      } /* alpha_refがゼロなら変化なし */
 
      /* 次の位置へ移動 */
      for (unsigned ii = 0; ii < begin_ptr.size(); ++ii) {
        if (begin_ptr.at(ii) != 0) {
          ++begin_ptr.at(ii);
        }
      }
      if (radius2 != before_radius) {
        before_radius = radius2;
      }
    }
  }
  /* 効果半径が変わらない場合 */
  else {
    for (unsigned xx = 0; xx < result.size(); ++xx) {
      /* 各ピクセルの処理 */
      result.at(xx) =
          maxmin_(result.at(xx), min_sw, begin_ptr, lens_sizes, lens_ratio);
 
      /* 次の位置へ移動 */
      for (unsigned ii = 0; ii < begin_ptr.size(); ++ii) {
        if (begin_ptr.at(ii) != 0) {
          ++begin_ptr.at(ii);
        }
      }
    }
  }
}