// TnzTools includes

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

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

// TnzCore includes

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

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

//    TReplicatorJitter implementation

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

class TReplicatorJitter final : public TReplicator {

  Q_DECLARE_TR_FUNCTIONS(TReplicatorJitter)

public:

  const TStringId m_idSkipFirst;

  const TStringId m_idPeriod;

  const TStringId m_idAmplitude;

protected:

  TAssistantPoint &m_center;

public:

  TReplicatorJitter(TMetaObject &object):

    TReplicator(object),

    m_idSkipFirst("skipFirst"),

    m_idPeriod("period"),

    m_idAmplitude("m_idAmplitude"),

    m_center( addPoint("center", TAssistantPoint::CircleCross) )

  {

    addProperty( createSpinProperty(m_idSkipFirst, getSkipFirst(), 0) );

    TDoubleProperty *p;

    p = new TDoubleProperty(m_idPeriod.str(), 0.0, 1000, getPeriod());

    p->setNonLinearSlider();

    addProperty(p);

    p = new TDoubleProperty(m_idAmplitude.str(), 0.0, 1000, getAmplitude());

    p->setNonLinearSlider();

    addProperty(p);

  }

  static QString getLocalName()

    { return tr("Jitter"); }

  void updateTranslation() const override {

    TReplicator::updateTranslation();

    setTranslation(m_idSkipFirst, tr("Skip First Tracks"));

    setTranslation(m_idPeriod, tr("Period"));

    setTranslation(m_idAmplitude, tr("Amplitude"));

  }

  inline int getSkipFirst() const

    { return (int)data()[m_idSkipFirst].getDouble(); }

  inline double getPeriod() const

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

  inline double getAmplitude() const

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

protected:

  inline void setSkipFirst(int x)

    { if (getSkipFirst() != (double)x) data()[m_idSkipFirst].setDouble((double)x); }

  inline void setPeriod(double x)

    { if (getPeriod() != x) data()[m_idPeriod].setDouble(x); }

  inline void setAmplitude(double x)

    { if (getAmplitude() != x) data()[m_idAmplitude].setDouble(x); }

  void onSetDefaults() override {

    setPeriod(30);

    setAmplitude(10);

    TReplicator::onSetDefaults();

  }

  void onFixData() override {

    TReplicator::onFixData();

    setPeriod( std::max(0.0, std::min(1000.0, getPeriod())) );

    setAmplitude( std::max(0.0, std::min(1000.0, getAmplitude())) );

  }

  double getScale(const TAffine &a) const {

    return sqrt( a.a11*a.a11 + a.a12*a.a12

               + a.a21*a.a21 + a.a22*a.a22 )/2;

  }

public:

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

    int skipFirst = getSkipFirst();

    if (skipFirst < 0) skipFirst = 0;

    if (skipFirst >= (int)points.size()) return;

    double scale = getScale(toTool);

    double period = getPeriod()*scale;

    double amplitude = getAmplitude()*scale;

    if (!(period > TConsts::epsilon && amplitude > TConsts::epsilon)) {

      int seedX = 0;

      int seedY = 7722441;

      for(PointList::iterator i = points.begin() + skipFirst; i != points.end(); ++i) {

        i->x += TModifierJitter::func(seedX, 0)*amplitude;

        i->y += TModifierJitter::func(seedY, 0)*amplitude;

        ++seedX, ++seedY;

      }

    }

  }

  void getModifiers(

    const TAffine &toTool,

    TInputModifier::List &outModifiers ) const override

  {

    double scale = getScale(toTool);

    outModifiers.push_back(new TModifierJitter(

      getPeriod()*scale,

      getAmplitude()*scale,

      getSkipFirst() ));

  }

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

    double alpha = getDrawingAlpha(enabled);

    double pixelSize = sqrt(tglGetPixelSize2());

    TPointD c = m_center.position;

    double h = getPeriod()/2;

    double q = h/2;

    double a = getAmplitude();

    drawSegment(TPointD(c.x-h, c.y  ), TPointD(c.x-q, c.y+a), pixelSize, alpha);

    drawSegment(TPointD(c.x-q, c.y+a), TPointD(c.x+q, c.y-a), pixelSize, alpha);

    drawSegment(TPointD(c.x+q, c.y-a), TPointD(c.x+h, c.y  ), pixelSize, alpha);

  }

};

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

//    Registration

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

static TAssistantTypeT<treplicatorjitter> replicatorJitter("replicatorJitter");</treplicatorjitter>