// TnzTools includes

#include <tools assistant.h=""></tools>

#include <tools assistants="" guidelineline.h=""></tools>

// TnzCore includes

#include <tgl.h></tgl.h>

//*****************************************************************************************

//    TAssistantLine implementation

//*****************************************************************************************

class TAssistantLine final : public TAssistant {

  Q_DECLARE_TR_FUNCTIONS(TAssistantVanishingPoint)

public:

  const TStringId m_idRestricktA;

  const TStringId m_idRestricktB;

  const TStringId m_idParallel;

  const TStringId m_idGrid;

  const TStringId m_idPerspective;

protected:

  TAssistantPoint &m_a;

  TAssistantPoint &m_b;

  TAssistantPoint &m_grid0;

  TAssistantPoint &m_grid1;

public:

  TAssistantLine(TMetaObject &object):

    TAssistant(object),

    m_idRestricktA("restrictA"),

    m_idRestricktB("restrictB"),

    m_idParallel("parallel"),

    m_idGrid("grid"),

    m_idPerspective("perspective"),

    m_a( addPoint("a", TAssistantPoint::CircleCross) ),

    m_b( addPoint("b", TAssistantPoint::Circle, TPointD(100.0, 0.0)) ),

    m_grid0( addPoint("grid0",  TAssistantPoint::CircleDoubleDots, TPointD(  0.0,-50.0)) ),

    m_grid1( addPoint("grid1",  TAssistantPoint::CircleDots,       TPointD( 25.0,-75.0)) )

  {

    addProperty( new TBoolProperty(m_idRestricktA.str(), getRestrictA()) );

    addProperty( new TBoolProperty(m_idRestricktB.str(), getRestrictB()) );

    addProperty( new TBoolProperty(m_idParallel.str(), getParallel()) );

    addProperty( new TBoolProperty(m_idGrid.str(), getGrid()) );

    addProperty( new TBoolProperty(m_idPerspective.str(), getPerspective()) );

  }

  static QString getLocalName()

    { return tr("Line"); }

  void updateTranslation() const override {

    setTranslation(m_idRestricktA, tr("Restrict A"));

    setTranslation(m_idRestricktB, tr("Restrict B"));

    setTranslation(m_idParallel, tr("Parallel"));

    setTranslation(m_idGrid, tr("Grid"));

    setTranslation(m_idPerspective, tr("Perspective"));

  }

  inline bool getRestrictA() const

    { return data()[m_idRestricktA].getBool(); }

  inline bool getRestrictB() const

    { return data()[m_idRestricktB].getBool(); }

  inline bool getParallel() const

    { return data()[m_idParallel].getBool(); }

  inline bool getGrid() const

    { return data()[m_idGrid].getBool(); }

  inline bool getPerspective() const

    { return data()[m_idPerspective].getBool(); }

  void onDataChanged(const TVariant &value) override {

    TAssistant::onDataChanged(value);

    m_grid0.visible = getGrid()

                   || (getParallel() && (getRestrictA() || getRestrictB()));

    m_grid1.visible = getGrid();

  }

private:

  void fixGrid1(const TPointD &previousA, const TPointD &previousB) {

    TPointD dx = previousB - previousA;

    double l = norm2(dx);

    if (l <= TConsts::epsilon*TConsts::epsilon) return;

    dx = dx*(1.0/sqrt(l));

    TPointD dy(-dx.y, dx.x);

    TPointD g1 = m_grid1.position - m_grid0.position;

    g1 = TPointD(dx*g1, dy*g1);

    dx = m_b.position - m_a.position;

    l = norm2(dx);

    if (l <= TConsts::epsilon*TConsts::epsilon) return;

    dx = dx*(1.0/sqrt(l));

    dy = TPointD(-dx.y, dx.x);

    m_grid1.position = m_grid0.position + dx*g1.x + dy*g1.y;

  }

public:

  void onMovePoint(TAssistantPoint &point, const TPointD &position) override {

    TPointD previousA = m_a.position;

    TPointD previousB = m_b.position;

    point.position = position;

    if (&point != &m_grid1)

      fixGrid1(previousA, previousB);

  }

  void getGuidelines(

    const TPointD &position,

    const TAffine &toTool,

    TGuidelineList &outGuidelines ) const override

  {

    bool restrictA = getRestrictA();

    bool restrictB = getRestrictB();

    bool parallel = getParallel();

    bool perspective = getPerspective();

    TPointD a = toTool*m_a.position;

    TPointD b = toTool*m_b.position;

    TPointD ab = b - a;

    double abLen2 = norm2(ab);

    if (abLen2 < TConsts::epsilon*TConsts::epsilon) return;

    if (parallel) {

      TPointD abp = rotate90(ab);

      TPointD ag = toTool*m_grid0.position - a;

      double k = abp*ag;

      if (fabs(k) <= TConsts::epsilon) {

        if (restrictA || restrictB) return;

        a = position;

      } else {

        k = (abp*(position - a))/k;

        a = a + ag*k;

      }

      if (perspective && (restrictA || restrictB))

        ab = ab*k;

      b = a + ab;

    }

    if (restrictA && restrictB)

      outGuidelines.push_back(TGuidelineP(

        new TGuidelineLine(

          getEnabled(), getMagnetism(), a,  b )));

    else if (restrictA)

      outGuidelines.push_back(TGuidelineP(

        new TGuidelineRay(

          getEnabled(), getMagnetism(), a,  b )));

    else if (restrictB)

      outGuidelines.push_back(TGuidelineP(

        new TGuidelineRay(

          getEnabled(), getMagnetism(), b,  a ))); // b first

    else

      outGuidelines.push_back(TGuidelineP(

        new TGuidelineInfiniteLine(

          getEnabled(), getMagnetism(), a,  b )));

  }

private:

  void drawRuler(const TPointD &a, const TPointD &b, double pixelSize, bool perspective) const {

    double minStep = 10.0*pixelSize;

    double alpha = getDrawingAlpha();

    TPointD direction = b - a;

    double l2 = norm2(direction);

    if (l2 <= TConsts::epsilon*TConsts::epsilon) return;

    double dirLen = sqrt(l2);

    TPointD dirProj = direction*(1.0/l2);

    TPointD normal = TPointD(-direction.y, direction.x)*(1.0/dirLen);

    double xg0 = dirProj*(m_grid0.position - a);

    double xg1 = dirProj*(m_grid1.position - a);

    if (perspective) {

      // draw perspective

      double xa0 = dirProj*(m_a.position - a);

      double k = 0.0, begin = 0.0, end = 0.0;

      if (!calcPerspectiveStep(minStep/dirLen, 0.0, 1.0, xa0, xg0, xg1, k, begin, end)) return;

      for(double x = begin; fabs(x) < fabs(end); x *= k)

        drawMark(a + direction*(xa0 + x), normal, pixelSize, alpha);

    } else {

      // draw linear

      double dx = fabs(xg1 - xg0);

      if (dx*dirLen < minStep) return;

      for(double x = xg0 - floor(xg0/dx)*dx; x < 1.0; x += dx)

        drawMark(a + direction*x, normal, pixelSize, alpha);

    }

  }

  void drawLine(

    const TAffine &matrix,

    const TAffine &matrixInv,

    double pixelSize,

    const TPointD &a,

    const TPointD &b,

    bool restrictA,

    bool restrictB,

    double alpha ) const

  {

    const TRectD oneBox(-1.0, -1.0, 1.0, 1.0);

    TPointD aa = matrix*a;

    TPointD bb = matrix*b;

    if ( restrictA && restrictB ? TGuidelineLineBase::truncateLine(oneBox, aa, bb)

       : restrictA              ? TGuidelineLineBase::truncateRay (oneBox, aa, bb)

       : restrictB              ? TGuidelineLineBase::truncateRay (oneBox, bb, aa) // aa first

       :                  TGuidelineLineBase::truncateInfiniteLine(oneBox, aa, bb) )

          drawSegment(matrixInv*aa, matrixInv*bb, pixelSize, alpha);

  }

  void drawGrid(

    const TAffine &matrix,

    const TAffine &matrixInv,

    double pixelSize,

    bool restrictA,

    bool restrictB,

    bool perspective ) const

  {

    double minStep = 10.0*pixelSize;

    double alpha = getDrawingGridAlpha();

    TPointD a = m_a.position;

    TPointD b = m_b.position;

    TPointD ab = b - a;

    double abLen2 = norm2(ab);

    if (abLen2 < TConsts::epsilon*TConsts::epsilon) return;

    double abLen = sqrt(abLen2);

    TPointD g0 = m_grid0.position;

    TPointD g1 = m_grid1.position;

    TPointD abp = rotate90(ab);

    TPointD ag = g0 - a;

    if (fabs(abp*ag) <= TConsts::epsilon) {

      if (restrictA || restrictB) return;

      ag = abp;

    }

    double agLen2 = norm2(ag);

    if (agLen2 < TConsts::epsilon*TConsts::epsilon) return;

    double agLen = sqrt(agLen2);

    double abpAgK = 1.0/(abp*ag);

    TPointD abpAgProj = abp*abpAgK;

    // draw restriction lines

    if (perspective) {

      if (restrictA) drawLine(matrix, matrixInv, pixelSize, a, a + ag, false, false, alpha);

      if (restrictB) drawLine(matrix, matrixInv, pixelSize, a, a + ag + ab, false, false, alpha);

    } else {

      if (restrictA) drawLine(matrix, matrixInv, pixelSize, a, a + ag, false, false, alpha);

      if (restrictB) drawLine(matrix, matrixInv, pixelSize, b, b + ag, false, false, alpha);

    }

    double minStepX = fabs(minStep*abLen*abpAgK);

    if (minStepX <= TConsts::epsilon) return;

    // calculate bounds

    const TRectD oneBox(-1.0, -1.0, 1.0, 1.0);

    TPointD corners[4] = {

      TPointD(oneBox.x0, oneBox.y0),

      TPointD(oneBox.x0, oneBox.y1),

      TPointD(oneBox.x1, oneBox.y0),

      TPointD(oneBox.x1, oneBox.y1) };

    double minX = 0.0, maxX = 0.0;

    for(int i = 0; i < 4; ++i) {

      double x = abpAgProj * (matrixInv*corners[i] - a);

      if (i == 0 || x < minX) minX = x;

      if (i == 0 || x > maxX) maxX = x;

    }

    if (maxX <= minX) return;

    double x0 = abpAgProj*(g0 - a);

    double x1 = abpAgProj*(g1 - a);

    if (perspective) {

      double k = 0.0, begin = 0.0, end = 0.0;

      if (!calcPerspectiveStep(minStepX, minX, maxX, 0.0, x0, x1, k, begin, end)) return;

      double abk = 1.0/fabs(x0);

      for(double x = begin; fabs(x) < fabs(end); x *= k) {

        TPointD ca = a + ag*x;

        TPointD cb = ca + ab*(abk*x);

        drawLine(matrix, matrixInv, pixelSize, ca, cb, restrictA, restrictB, alpha);

      }

    } else {

      double dx = fabs(x1 - x0);

      if (dx < minStepX) return;

      for(double x = x0 + ceil((minX - x0)/dx)*dx; x < maxX; x += dx) {

        TPointD ca = a + ag*x;

        drawLine(matrix, matrixInv, pixelSize, ca, ca + ab, restrictA, restrictB, alpha);

      }

    }

  }

public:

  void draw(TToolViewer *viewer, bool enabled) const override {

    double alpha = getDrawingAlpha(enabled);

    bool restrictA = getRestrictA();

    bool restrictB = getRestrictB();

    bool parallel = getParallel();

    bool grid = getGrid();

    bool perspective = getPerspective();

    // common data about viewport

    const TRectD oneBox(-1.0, -1.0, 1.0, 1.0);

    TAffine4 modelview, projection;

    glGetDoublev(GL_MODELVIEW_MATRIX, modelview.a);

    glGetDoublev(GL_PROJECTION_MATRIX, projection.a);

    TAffine matrix = (projection*modelview).get2d();

    TAffine matrixInv = matrix.inv();

    double pixelSize = sqrt(tglGetPixelSize2());

    // calculate range

    TPointD aa = matrix*m_a.position;

    TPointD bb = matrix*m_b.position;

    bool success = false;

    if (restrictA && restrictB)

      success = TGuidelineLineBase::truncateLine(oneBox, aa, bb);

    else if (restrictA)

      success = TGuidelineLineBase::truncateRay(oneBox, aa, bb);

    else if (restrictB)

      success = TGuidelineLineBase::truncateRay(oneBox, bb, aa);

    else

      success = TGuidelineLineBase::truncateInfiniteLine(oneBox, aa, bb);

    if (!success) {

      // line is out of screen, bud grid still can be visible

      if (grid && getParallel())

          drawGrid(matrix, matrixInv, pixelSize, restrictA, restrictB, perspective);

      return;

    }

    TPointD a = matrixInv*aa;

    TPointD b = matrixInv*bb;

    // draw line

    drawSegment(a, b, pixelSize, alpha);

    // draw restriction marks

    if (restrictA || (!parallel && grid && perspective))

      drawDot(m_a.position);

    if (restrictB)

      drawDot(m_b.position);

    if (grid) {

      if (getParallel()) {

        drawGrid(matrix, matrixInv, pixelSize, restrictA, restrictB, perspective);

      } else {

        drawRuler(a, b, pixelSize, perspective);

      }

    }

  }

};

//*****************************************************************************************

//    Registration

//*****************************************************************************************

static TAssistantTypeT<tassistantline> assistantLine("assistantLine");</tassistantline>