#include "flowlinestrokestyle.h"

#include "tcolorfunctions.h"
#include "tcurves.h"

#define BUFFER_OFFSET(bytes) ((GLubyte *)NULL + (bytes))
#define V_BUFFER_SIZE 1000

namespace {
double getMaxThickness(const TStroke *s) {
  int count           = s->getControlPointCount();
  double maxThickness = -1;

  for (int i = 0; i < s->getControlPointCount(); i++) {
    double thick = s->getControlPoint(i).thick;
    if (thick > maxThickness) maxThickness = thick;
  }
  return maxThickness;
}

struct float2 {
  float x;
  float y;
};

inline double dot(const TPointD &v1, const TPointD &v2) {
  return v1.x * v2.x + v1.y * v2.y;
}

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

inline bool isLinearPoint(const TPointD &p0, const TPointD &p1,
                          const TPointD &p2) {
  return (tdistance(p0, p1) < 0.02) && (tdistance(p1, p2) < 0.02);
}

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

//! Ritorna \b true se il punto \b p1 e' una cuspide.
bool isCuspPoint(const TPointD &p0, const TPointD &p1, const TPointD &p2) {
  TPointD p0_p1(p0 - p1), p2_p1(p2 - p1);
  double n1 = norm(p0_p1), n2 = norm(p2_p1);

  // Partial linear points are ALWAYS cusps (since directions from them are
  // determined by neighbours, not by the points themselves)
  if ((n1 < 0.02) || (n2 < 0.02)) return true;

  p0_p1 = p0_p1 * (1.0 / n1);
  p2_p1 = p2_p1 * (1.0 / n2);

  return (p0_p1 * p2_p1 > 0) ||
         (fabs(cross(p0_p1, p2_p1)) > 0.09);  // more than 5° is yes

  // Distance-based check. Unscalable...
  // return
  // !areAlmostEqual(tdistance(p0,p2),tdistance(p0,p1)+tdistance(p1,p2),2);
}

//-----------------------------------------------------------------------------
/*! Insert a point in the most long chunk between chunk \b indexA and chunk \b
 * indexB. */
void insertPoint(TStroke *stroke, int indexA, int indexB) {
  assert(stroke);
  int j          = 0;
  int chunkCount = indexB - indexA;
  if (chunkCount % 2 == 0) return;
  double length = 0;
  double firstW, lastW;
  for (j = indexA; j < indexB; j++) {
    // cerco il chunk piu' lungo
    double w0 = stroke->getW(stroke->getChunk(j)->getP0());
    double w1;
    if (j == stroke->getChunkCount() - 1)
      w1 = 1;
    else
      w1 = stroke->getW(stroke->getChunk(j)->getP2());
    double length0 = stroke->getLength(w0);
    double length1 = stroke->getLength(w1);
    if (length < length1 - length0) {
      firstW = w0;
      lastW  = w1;
      length = length1 - length0;
    }
  }
  stroke->insertControlPoints((firstW + lastW) * 0.5);
}
};  // namespace
//-----------------------------------------------------------------------------

FlowLineStrokeStyle::FlowLineStrokeStyle()
    : m_color(TPixel32(100, 200, 200, 255))
    , m_density(0.25)
    , m_extension(5.0)
    , m_widthScale(5.0)
    , m_straightenEnds(true) {}

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

TColorStyle *FlowLineStrokeStyle::clone() const {
  return new FlowLineStrokeStyle(*this);
}

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

int FlowLineStrokeStyle::getParamCount() const { return ParamCount; }

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

TColorStyle::ParamType FlowLineStrokeStyle::getParamType(int index) const {
  assert(0 <= index && index < getParamCount());
  switch (index) {
  case Density:
  case Extension:
  case WidthScale:
    return TColorStyle::DOUBLE;
  case StraightenEnds:
    return TColorStyle::BOOL;
  }
  return TColorStyle::DOUBLE;
}

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

QString FlowLineStrokeStyle::getParamNames(int index) const {
  assert(0 <= index && index < ParamCount);
  switch (index) {
  case Density:
    return QCoreApplication::translate("FlowLineStrokeStyle", "Density");
  case Extension:
    return QCoreApplication::translate("FlowLineStrokeStyle", "Extension");
  case WidthScale:
    return QCoreApplication::translate("FlowLineStrokeStyle", "Width Scale");
  case StraightenEnds:
    return QCoreApplication::translate("FlowLineStrokeStyle",
                                       "Straighten Ends");
  }
  return QString();
}

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

void FlowLineStrokeStyle::getParamRange(int index, double &min,
                                        double &max) const {
  assert(0 <= index && index < ParamCount);
  switch (index) {
  case Density:
    min = 0.2;
    max = 5.0;
    break;
  case Extension:
    min = 0.0;
    max = 20.0;
    break;
  case WidthScale:
    min = 1.0;
    max = 50.0;
    break;
  }
}

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

double FlowLineStrokeStyle::getParamValue(TColorStyle::double_tag,
                                          int index) const {
  assert(0 <= index && index < ParamCount);
  switch (index) {
  case Density:
    return m_density;
  case Extension:
    return m_extension;
  case WidthScale:
    return m_widthScale;
  }
  return 0.0;
}

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

void FlowLineStrokeStyle::setParamValue(int index, double value) {
  assert(0 <= index && index < ParamCount);
  switch (index) {
  case Density:
    m_density = value;
    break;
  case Extension:
    m_extension = value;
    break;
  case WidthScale:
    m_widthScale = value;
    break;
  }
  updateVersionNumber();
}

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

bool FlowLineStrokeStyle::getParamValue(TColorStyle::bool_tag,
                                        int index) const {
  assert(index == StraightenEnds);
  return m_straightenEnds;
}

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

void FlowLineStrokeStyle::setParamValue(int index, bool value) {
  assert(index == StraightenEnds);
  m_straightenEnds = value;
}

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

void FlowLineStrokeStyle::drawStroke(const TColorFunction *cf,
                                     const TStroke *stroke) const {
  auto lerp = [](float val1, float val2, float ratio) {
    return val1 * (1.0 - ratio) + val2 * ratio;
  };
  auto length2 = [](TPointD p) { return p.x * p.x + p.y * p.y; };

  // Length and position of the stroke is in "actual size" (i.e. not in pixels).
  // 1unit = 1/53.3333inches
  // Strokeの長さや座標は実寸（１単位＝1/53.3333インチ）
  double length = stroke->getLength();
  if (length <= 0) return;

  double maxThickness = getMaxThickness(stroke) * m_widthScale;
  if (maxThickness <= 0) return;

  TStroke *tmpStroke = new TStroke(*stroke);

  // straighten ends. replace the control point only if the new handle will
  // become longer
  if (m_straightenEnds && stroke->getControlPointCount() >= 5 &&
      !stroke->isSelfLoop()) {
    TPointD newPos = tmpStroke->getControlPoint(0) * 0.75 +
                     tmpStroke->getControlPoint(3) * 0.25;
    TPointD oldVec =
        tmpStroke->getControlPoint(1) - tmpStroke->getControlPoint(0);
    TPointD newVec = newPos - tmpStroke->getControlPoint(0);
    if (length2(oldVec) < length2(newVec))
      tmpStroke->setControlPoint(1, newPos);

    int lastId = stroke->getControlPointCount() - 1;
    newPos     = tmpStroke->getControlPoint(lastId) * 0.75 +
             tmpStroke->getControlPoint(lastId - 3) * 0.25;
    oldVec = tmpStroke->getControlPoint(lastId - 1) -
             tmpStroke->getControlPoint(lastId);
    newVec = newPos - tmpStroke->getControlPoint(lastId);
    if (length2(oldVec) < length2(newVec))
      tmpStroke->setControlPoint(lastId - 1, newPos);
  }

  // see ControlPointEditorStroke::adjustChunkParity() in
  // controlpointselection.cpp
  int firstChunk;
  int secondChunk = tmpStroke->getChunkCount();
  int i;
  for (i = tmpStroke->getChunkCount() - 1; i > 0; i--) {
    if (tdistance(tmpStroke->getChunk(i - 1)->getP0(),
                  tmpStroke->getChunk(i)->getP2()) < 0.5)
      continue;
    TPointD p0 = tmpStroke->getChunk(i - 1)->getP1();
    TPointD p1 = tmpStroke->getChunk(i - 1)->getP2();
    TPointD p2 = tmpStroke->getChunk(i)->getP1();
    if (isCuspPoint(p0, p1, p2) || isLinearPoint(p0, p1, p2)) {
      firstChunk = i;
      insertPoint(tmpStroke, firstChunk, secondChunk);
      secondChunk = firstChunk;
    }
  }
  insertPoint(tmpStroke, 0, secondChunk);

  // thin lines amount 細線の本数
  int count = 2 * (int)std::ceil(maxThickness * m_density) - 1;

  TPixel32 color;
  if (cf)
    color = (*(cf))(m_color);
  else
    color = m_color;

  float2 *vertBuf  = new float2[V_BUFFER_SIZE];
  int maxVertCount = 0;

  glEnableClientState(GL_VERTEX_ARRAY);

  int centerId = (count - 1) / 2;

  TThickPoint p0 = tmpStroke->getThickPoint(0);
  TThickPoint p1 = tmpStroke->getThickPoint(1);
  double d01     = tdistance(p0, p1);
  if (d01 == 0) return;

  int len = (int)(d01);
  if (len == 0) return;

  TPointD v0 = tmpStroke->getSpeed(0);
  TPointD v1 = tmpStroke->getSpeed(1);

  if (norm2(v0) == 0 || norm2(v1) == 0) return;

  TPointD startVec = -normalize(v0);
  TPointD endVec   = normalize(v1);

  for (int i = 0; i < count; i++) {
    double widthRatio =
        (count == 1) ? 0.0 : (double)(i - centerId) / (double)centerId;
    double extensionLength =
        (1.0 - std::abs(widthRatio)) * maxThickness * m_extension;

    glColor4ub(color.r, color.g, color.b, color.m);

    int divAmount = len * 5;
    if (divAmount + 3 > V_BUFFER_SIZE) divAmount = V_BUFFER_SIZE - 3;

    float2 *vp = vertBuf;

    for (int j = 0; j <= divAmount; j++, vp++) {
      // current position ratio  今の座標の割合位置
      double t = double(j) / double(divAmount);

      // position ratio on the stroke ストローク上のratio位置
      double w = t;
      // unit vector perpendicular to the stroke 鉛直方向の単位ベクトル
      TPointD v = rotate90(normalize(tmpStroke->getSpeed(w)));
      assert(0 <= w && w <= 1);
      // position on the stroke ストローク上の位置
      TPointD p = tmpStroke->getPoint(w);

      TPointD pos = p + v * maxThickness * widthRatio;

      if (j == 0) {
        TPointD sPos = pos + startVec * extensionLength;
        *vp          = {float(sPos.x), float(sPos.y)};
        vp++;
      }
      *vp = {float(pos.x), float(pos.y)};
      if (j == divAmount) {
        vp++;
        TPointD ePos = pos + endVec * extensionLength;
        *vp          = {float(ePos.x), float(ePos.y)};
      }
    }

    glVertexPointer(2, GL_FLOAT, 0, vertBuf);
    // draw
    glDrawArrays(GL_LINE_STRIP, 0, divAmount + 3);
  }
  glColor4d(0, 0, 0, 1);
  glDisableClientState(GL_VERTEX_ARRAY);
  delete[] vertBuf;
  delete tmpStroke;
}

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

TRectD FlowLineStrokeStyle::getStrokeBBox(const TStroke *stroke) const {
  TRectD rect = TColorStyle::getStrokeBBox(stroke);
  double margin =
      getMaxThickness(stroke) * m_widthScale * std::max(1.0, m_extension);
  return rect.enlarge(margin);
}

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