// TnzTools includes
#include <tools/replicator.h>
#include <tools/modifiers/modifierclone.h>
 
 
// TnzCore includes
#include <tgl.h>
 
 
//*****************************************************************************************
//    TReplicatorGrid implementation
//*****************************************************************************************
 
class TReplicatorGrid final : public TReplicator {
  Q_DECLARE_TR_FUNCTIONS(TReplicatorGrid)
public:
  const TStringId m_idFixAngle;
  const TStringId m_idFixSkew;
  const TStringId m_idMirrorA;
  const TStringId m_idMirrorB;
  const TStringId m_idCountA;
  const TStringId m_idCountAInv;
  const TStringId m_idCountB;
  const TStringId m_idCountBInv;
 
protected:
  TAssistantPoint &m_center;
  TAssistantPoint &m_a;
  TAssistantPoint &m_b;
 
public:
  TReplicatorGrid(TMetaObject &object):
    TReplicator(object),
    m_idFixAngle("fixAngle"),
    m_idFixSkew("fixSkew"),
    m_idMirrorA("mirrorA"),
    m_idMirrorB("mirrorB"),
    m_idCountA("countA"),
    m_idCountAInv("countAInv"),
    m_idCountB("countB"),
    m_idCountBInv("countBInv"),
    m_center( addPoint("center", TAssistantPoint::CircleCross) ),
    m_a     ( addPoint("a",      TAssistantPoint::CircleFill, TPointD(80,   0)) ),
    m_b     ( addPoint("b",      TAssistantPoint::Circle,     TPointD( 0, -80)) )
  {
    addProperty( new TBoolProperty(m_idFixAngle.str(),  getFixAngle()) );
    addProperty( new TBoolProperty(m_idFixSkew.str(),   getFixSkew()) );
    addProperty( new TBoolProperty(m_idMirrorA.str(),   getMirrorA()) );
    addProperty( new TBoolProperty(m_idMirrorB.str(),   getMirrorB()) );
    addProperty( createCountProperty(m_idCountA, getCountA(), 1) );
    addProperty( createCountProperty(m_idCountAInv, getCountAInv(), 0) );
    addProperty( createCountProperty(m_idCountB, getCountB(), 1) );
    addProperty( createCountProperty(m_idCountBInv, getCountBInv(), 0) );
  }
 
  
  static QString getLocalName()
    { return tr("Replicator Grid"); }
 
    
  void updateTranslation() const override {
    TReplicator::updateTranslation();
    setTranslation(m_idFixAngle, tr("Fix Angle"));
    setTranslation(m_idFixSkew, tr("Fix Skew"));
    setTranslation(m_idMirrorA, tr("Mirror A"));
    setTranslation(m_idMirrorB, tr("Mirror B"));
    setTranslation(m_idCountA, tr("Count A"));
    setTranslation(m_idCountAInv, tr("Inv. Count A"));
    setTranslation(m_idCountB, tr("Count B"));
    setTranslation(m_idCountBInv, tr("Inv. Count B"));
  }
 
  
  inline bool getFixAngle() const
    { return data()[m_idFixAngle].getBool(); }
  inline bool getFixSkew() const
    { return data()[m_idFixSkew].getBool(); }
  inline bool getMirrorA() const
    { return data()[m_idMirrorA].getBool(); }
  inline bool getMirrorB() const
    { return data()[m_idMirrorB].getBool(); }
  inline int getCountA() const
    { return (int)data()[m_idCountA].getDouble(); }
  inline int getCountAInv() const
    { return (int)data()[m_idCountAInv].getDouble(); }
  inline int getCountB() const
    { return (int)data()[m_idCountB].getDouble(); }
  inline int getCountBInv() const
    { return (int)data()[m_idCountBInv].getDouble(); }
 
protected:
  inline void setCountA(int x)
    { if (getCountA() != (double)x) data()[m_idCountA].setDouble((double)x); }
  inline void setCountAInv(int x)
    { if (getCountAInv() != (double)x) data()[m_idCountAInv].setDouble((double)x); }
  inline void setCountB(int x)
    { if (getCountB() != (double)x) data()[m_idCountB].setDouble((double)x); }
  inline void setCountBInv(int x)
    { if (getCountBInv() != (double)x) data()[m_idCountBInv].setDouble((double)x); }
 
    
  void onSetDefaults() override {
    setCountA(3);
    setCountAInv(2);
    setCountB(2);
    setCountBInv(1);
    TReplicator::onSetDefaults();
  }
 
  
  void onFixData() override {
    TReplicator::onFixData();
    setCountA( std::max(1, std::min(multiplierSoftLimit, getCountA())) );
    setCountAInv( std::max(0, std::min(multiplierSoftLimit, getCountAInv())) );
    setCountB( std::max(1, std::min(multiplierSoftLimit, getCountB())) );
    setCountBInv( std::max(0, std::min(multiplierSoftLimit, getCountBInv())) );
  }
 
 
  void onFixPoints() override {
    TPointD &c = m_center.position;
    TPointD &a = m_a.position;
    TPointD &b = m_b.position;
 
    if (getFixAngle()) {
      double la = tdistance(a, c);
      double lb = tdistance(b, c);
      a = TPointD(a.x < c.x ? -la : la, 0) + c;
      b = TPointD(0, b.y < c.y ? -lb : lb) + c;
    } else
    if (getFixSkew()) {
      TPointD pa(c.y - a.y, a.x - c.x);
      double l = norm2(pa);
      if (l > TConsts::epsilon*TConsts::epsilon) {
        TPointD db = b - c;
        double k = sqrt(norm2(db)/l);
        if (db*pa < 0) k = -k;
        b = pa*k + c;
      }
    }
  }
  
  
  void onMovePoint(TAssistantPoint &point, const TPointD &position) override {
    TPointD pc = m_center.position;
    TPointD pa = m_a.position;
    point.position = position;
    if (&point == &m_center) {
      TPointD d = m_center.position - pc;
      m_a.position += d;
      m_b.position += d;
    } else {
      fixPoints();
    }
  }
  
  
  void onDataFieldChanged(const TStringId &name, const TVariant &value) override {
    TReplicator::onDataFieldChanged(name, value);
    if ( name == m_idFixAngle
      || name == m_idFixSkew )
        fixPoints();
  }
 
 
public:
  int getMultipler() const override {
    return (getCountA() + getCountAInv())
         * (getCountB() + getCountBInv())
         * (getMirrorA() ? 2 : 1)
         * (getMirrorB() ? 2 : 1);    
  }
  
  
  void getPoints(const TAffine &toTool, PointList &points) const override {
    points.reserve(points.size() * getMultipler());
    int pointsCount = (int)points.size();
    int i0 = getSkipFirst();
    int i1 = pointsCount - getSkipLast();
    
    TPointD c = toTool*m_center.position;
    TPointD da = toTool*m_a.position - c;
    TPointD db = toTool*m_b.position - c;
    
    bool mirrorA = getMirrorA();
    bool mirrorB = getMirrorB();
    TAffine t, ma, mb, mc;
    if (mirrorA || mirrorB) {
      if (fabs(da*db) > TConsts::epsilon) {
        t  = TAffine(  da.x,  db.x, c.x,
                       da.y,  db.y, c.y ).inv();
        ma = TAffine( -da.x,  db.x, c.x,
                      -da.y,  db.y, c.y )*t;
        mb = TAffine(  da.x, -db.x, c.x,
                       da.y, -db.y, c.y )*t;
        mc = TAffine( -da.x, -db.x, c.x,
                      -da.y, -db.y, c.y )*t;
      } else {
        mirrorA = mirrorB = false;
      }
    }
    
    int a1 = getCountA();
    int b1 = getCountB();
    int a0 = -getCountAInv();
    int b0 = -getCountBInv();
    
    for(int ib = b0; ib < b1; ++ib)
    for(int ia = a0; ia < a1; ++ia) {
      TPointD o = da*ia + db*ib;
      if (ia || ib)
        transformPoints(
          TAffine( 1, 0, o.x,
                   0, 1, o.y ),
          points, i0, i1 );
      if (mirrorA)
        transformPoints(
          TAffine( ma.a11, ma.a12, ma.a13 + o.x,
                   ma.a21, ma.a22, ma.a23 + o.y ),
          points, i0, i1 );
      if (mirrorB)
        transformPoints(
          TAffine( mb.a11, mb.a12, mb.a13 + o.x,
                   mb.a21, mb.a22, mb.a23 + o.y ),
          points, i0, i1 );
      if (mirrorA && mirrorB)
        transformPoints(
          TAffine( mc.a11, mc.a12, mc.a13 + o.x,
                   mc.a21, mc.a22, mc.a23 + o.y ),
          points, i0, i1 );
    }
  }
 
  
  void getModifiers(
    const TAffine &toTool,
    TInputModifier::List &outModifiers ) const override
  {
    TPointD c = toTool*m_center.position;
    TPointD da = toTool*m_a.position - c;
    TPointD db = toTool*m_b.position - c;
    
    bool mirrorA = getMirrorA();
    bool mirrorB = getMirrorB();
    TAffine t, ma, mb, mc;
    if (mirrorA || mirrorB) {
      if (fabs(da*db) > TConsts::epsilon) {
        t  = TAffine(  da.x,  db.x, c.x,
                       da.y,  db.y, c.y ).inv();
        ma = TAffine( -da.x,  db.x, c.x,
                      -da.y,  db.y, c.y )*t;
        mb = TAffine(  da.x, -db.x, c.x,
                       da.y, -db.y, c.y )*t;
        mc = TAffine( -da.x, -db.x, c.x,
                      -da.y, -db.y, c.y )*t;
      } else {
        mirrorA = mirrorB = false;
      }
    }
    
    int a1 = getCountA();
    int b1 = getCountB();
    int a0 = -getCountAInv();
    int b0 = -getCountBInv();
    
    TModifierClone *modifier = new TModifierClone(true, getSkipFirst(), getSkipLast());
    for(int ib = b0; ib < b1; ++ib)
    for(int ia = a0; ia < a1; ++ia) {
      TPointD o = da*ia + db*ib;
      if (ia || ib)
        modifier->transforms.push_back(TTrackTransform(
          TAffine( 1, 0, o.x,
                   0, 1, o.y ) ));
      if (mirrorA)
        modifier->transforms.push_back(TTrackTransform(
          TAffine( ma.a11, ma.a12, ma.a13 + o.x,
                   ma.a21, ma.a22, ma.a23 + o.y ) ));
      if (mirrorB)
        modifier->transforms.push_back(TTrackTransform(
          TAffine( mb.a11, mb.a12, mb.a13 + o.x,
                   mb.a21, mb.a22, mb.a23 + o.y ) ));
      if (mirrorA && mirrorB)
        modifier->transforms.push_back(TTrackTransform(
          TAffine( mc.a11, mc.a12, mc.a13 + o.x,
                   mc.a21, mc.a22, mc.a23 + o.y ) ));
    }
    outModifiers.push_back(modifier);
  }
 
  
  void draw(TToolViewer*, bool enabled) const override {
    double alpha = getDrawingAlpha(enabled);
    double gridAlpha = getDrawingGridAlpha();
    double pixelSize = sqrt(tglGetPixelSize2());
 
    TPointD c = m_center.position;
    TPointD a = m_a.position;
    TPointD b = m_b.position;
    TPointD da = a - c;
    TPointD db = b - c;
 
    int a1 = getCountA();
    int b1 = getCountB();
    int a0 = -getCountAInv();
    int b0 = -getCountBInv();
    
    bool mirrorA = getMirrorA();
    bool mirrorB = getMirrorB();
    
    // draw base
    drawSegment(c, a, pixelSize, alpha);
    drawSegment(c, b, pixelSize, alpha);
    
    // draw clones
    for(int ib = b0; ib < b1; ++ib)
    for(int ia = a0; ia < a1; ++ia) {
      TPointD o = c + da*ia + db*ib;
      if (ia || ib) {
        drawSegment(o, o + da*0.2, pixelSize, gridAlpha);
        drawSegment(o, o + db*0.2, pixelSize, gridAlpha);
      }
      if (mirrorA && (ib || ia != 1))
        drawSegment(o - da*0.2, o, pixelSize, gridAlpha);
      if (mirrorB && (ia || ib != 1))
        drawSegment(o - db*0.2, o, pixelSize, gridAlpha);
    }
  }
};
 
 
//*****************************************************************************************
//    Registration
//*****************************************************************************************
 
static TAssistantTypeT<TReplicatorGrid> replicatorGrid("replicatorGrid");