// TnzTools includes

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

#include <tools modifierclone.h="" modifiers=""></tools>

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

// TnzCore includes

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

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

//    TReplicatorMirror implementation

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

class TReplicatorMirror final : public TReplicator {

  Q_DECLARE_TR_FUNCTIONS(TReplicatorMirror)

public:

  const TStringId m_idDiscreteAngle;

  const TStringId m_idPressure;

protected:

  TAssistantPoint &m_a;

  TAssistantPoint &m_b;

public:

  TReplicatorMirror(TMetaObject &object):

    TReplicator(object),

    m_idDiscreteAngle("discreteAngle"),

    m_idPressure("pressure"),

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

    m_b( addPoint("b", TAssistantPoint::Circle, TPointD(0, -50)) )

  {

    addProperty( new TBoolProperty(m_idDiscreteAngle.str(),  getDiscreteAngle()) );

    addProperty( new TDoubleProperty(m_idPressure.str(), 0.0, 2.0, getPressure()) );

  }

  static QString getLocalName()

    { return tr("Replicator Mirror"); }

  void updateTranslation() const override {

    TReplicator::updateTranslation();

    setTranslation(m_idDiscreteAngle, tr("Discrete Angle"));

    setTranslation(m_idPressure, tr("Pressure"));

  }

  inline bool getDiscreteAngle() const

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

  inline double getPressure() const

    { return data()[m_idPressure].getDouble(); }

protected:

  inline void setPressure(double x)

    { if (getPressure() != x) data()[m_idPressure].setDouble(x); }

  void onSetDefaults() override {

    setPressure(1);

    TReplicator::onSetDefaults();

  }

  void onFixData() override {

    TReplicator::onFixData();

    setPressure( std::max(0.0, std::min(2.0, getPressure())) );

  }

  TPointD fixB() const {

    TPointD b = m_b.position;

    if (getDiscreteAngle()) {

      TPointD d = b - m_a.position;

      double l = norm2(d);

      if (l > TConsts::epsilon*TConsts::epsilon) {

        l = sqrt(l);

        double angle = atan2(d.y, d.x);

        angle = round(angle*4/M_PI)*M_PI/4;

        b.x = cos(angle)*l + m_a.position.x;

        b.y = sin(angle)*l + m_a.position.y;

      }

    }

    if (areAlmostEqual(b, m_a.position))

      b = m_a.position + TPointD(1, 0);

    return b;

  }

  TAffine getAffine(const TAffine &toTool = TAffine()) const {

    TPointD c = toTool*m_a.position;

    TPointD x = toTool*fixB() - c;

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

    TAffine t0( x.x,  y.x, c.x,

                x.y,  y.y, c.y );

    TAffine t1( x.x, -y.x, c.x,

                x.y, -y.y, c.y );

    return t1*t0.inv();

  }

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

    if (&point == &m_a)

      m_b.position += position - m_a.position;

    point.position = position;

  }

public:

  int getMultipler() const override

    { return 2; }

  void getPoints(const TAffine &toTool, PointList &points) const override

    { transformPoints(getAffine(toTool), points, (int)points.size()); }

  void getModifiers(

    const TAffine &toTool,

    TInputModifier::List &outModifiers ) const override

  {

    TModifierClone *modifier = new TModifierClone();

    modifier->transforms.push_back(TTrackTransform(

      getAffine(toTool), getPressure() ));

    outModifiers.push_back(modifier);

  }

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

    TPointD p0 = m_a.position;

    TPointD p1 = fixB();

    TAffine4 modelview, projection;

    glGetDoublev(GL_MODELVIEW_MATRIX, modelview.a);

    glGetDoublev(GL_PROJECTION_MATRIX, projection.a);

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

    TPointD pp0 = matrix*p0;

    TPointD pp1 = matrix*p1;

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

    if (!TGuidelineLine::truncateInfiniteLine(oneBox, pp0, pp1)) return;

    double alpha = getDrawingAlpha(enabled);

    double pixelSize = sqrt(tglGetPixelSize2());

    TAffine matrixInv = matrix.inv();

    drawSegment(matrixInv*pp0, matrixInv*pp1, pixelSize, alpha);

  }

};

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

//    Registration

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

static TAssistantTypeT<treplicatormirror> replicatorMirror("replicatorMirror");</treplicatormirror>