#include <cmath>  // sqrt() sin() cos()
#ifndef M_PI      /* only Microsoft C++ */
#define M_PI 3.14159265358979323846
#endif
#include <iostream>  // std::cout
#include "igs_maxmin_lens_matrix.h"
 
namespace {
/*
                        y
                        ^
                        |   <-
                        |      \
                        |	|
        <---------------+----------------> x
                        |
                        |
                        |
                        v
 */
bool inside_polygon_(double radius, int odd_diameter, double xp, double yp,
                     int polygon_number, double roll_degree) {
  if (polygon_number < 3) { /* equal less than 2  is circle */
    return true;
  }
  double radian     = roll_degree * (M_PI / 180),
         add_radian = 2.0 * M_PI / polygon_number;
  double x1 = radius * cos(radian), y1 = radius * sin(radian), x2 = 0, y2 = 0,
         xa = odd_diameter, xb = odd_diameter;
  radian += add_radian;
 
  /* 線分の回数loop回す */
  for (int ii = 0; ii < polygon_number;
       ++ii, radian += add_radian, x1 = x2, y1 = y2) {
    /* (0,0)を原点とした正多角形の各頂点
    数学的開始点(右)及び回転方向(CCW)とするため、
    内部では上下左右反転する。
    これをしないと左からCW回転となる
    計算の考えを単純にするため反転しない2013-12-10
    */
    x2 = radius * cos(radian);
    y2 = radius * sin(radian);
 
    /* scanline方向でy1とy2の間で区切った領域外なら次へ
    ((y2==y1==yp)の場合も)しない線分なら次へ */
    if (!(((y1 <= yp) && (yp <= y2)) || ((y2 <= yp) && (yp <= y1)))) {
      continue;
    }
 
    /* scanline方向でy1とy2の間で区切った領域 */
 
    /* 水平線分 */
    if (y2 == y1) {
      if (((x1 <= xp) && (xp <= x2)) || ((x2 <= xp) && (xp <= x1))) {
        return true;
      } /* 水平線分上 */
      else {
        return false;
      } /* 水平範囲外 */
    }
 
    /* 水平方向の初めの交差位置(xa) */
    if (xa == odd_diameter) {
      /* (x2 - x1)/(y2 - y1)=(xa - x1)/(yp - y1);
(xa - x1)=(yp - y1)*(x2 - x1)/(y2 - y1); */
      xa = (yp - y1) * (x2 - x1) / (y2 - y1) + x1;
    } else
        /* 2番目の交差位置(xb) */
        if (xb == odd_diameter) {
      xb = (yp - y1) * (x2 - x1) / (y2 - y1) + x1;
      if (((xa <= xp) && (xp <= xb)) || ((xb <= xp) && (xp <= xa))) {
        return true;
      } /* 水平範囲内 */
      else {
        return false;
      } /* 水平範囲外 */
    }
  }
  return false;
}
/*
        二点(x1,y1),(x2,y2)を通る直線
         x - x1    y - y1
        ------- = -------
        x2 - x1   y2 - y1
    -->	(x - x1) * (y2 - y1) = (y - y1) * (x2 - x1)
    -->	x * (y2 - y1) - x1 * (y2 - y1) = y * (x2 - x1) - y1 * (x2 - x1)
    --> y * (x2 - x1) - y1 * (x2 - x1) = x * (y2 - y1) - x1 * (y2 - y1)
    -->	y * (x2 - x1) + x1 * (y2 - y1) = x * (y2 - y1) + y1 * (x2 - x1)
    -->	(y1 - y2) * x + (x2 - x1) * y + x1 * (y2 - y1) - y1 * (x2 - x1) = 0
    --> (y1 - y2) * x + (x2 - x1) * y + x1*y2 - x1*y1 - y1*x2 + y1*x1 = 0
    --> (y1 - y2) * x + (x2 - x1) * y + x1*y2 - y1*x2 = 0
 
        点(x0,y0)と直線との距離(垂線の長さ)(h)
        a * x + b * y + c = 0 ならば、
                | a * x0 + b * y0 + c |
        h =	-----------------------
                  sqrt(a * a + b * b)
                | (y1 - y2) * x0 + (x2 - x1) * y0 + x1*y2 - y1*x2 |
        h =	---------------------------------------------------
                sqrt((y1 - y2) * (y1 - y2) + (x2 - x1) * (x2 - x1))
 */
double length_to_polygon_(double radius, double xp, double yp,
                          int polygon_number, double roll_degree) {
  /* 現在位置での角度 */
  double radian = atan2(yp, xp); /* 0 ... M_PI , -M_PI ... 0 */
  if (radian < 0) {
    radian += M_PI * 2.0;
  } /* 0 ... M_PI*2 */
 
  /* 多角形の辺の2点 */
  double x1 = 0.0, y1 = 0.0, x2 = 0.0, y2 = 0.0;
  const double add_radian = 2.0 * M_PI / polygon_number;
  double radian1          = roll_degree * (M_PI / 180);
  /* rad1だとMS-VC++_v10でエラー!!! */
  while (radian1 < 0.0) {
    radian1 += add_radian;
  }
  double radian2 = radian1 + add_radian;
  /* rad2だとMS-VC++_v10でエラー!!! */
 
  /* 開始角度より現在位置の角度が小さい場合360先に進める */
  if (radian < radian1) {
    radian += M_PI * 2.0;
  }
 
  for (int ii = 0; ii < polygon_number;
       ++ii, radian1 = radian2, radian2 += add_radian) {
    if (radian1 <= radian && radian <= radian2) {
      x1 = radius * cos(radian1);
      y1 = radius * sin(radian1);
      x2 = radius * cos(radian2);
      y2 = radius * sin(radian2);
      break;
    }
  }
  if (x1 == 0.0) {
    /* エラー */
    return -1.0;  //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  }
  return fabs((y1 - y2) * xp + (x2 - x1) * yp + x1 * y2 - y1 * x2) /
         sqrt((y1 - y2) * (y1 - y2) + (x2 - x1) * (x2 - x1));
}
void alloc_lens_matrix_(const int odd_diameter, std::vector<int> &lens_offsets,
                        std::vector<int> &lens_sizes,
                        std::vector<std::vector<double>> &lens_ratio) {
  lens_offsets.resize(odd_diameter);
  lens_sizes.resize(odd_diameter);
  lens_ratio.resize(odd_diameter);
  for (int yy = 0; yy < odd_diameter; ++yy) {
    lens_ratio.at(yy).resize(odd_diameter);
  }
}
void free_lens_matrix_(std::vector<int> &lens_offsets,
                       std::vector<int> &lens_sizes,
                       std::vector<std::vector<double>> &lens_ratio) {
  lens_ratio.clear();
  lens_sizes.clear();
  lens_offsets.clear();
}
}
const int igs::maxmin::diameter_from_outer_radius(const double outer_radius) {
  /* -------- 半径(radius)を含むピクセル直径 --------
  中心pixelが必要、奇数(1,3,5...)となる
           ---+---|---+---|---+---|---+---|---+---
outer_radius-->		    +---->
Pixelの半分幅足す(+0.5)	|-------->
全体が入るPixel数幅(ceil())	|--------------->
整数化時誤差防ぐ(+0.5)		|------------------->
整数化(static_cast<int>)	|-------|------->
中心を除く半径Pixel幅(-1)		|------->
中心除く直径(*2)	<-------|	|------->
直径(+1)		<-------|-------|------->
-->odd_diameter
  */
  return (static_cast<int>(ceil(outer_radius + 0.5) + 0.5) - 1) * 2 + 1;
}
const double igs::maxmin::outer_radius_from_radius(
    const double radius, const double smooth_outer_range) {
  if (radius < 1.0) {
    /*
    半径ゼロでは処理しない絵となり、
    わずかな半径に変化したとき、
    いきなり大きなエッジ足(smooth_outer_range)が
    飛び出さないように
 
    radiusがゼロなら足長さを1.0(影響のない最小値)に、
    radiusが1ならradius + smooth_outer_rangeになり、
    影響が反映される
 
    smooth_outer_rangeは1以上でないとsmoothにならない。
*/
    return 1.0 + radius * (radius + smooth_outer_range - 1.0);
  }
  return radius + smooth_outer_range;
}
const int igs::maxmin::alloc_and_shape_lens_matrix(
    const double radius  // 0<=
    ,
    const double outer_radius, const int polygon_number  // =2
    ,
    const double roll_degree  // 0<= ... <=360
    ,
    std::vector<int> &lens_offsets, std::vector<int> &lens_sizes,
    std::vector<std::vector<double>> &lens_ratio) {
  /*------ 大きさが無い指定のときMemory解放 ------*/
  if (radius <= 0.0) {
    free_lens_matrix_(lens_offsets, lens_sizes, lens_ratio);
    return 0;
  }
 
  /*------ 半径から必要なピクセル単位の直径を求める ------*/
  const int odd_diameter =
      igs::maxmin::diameter_from_outer_radius(outer_radius);
 
  /*------ Memory確保or再利用 ------*/
  alloc_lens_matrix_(odd_diameter, lens_offsets, lens_sizes, lens_ratio);
 
  /*------ lens matrix情報を書き込む ------*/
  igs::maxmin::reshape_lens_matrix(
      radius,
      igs::maxmin::outer_radius_from_radius(radius, outer_radius - radius),
      odd_diameter, polygon_number, roll_degree, lens_offsets, lens_sizes,
      lens_ratio);
  return odd_diameter;
}
const void igs::maxmin::reshape_lens_matrix(
    const double radius  // 0<=
    ,
    const double outer_radius, const int odd_diameter /* 最大直径 */
    ,
    const int polygon_number  // =2
    ,
    const double roll_degree  // 0<= ... <=360
    ,
    std::vector<int> &lens_offsets /* 最大直径分の配列 */
    ,
    std::vector<int> &lens_sizes /* 最大直径分の配列 */
    ,
    std::vector<std::vector<double>> &lens_ratio /* 最大直径分の配列 */
    ) {
  /***std::cout
<< "ra=" << radius
<< " outr=" << outer_radius
<< " dia=" << odd_diameter
<< " pol=" << polygon_number
<< " deg=" << roll_degree
<< " lens_offsets=" << lens_offsets.size()
<< " lens_sizes=" << lens_sizes.size()
<< " lens_ratio=" << lens_ratio.size()
<< std::endl;***/
 
  /* --- scanlineスタート位置とscanlineサイズ生成 --- */
  double yp = 0.5 - (odd_diameter / 2.0); /* matrix中心からのy距離 */
  for (int yy = 0; yy < odd_diameter; ++yy, yp += 1.0) {
    /* --- 開始位置とサイズを計算 ------------------- */
    lens_offsets.at(yy) = -1;               /* 初期化 */
    lens_sizes.at(yy)   = 0;                /* 初期化 */
    double xp = 0.5 - (odd_diameter / 2.0); /* matrix中心からのx距離 */
    for (int xx = 0; xx < odd_diameter; ++xx, xp += 1.0) {
      const double current_radius = sqrt(xp * xp + yp * yp);
      /* 外枠影響内 */
      if ((current_radius <= outer_radius) &&
          inside_polygon_(outer_radius, odd_diameter, xp, yp, polygon_number,
                          roll_degree)) {
        /* scanlineスタート位置(ポインタ)のセット */
        if (lens_offsets.at(yy) < 0) {
          /* 半径内に入った瞬間その位置を記録 */
          lens_offsets.at(yy) = xx;
        }
 
      } else { /* 影響外 */
        /* scalineサイズのセット */
        if ((0 <= lens_offsets.at(yy)) && (lens_sizes.at(yy) == 0)) {
          /* 半径内を出た瞬間そこまでのサイズを記録 */
          lens_sizes.at(yy) = xx - lens_offsets.at(yy);
        }
      }
    }
    /* scanlineの最後までが半径内のとき */
    if ((0 <= lens_offsets.at(yy)) && (lens_sizes.at(yy) == 0)) {
      lens_sizes.at(yy) = odd_diameter - lens_offsets.at(yy);
    }
 
    /* --- 外枠から内枠へのリニア変化 --------------- */
    /* 円の外 */
    if (lens_sizes.at(yy) <= 0) {
      continue;
    }
    /* ratio設定 */
    xp     = 0.5 - (odd_diameter / 2.0); /* matrix中心からのx距離 */
    int xr = 0;
    for (int xx = 0; xx < odd_diameter; ++xx, xp += 1.0) {
      const double current_radius = sqrt(xp * xp + yp * yp);
      /* 外枠内 */
      if ((current_radius <= outer_radius) &&
          inside_polygon_(outer_radius, odd_diameter, xp, yp, polygon_number,
                          roll_degree)) {
        /* 内枠内 */
        if ((current_radius <= radius) &&
            inside_polygon_(radius, odd_diameter, xp, yp, polygon_number,
                            roll_degree)) {
          lens_ratio.at(yy).at(xr++) = 1.0;
        }
        /* 外枠と内枠の間 */
        else {
          if (polygon_number < 3) {
            lens_ratio.at(yy).at(xr++) =
                (outer_radius - current_radius) / (outer_radius - radius);
          } else {
            const double leninn =
                length_to_polygon_(radius, xp, yp, polygon_number, roll_degree);
            const double lenout = length_to_polygon_(
                outer_radius, xp, yp, polygon_number, roll_degree);
            lens_ratio.at(yy).at(xr++) = lenout / (leninn + lenout);
          }
        }
      }
    }
  }
}